Production Deployment

# Database Configuration
DATABASE_URL="postgresql://user:password@host:6543/db?pgbouncer=true"
DIRECT_URL="postgresql://user:password@host:5432/db"

# JWT Configuration
JWT_SECRET="your-random-32-char-secret-key-here"
JWT_EXPIRES_IN="7d"

# Application
NODE_ENV="production"
PORT="3000"

# Frontend URL (for CORS)
FRONTEND_URL="https://your-frontend-domain.com"

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {
  // Seed default categories, demo user, etc.
  console.log('Seeding database...');
  
  // Example: Create default categories
  await prisma.category.createMany({
    data: DEFAULT_CATEGORIES
  });
}

main()
  .catch(console.error)
  .finally(() => prisma.$disconnect());

{
  "buildCommand": "pnpm build",
  "outputDirectory": "dist",
  "framework": "vite",
  "rewrites": [
    { "source": "/(.*)", "destination": "/index.html" }
  ]
}

# Build stage
FROM node:18-alpine AS builder

WORKDIR /app

# Install pnpm
RUN npm install -g pnpm

# Copy package files
COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
COPY apps/backend/package.json ./apps/backend/

# Install dependencies
RUN pnpm install --frozen-lockfile

# Copy source code
COPY apps/backend ./apps/backend

# Generate Prisma client
RUN pnpm --filter backend prisma generate

# Build application
RUN pnpm --filter backend build

# Production stage
FROM node:18-alpine

WORKDIR /app

RUN npm install -g pnpm

# Copy built files and dependencies
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/apps/backend/dist ./dist
COPY --from=builder /app/apps/backend/node_modules ./apps/backend/node_modules
COPY --from=builder /app/apps/backend/prisma ./prisma

# Expose port
EXPOSE 3000

# Start application
CMD ["node", "dist/main.js"]

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - DIRECT_URL=${DIRECT_URL}
      - JWT_SECRET=${JWT_SECRET}
      - NODE_ENV=production
    depends_on:
      - postgres

  postgres:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=finance
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

volumes:
  postgres_data:

export class AppLogger {
  constructor(private context: string) {}

  log(message: string) {
    console.log(`[${this.context}] ${message}`);
  }

  logOperation(operation: string, data: any) {
    console.log(`[${this.context}] ${operation}:`, JSON.stringify(data));
  }

  logSuccess(operation: string, data: any) {
    console.log(`[${this.context}] ✓ ${operation}:`, JSON.stringify(data));
  }

  logFailure(operation: string, error: Error) {
    console.error(`[${this.context}] ✗ ${operation}:`, error.message);
  }
}

@Controller()
export class AppController {
  @Get('health')
  healthCheck() {
    return {
      status: 'ok',
      timestamp: new Date().toISOString(),
      uptime: process.uptime()
    };
  }

  @Get('health/db')
  async databaseHealth() {
    try {
      await this.prisma.$queryRaw`SELECT 1`;
      return { status: 'ok', database: 'connected' };
    } catch (error) {
      return { status: 'error', database: 'disconnected' };
    }
  }
}

import compression from 'compression';

app.use(compression());

import { ThrottlerModule } from '@nestjs/throttler';

@Module({
  imports: [
    ThrottlerModule.forRoot({
      ttl: 60,      // Time window in seconds
      limit: 100    // Max requests per window
    })
  ]
})
export class AppModule {}

import helmet from 'helmet';

app.use(helmet());

const app = await NestFactory.create(AppModule, {
  cors: {
    origin: process.env.FRONTEND_URL,
    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE,OPTIONS',
    credentials: true,
    allowedHeaders: 'Content-Type,Authorization'
  }
});