nestjs-ddd-cli 2.2.0 → 3.2.1

package/dist/commands/i18n-setup.js

@@ -0,0 +1,677 @@
+"use strict";
+/**
+ * Internationalization (i18n) & Localization Engine Generator
+ * Generates comprehensive i18n infrastructure
+ */
+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.setupI18n = setupI18n;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+async function setupI18n(basePath, options = {}) {
+    console.log(chalk_1.default.bold.blue('\n🌍 Setting up i18n Infrastructure\n'));
+    const sharedPath = path.join(basePath, 'src/shared/i18n');
+    const localesPath = path.join(basePath, 'src/locales');
+    for (const dir of [sharedPath, localesPath]) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    // Generate i18n module
+    const moduleContent = generateI18nModule(options);
+    fs.writeFileSync(path.join(sharedPath, 'i18n.module.ts'), moduleContent);
+    console.log(chalk_1.default.green(`  ✓ Created i18n module`));
+    // Generate i18n service
+    const serviceContent = generateI18nService();
+    fs.writeFileSync(path.join(sharedPath, 'i18n.service.ts'), serviceContent);
+    console.log(chalk_1.default.green(`  ✓ Created i18n service`));
+    // Generate translation loader
+    const loaderContent = generateTranslationLoader();
+    fs.writeFileSync(path.join(sharedPath, 'translation.loader.ts'), loaderContent);
+    console.log(chalk_1.default.green(`  ✓ Created translation loader`));
+    // Generate locale interceptor
+    const interceptorContent = generateLocaleInterceptor();
+    fs.writeFileSync(path.join(sharedPath, 'locale.interceptor.ts'), interceptorContent);
+    console.log(chalk_1.default.green(`  ✓ Created locale interceptor`));
+    // Generate i18n decorators
+    const decoratorContent = generateI18nDecorators();
+    fs.writeFileSync(path.join(sharedPath, 'i18n.decorators.ts'), decoratorContent);
+    console.log(chalk_1.default.green(`  ✓ Created i18n decorators`));
+    // Generate sample locale files
+    generateSampleLocales(localesPath, options);
+    console.log(chalk_1.default.bold.green('\n✅ i18n infrastructure ready!\n'));
+}
+function generateI18nModule(options) {
+    const defaultLocale = options.defaultLocale || 'en';
+    const supportedLocales = options.supportedLocales || ['en', 'fr', 'es'];
+    return `import { Module, Global, DynamicModule } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { I18nService } from './i18n.service';
+import { TranslationLoader } from './translation.loader';
+import { LocaleInterceptor } from './locale.interceptor';
+
+export interface I18nModuleOptions {
+  defaultLocale: string;
+  supportedLocales: string[];
+  fallbackLocale?: string;
+  localesPath: string;
+  resolvers?: LocaleResolver[];
+  enableCaching?: boolean;
+}
+
+export type LocaleResolver = 'header' | 'query' | 'cookie' | 'accept-language';
+
+@Global()
+@Module({})
+export class I18nModule {
+  static forRoot(options: I18nModuleOptions): DynamicModule {
+    return {
+      module: I18nModule,
+      providers: [
+        {
+          provide: 'I18N_OPTIONS',
+          useValue: options,
+        },
+        TranslationLoader,
+        I18nService,
+        {
+          provide: APP_INTERCEPTOR,
+          useClass: LocaleInterceptor,
+        },
+      ],
+      exports: [I18nService, TranslationLoader],
+    };
+  }
+}
+
+/**
+ * Default i18n configuration
+ */
+export const DEFAULT_I18N_OPTIONS: Partial<I18nModuleOptions> = {
+  defaultLocale: '${defaultLocale}',
+  supportedLocales: ${JSON.stringify(supportedLocales)},
+  fallbackLocale: '${defaultLocale}',
+  resolvers: ['header', 'accept-language'],
+  enableCaching: true,
+};
+`;
+}
+function generateI18nService() {
+    return `import { Injectable, Inject, Logger, OnModuleInit } from '@nestjs/common';
+import { TranslationLoader } from './translation.loader';
+
+export interface TranslateOptions {
+  locale?: string;
+  defaultValue?: string;
+  args?: Record<string, any>;
+  count?: number;
+}
+
+@Injectable()
+export class I18nService implements OnModuleInit {
+  private readonly logger = new Logger(I18nService.name);
+  private currentLocale: string;
+  private translations: Map<string, Record<string, any>> = new Map();
+
+  constructor(
+    @Inject('I18N_OPTIONS') private readonly options: any,
+    private readonly loader: TranslationLoader,
+  ) {
+    this.currentLocale = options.defaultLocale;
+  }
+
+  async onModuleInit() {
+    await this.loadTranslations();
+  }
+
+  private async loadTranslations(): Promise<void> {
+    for (const locale of this.options.supportedLocales) {
+      try {
+        const translations = await this.loader.load(locale);
+        this.translations.set(locale, translations);
+        this.logger.log(\`Loaded translations for locale: \${locale}\`);
+      } catch (error) {
+        this.logger.warn(\`Failed to load translations for locale: \${locale}\`);
+      }
+    }
+  }
+
+  /**
+   * Translate a key
+   */
+  t(key: string, options?: TranslateOptions): string {
+    const locale = options?.locale || this.currentLocale;
+    const translations = this.translations.get(locale);
+
+    if (!translations) {
+      return this.fallback(key, options);
+    }
+
+    let value = this.getNestedValue(translations, key);
+
+    if (value === undefined) {
+      return this.fallback(key, options);
+    }
+
+    // Handle pluralization
+    if (typeof value === 'object' && options?.count !== undefined) {
+      value = this.pluralize(value, options.count);
+    }
+
+    // Handle interpolation
+    if (options?.args) {
+      value = this.interpolate(value, options.args);
+    }
+
+    return value;
+  }
+
+  /**
+   * Translate with context
+   */
+  translate(key: string, options?: TranslateOptions): string {
+    return this.t(key, options);
+  }
+
+  /**
+   * Check if translation exists
+   */
+  exists(key: string, locale?: string): boolean {
+    const translations = this.translations.get(locale || this.currentLocale);
+    return translations ? this.getNestedValue(translations, key) !== undefined : false;
+  }
+
+  /**
+   * Get all translations for a namespace
+   */
+  getNamespace(namespace: string, locale?: string): Record<string, any> {
+    const translations = this.translations.get(locale || this.currentLocale);
+    return translations ? this.getNestedValue(translations, namespace) || {} : {};
+  }
+
+  /**
+   * Set current locale
+   */
+  setLocale(locale: string): void {
+    if (this.options.supportedLocales.includes(locale)) {
+      this.currentLocale = locale;
+    } else {
+      this.logger.warn(\`Unsupported locale: \${locale}\`);
+    }
+  }
+
+  /**
+   * Get current locale
+   */
+  getLocale(): string {
+    return this.currentLocale;
+  }
+
+  /**
+   * Get supported locales
+   */
+  getSupportedLocales(): string[] {
+    return this.options.supportedLocales;
+  }
+
+  /**
+   * Format date
+   */
+  formatDate(date: Date, format?: Intl.DateTimeFormatOptions, locale?: string): string {
+    return new Intl.DateTimeFormat(locale || this.currentLocale, format).format(date);
+  }
+
+  /**
+   * Format number
+   */
+  formatNumber(value: number, options?: Intl.NumberFormatOptions, locale?: string): string {
+    return new Intl.NumberFormat(locale || this.currentLocale, options).format(value);
+  }
+
+  /**
+   * Format currency
+   */
+  formatCurrency(amount: number, currency: string, locale?: string): string {
+    return new Intl.NumberFormat(locale || this.currentLocale, {
+      style: 'currency',
+      currency,
+    }).format(amount);
+  }
+
+  /**
+   * Format relative time
+   */
+  formatRelativeTime(value: number, unit: Intl.RelativeTimeFormatUnit, locale?: string): string {
+    return new Intl.RelativeTimeFormat(locale || this.currentLocale, {
+      numeric: 'auto',
+    }).format(value, unit);
+  }
+
+  private fallback(key: string, options?: TranslateOptions): string {
+    // Try fallback locale
+    if (this.options.fallbackLocale && this.options.fallbackLocale !== this.currentLocale) {
+      const fallbackTranslations = this.translations.get(this.options.fallbackLocale);
+      if (fallbackTranslations) {
+        const value = this.getNestedValue(fallbackTranslations, key);
+        if (value !== undefined) {
+          return typeof value === 'string' ? value : key;
+        }
+      }
+    }
+
+    return options?.defaultValue || key;
+  }
+
+  private getNestedValue(obj: Record<string, any>, path: string): any {
+    return path.split('.').reduce((current, key) => {
+      return current && current[key] !== undefined ? current[key] : undefined;
+    }, obj);
+  }
+
+  private pluralize(value: Record<string, string>, count: number): string {
+    if (count === 0 && value.zero) return value.zero;
+    if (count === 1 && value.one) return value.one;
+    if (value.other) return value.other;
+    return Object.values(value)[0] || '';
+  }
+
+  private interpolate(text: string, args: Record<string, any>): string {
+    return text.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => {
+      return args[key] !== undefined ? String(args[key]) : match;
+    });
+  }
+
+  /**
+   * Reload translations
+   */
+  async reload(): Promise<void> {
+    this.translations.clear();
+    await this.loadTranslations();
+  }
+}
+`;
+}
+function generateTranslationLoader() {
+    return `import { Injectable, Inject, Logger } from '@nestjs/common';
+import * as fs from 'fs';
+import * as path from 'path';
+
+@Injectable()
+export class TranslationLoader {
+  private readonly logger = new Logger(TranslationLoader.name);
+  private cache: Map<string, Record<string, any>> = new Map();
+
+  constructor(@Inject('I18N_OPTIONS') private readonly options: any) {}
+
+  /**
+   * Load translations for a locale
+   */
+  async load(locale: string): Promise<Record<string, any>> {
+    // Check cache
+    if (this.options.enableCaching && this.cache.has(locale)) {
+      return this.cache.get(locale)!;
+    }
+
+    const translations: Record<string, any> = {};
+    const localeDir = path.join(this.options.localesPath, locale);
+
+    if (!fs.existsSync(localeDir)) {
+      // Try single file format
+      const singleFile = path.join(this.options.localesPath, \`\${locale}.json\`);
+      if (fs.existsSync(singleFile)) {
+        const content = fs.readFileSync(singleFile, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (this.options.enableCaching) {
+          this.cache.set(locale, parsed);
+        }
+        return parsed;
+      }
+      throw new Error(\`Locale directory or file not found: \${locale}\`);
+    }
+
+    // Load all JSON files in locale directory
+    const files = fs.readdirSync(localeDir).filter(f => f.endsWith('.json'));
+
+    for (const file of files) {
+      const namespace = path.basename(file, '.json');
+      const filePath = path.join(localeDir, file);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      translations[namespace] = JSON.parse(content);
+    }
+
+    if (this.options.enableCaching) {
+      this.cache.set(locale, translations);
+    }
+
+    return translations;
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Get available locales
+   */
+  getAvailableLocales(): string[] {
+    const localesPath = this.options.localesPath;
+
+    if (!fs.existsSync(localesPath)) {
+      return [];
+    }
+
+    const entries = fs.readdirSync(localesPath, { withFileTypes: true });
+    const locales: string[] = [];
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        locales.push(entry.name);
+      } else if (entry.name.endsWith('.json')) {
+        locales.push(entry.name.replace('.json', ''));
+      }
+    }
+
+    return locales;
+  }
+}
+`;
+}
+function generateLocaleInterceptor() {
+    return `import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  Inject,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { I18nService } from './i18n.service';
+
+@Injectable()
+export class LocaleInterceptor implements NestInterceptor {
+  constructor(
+    private readonly i18n: I18nService,
+    @Inject('I18N_OPTIONS') private readonly options: any,
+  ) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const response = context.switchToHttp().getResponse();
+
+    // Detect locale from request
+    const locale = this.detectLocale(request);
+
+    // Set locale for this request
+    request.locale = locale;
+    request.i18n = this.i18n;
+
+    // Set locale header in response
+    response.setHeader('Content-Language', locale);
+
+    return next.handle();
+  }
+
+  private detectLocale(request: any): string {
+    const resolvers = this.options.resolvers || ['header', 'accept-language'];
+    const supportedLocales = this.options.supportedLocales;
+
+    for (const resolver of resolvers) {
+      const locale = this.resolveLocale(resolver, request);
+      if (locale && supportedLocales.includes(locale)) {
+        return locale;
+      }
+    }
+
+    return this.options.defaultLocale;
+  }
+
+  private resolveLocale(resolver: string, request: any): string | null {
+    switch (resolver) {
+      case 'header':
+        return request.headers['x-locale'] || request.headers['x-lang'];
+
+      case 'query':
+        return request.query.locale || request.query.lang;
+
+      case 'cookie':
+        return request.cookies?.locale;
+
+      case 'accept-language':
+        return this.parseAcceptLanguage(request.headers['accept-language']);
+
+      default:
+        return null;
+    }
+  }
+
+  private parseAcceptLanguage(header: string | undefined): string | null {
+    if (!header) return null;
+
+    const locales = header.split(',').map(lang => {
+      const [locale, priority = 'q=1.0'] = lang.trim().split(';');
+      const q = parseFloat(priority.replace('q=', ''));
+      return { locale: locale.split('-')[0], priority: q };
+    });
+
+    locales.sort((a, b) => b.priority - a.priority);
+
+    return locales[0]?.locale || null;
+  }
+}
+`;
+}
+function generateI18nDecorators() {
+    return `import { createParamDecorator, ExecutionContext, SetMetadata } from '@nestjs/common';
+
+/**
+ * Get current locale from request
+ */
+export const CurrentLocale = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext): string => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.locale;
+  },
+);
+
+/**
+ * Get i18n service from request
+ */
+export const I18n = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.i18n;
+  },
+);
+
+/**
+ * Get translation function from request
+ */
+export const T = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+    const locale = request.locale;
+    return (key: string, args?: Record<string, any>) => {
+      return request.i18n?.t(key, { locale, args }) || key;
+    };
+  },
+);
+
+/**
+ * Set required locale for endpoint
+ */
+export function RequireLocale(...locales: string[]) {
+  return SetMetadata('requiredLocales', locales);
+}
+
+/**
+ * Mark endpoint as locale-specific
+ */
+export function LocaleSpecific() {
+  return SetMetadata('localeSpecific', true);
+}
+`;
+}
+function generateSampleLocales(localesPath, options) {
+    const locales = options.supportedLocales || ['en', 'fr', 'es'];
+    const translations = {
+        en: {
+            common: {
+                welcome: 'Welcome',
+                hello: 'Hello, {{name}}!',
+                goodbye: 'Goodbye',
+                yes: 'Yes',
+                no: 'No',
+                save: 'Save',
+                cancel: 'Cancel',
+                delete: 'Delete',
+                edit: 'Edit',
+                loading: 'Loading...',
+                error: 'An error occurred',
+                success: 'Success',
+            },
+            errors: {
+                notFound: 'Resource not found',
+                unauthorized: 'Unauthorized access',
+                forbidden: 'Access forbidden',
+                validation: 'Validation error',
+                serverError: 'Internal server error',
+            },
+            validation: {
+                required: '{{field}} is required',
+                email: 'Invalid email format',
+                minLength: '{{field}} must be at least {{min}} characters',
+                maxLength: '{{field}} must not exceed {{max}} characters',
+            },
+            plurals: {
+                items: {
+                    zero: 'No items',
+                    one: '1 item',
+                    other: '{{count}} items',
+                },
+            },
+        },
+        fr: {
+            common: {
+                welcome: 'Bienvenue',
+                hello: 'Bonjour, {{name}} !',
+                goodbye: 'Au revoir',
+                yes: 'Oui',
+                no: 'Non',
+                save: 'Enregistrer',
+                cancel: 'Annuler',
+                delete: 'Supprimer',
+                edit: 'Modifier',
+                loading: 'Chargement...',
+                error: 'Une erreur est survenue',
+                success: 'Succès',
+            },
+            errors: {
+                notFound: 'Ressource non trouvée',
+                unauthorized: 'Accès non autorisé',
+                forbidden: 'Accès interdit',
+                validation: 'Erreur de validation',
+                serverError: 'Erreur interne du serveur',
+            },
+            validation: {
+                required: '{{field}} est requis',
+                email: 'Format email invalide',
+                minLength: '{{field}} doit contenir au moins {{min}} caractères',
+                maxLength: '{{field}} ne doit pas dépasser {{max}} caractères',
+            },
+            plurals: {
+                items: {
+                    zero: 'Aucun élément',
+                    one: '1 élément',
+                    other: '{{count}} éléments',
+                },
+            },
+        },
+        es: {
+            common: {
+                welcome: 'Bienvenido',
+                hello: '¡Hola, {{name}}!',
+                goodbye: 'Adiós',
+                yes: 'Sí',
+                no: 'No',
+                save: 'Guardar',
+                cancel: 'Cancelar',
+                delete: 'Eliminar',
+                edit: 'Editar',
+                loading: 'Cargando...',
+                error: 'Se produjo un error',
+                success: 'Éxito',
+            },
+            errors: {
+                notFound: 'Recurso no encontrado',
+                unauthorized: 'Acceso no autorizado',
+                forbidden: 'Acceso prohibido',
+                validation: 'Error de validación',
+                serverError: 'Error interno del servidor',
+            },
+            validation: {
+                required: '{{field}} es requerido',
+                email: 'Formato de email inválido',
+                minLength: '{{field}} debe tener al menos {{min}} caracteres',
+                maxLength: '{{field}} no debe exceder {{max}} caracteres',
+            },
+            plurals: {
+                items: {
+                    zero: 'Ningún elemento',
+                    one: '1 elemento',
+                    other: '{{count}} elementos',
+                },
+            },
+        },
+    };
+    for (const locale of locales) {
+        const localeDir = path.join(localesPath, locale);
+        if (!fs.existsSync(localeDir)) {
+            fs.mkdirSync(localeDir, { recursive: true });
+        }
+        const trans = translations[locale] || translations.en;
+        for (const [namespace, content] of Object.entries(trans)) {
+            fs.writeFileSync(path.join(localeDir, `${namespace}.json`), JSON.stringify(content, null, 2));
+        }
+        console.log(chalk_1.default.green(`  ✓ Created locale files for: ${locale}`));
+    }
+}
+//# sourceMappingURL=i18n-setup.js.map

package/dist/commands/i18n-setup.js.map

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

package/dist/commands/init-config.d.ts

@@ -0,0 +1,6 @@
+export interface InitConfigOptions {
+    preset?: string;
+    force?: boolean;
+}
+export declare function initConfig(options?: InitConfigOptions): Promise<void>;
+export declare function listPresets(): void;