// src/domain/shared/ports/ILogger.ts
export interface ILogger {
  info(message: string, context?: Record<string, unknown>): void;
  warn(message: string, context?: Record<string, unknown>): void;
  error(message: string, error?: Error, context?: Record<string, unknown>): void;
  debug(message: string, context?: Record<string, unknown>): void;
}

// src/infrastructure/logging/PinoLogger.ts
import pino from 'pino';
import { injectable } from 'inversify';
import { ILogger } from '../../domain/shared/ports/ILogger';

@injectable()
export class PinoLogger implements ILogger {
  private readonly logger = pino({
    level: process.env.LOG_LEVEL ?? 'info',
    transport: process.env.NODE_ENV === 'development'
      ? { target: 'pino-pretty' }
      : undefined, // JSON in production — consumed by Datadog/CloudWatch
  });

  info(message: string, context?: Record<string, unknown>): void {
    this.logger.info(context ?? {}, message);
  }

  warn(message: string, context?: Record<string, unknown>): void {
    this.logger.warn(context ?? {}, message);
  }

  error(message: string, error?: Error, context?: Record<string, unknown>): void {
    this.logger.error({ err: error, ...context }, message);
  }

  debug(message: string, context?: Record<string, unknown>): void {
    this.logger.debug(context ?? {}, message);
  }
}

// src/application/order/PlaceOrderUseCase.ts (with logging)
export class PlaceOrderUseCase {
  constructor(
    private readonly orders: IOrderRepository,
    private readonly customers: ICustomerRepository,
    private readonly discountService: DiscountCalculationService,
    private readonly discountStrategies: IDiscountStrategy[],
    private readonly eventBus: IEventBus,
    private readonly logger: ILogger,  // Injected via DI
  ) {}

  async execute(command: PlaceOrderCommand): Promise<OrderId> {
    this.logger.info('PlaceOrder started', { customerId: command.customerId });
    try {
      const orderId = await this.attemptExecution(command);
      this.logger.info('PlaceOrder succeeded', { customerId: command.customerId, orderId });
      return orderId;
    } catch (err) {
      if (err instanceof DomainError) {
        this.logger.warn('PlaceOrder rejected by domain', { reason: err.message, customerId: command.customerId });
      } else {
        this.logger.error('PlaceOrder failed unexpectedly', err as Error, { customerId: command.customerId });
      }
      throw err;
    }
  }
}

// src/interface/http/HealthController.ts
import { PrismaClient } from '@prisma/client';
import { Request, Response } from 'express';

export class HealthController {
  constructor(private readonly prisma: PrismaClient) {}

  /** Liveness: is the process running? */
  async live(_req: Request, res: Response): Promise<void> {
    res.status(200).json({ status: 'ok', timestamp: new Date().toISOString() });
  }

  /** Readiness: can the process serve requests? (Checks all dependencies) */
  async ready(_req: Request, res: Response): Promise<void> {
    const checks = await Promise.allSettled([
      this.checkDatabase(),
    ]);

    const results = {
      database: checks[0].status === 'fulfilled' ? 'ok' : 'error',
    };

    const allHealthy = Object.values(results).every(v => v === 'ok');
    res.status(allHealthy ? 200 : 503).json({ status: allHealthy ? 'ready' : 'degraded', checks: results });
  }

  private async checkDatabase(): Promise<void> {
    await this.prisma.$queryRaw`SELECT 1`;
  }
}

// Route registration
app.get('/health/live',  (req, res) => healthController.live(req, res));
app.get('/health/ready', (req, res) => healthController.ready(req, res));

// src/main.ts — graceful shutdown
async function bootstrap(): Promise<void> {
  const container = await buildProductionContainer();
  const prisma    = container.get<PrismaClient>(TYPES.PrismaClient);
  const logger    = container.get<ILogger>(TYPES.ILogger);

  const app    = buildApp(container);
  const server = app.listen(process.env.PORT ?? 3000, () => {
    logger.info('Billing engine started', { port: process.env.PORT ?? 3000 });
  });

  // Start the Outbox poller
  container.get<OutboxPublisher>(TYPES.OutboxPublisher).start();

  const shutdown = async (signal: string) => {
    logger.info(`${signal} received — starting graceful shutdown`);

    // Stop accepting new connections
    server.close(async () => {
      logger.info('HTTP server closed');
      await prisma.$disconnect();
      logger.info('Database disconnected — shutdown complete');
      process.exit(0);
    });

    // Force shutdown after 30s if in-flight requests don't drain
    setTimeout(() => {
      logger.error('Forced shutdown after 30s timeout');
      process.exit(1);
    }, 30_000);
  };

  process.on('SIGTERM', () => shutdown('SIGTERM'));
  process.on('SIGINT',  () => shutdown('SIGINT'));
}

# Dockerfile
FROM node:20-alpine AS base
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM base AS builder
RUN npm ci
COPY . .
RUN npx prisma generate
RUN npm run build  # tsc --build

FROM node:20-alpine AS production
WORKDIR /app
ENV NODE_ENV=production

COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist         ./dist
COPY --from=builder /app/prisma       ./prisma
COPY package.json .

USER node  # Run as non-root

EXPOSE 3000
CMD ["node", "dist/main.js"]

# docker-compose.yml
version: '3.9'

services:
  billing-engine:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://billing:billing@postgres:5432/billing
      STRIPE_KEY:   ${STRIPE_KEY}
      REDIS_URL:    redis://redis:6379
      LOG_LEVEL:    debug
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - ./src:/app/src  # Hot reload in development

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER:     billing
      POSTGRES_PASSWORD: billing
      POSTGRES_DB:       billing
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U billing"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main, dev]
  pull_request:
    branches: [main]

jobs:
  lint-and-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20', cache: 'npm' }
      - run: npm ci

      # Verify architectural boundary constraint
      - name: Check no infrastructure imports in domain
        run: |
          ! grep -r "from.*infrastructure" src/domain/
          ! grep -r "from.*@prisma" src/domain/
          ! grep -r "from.*stripe" src/application/

      # TypeScript project references — enforces layer boundaries at compile time
      - run: npx tsc --build --force

      # Fast unit tests (no Docker needed)
      - run: npx vitest run --reporter=verbose

      # Coverage gates
      - run: npx vitest run --coverage

  integration-tests:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16-alpine
        env:
          POSTGRES_USER: billing
          POSTGRES_PASSWORD: billing
          POSTGRES_DB: billing
        ports: ['5432:5432']
        options: >-
          --health-cmd pg_isready
          --health-interval 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20', cache: 'npm' }
      - run: npm ci
      - run: npx prisma migrate deploy
        env:
          DATABASE_URL: postgresql://billing:billing@localhost:5432/billing
      - run: npx vitest run --config vitest.integration.config.ts
        env:
          DATABASE_URL: postgresql://billing:billing@localhost:5432/billing