nestjs-ddd-cli 2.2.1 → 3.2.1

package/dist/commands/metrics-prometheus.js

@@ -0,0 +1,681 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMetricsPrometheus = setupMetricsPrometheus;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const naming_utils_1 = require("../utils/naming.utils");
+async function setupMetricsPrometheus(basePath, options = {}) {
+    console.log(chalk_1.default.bold.blue('\n📊 Setting up Prometheus Metrics\n'));
+    const moduleName = options.module || 'shared';
+    const pascalName = (0, naming_utils_1.toPascalCase)(moduleName);
+    const camelName = (0, naming_utils_1.toCamelCase)(moduleName);
+    const kebabName = (0, naming_utils_1.toKebabCase)(moduleName);
+    const customMetrics = options.customMetrics || [];
+    const includeDefaultMetrics = options.includeDefaultMetrics !== false;
+    const baseDir = path.join(basePath, 'src', kebabName, 'infrastructure', 'metrics');
+    fs.mkdirSync(baseDir, { recursive: true });
+    // Metrics registry
+    const metricsRegistryContent = `import { Injectable, OnModuleInit } from '@nestjs/common';
+import {
+  Registry,
+  Counter,
+  Gauge,
+  Histogram,
+  Summary,
+  collectDefaultMetrics,
+  Metric,
+} from 'prom-client';
+
+export type MetricType = 'counter' | 'gauge' | 'histogram' | 'summary';
+
+export interface MetricConfig {
+  name: string;
+  help: string;
+  type: MetricType;
+  labelNames?: string[];
+  buckets?: number[]; // For histograms
+  percentiles?: number[]; // For summaries
+}
+
+/**
+ * Prometheus metrics registry and factory
+ */
+@Injectable()
+export class MetricsRegistry implements OnModuleInit {
+  private readonly registry: Registry;
+  private readonly metrics: Map<string, Metric<string>> = new Map();
+
+  constructor() {
+    this.registry = new Registry();
+    this.registry.setDefaultLabels({
+      app: process.env.APP_NAME || '${kebabName}',
+      env: process.env.NODE_ENV || 'development',
+    });
+  }
+
+  async onModuleInit(): Promise<void> {
+    ${includeDefaultMetrics ? `// Collect default Node.js metrics
+    collectDefaultMetrics({
+      register: this.registry,
+      prefix: '${camelName}_',
+      gcDurationBuckets: [0.001, 0.01, 0.1, 1, 2, 5],
+    });` : '// Default metrics disabled'}
+  }
+
+  /**
+   * Get the Prometheus registry
+   */
+  getRegistry(): Registry {
+    return this.registry;
+  }
+
+  /**
+   * Get metrics in Prometheus format
+   */
+  async getMetrics(): Promise<string> {
+    return this.registry.metrics();
+  }
+
+  /**
+   * Get metrics as JSON
+   */
+  async getMetricsAsJson(): Promise<object> {
+    return this.registry.getMetricsAsJSON();
+  }
+
+  /**
+   * Create or get a counter
+   */
+  counter(config: Omit<MetricConfig, 'type'>): Counter<string> {
+    const key = \`counter_\${config.name}\`;
+
+    if (!this.metrics.has(key)) {
+      const counter = new Counter({
+        name: config.name,
+        help: config.help,
+        labelNames: config.labelNames || [],
+        registers: [this.registry],
+      });
+      this.metrics.set(key, counter);
+    }
+
+    return this.metrics.get(key) as Counter<string>;
+  }
+
+  /**
+   * Create or get a gauge
+   */
+  gauge(config: Omit<MetricConfig, 'type'>): Gauge<string> {
+    const key = \`gauge_\${config.name}\`;
+
+    if (!this.metrics.has(key)) {
+      const gauge = new Gauge({
+        name: config.name,
+        help: config.help,
+        labelNames: config.labelNames || [],
+        registers: [this.registry],
+      });
+      this.metrics.set(key, gauge);
+    }
+
+    return this.metrics.get(key) as Gauge<string>;
+  }
+
+  /**
+   * Create or get a histogram
+   */
+  histogram(config: Omit<MetricConfig, 'type'> & { buckets?: number[] }): Histogram<string> {
+    const key = \`histogram_\${config.name}\`;
+
+    if (!this.metrics.has(key)) {
+      const histogram = new Histogram({
+        name: config.name,
+        help: config.help,
+        labelNames: config.labelNames || [],
+        buckets: config.buckets || [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+        registers: [this.registry],
+      });
+      this.metrics.set(key, histogram);
+    }
+
+    return this.metrics.get(key) as Histogram<string>;
+  }
+
+  /**
+   * Create or get a summary
+   */
+  summary(config: Omit<MetricConfig, 'type'> & { percentiles?: number[] }): Summary<string> {
+    const key = \`summary_\${config.name}\`;
+
+    if (!this.metrics.has(key)) {
+      const summary = new Summary({
+        name: config.name,
+        help: config.help,
+        labelNames: config.labelNames || [],
+        percentiles: config.percentiles || [0.5, 0.9, 0.95, 0.99],
+        registers: [this.registry],
+      });
+      this.metrics.set(key, summary);
+    }
+
+    return this.metrics.get(key) as Summary<string>;
+  }
+
+  /**
+   * Remove a metric
+   */
+  removeMetric(name: string): void {
+    this.registry.removeSingleMetric(name);
+    // Remove from all type keys
+    ['counter', 'gauge', 'histogram', 'summary'].forEach((type) => {
+      this.metrics.delete(\`\${type}_\${name}\`);
+    });
+  }
+
+  /**
+   * Clear all metrics
+   */
+  clear(): void {
+    this.registry.clear();
+    this.metrics.clear();
+  }
+}
+`;
+    fs.writeFileSync(path.join(baseDir, 'metrics-registry.ts'), metricsRegistryContent);
+    // HTTP metrics interceptor
+    const httpMetricsContent = `import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { MetricsRegistry } from './metrics-registry';
+import { Counter, Histogram } from 'prom-client';
+
+/**
+ * HTTP request metrics interceptor
+ */
+@Injectable()
+export class HttpMetricsInterceptor implements NestInterceptor {
+  private readonly requestCounter: Counter<string>;
+  private readonly requestDuration: Histogram<string>;
+  private readonly requestSize: Histogram<string>;
+  private readonly responseSize: Histogram<string>;
+
+  constructor(private readonly metricsRegistry: MetricsRegistry) {
+    this.requestCounter = this.metricsRegistry.counter({
+      name: 'http_requests_total',
+      help: 'Total number of HTTP requests',
+      labelNames: ['method', 'path', 'status'],
+    });
+
+    this.requestDuration = this.metricsRegistry.histogram({
+      name: 'http_request_duration_seconds',
+      help: 'HTTP request duration in seconds',
+      labelNames: ['method', 'path', 'status'],
+      buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+    });
+
+    this.requestSize = this.metricsRegistry.histogram({
+      name: 'http_request_size_bytes',
+      help: 'HTTP request size in bytes',
+      labelNames: ['method', 'path'],
+      buckets: [100, 1000, 10000, 100000, 1000000],
+    });
+
+    this.responseSize = this.metricsRegistry.histogram({
+      name: 'http_response_size_bytes',
+      help: 'HTTP response size in bytes',
+      labelNames: ['method', 'path', 'status'],
+      buckets: [100, 1000, 10000, 100000, 1000000],
+    });
+  }
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const response = context.switchToHttp().getResponse();
+    const startTime = process.hrtime();
+
+    const method = request.method;
+    const path = this.normalizePath(request.route?.path || request.url);
+
+    // Record request size
+    const contentLength = parseInt(request.headers['content-length'] || '0', 10);
+    if (contentLength > 0) {
+      this.requestSize.observe({ method, path }, contentLength);
+    }
+
+    return next.handle().pipe(
+      tap({
+        next: (data) => {
+          this.recordMetrics(method, path, response.statusCode, startTime, data);
+        },
+        error: (error) => {
+          const status = error.status || 500;
+          this.recordMetrics(method, path, status, startTime);
+        },
+      }),
+    );
+  }
+
+  private recordMetrics(
+    method: string,
+    path: string,
+    status: number,
+    startTime: [number, number],
+    data?: any,
+  ): void {
+    const [seconds, nanoseconds] = process.hrtime(startTime);
+    const duration = seconds + nanoseconds / 1e9;
+
+    const labels = { method, path, status: status.toString() };
+
+    this.requestCounter.inc(labels);
+    this.requestDuration.observe(labels, duration);
+
+    // Estimate response size
+    if (data) {
+      const responseSize = JSON.stringify(data).length;
+      this.responseSize.observe(labels, responseSize);
+    }
+  }
+
+  private normalizePath(path: string): string {
+    // Replace dynamic segments with placeholders
+    return path
+      .replace(/\\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '/:uuid')
+      .replace(/\\/\\d+/g, '/:id')
+      .replace(/\\?.*/g, ''); // Remove query string
+  }
+}
+`;
+    fs.writeFileSync(path.join(baseDir, 'http-metrics.interceptor.ts'), httpMetricsContent);
+    // Business metrics service
+    const businessMetricsContent = `import { Injectable } from '@nestjs/common';
+import { MetricsRegistry } from './metrics-registry';
+import { Counter, Gauge, Histogram } from 'prom-client';
+
+/**
+ * Business-specific metrics for ${pascalName}
+ */
+@Injectable()
+export class ${pascalName}MetricsService {
+  // Counters
+  private readonly operationsTotal: Counter<string>;
+  private readonly errorsTotal: Counter<string>;
+  private readonly eventsProcessed: Counter<string>;
+
+  // Gauges
+  private readonly activeUsers: Gauge<string>;
+  private readonly queueSize: Gauge<string>;
+  private readonly cacheHitRatio: Gauge<string>;
+
+  // Histograms
+  private readonly operationDuration: Histogram<string>;
+  private readonly payloadSize: Histogram<string>;
+
+  constructor(private readonly metricsRegistry: MetricsRegistry) {
+    // Initialize counters
+    this.operationsTotal = this.metricsRegistry.counter({
+      name: '${camelName}_operations_total',
+      help: 'Total number of ${camelName} operations',
+      labelNames: ['operation', 'status'],
+    });
+
+    this.errorsTotal = this.metricsRegistry.counter({
+      name: '${camelName}_errors_total',
+      help: 'Total number of ${camelName} errors',
+      labelNames: ['operation', 'error_type'],
+    });
+
+    this.eventsProcessed = this.metricsRegistry.counter({
+      name: '${camelName}_events_processed_total',
+      help: 'Total number of events processed',
+      labelNames: ['event_type'],
+    });
+
+    // Initialize gauges
+    this.activeUsers = this.metricsRegistry.gauge({
+      name: '${camelName}_active_users',
+      help: 'Number of currently active users',
+    });
+
+    this.queueSize = this.metricsRegistry.gauge({
+      name: '${camelName}_queue_size',
+      help: 'Current size of processing queue',
+      labelNames: ['queue_name'],
+    });
+
+    this.cacheHitRatio = this.metricsRegistry.gauge({
+      name: '${camelName}_cache_hit_ratio',
+      help: 'Cache hit ratio (0-1)',
+      labelNames: ['cache_name'],
+    });
+
+    // Initialize histograms
+    this.operationDuration = this.metricsRegistry.histogram({
+      name: '${camelName}_operation_duration_seconds',
+      help: 'Duration of ${camelName} operations',
+      labelNames: ['operation'],
+      buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10],
+    });
+
+    this.payloadSize = this.metricsRegistry.histogram({
+      name: '${camelName}_payload_size_bytes',
+      help: 'Size of ${camelName} payloads',
+      labelNames: ['operation'],
+      buckets: [100, 500, 1000, 5000, 10000, 50000, 100000],
+    });
+  }
+
+  // ==================
+  // Counter Methods
+  // ==================
+
+  /**
+   * Increment operation counter
+   */
+  recordOperation(operation: string, status: 'success' | 'failure'): void {
+    this.operationsTotal.inc({ operation, status });
+  }
+
+  /**
+   * Record an error
+   */
+  recordError(operation: string, errorType: string): void {
+    this.errorsTotal.inc({ operation, error_type: errorType });
+  }
+
+  /**
+   * Record event processing
+   */
+  recordEventProcessed(eventType: string): void {
+    this.eventsProcessed.inc({ event_type: eventType });
+  }
+
+  // ==================
+  // Gauge Methods
+  // ==================
+
+  /**
+   * Set active users count
+   */
+  setActiveUsers(count: number): void {
+    this.activeUsers.set(count);
+  }
+
+  /**
+   * Update queue size
+   */
+  setQueueSize(queueName: string, size: number): void {
+    this.queueSize.set({ queue_name: queueName }, size);
+  }
+
+  /**
+   * Update cache hit ratio
+   */
+  setCacheHitRatio(cacheName: string, ratio: number): void {
+    this.cacheHitRatio.set({ cache_name: cacheName }, Math.min(1, Math.max(0, ratio)));
+  }
+
+  // ==================
+  // Histogram Methods
+  // ==================
+
+  /**
+   * Record operation duration
+   */
+  recordOperationDuration(operation: string, durationSeconds: number): void {
+    this.operationDuration.observe({ operation }, durationSeconds);
+  }
+
+  /**
+   * Record payload size
+   */
+  recordPayloadSize(operation: string, sizeBytes: number): void {
+    this.payloadSize.observe({ operation }, sizeBytes);
+  }
+
+  /**
+   * Create a timer for measuring operation duration
+   */
+  startTimer(operation: string): () => void {
+    const startTime = process.hrtime();
+    return () => {
+      const [seconds, nanoseconds] = process.hrtime(startTime);
+      const duration = seconds + nanoseconds / 1e9;
+      this.recordOperationDuration(operation, duration);
+    };
+  }
+}
+`;
+    fs.writeFileSync(path.join(baseDir, `${kebabName}-metrics.service.ts`), businessMetricsContent);
+    // Metrics controller
+    const metricsControllerContent = `import { Controller, Get, Res, Header } from '@nestjs/common';
+import { Response } from 'express';
+import { MetricsRegistry } from './metrics-registry';
+
+/**
+ * Prometheus metrics endpoint
+ */
+@Controller('metrics')
+export class MetricsController {
+  constructor(private readonly metricsRegistry: MetricsRegistry) {}
+
+  /**
+   * Get metrics in Prometheus format
+   */
+  @Get()
+  @Header('Content-Type', 'text/plain; version=0.0.4; charset=utf-8')
+  async getMetrics(@Res() res: Response): Promise<void> {
+    const metrics = await this.metricsRegistry.getMetrics();
+    res.send(metrics);
+  }
+
+  /**
+   * Get metrics as JSON (for debugging)
+   */
+  @Get('json')
+  async getMetricsJson(): Promise<object> {
+    return this.metricsRegistry.getMetricsAsJson();
+  }
+}
+`;
+    fs.writeFileSync(path.join(baseDir, 'metrics.controller.ts'), metricsControllerContent);
+    // Metrics decorator
+    const metricsDecoratorContent = `import { SetMetadata } from '@nestjs/common';
+
+export const METRICS_KEY = 'metrics';
+
+export interface MetricsOptions {
+  name?: string;
+  labels?: Record<string, string>;
+  recordDuration?: boolean;
+  recordPayloadSize?: boolean;
+}
+
+/**
+ * Decorator to automatically record metrics for a method
+ */
+export function RecordMetrics(options: MetricsOptions = {}): MethodDecorator {
+  return SetMetadata(METRICS_KEY, options);
+}
+
+/**
+ * Decorator to skip metrics recording
+ */
+export function SkipMetrics(): MethodDecorator {
+  return SetMetadata(METRICS_KEY, { skip: true });
+}
+`;
+    fs.writeFileSync(path.join(baseDir, 'metrics.decorator.ts'), metricsDecoratorContent);
+    // Metrics module
+    const metricsModuleContent = `import { Module, Global } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { MetricsRegistry } from './metrics-registry';
+import { MetricsController } from './metrics.controller';
+import { HttpMetricsInterceptor } from './http-metrics.interceptor';
+import { ${pascalName}MetricsService } from './${kebabName}-metrics.service';
+
+@Global()
+@Module({
+  controllers: [MetricsController],
+  providers: [
+    MetricsRegistry,
+    ${pascalName}MetricsService,
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: HttpMetricsInterceptor,
+    },
+  ],
+  exports: [MetricsRegistry, ${pascalName}MetricsService],
+})
+export class ${pascalName}MetricsModule {}
+`;
+    fs.writeFileSync(path.join(baseDir, 'metrics.module.ts'), metricsModuleContent);
+    // Grafana dashboard JSON
+    const grafanaDashboardContent = `{
+  "annotations": {
+    "list": []
+  },
+  "title": "${pascalName} Metrics Dashboard",
+  "uid": "${kebabName}-metrics",
+  "version": 1,
+  "panels": [
+    {
+      "title": "Request Rate",
+      "type": "graph",
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 0 },
+      "targets": [
+        {
+          "expr": "rate(http_requests_total{app=\\"${kebabName}\\"}[5m])",
+          "legendFormat": "{{method}} {{path}}"
+        }
+      ]
+    },
+    {
+      "title": "Request Duration (p99)",
+      "type": "graph",
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 0 },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{app=\\"${kebabName}\\"}[5m]))",
+          "legendFormat": "{{method}} {{path}}"
+        }
+      ]
+    },
+    {
+      "title": "Error Rate",
+      "type": "graph",
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 8 },
+      "targets": [
+        {
+          "expr": "rate(${camelName}_errors_total[5m])",
+          "legendFormat": "{{operation}} - {{error_type}}"
+        }
+      ]
+    },
+    {
+      "title": "Active Users",
+      "type": "stat",
+      "gridPos": { "h": 4, "w": 6, "x": 12, "y": 8 },
+      "targets": [
+        {
+          "expr": "${camelName}_active_users",
+          "legendFormat": "Active Users"
+        }
+      ]
+    },
+    {
+      "title": "Cache Hit Ratio",
+      "type": "gauge",
+      "gridPos": { "h": 4, "w": 6, "x": 18, "y": 8 },
+      "targets": [
+        {
+          "expr": "${camelName}_cache_hit_ratio",
+          "legendFormat": "{{cache_name}}"
+        }
+      ]
+    },
+    {
+      "title": "Memory Usage",
+      "type": "graph",
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 16 },
+      "targets": [
+        {
+          "expr": "${camelName}_nodejs_heap_size_used_bytes / 1024 / 1024",
+          "legendFormat": "Heap Used (MB)"
+        },
+        {
+          "expr": "${camelName}_nodejs_external_memory_bytes / 1024 / 1024",
+          "legendFormat": "External (MB)"
+        }
+      ]
+    },
+    {
+      "title": "Event Loop Lag",
+      "type": "graph",
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 16 },
+      "targets": [
+        {
+          "expr": "${camelName}_nodejs_eventloop_lag_seconds",
+          "legendFormat": "Event Loop Lag"
+        }
+      ]
+    }
+  ]
+}
+`;
+    fs.writeFileSync(path.join(baseDir, 'grafana-dashboard.json'), grafanaDashboardContent);
+    console.log(chalk_1.default.green(`  ✓ Created metrics registry`));
+    console.log(chalk_1.default.green(`  ✓ Created HTTP metrics interceptor`));
+    console.log(chalk_1.default.green(`  ✓ Created ${kebabName}-metrics.service.ts`));
+    console.log(chalk_1.default.green(`  ✓ Created metrics controller`));
+    console.log(chalk_1.default.green(`  ✓ Created metrics decorator`));
+    console.log(chalk_1.default.green(`  ✓ Created metrics module`));
+    console.log(chalk_1.default.green(`  ✓ Created Grafana dashboard`));
+    console.log(chalk_1.default.bold.green(`\n✅ Prometheus metrics setup complete for ${pascalName}`));
+    console.log(chalk_1.default.cyan(`Generated files in: ${baseDir}`));
+    console.log(chalk_1.default.gray('  - metrics-registry.ts (Prometheus registry)'));
+    console.log(chalk_1.default.gray('  - http-metrics.interceptor.ts (HTTP metrics)'));
+    console.log(chalk_1.default.gray(`  - ${kebabName}-metrics.service.ts (Business metrics)`));
+    console.log(chalk_1.default.gray('  - metrics.controller.ts (/metrics endpoint)'));
+    console.log(chalk_1.default.gray('  - metrics.decorator.ts (Metrics decorators)'));
+    console.log(chalk_1.default.gray('  - metrics.module.ts (Module definition)'));
+    console.log(chalk_1.default.gray('  - grafana-dashboard.json (Grafana dashboard)'));
+}
+//# sourceMappingURL=metrics-prometheus.js.map

package/dist/commands/metrics-prometheus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-prometheus.js","sourceRoot":"","sources":["../../src/commands/metrics-prometheus.ts"],"names":[],"mappings":"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"}

package/dist/commands/migration-engine.d.ts

@@ -0,0 +1,6 @@
+export interface MigrationEngineOptions {
+    path?: string;
+    orm?: 'typeorm' | 'prisma';
+    dryRun?: boolean;
+}
+export declare function diffMigration(basePath: string, options?: MigrationEngineOptions): Promise<void>;