[WIP] Scaffold full-stack monorepo for MatchPoint esports application

[Copilot]

• Inspect current repository state and check existing CI/workflow runs
• Confirm baseline lint/build/test commands available before changes
• Scaffold root Turborepo + pnpm workspace configuration files
• Scaffold packages/db with Prisma package setup and MVP schema (Rainbow Six Siege-ready)
• Scaffold apps/web with baseline Next.js TypeScript configuration
• Scaffold apps/api with baseline Express + TypeScript entrypoint and configs
• Validate repository structure and run targeted checks available in repo
• Capture a screenshot showing the resulting scaffolded repository tree

Original prompt

Please scaffold a full-stack monorepo for our esports application "MatchPoint" using Turborepo and pnpm. The MVP is focused on Rainbow Six Siege.

Please create the following foundational files and folder structure:

1. Root Configuration:

• package.json (setup for pnpm workspaces targeting apps/* and packages/*)
• turbo.json (pipeline for build, lint, dev)
• docker-compose.yml (PostgreSQL 15 and Redis 7 services)
• .prettierrc and .gitignore

2. Database Package (packages/db):

• package.json
• prisma/schema.prisma containing the models for User, Follows, Post, Clip, Match, Team, Game, Comment, Like (as discussed, for a social media and live match tracking app).

3. Frontend App (apps/web):

• A basic Next.js setup (package.json, tsconfig.json, next.config.js).

4. Backend App (apps/api):

• A basic Express + TypeScript setup (package.json, tsconfig.json, src/index.ts).

Make sure the setup uses industry best practices for a scalable TypeScript monorepo.

The following is the prior conversation context from the user's chat exploration (may be truncated):

User: We are building a full-stack esports-focused social media platform and want help scaffolding the repository architecture, backend structure, database schema, and development environment setup.

Tech Stack:
Frontend:

• Next.js
• React
• TypeScript
• TailwindCSS

Backend:

• Node.js
• Express
• TypeScript

Database:

• PostgreSQL

Caching / Real-Time:

• Redis
• WebSockets (Socket.IO preferred)

Project Goals:
This platform is focused on esports communities and live esports engagement.

Our MVP (minimum viable product) should support:

1. Live Esports Match Tracking

• Live match pages
• Real-time score/status updates
• Live discussion/chat per match
• Match metadata (teams, game, tournament, start time, status)

2. Social Media Posts

• Twitter/Reddit style posts
• Likes
• Comments/replies
• Reposts/shares
• Infinite scrolling feed

3. Clips Feature

• Short-form gaming clips similar to Instagram Reels/TikTok
• Video uploads
• Likes/comments
• Scrollable clips feed

4. User Profiles

• Username/display name
• Bio
• Favorite games
• Favorite teams
• Profile picture/banner
• Followers/following

Requirements:

1. Help generate a scalable monorepo folder structure for frontend + backend.
2. Use clean architecture and industry best practices.
3. Configure TypeScript properly for both frontend and backend.
4. Suggest useful libraries and tooling.
5. Help initialize:
   • ESLint
   • Prettier
   • Husky
   • Docker
   • environment variables
   • GitHub Actions CI/CD
6. Design the PostgreSQL schema for the MVP.
7. Include proper relationships and normalization.
8. Generate SQL tables or Prisma schema.
9. Include Redis usage suggestions for:
   • caching feeds
   • live match updates
   • websocket sessions
10. Include API route structure examples for Express.
11. Include authentication architecture recommendations (JWT + refresh tokens preferred).
12. Include recommendations for handling media uploads for clips.
13. Suggest scalable real-time architecture for live match discussions.
14. Recommend a good state management solution for Next.js.
15. Recommend deployment architecture for both development and production.

Please provide:

• Recommended repository structure
• Initial database schema
• Core backend architecture
• Suggested dependencies
• Docker compose setup idea
• Recommended development workflow
• Recommended Git branching strategy
• Initial roadmap for development

Focus on scalability, maintainability, and resume-quality engineering practices.

Assistant: Here is a comprehensive architecture and scaffolding plan for MatchPoint, designed for high scalability, maintainability, and resume-quality engineering.

1. Repository Structure (Monorepo)

For a TypeScript-heavy full-stack app, Turborepo with pnpm workspaces is the industry standard. It shares types seamlessly and caches builds.

matchpoint/
├── apps/
│   ├── web/                # Next.js Frontend (React, Tailwind)
│   └── api/                # Node.js/Express Backend
├── packages/
│   ├── db/                 # Prisma schema, migrations, and generated client
│   ├── shared/             # Shared TypeScript interfaces, schemas (Zod), and utils
│   ├── eslint-config/      # Shared ESLint rules
│   └── typescript-config/  # Shared tsconfig.json bases
├── docker-compose.yml      # Local dev infrastructure (Postgres, Redis)
├── .github/
│   └── workflows/          # CI/CD pipelines
├── .husky/                 # Pre-commit hooks
├── package.json            # Root workspace config
└── turbo.json              # Turborepo build pipeline config

2. Database Schema (Prisma)

Prisma is highly recommended here because it generates fully typed database clients which you can export from the packages/db package to both web and api.

generator client {
  provider = "prisma-client-js"
}

datasourc...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

*This pull request was created from Copilot chat.*
>