GitHunt
JO

joshajh/nest-prisma-vue-turborepo

Fullstack Typescript-first starter template using NestJS, Prisma, Vue 3, and Turborepo; comprehensive testing with Jest; rapid codegen with Plop; git hooks and branching rules with Husky; and more.

fullstackfullstack-typescripthuskynestjsnestjs-boilerplateplopplop-generatorsstarter-templateturborepoturborepo-startertypescriptvuevue3

Fullstack Starter Template

A production-ready fullstack starter template featuring NestJS, Prisma, Vue 3, and Turborepo with comprehensive testing, code generation, and quality tools.

✨ Highlights

  • 🎯 Production-Ready: 86.66% test coverage on critical paths, all builds passing
  • 🚀 Rapid Development: Plop generators for instant scaffolding
  • 📚 API Documentation: Auto-generated Swagger/OpenAPI docs
  • 🧪 Comprehensive Testing: 30+ unit tests with Jest
  • 🎨 Code Quality: ESLint, Prettier, Husky git hooks
  • 🔒 Type-Safe: Shared TypeScript types across frontend and backend
  • ⚡ Fast Builds: Turborepo caching for lightning-fast builds

Stack

Project Structure

├── apps/
│   ├── backend/          # NestJS API server
│   │   ├── src/
│   │   ├── prisma/       # Prisma schema & migrations
│   │   └── test/
│   └── frontend/         # Vue 3 application
│       ├── src/
│       │   ├── router/   # Vue Router
│       │   ├── stores/   # Pinia stores
│       │   ├── services/ # API services
│       │   ├── views/    # Page components
│       │   └── components/
├── packages/
│   └── types/            # Shared TypeScript types
└── turbo.json            # Turborepo config

Prerequisites

  • Node.js >= 18.0.0
  • npm >= 9.0.0
  • PostgreSQL database

Getting Started

1. Install Dependencies

npm install

2. Set Up Environment Variables

Backend (apps/backend/.env):

cp apps/backend/.env.example apps/backend/.env

Edit apps/backend/.env and set your database URL:

DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"
PORT=3000
NODE_ENV=development

Frontend (apps/frontend/.env):

cp apps/frontend/.env.example apps/frontend/.env

3. Initialize Database

cd apps/backend
npm run prisma:migrate
npm run prisma:seed  # Optional: seed sample data

4. Build Shared Packages

# From root
npm run build

5. Start Development Servers

# From root - starts all apps in parallel
npm run dev

Or start individually:

# Backend (http://localhost:3000)
cd apps/backend
npm run dev

# Frontend (http://localhost:5173)
cd apps/frontend
npm run dev

Available Scripts

Root Commands

  • npm run dev - Start all apps in development mode
  • npm run build - Build all apps for production
  • npm run lint - Lint all apps
  • npm run format - Format code with Prettier
  • npm run clean - Clean all build outputs
  • npm run generate - Run Plop code generators (see Code Generation)
  • npm run test - Run all tests

Backend Commands

  • npm run dev - Start in watch mode
  • npm run build - Build for production
  • npm run start - Start production server
  • npm run prisma:migrate - Run database migrations
  • npm run prisma:generate - Generate Prisma Client
  • npm run prisma:studio - Open Prisma Studio
  • npm run prisma:seed - Seed database
  • npm run lint - Lint code
  • npm run test - Run tests

Frontend Commands

  • npm run dev - Start dev server
  • npm run build - Build for production
  • npm run clean - Clean build output

Project Features

Backend Features

  • ✅ Clean Architecture: Controllers, services, and DTOs pattern
  • ✅ Prisma ORM: Type-safe database access with migrations
  • ✅ Validation: Global validation pipe with class-validator
  • ✅ API Documentation: Auto-generated Swagger/OpenAPI docs at /api/docs
  • ✅ Testing: Comprehensive unit tests with Jest (86.66% coverage)
  • ✅ CORS: Configured and ready
  • ✅ Error Handling: Proper error responses with HTTP status codes
  • ✅ Sample CRUD: Complete User entity example
  • ✅ Database Seeding: Sample data generator

Frontend Features

  • ✅ Vue 3: Composition API with <script setup>
  • ✅ TypeScript: Full type safety
  • ✅ Vue Router: File-based routing setup
  • ✅ Pinia: State management with stores
  • ✅ Axios: HTTP client with interceptors
  • ✅ Vite: Lightning-fast HMR and builds
  • ✅ Sample UI: Complete User CRUD interface

Code Quality & DX

  • ✅ Shared TypeScript Types: Type-safe contracts between frontend and backend
  • ✅ Turborepo: Smart caching for faster builds
  • ✅ ESLint: Code linting with TypeScript and Vue support
  • ✅ Prettier: Consistent code formatting
  • ✅ Husky: Git hooks for pre-commit linting and pre-push builds
  • ✅ Plop Generators: Instant code scaffolding (see Code Generation)
  • ✅ Comprehensive Tests: 30+ unit tests covering critical paths

Development Workflow

Code Generation

This template includes Plop generators for rapid scaffolding:

# Run the interactive generator
npm run generate

Available Generators:

  1. NestJS Module - Generates complete CRUD module:

    • Controller with all REST endpoints
    • Service with business logic
    • Create/Update DTOs
    • Swagger decorators
    • Imports Prisma service

  2. Vue Component - Generates Vue 3 component:

    • TypeScript with <script setup>
    • Template and style sections
    • Proper naming conventions

