nestjs-ddd-cli 2.2.1 → 3.2.1

package/dist/commands/api-versioning.js

@@ -0,0 +1,643 @@
+"use strict";
+/**
+ * API Versioning & Backward Compatibility Engine
+ * Generates versioned APIs with deprecation handling
+ */
+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.setupApiVersioning = setupApiVersioning;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+async function setupApiVersioning(basePath, options = {}) {
+    console.log(chalk_1.default.bold.blue('\n📦 Setting up API Versioning\n'));
+    const sharedPath = path.join(basePath, 'src/shared/versioning');
+    if (!fs.existsSync(sharedPath)) {
+        fs.mkdirSync(sharedPath, { recursive: true });
+    }
+    // Generate versioning module
+    const moduleContent = generateVersioningModule(options);
+    fs.writeFileSync(path.join(sharedPath, 'versioning.module.ts'), moduleContent);
+    console.log(chalk_1.default.green(`  ✓ Created versioning module`));
+    // Generate version interceptor
+    const interceptorContent = generateVersionInterceptor();
+    fs.writeFileSync(path.join(sharedPath, 'version.interceptor.ts'), interceptorContent);
+    console.log(chalk_1.default.green(`  ✓ Created version interceptor`));
+    // Generate deprecation handler
+    const deprecationContent = generateDeprecationHandler();
+    fs.writeFileSync(path.join(sharedPath, 'deprecation.handler.ts'), deprecationContent);
+    console.log(chalk_1.default.green(`  ✓ Created deprecation handler`));
+    // Generate versioned controller decorator
+    const decoratorContent = generateVersionedDecorator();
+    fs.writeFileSync(path.join(sharedPath, 'versioned.decorator.ts'), decoratorContent);
+    console.log(chalk_1.default.green(`  ✓ Created versioned decorator`));
+    // Generate DTO migrator
+    const migratorContent = generateDtoMigrator();
+    fs.writeFileSync(path.join(sharedPath, 'dto-migrator.ts'), migratorContent);
+    console.log(chalk_1.default.green(`  ✓ Created DTO migrator`));
+    // Generate version registry
+    const registryContent = generateVersionRegistry();
+    fs.writeFileSync(path.join(sharedPath, 'version.registry.ts'), registryContent);
+    console.log(chalk_1.default.green(`  ✓ Created version registry`));
+    console.log(chalk_1.default.bold.green('\n✅ API versioning setup complete!\n'));
+}
+function generateVersioningModule(options) {
+    const strategy = options.strategy || 'uri';
+    const version = options.currentVersion || '1';
+    return `import { Module, Global, DynamicModule } from '@nestjs/common';
+import { APP_INTERCEPTOR, APP_GUARD } from '@nestjs/core';
+import { VersionInterceptor } from './version.interceptor';
+import { DeprecationHandler } from './deprecation.handler';
+import { VersionRegistry } from './version.registry';
+import { DtoMigrator } from './dto-migrator';
+
+export interface VersioningModuleOptions {
+  strategy: 'uri' | 'header' | 'query';
+  defaultVersion: string;
+  supportedVersions: string[];
+  deprecatedVersions?: string[];
+  sunsetVersions?: { version: string; sunsetDate: Date }[];
+}
+
+@Global()
+@Module({})
+export class VersioningModule {
+  static forRoot(options: VersioningModuleOptions): DynamicModule {
+    return {
+      module: VersioningModule,
+      providers: [
+        {
+          provide: 'VERSIONING_OPTIONS',
+          useValue: options,
+        },
+        VersionRegistry,
+        DtoMigrator,
+        DeprecationHandler,
+        {
+          provide: APP_INTERCEPTOR,
+          useClass: VersionInterceptor,
+        },
+      ],
+      exports: [VersionRegistry, DtoMigrator, DeprecationHandler],
+    };
+  }
+}
+
+/**
+ * Default versioning configuration
+ */
+export const DEFAULT_VERSIONING_OPTIONS: VersioningModuleOptions = {
+  strategy: '${strategy}',
+  defaultVersion: '${version}',
+  supportedVersions: ['1', '2'],
+  deprecatedVersions: [],
+  sunsetVersions: [],
+};
+`;
+}
+function generateVersionInterceptor() {
+    return `import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  Inject,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { DeprecationHandler } from './deprecation.handler';
+
+@Injectable()
+export class VersionInterceptor implements NestInterceptor {
+  constructor(
+    @Inject('VERSIONING_OPTIONS') private readonly options: any,
+    private readonly deprecationHandler: DeprecationHandler,
+  ) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const response = context.switchToHttp().getResponse();
+    const version = this.extractVersion(request);
+
+    // Set version header in response
+    response.setHeader('X-API-Version', version);
+
+    // Check for deprecation
+    const deprecationInfo = this.deprecationHandler.check(version);
+    if (deprecationInfo.deprecated) {
+      response.setHeader('X-API-Deprecated', 'true');
+      response.setHeader('X-API-Sunset', deprecationInfo.sunsetDate?.toISOString() || '');
+      response.setHeader('X-API-Deprecation-Notice', deprecationInfo.message || '');
+    }
+
+    // Add supported versions header
+    response.setHeader('X-API-Supported-Versions', this.options.supportedVersions.join(', '));
+
+    return next.handle().pipe(
+      tap(() => {
+        // Log version usage for analytics
+        this.logVersionUsage(version, request.path);
+      }),
+    );
+  }
+
+  private extractVersion(request: any): string {
+    switch (this.options.strategy) {
+      case 'header':
+        return request.headers['x-api-version'] || this.options.defaultVersion;
+      case 'query':
+        return request.query.version || this.options.defaultVersion;
+      case 'uri':
+      default:
+        // Extract from URL path like /v1/resource
+        const match = request.path.match(/\\/v(\\d+)\\//);
+        return match ? match[1] : this.options.defaultVersion;
+    }
+  }
+
+  private logVersionUsage(version: string, path: string): void {
+    // Implement version usage logging/analytics
+  }
+}
+`;
+}
+function generateDeprecationHandler() {
+    return `import { Injectable, Inject, Logger } from '@nestjs/common';
+
+export interface DeprecationInfo {
+  deprecated: boolean;
+  sunsetDate?: Date;
+  message?: string;
+  replacementVersion?: string;
+}
+
+@Injectable()
+export class DeprecationHandler {
+  private readonly logger = new Logger(DeprecationHandler.name);
+
+  constructor(@Inject('VERSIONING_OPTIONS') private readonly options: any) {}
+
+  /**
+   * Check if a version is deprecated
+   */
+  check(version: string): DeprecationInfo {
+    // Check if version is in deprecated list
+    if (this.options.deprecatedVersions?.includes(version)) {
+      const sunsetInfo = this.options.sunsetVersions?.find(
+        (s: any) => s.version === version,
+      );
+
+      return {
+        deprecated: true,
+        sunsetDate: sunsetInfo?.sunsetDate,
+        message: \`API version \${version} is deprecated. Please upgrade to version \${this.options.defaultVersion}.\`,
+        replacementVersion: this.options.defaultVersion,
+      };
+    }
+
+    return { deprecated: false };
+  }
+
+  /**
+   * Check if a version is sunsetted (no longer available)
+   */
+  isSunsetted(version: string): boolean {
+    const sunsetInfo = this.options.sunsetVersions?.find(
+      (s: any) => s.version === version,
+    );
+
+    if (sunsetInfo && new Date() > sunsetInfo.sunsetDate) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get deprecation notice for documentation
+   */
+  getDeprecationNotice(version: string): string | null {
+    const info = this.check(version);
+    if (!info.deprecated) return null;
+
+    let notice = \`This API version (\${version}) is deprecated.\`;
+
+    if (info.sunsetDate) {
+      notice += \` It will be removed on \${info.sunsetDate.toISOString().split('T')[0]}.\`;
+    }
+
+    if (info.replacementVersion) {
+      notice += \` Please migrate to version \${info.replacementVersion}.\`;
+    }
+
+    return notice;
+  }
+}
+
+/**
+ * Deprecated decorator for marking deprecated endpoints
+ */
+export function Deprecated(options?: {
+  version?: string;
+  replacement?: string;
+  sunsetDate?: Date;
+}): MethodDecorator {
+  return function (
+    target: any,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    Reflect.defineMetadata('deprecated', true, target, propertyKey);
+    Reflect.defineMetadata('deprecatedOptions', options || {}, target, propertyKey);
+    return descriptor;
+  };
+}
+`;
+}
+function generateVersionedDecorator() {
+    return `import { Controller, applyDecorators, SetMetadata } from '@nestjs/common';
+import { ApiTags, ApiHeader } from '@nestjs/swagger';
+
+/**
+ * Versioned controller decorator
+ * Creates a controller with version prefix
+ */
+export function VersionedController(
+  path: string,
+  version: string | string[],
+  options?: { deprecated?: boolean },
+): ClassDecorator {
+  const versions = Array.isArray(version) ? version : [version];
+
+  return applyDecorators(
+    Controller({
+      path,
+      version: versions,
+    }),
+    SetMetadata('apiVersion', versions),
+    ApiTags(\`v\${versions.join(', v')} - \${path}\`),
+    ApiHeader({
+      name: 'X-API-Version',
+      description: 'API version',
+      required: false,
+    }),
+    ...(options?.deprecated
+      ? [SetMetadata('deprecated', true)]
+      : []),
+  );
+}
+
+/**
+ * Version decorator for individual endpoints
+ */
+export function Version(version: string | string[]): MethodDecorator {
+  return SetMetadata('version', Array.isArray(version) ? version : [version]);
+}
+
+/**
+ * Sunset decorator for endpoints being removed
+ */
+export function Sunset(date: Date, message?: string): MethodDecorator {
+  return function (
+    target: any,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    Reflect.defineMetadata('sunsetDate', date, target, propertyKey);
+    Reflect.defineMetadata('sunsetMessage', message, target, propertyKey);
+    return descriptor;
+  };
+}
+
+/**
+ * Since decorator for documenting when an endpoint was added
+ */
+export function Since(version: string): MethodDecorator {
+  return SetMetadata('sinceVersion', version);
+}
+
+/**
+ * Until decorator for documenting when an endpoint will be removed
+ */
+export function Until(version: string): MethodDecorator {
+  return SetMetadata('untilVersion', version);
+}
+`;
+}
+function generateDtoMigrator() {
+    return `import { Injectable, Logger } from '@nestjs/common';
+
+/**
+ * DTO Migrator
+ * Handles transformation between different API versions
+ */
+@Injectable()
+export class DtoMigrator {
+  private readonly logger = new Logger(DtoMigrator.name);
+  private readonly migrations = new Map<string, MigrationDefinition[]>();
+
+  /**
+   * Register a migration between versions
+   */
+  register<TFrom, TTo>(
+    dtoName: string,
+    fromVersion: string,
+    toVersion: string,
+    migrate: (data: TFrom) => TTo,
+    rollback?: (data: TTo) => TFrom,
+  ): void {
+    const key = \`\${dtoName}:\${fromVersion}:\${toVersion}\`;
+    const existing = this.migrations.get(dtoName) || [];
+
+    existing.push({
+      fromVersion,
+      toVersion,
+      migrate,
+      rollback,
+    });
+
+    this.migrations.set(dtoName, existing);
+    this.logger.debug(\`Registered migration: \${key}\`);
+  }
+
+  /**
+   * Migrate DTO from one version to another
+   */
+  migrate<T>(dtoName: string, data: any, fromVersion: string, toVersion: string): T {
+    if (fromVersion === toVersion) {
+      return data as T;
+    }
+
+    const migrations = this.migrations.get(dtoName);
+    if (!migrations) {
+      this.logger.warn(\`No migrations found for \${dtoName}\`);
+      return data as T;
+    }
+
+    // Find migration path
+    const path = this.findMigrationPath(migrations, fromVersion, toVersion);
+    if (!path.length) {
+      throw new Error(\`No migration path found from v\${fromVersion} to v\${toVersion} for \${dtoName}\`);
+    }
+
+    // Apply migrations in sequence
+    let result = data;
+    for (const migration of path) {
+      result = migration.migrate(result);
+    }
+
+    return result as T;
+  }
+
+  /**
+   * Rollback DTO from newer version to older
+   */
+  rollback<T>(dtoName: string, data: any, fromVersion: string, toVersion: string): T {
+    if (fromVersion === toVersion) {
+      return data as T;
+    }
+
+    const migrations = this.migrations.get(dtoName);
+    if (!migrations) {
+      return data as T;
+    }
+
+    // Find rollback path (reverse)
+    const path = this.findMigrationPath(migrations, toVersion, fromVersion);
+    if (!path.length) {
+      throw new Error(\`No rollback path found from v\${fromVersion} to v\${toVersion} for \${dtoName}\`);
+    }
+
+    // Apply rollbacks in reverse sequence
+    let result = data;
+    for (const migration of path.reverse()) {
+      if (!migration.rollback) {
+        throw new Error(\`Rollback not supported for \${dtoName} migration\`);
+      }
+      result = migration.rollback(result);
+    }
+
+    return result as T;
+  }
+
+  private findMigrationPath(
+    migrations: MigrationDefinition[],
+    fromVersion: string,
+    toVersion: string,
+  ): MigrationDefinition[] {
+    // Simple linear path finding (for more complex scenarios, use graph algorithms)
+    const path: MigrationDefinition[] = [];
+    let currentVersion = fromVersion;
+
+    while (currentVersion !== toVersion) {
+      const migration = migrations.find(m => m.fromVersion === currentVersion);
+      if (!migration) break;
+
+      path.push(migration);
+      currentVersion = migration.toVersion;
+    }
+
+    return path;
+  }
+}
+
+interface MigrationDefinition {
+  fromVersion: string;
+  toVersion: string;
+  migrate: (data: any) => any;
+  rollback?: (data: any) => any;
+}
+
+/**
+ * DTO version decorator
+ */
+export function DtoVersion(version: string): ClassDecorator {
+  return function (target: Function) {
+    Reflect.defineMetadata('dtoVersion', version, target);
+  };
+}
+
+/**
+ * Property migration decorator
+ */
+export function Migrated(options: {
+  from?: string;
+  to?: string;
+  transformer?: (value: any) => any;
+}): PropertyDecorator {
+  return function (target: Object, propertyKey: string | symbol) {
+    const existing = Reflect.getMetadata('migratedProperties', target.constructor) || [];
+    existing.push({ propertyKey, ...options });
+    Reflect.defineMetadata('migratedProperties', existing, target.constructor);
+  };
+}
+`;
+}
+function generateVersionRegistry() {
+    return `import { Injectable, Inject, Logger } from '@nestjs/common';
+
+/**
+ * Version Registry
+ * Tracks API versions and their metadata
+ */
+@Injectable()
+export class VersionRegistry {
+  private readonly logger = new Logger(VersionRegistry.name);
+  private readonly versions = new Map<string, VersionMetadata>();
+
+  constructor(@Inject('VERSIONING_OPTIONS') private readonly options: any) {
+    this.initializeVersions();
+  }
+
+  private initializeVersions(): void {
+    for (const version of this.options.supportedVersions) {
+      this.versions.set(version, {
+        version,
+        status: this.getVersionStatus(version),
+        releaseDate: new Date(), // Should be loaded from config
+        endpoints: [],
+      });
+    }
+  }
+
+  private getVersionStatus(version: string): VersionStatus {
+    if (this.options.deprecatedVersions?.includes(version)) {
+      return 'deprecated';
+    }
+    if (version === this.options.defaultVersion) {
+      return 'current';
+    }
+    return 'supported';
+  }
+
+  /**
+   * Register an endpoint for a version
+   */
+  registerEndpoint(version: string, endpoint: EndpointMetadata): void {
+    const versionMeta = this.versions.get(version);
+    if (versionMeta) {
+      versionMeta.endpoints.push(endpoint);
+    }
+  }
+
+  /**
+   * Get all versions with their metadata
+   */
+  getAllVersions(): VersionMetadata[] {
+    return Array.from(this.versions.values());
+  }
+
+  /**
+   * Get specific version metadata
+   */
+  getVersion(version: string): VersionMetadata | undefined {
+    return this.versions.get(version);
+  }
+
+  /**
+   * Check if version is supported
+   */
+  isSupported(version: string): boolean {
+    return this.options.supportedVersions.includes(version);
+  }
+
+  /**
+   * Get current/default version
+   */
+  getCurrentVersion(): string {
+    return this.options.defaultVersion;
+  }
+
+  /**
+   * Generate version documentation
+   */
+  generateDocs(): VersionDocumentation {
+    return {
+      currentVersion: this.options.defaultVersion,
+      supportedVersions: this.options.supportedVersions,
+      deprecatedVersions: this.options.deprecatedVersions || [],
+      versions: this.getAllVersions().map(v => ({
+        version: v.version,
+        status: v.status,
+        releaseDate: v.releaseDate?.toISOString(),
+        endpointCount: v.endpoints.length,
+      })),
+    };
+  }
+}
+
+export type VersionStatus = 'current' | 'supported' | 'deprecated' | 'sunset';
+
+export interface VersionMetadata {
+  version: string;
+  status: VersionStatus;
+  releaseDate?: Date;
+  sunsetDate?: Date;
+  endpoints: EndpointMetadata[];
+}
+
+export interface EndpointMetadata {
+  path: string;
+  method: string;
+  handler: string;
+  deprecated?: boolean;
+  since?: string;
+  until?: string;
+}
+
+export interface VersionDocumentation {
+  currentVersion: string;
+  supportedVersions: string[];
+  deprecatedVersions: string[];
+  versions: {
+    version: string;
+    status: VersionStatus;
+    releaseDate?: string;
+    endpointCount: number;
+  }[];
+}
+`;
+}
+// Helper functions
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+//# sourceMappingURL=api-versioning.js.map

package/dist/commands/api-versioning.js.map

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

package/dist/commands/audit-logging.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Audit Logging & Compliance Framework Generator
+ * Generates comprehensive audit trail infrastructure
+ */
+export interface AuditLoggingOptions {
+    path?: string;
+    storage?: 'database' | 'file' | 'elasticsearch';
+}
+export declare function setupAuditLogging(basePath: string, options?: AuditLoggingOptions): Promise<void>;