@currentjs/gen 0.3.1 → 0.5.0

package/dist/generators/templates/storeTemplates.js

@@ -1,260 +1,143 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileTemplates = exports.storeTemplates = void 0;
+exports.storeFileTemplate = exports.storeTemplates = void 0;
 exports.storeTemplates = {
     rowInterface: `export interface {{ENTITY_NAME}}Row {
   id: number;
 {{ROW_FIELDS}}
-  created_at: Date;
-  updated_at: Date;
-  deleted_at?: Date;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string;
 }`,
-    storeClass: `export class {{ENTITY_NAME}}Store implements StoreInterface<{{ENTITY_NAME}}, {{ENTITY_NAME}}Row> {
-  private static readonly FILTERABLE_FIELDS = [{{FILTERABLE_FIELDS_ARRAY}}];
-  private static readonly UPDATABLE_FIELDS = [{{UPDATABLE_FIELDS_ARRAY}}];
-  
+    storeClass: `/**
+ * Data access layer for {{ENTITY_NAME}}
+ */
+@Injectable()
+export class {{ENTITY_NAME}}Store {
+  private tableName = '{{TABLE_NAME}}';
+
   constructor(private db: ISqlProvider) {}
 
-  async getById(id: number): Promise<{{ENTITY_NAME}} | null> {
-    try {
-      const query = 'SELECT * FROM {{TABLE_NAME}} WHERE id = :id AND deleted_at IS NULL';
-      const result = await this.db.query(query, { id });
-      
-      if (!result.success || result.data.length === 0) {
-        return null;
-      }
-      
-      return {{ENTITY_NAME}}Store.rowToModel(result.data[0] as {{ENTITY_NAME}}Row);
-    } catch (error) {
-      if (error instanceof MySQLConnectionError) {
-        throw new Error(\`Database connection error while fetching {{ENTITY_NAME}} with id \${id}: \${error.message}\`);
-      } else if (error instanceof MySQLQueryError) {
-        throw new Error(\`Query error while fetching {{ENTITY_NAME}} with id \${id}: \${error.message}\`);
-      }
-      throw error;
-    }
+  private toMySQLDatetime(date: Date): string {
+    return date.toISOString().slice(0, 19).replace('T', ' ');
   }
 
-  async getAll(page: number = 1, limit: number = 10): Promise<{{ENTITY_NAME}}[]> {
-    const offset = (page - 1) * limit;
-    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE deleted_at IS NULL ORDER BY created_at DESC LIMIT \${limit} OFFSET \${offset}\`;
-    const result = await this.db.query(query, {});
-    
-    if (!result.success) {
-      return [];
-    }
-    
-    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
+  private rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
+    return new {{ENTITY_NAME}}(
+      row.id,
+{{ROW_TO_MODEL_MAPPING}}
+    );
   }
 
-  async getAllByUserId(userId: number, page: number = 1, limit: number = 10): Promise<{{ENTITY_NAME}}[]> {
+  async getAll(page: number = 1, limit: number = 20): Promise<{{ENTITY_NAME}}[]> {
     const offset = (page - 1) * limit;
-    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE user_id = :userId AND deleted_at IS NULL ORDER BY created_at DESC LIMIT \${limit} OFFSET \${offset}\`;
-    const result = await this.db.query(query, { userId });
-    
-    if (!result.success) {
-      return [];
-    }
-    
-    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
-  }
+    const result = await this.db.query(
+      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL LIMIT :limit OFFSET :offset\`,
+      { limit: String(limit), offset: String(offset) }
+    );
 
-  async getBy(filters: Partial<Pick<{{ENTITY_NAME}}Row, {{FILTERABLE_FIELDS}}>>): Promise<{{ENTITY_NAME}} | null> {
-    const filterKeys = Object.keys(filters);
-    
-    // Runtime validation against SQL injection
-    for (const key of filterKeys) {
-      if (!{{ENTITY_NAME}}Store.FILTERABLE_FIELDS.includes(key)) {
-        throw new Error(\`Invalid filter field: \${key}\`);
-      }
+    if (result.success && result.data) {
+      return result.data.map((row: {{ENTITY_NAME}}Row) => this.rowToModel(row));
     }
-    
-    const whereConditions = filterKeys.map(key => \`\${key} = :\${key}\`);
-    
-    if (whereConditions.length === 0) {
-      throw new Error('At least one filter condition is required');
-    }
-    
-    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE \${whereConditions.join(' AND ')} AND deleted_at IS NULL LIMIT 1\`;
-    const result = await this.db.query(query, filters);
-    
-    if (!result.success || result.data.length === 0) {
-      return null;
-    }
-    
-    return {{ENTITY_NAME}}Store.rowToModel(result.data[0] as {{ENTITY_NAME}}Row);
+    return [];
   }
 
-  async getAllBy(filters: Partial<Pick<{{ENTITY_NAME}}Row, {{FILTERABLE_FIELDS}}>>): Promise<{{ENTITY_NAME}}[]> {
-    const filterKeys = Object.keys(filters);
-    
-    // Runtime validation against SQL injection
-    for (const key of filterKeys) {
-      if (!{{ENTITY_NAME}}Store.FILTERABLE_FIELDS.includes(key)) {
-        throw new Error(\`Invalid filter field: \${key}\`);
-      }
-    }
-    
-    const whereConditions = filterKeys.map(key => \`\${key} = :\${key}\`);
-    
-    if (whereConditions.length === 0) {
-      return this.getAll();
-    }
-    
-    const query = \`SELECT * FROM {{TABLE_NAME}} WHERE \${whereConditions.join(' AND ')} AND deleted_at IS NULL ORDER BY created_at DESC\`;
-    const result = await this.db.query(query, filters);
-    
-    if (!result.success) {
-      return [];
+  async count(): Promise<number> {
+    const result = await this.db.query(
+      \`SELECT COUNT(*) as count FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL\`,
+      {}
+    );
+
+    if (result.success && result.data && result.data.length > 0) {
+      return parseInt(result.data[0].count, 10);
     }
-    
-    return result.data.map((row: {{ENTITY_NAME}}Row) => {{ENTITY_NAME}}Store.rowToModel(row));
+    return 0;
   }
 
-  async insert(model: Omit<{{ENTITY_NAME}}, 'id'>): Promise<{{ENTITY_NAME}}> {
-    try {
-      const row = {{ENTITY_NAME}}Store.modelToRow(model as {{ENTITY_NAME}});
-      delete row.id; // Remove id for insert
-      row.created_at = new Date();
-      row.updated_at = new Date();
-      
-      const fields = Object.keys(row);
-      const placeholders = fields.map(field => \`:\${field}\`).join(', ');
-      
-      const query = \`INSERT INTO {{TABLE_NAME}} (\${fields.join(', ')}) VALUES (\${placeholders})\`;
-      const result = await this.db.query(query, row);
-      
-      if (!result.success || !result.insertId) {
-        throw new Error('Failed to insert {{ENTITY_NAME}}: Insert operation did not return a valid ID');
-      }
-      
-      return this.getById(Number(result.insertId));
-    } catch (error) {
-      if (error instanceof MySQLQueryError) {
-        throw new Error(\`Failed to insert {{ENTITY_NAME}}: \${error.message}\`);
-      } else if (error instanceof MySQLConnectionError) {
-        throw new Error(\`Database connection error while inserting {{ENTITY_NAME}}: \${error.message}\`);
-      }
-      throw error;
+  async getById(id: number): Promise<{{ENTITY_NAME}} | null> {
+    const result = await this.db.query(
+      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deleted_at IS NULL\`,
+      { id }
+    );
+
+    if (result.success && result.data && result.data.length > 0) {
+      return this.rowToModel(result.data[0] as {{ENTITY_NAME}}Row);
     }
+    return null;
   }
 
-  async update(id: number, updates: Partial<Omit<{{ENTITY_NAME}}, 'id' | 'createdAt'>>): Promise<{{ENTITY_NAME}} | null> {
-    const existing = await this.getById(id);
-    if (!existing) {
-      return null;
-    }
-    
-    // Extract only data properties, not methods
-    const updateData = this.extractDataProperties(updates);
-    const updateKeys = Object.keys(updateData);
-    
-    // Runtime validation against SQL injection
-    for (const key of updateKeys) {
-      if (!{{ENTITY_NAME}}Store.UPDATABLE_FIELDS.includes(key)) {
-        throw new Error(\`Invalid update field: \${key}\`);
-      }
-    }
-    
-    const updateFields = updateKeys.map(key => \`\${key} = :\${key}\`);
-    
-    if (updateFields.length === 0) {
-      return existing;
+  async insert(entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
+    const now = new Date();
+    const data: Partial<{{ENTITY_NAME}}Row> = {
+{{INSERT_DATA_MAPPING}},
+      created_at: this.toMySQLDatetime(now),
+      updated_at: this.toMySQLDatetime(now)
+    };
+
+    const fieldsList = Object.keys(data).map(f => \`\\\`\${f}\\\`\`).join(', ');
+    const placeholders = Object.keys(data).map(f => \`:\${f}\`).join(', ');
+
+    const result = await this.db.query(
+      \`INSERT INTO \\\`\${this.tableName}\\\` (\${fieldsList}) VALUES (\${placeholders})\`,
+      data
+    );
+
+    if (result.success && result.insertId) {
+      const newId = typeof result.insertId === 'string' ? parseInt(result.insertId, 10) : result.insertId;
+      return this.getById(newId) as Promise<{{ENTITY_NAME}}>;
     }
-    
-    const params = { ...updateData, updated_at: new Date(), id };
-    
-    const query = \`UPDATE {{TABLE_NAME}} SET \${updateFields.join(', ')}, updated_at = :updated_at WHERE id = :id\`;
-    await this.db.query(query, params);
-    
-    return this.getById(id);
+
+    throw new Error('Failed to insert {{ENTITY_NAME}}');
   }
 
-  async upsert(model: Partial<{{ENTITY_NAME}}>): Promise<{{ENTITY_NAME}}> {
-    if (model.id) {
-      const existing = await this.getById(model.id);
-      if (existing) {
-        return this.update(model.id, model) as Promise<{{ENTITY_NAME}}>;
-      }
+  async update(id: number, entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
+    const now = new Date();
+    const data: Partial<{{ENTITY_NAME}}Row> & { id: number } = {
+{{UPDATE_DATA_MAPPING}},
+      updated_at: this.toMySQLDatetime(now),
+      id
+    };
+
+    const updateFields = {{UPDATE_FIELDS_ARRAY}}.map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
+
+    const result = await this.db.query(
+      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updated_at = :updated_at WHERE id = :id\`,
+      data
+    );
+
+    if (result.success) {
+      return this.getById(id) as Promise<{{ENTITY_NAME}}>;
     }
-    
-    return this.insert(model as Omit<{{ENTITY_NAME}}, 'id'>);
+
+    throw new Error('Failed to update {{ENTITY_NAME}}');
   }
 
   async softDelete(id: number): Promise<boolean> {
-    const query = 'UPDATE {{TABLE_NAME}} SET deleted_at = :deleted_at WHERE id = :id AND deleted_at IS NULL';
-    const result = await this.db.query(query, { deleted_at: new Date(), id });
-    
-    return result.success && (result.affectedRows || 0) > 0;
-  }
+    const now = new Date();
+    const result = await this.db.query(
+      \`UPDATE \\\`\${this.tableName}\\\` SET deleted_at = :deleted_at WHERE id = :id\`,
+      { deleted_at: this.toMySQLDatetime(now), id }
+    );
 
-  async count(filters?: Partial<Pick<{{ENTITY_NAME}}Row, {{FILTERABLE_FIELDS}}>>): Promise<number> {
-    let query = 'SELECT COUNT(*) as count FROM {{TABLE_NAME}} WHERE deleted_at IS NULL';
-    let params: Record<string, any> = {};
-    
-    if (filters && Object.keys(filters).length > 0) {
-      const whereConditions = Object.keys(filters).map(key => \`\${key} = :\${key}\`);
-      params = { ...filters };
-      query += \` AND \${whereConditions.join(' AND ')}\`;
-    }
-    
-    const result = await this.db.query(query, params);
-    
-    if (!result.success || result.data.length === 0) {
-      return 0;
-    }
-    
-    return result.data[0].count;
+    return result.success;
   }
 
-{{CONVERSION_METHODS}}
-}`,
-    conversionMethods: `  static rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
-    return new {{ENTITY_NAME}}(
-      row.id,
-{{ROW_TO_MODEL_MAPPING}}
+  async hardDelete(id: number): Promise<boolean> {
+    const result = await this.db.query(
+      \`DELETE FROM \\\`\${this.tableName}\\\` WHERE id = :id\`,
+      { id }
     );
-  }
 
-  static modelToRow(model: {{ENTITY_NAME}}): Partial<{{ENTITY_NAME}}Row> {
-    return {
-      id: model.id,
-{{MODEL_TO_ROW_MAPPING}},
-      updated_at: new Date()
-    };
+    return result.success;
   }
-
-  private extractDataProperties(obj: any): Record<string, any> {
-    const result: Record<string, any> = {};
-    
-    for (const [key, value] of Object.entries(obj)) {
-      // Only include properties that are not functions and are in updatable fields
-      if (typeof value !== 'function' && {{ENTITY_NAME}}Store.UPDATABLE_FIELDS.includes(key)) {
-        result[key] = value;
-      }
-    }
-    
-    return result;
-  }`
+{{GET_BY_PARENT_ID_METHOD}}
+{{GET_RESOURCE_OWNER_METHOD}}}`
 };
-exports.fileTemplates = {
-    storeFile: `import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';
-import { StoreInterface } from '../interfaces/StoreInterface';
-import { ProviderMysql, ISqlProvider, MySQLQueryError, MySQLConnectionError } from '@currentjs/provider-mysql';
+exports.storeFileTemplate = `import { Injectable } from '../../../../system';
+import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';
+import type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}
 
 {{ROW_INTERFACE}}
 
-{{STORE_CLASS}}`,
-    storeInterface: `export interface StoreInterface<TModel, TRow> {
-  getById(id: number): Promise<TModel | null>;
-  getAll(page?: number, limit?: number): Promise<TModel[]>;
-  getAllByUserId(userId: number, page?: number, limit?: number): Promise<TModel[]>;
-  getBy(filters: Partial<TRow>): Promise<TModel | null>;
-  getAllBy(filters: Partial<TRow>): Promise<TModel[]>;
-  insert(model: Omit<TModel, 'id'>): Promise<TModel>;
-  update(id: number, updates: Partial<Omit<TModel, 'id' | 'createdAt'>>): Promise<TModel | null>;
-  upsert(model: Partial<TModel>): Promise<TModel>;
-  softDelete(id: number): Promise<boolean>;
-  count(filters?: Partial<TRow>): Promise<number>;
-}`
-};
+{{STORE_CLASS}}
+`;

package/dist/generators/templates/viewTemplates.js

@@ -484,7 +484,7 @@ function renderLayoutTemplate(layoutName) {
     <title>${layoutName}</title>
   </head>
   <body>
-    {{ content }}
+    {{{ content }}}
   </body>
   </html>
 `;

package/dist/generators/useCaseGenerator.d.ts

@@ -0,0 +1,13 @@
+import { ModuleConfig } from '../types/configTypes';
+export declare class UseCaseGenerator {
+    private availableAggregates;
+    private generateUseCaseMethod;
+    private generateGetResourceOwnerMethod;
+    private generateUseCase;
+    generateFromConfig(config: ModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}

package/dist/generators/useCaseGenerator.js

@@ -0,0 +1,188 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseCaseGenerator = void 0;
+const yaml_1 = require("yaml");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const configTypes_1 = require("../types/configTypes");
+const typeUtils_1 = require("../utils/typeUtils");
+class UseCaseGenerator {
+    constructor() {
+        this.availableAggregates = new Map();
+    }
+    generateUseCaseMethod(modelName, actionName, useCaseConfig) {
+        const methodName = actionName;
+        const inputType = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+        // Determine the return type based on action
+        let returnType;
+        if (useCaseConfig.output === 'void') {
+            returnType = '{ success: boolean; message: string }';
+        }
+        else if (actionName === 'list') {
+            returnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+        }
+        else {
+            returnType = modelName;
+        }
+        // Generate handler calls
+        const handlerCalls = useCaseConfig.handlers.map((handler, index) => {
+            var _a;
+            const isLast = index === useCaseConfig.handlers.length - 1;
+            if (handler.startsWith('default:')) {
+                // Default handler - call service method directly
+                const defaultAction = handler.replace('default:', '');
+                const resultVar = isLast ? 'result' : `result${index}`;
+                // Determine parameters based on action
+                let params = '';
+                if (defaultAction === 'list') {
+                    params = ((_a = useCaseConfig.input) === null || _a === void 0 ? void 0 : _a.pagination)
+                        ? 'input.page || 1, input.limit || 20'
+                        : '';
+                }
+                else if (defaultAction === 'get') {
+                    params = 'input.id';
+                }
+                else if (defaultAction === 'create') {
+                    params = 'input';
+                }
+                else if (defaultAction === 'update') {
+                    params = 'input.id, input';
+                }
+                else if (defaultAction === 'delete') {
+                    params = 'input.id';
+                }
+                else {
+                    params = 'input';
+                }
+                return `    const ${resultVar} = await this.${modelName.toLowerCase()}Service.${defaultAction}(${params});`;
+            }
+            else {
+                // Custom handler
+                const prevResult = index === 0 ? 'null' : `result${index - 1}`;
+                const resultVar = isLast ? 'result' : `result${index}`;
+                return `    const ${resultVar} = await this.${modelName.toLowerCase()}Service.${handler}(${prevResult}, input);`;
+            }
+        }).join('\n');
+        const returnStatement = '\n    return result;';
+        return `  async ${methodName}(input: ${inputType}): Promise<${returnType}> {
+${handlerCalls}${returnStatement}
+  }`;
+    }
+    generateGetResourceOwnerMethod(modelName) {
+        const serviceVar = `${modelName.toLowerCase()}Service`;
+        return `
+  /**
+   * Get the owner ID of a resource by its ID.
+   * Used for pre-mutation authorization checks in controllers.
+   */
+  async getResourceOwner(id: number): Promise<number | null> {
+    return await this.${serviceVar}.getResourceOwner(id);
+  }`;
+    }
+    generateUseCase(modelName, useCases) {
+        const className = `${modelName}UseCase`;
+        const serviceName = `${modelName}Service`;
+        const serviceVar = `${modelName.toLowerCase()}Service`;
+        // Generate imports for DTOs (only Input types since UseCases return models)
+        const dtoImports = Object.keys(useCases)
+            .map(actionName => {
+            const inputType = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+            return `import { ${inputType} } from '../dto/${modelName}${(0, typeUtils_1.capitalize)(actionName)}';`;
+        })
+            .join('\n');
+        // Generate methods
+        const methods = Object.entries(useCases)
+            .map(([actionName, useCaseConfig]) => this.generateUseCaseMethod(modelName, actionName, useCaseConfig))
+            .join('\n\n');
+        const getResourceOwnerMethod = this.generateGetResourceOwnerMethod(modelName);
+        return `import { Injectable } from '../../../../system';
+import { ${modelName} } from '../../domain/entities/${modelName}';
+${dtoImports}
+import { ${serviceName} } from '../services/${serviceName}';
+
+/**
+ * Use Case orchestrator for ${modelName}
+ * Coordinates business logic by calling service handlers in sequence
+ */
+@Injectable()
+export class ${className} {
+  constructor(
+    private ${serviceVar}: ${serviceName}
+  ) {}
+
+${methods}${getResourceOwnerMethod}
+}`;
+    }
+    generateFromConfig(config) {
+        var _a;
+        const result = {};
+        // Collect all aggregates to know which are roots
+        this.availableAggregates.clear();
+        if ((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
+                this.availableAggregates.set(name, aggConfig);
+            });
+        }
+        // Generate a UseCase file for each model
+        Object.entries(config.useCases).forEach(([modelName, useCases]) => {
+            result[modelName] = this.generateUseCase(modelName, useCases);
+        });
+        return result;
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        if (!(0, configTypes_1.isValidModuleConfig)(config)) {
+            throw new Error('Configuration does not match new module format. Expected useCases structure.');
+        }
+        return this.generateFromConfig(config);
+    }
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const useCasesByModel = this.generateFromYamlFile(yamlFilePath);
+        const useCasesDir = path.join(moduleDir, 'application', 'useCases');
+        fs.mkdirSync(useCasesDir, { recursive: true });
+        for (const [modelName, code] of Object.entries(useCasesByModel)) {
+            const filePath = path.join(useCasesDir, `${modelName}UseCase.ts`);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, code, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+        }
+        // eslint-disable-next-line no-console
+        console.log('\n' + colors_1.colors.green('Use Case files generated successfully!') + '\n');
+    }
+}
+exports.UseCaseGenerator = UseCaseGenerator;