Example: Generate a NestJS module

npm run generate
? What do you want to generate? nest-module
? Module name: products

This creates:

  • apps/backend/src/products/products.module.ts
  • apps/backend/src/products/products.controller.ts
  • apps/backend/src/products/products.service.ts
  • apps/backend/src/products/dto/create-product.dto.ts
  • apps/backend/src/products/dto/update-product.dto.ts

Adding a New API Endpoint

Option 1: Use Plop Generator (Recommended)

npm run generate
# Select "nest-module" and follow prompts

Option 2: Manual Setup

  1. Define types in packages/types/src/
  2. Create Prisma model in apps/backend/prisma/schema.prisma
  3. Generate Prisma Client: npm run prisma:generate
  4. Create NestJS module/controller/service in apps/backend/src/
  5. Use types from @repo/types

Adding a New Frontend Page

Option 1: Use Plop Generator (Recommended)

npm run generate
# Select "vue-component" and follow prompts

Option 2: Manual Setup

  1. Create view in apps/frontend/src/views/
  2. Add route in apps/frontend/src/router/index.ts
  3. Create service in apps/frontend/src/services/ if needed
  4. Use types from @repo/types

API Documentation

This template includes Swagger/OpenAPI documentation for the backend API.

Access Swagger UI:

http://localhost:3000/api/docs

All endpoints are automatically documented with:

  • Request/response schemas
  • Validation rules
  • HTTP status codes
  • Example payloads

Adding Swagger Docs to New Endpoints:
The Plop generator automatically adds Swagger decorators. For manual endpoints, use:

import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';

@ApiTags('products')
@Controller('products')
export class ProductsController {
  @Get()
  @ApiOperation({ summary: 'Get all products' })
  @ApiResponse({ status: 200, description: 'Returns all products' })
  findAll() {
    // ...
  }
}

Testing

This template includes comprehensive testing setup with Jest.

Running Tests

# Run all tests
npm run test

# Run tests with coverage
cd apps/backend
npm run test -- --coverage

# Run tests in watch mode
npm run test -- --watch

Test Coverage

Current coverage (see TEST_REPORT.md for details):

  • Overall: 64.76% statements, 75% branches
  • Users Module: 86.66% statements (critical paths)
  • 30 unit tests covering:
    • Service layer (CRUD operations, error handling)
    • Controller layer (HTTP responses, validation)
    • Edge cases and error scenarios

Writing Tests

Tests are located alongside source files:

  • *.spec.ts - Unit tests
  • *.e2e-spec.ts - E2E tests (in test/ directory)

Example test structure:

describe('UsersService', () => {
  describe('findAll', () => {
    it('should return an array of users', async () => {
      // Test implementation
    });
  });
});

Database Migrations

# Create a new migration
cd apps/backend
npm run prisma:migrate

# View database in Prisma Studio
npm run prisma:studio

# Reset database (WARNING: deletes all data)
npx prisma migrate reset

Building for Production

# Build all packages
npm run build

# Backend will be in apps/backend/dist
# Frontend will be in apps/frontend/dist

Troubleshooting

Port Already in Use

Change the port in apps/backend/.env:

PORT=3001

Database Connection Failed

Ensure PostgreSQL is running and the DATABASE_URL in .env is correct.

Types Not Found

Build the types package:

cd packages/types
npm run build

Git Hooks

This template uses Husky for git hooks:

  • Pre-commit: Runs Prettier on staged files (via lint-staged)
  • Pre-push: Runs full build to ensure everything compiles

To skip hooks (not recommended):

git commit --no-verify
git push --no-verify

Project Quality

See TEST_REPORT.md for comprehensive quality assessment:

  • ✅ All builds passing
  • ✅ Linting configured
  • ✅ 30/30 tests passing
  • ✅ Quality Score: 8.35/10 (Excellent)

Example: Complete User CRUD

This template includes a complete User CRUD example demonstrating:

Backend (apps/backend/src/users/):

  • User entity with Prisma schema
  • Full REST API (GET, POST, PUT, DELETE)
  • Input validation with class-validator
  • Error handling (404, validation errors)
  • Swagger documentation
  • Unit tests (service + controller)

Frontend (apps/frontend/src/):

  • Users list view with table
  • Create/Edit user modals
  • Delete confirmation
  • Pinia store for state management
  • API service layer
  • Error handling and loading states

API Endpoints:

  • GET /api/users - List all users
  • GET /api/users/:id - Get single user
  • POST /api/users - Create user
  • PUT /api/users/:id - Update user
  • DELETE /api/users/:id - Delete user

Short-term (1-2 weeks):

  • Add JWT authentication
  • Add role-based authorization
  • Configure CORS for production domains
  • Add Docker Compose setup
  • Add frontend component tests (Vitest)
  • Add E2E tests with real database

Long-term (Production):

  • Set up CI/CD pipeline (GitHub Actions)
  • Add rate limiting (NestJS throttler)
  • Add logging (Winston/Pino)
  • Add monitoring (Sentry/DataDog)
  • Add security headers (Helmet)
  • Add request/response logging
  • Add database backups
  • Add performance monitoring

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT

Generated with ❤️ using Claude Code

Languages

TypeScript60.5%Vue13.3%Handlebars11.5%JavaScript10.9%CSS2.9%HTML0.8%

Contributors

JO
Created September 30, 2025
Updated September 30, 2025
joshajh/nest-prisma-vue-turborepo | GitHunt