@currentjs/gen 0.5.5 → 0.5.6

package/dist/generators/storeGenerator.js

@@ -47,6 +47,7 @@ class StoreGenerator {
     constructor() {
         this.availableValueObjects = new Map();
         this.availableAggregates = new Set();
+        this.identifiers = 'numeric';
     }
     isAggregateField(fieldConfig) {
         return (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
@@ -200,11 +201,12 @@ class StoreGenerator {
     }
     generateRowFields(fields, childInfo) {
         const result = [];
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
-        result.push(`  ${ownerOrParentField}: number;`);
+        result.push(`  ${ownerOrParentField}: ${idTs};`);
         fields.forEach(([fieldName, fieldConfig]) => {
             if (this.isAggregateField(fieldConfig)) {
-                result.push(`  ${fieldName}Id?: number;`);
+                result.push(`  ${fieldName}Id?: ${idTs};`);
                 return;
             }
             const tsType = this.mapTypeToRowType(fieldConfig.type);
@@ -214,10 +216,27 @@ class StoreGenerator {
         return result.join('\n');
     }
     generateFieldNamesStr(fields, childInfo) {
-        const fieldNames = ['id'];
-        fieldNames.push(childInfo ? childInfo.parentIdField : 'ownerId');
-        fieldNames.push(...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name));
-        return fieldNames.map(f => `\\\`${f}\\\``).join(', ');
+        const isUuid = this.identifiers === 'uuid';
+        const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
+        const allFields = [
+            'id',
+            ownerOrParentField,
+            ...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name)
+        ];
+        if (!isUuid) {
+            return allFields.map(f => `\\\`${f}\\\``).join(', ');
+        }
+        // For UUID: id-type columns need BIN_TO_UUID wrapping in SELECT
+        const idFields = new Set(['id', ownerOrParentField]);
+        fields.forEach(([name, config]) => {
+            if (this.isAggregateField(config))
+                idFields.add(`${name}Id`);
+        });
+        return allFields.map(f => {
+            if (idFields.has(f))
+                return `BIN_TO_UUID(\\\`${f}\\\`, 1) as \\\`${f}\\\``;
+            return `\\\`${f}\\\``;
+        }).join(', ');
     }
     generateRowToModelMapping(modelName, fields, childInfo) {
         const result = [];
@@ -411,9 +430,15 @@ class StoreGenerator {
     }
     generateListMethods(modelName, fieldNamesStr, childInfo) {
         const isRoot = !childInfo;
-        const ownerParam = isRoot ? ', ownerId?: number' : '';
+        const isUuid = this.identifiers === 'uuid';
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+        const ownerParam = isRoot ? `, ownerId?: ${idTs}` : '';
+        // UUID_TO_BIN(:ownerId, 1) — the ", 1" is a SQL literal inside the query string, not a JS param key
+        const ownerFilterExpr = isUuid
+            ? `' AND \\\`ownerId\\\` = UUID_TO_BIN(:ownerId, 1)'`
+            : `' AND \\\`ownerId\\\` = :ownerId'`;
         const ownerFilter = isRoot
-            ? `\n    const ownerFilter = ownerId != null ? ' AND \\\`ownerId\\\` = :ownerId' : '';`
+            ? `\n    const ownerFilter = ownerId != null ? ${ownerFilterExpr} : '';`
             : '';
         const ownerFilterRef = isRoot ? '\${ownerFilter}' : '';
         const ownerParamsSetup = isRoot
@@ -432,7 +457,7 @@ class StoreGenerator {
     }
     return [];
   }`;
-        const getAll = `  async getAll(${isRoot ? 'ownerId?: number' : ''}): Promise<${modelName}[]> {${ownerFilter}
+        const getAll = `  async getAll(${isRoot ? `ownerId?: ${idTs}` : ''}): Promise<${modelName}[]> {${ownerFilter}
     const params: Record<string, any> = {};${ownerParamsSetup}
     const result = await this.db.query(
       \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef}\`,
@@ -444,7 +469,7 @@ class StoreGenerator {
     }
     return [];
   }`;
-        const count = `  async count(${isRoot ? 'ownerId?: number' : ''}): Promise<number> {${ownerFilter}
+        const count = `  async count(${isRoot ? `ownerId?: ${idTs}` : ''}): Promise<number> {${ownerFilter}
     const params: Record<string, any> = {};${ownerParamsSetup}
     const result = await this.db.query(
       \`SELECT COUNT(*) as count FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef}\`,
@@ -461,13 +486,26 @@ class StoreGenerator {
     generateGetByParentIdMethod(modelName, fields, childInfo) {
         if (!childInfo)
             return '';
-        const fieldList = ['id', childInfo.parentIdField, ...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name)].map(f => '\\`' + f + '\\`').join(', ');
+        const isUuid = this.identifiers === 'uuid';
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         const parentIdField = childInfo.parentIdField;
+        // Build field list for SELECT (reuse the same UUID-aware logic)
+        const idFields = new Set(['id', parentIdField]);
+        fields.forEach(([name, config]) => {
+            if (this.isAggregateField(config))
+                idFields.add(`${name}Id`);
+        });
+        const rawFields = ['id', parentIdField, ...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name)];
+        const bt = '\\`';
+        const fieldList = isUuid
+            ? rawFields.map(f => idFields.has(f) ? `BIN_TO_UUID(${bt}${f}${bt}, 1) as ${bt}${f}${bt}` : `${bt}${f}${bt}`).join(', ')
+            : rawFields.map(f => `${bt}${f}${bt}`).join(', ');
+        const whereExpr = isUuid ? `\\\`${parentIdField}\\\` = UUID_TO_BIN(:parentId, 1)` : `\\\`${parentIdField}\\\` = :parentId`;
         return `
 
-  async getByParentId(parentId: number): Promise<${modelName}[]> {
+  async getByParentId(parentId: ${idTs}): Promise<${modelName}[]> {
     const result = await this.db.query(
-      \`SELECT ${fieldList} FROM \\\`\${this.tableName}\\\` WHERE \\\`${parentIdField}\\\` = :parentId AND deletedAt IS NULL\`,
+      \`SELECT ${fieldList} FROM \\\`\${this.tableName}\\\` WHERE ${whereExpr} AND deletedAt IS NULL\`,
       { parentId }
     );
 
@@ -478,23 +516,32 @@ class StoreGenerator {
   }`;
     }
     generateGetResourceOwnerMethod(childInfo) {
+        const isUuid = this.identifiers === 'uuid';
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+        const whereExpr = isUuid ? 'id = UUID_TO_BIN(:id, 1)' : 'id = :id';
+        const ownerSelect = isUuid ? 'BIN_TO_UUID(p.ownerId, 1) as ownerId' : 'p.ownerId';
+        const ownerSelectSimple = isUuid ? 'BIN_TO_UUID(ownerId, 1) as ownerId' : 'ownerId';
         if (childInfo) {
             const parentTable = childInfo.parentTableName;
             const parentIdField = childInfo.parentIdField;
+            const joinExpr = isUuid
+                ? `p.id = UUID_TO_BIN(c.\\\`${parentIdField}\\\`, 1)`
+                : `p.id = c.\\\`${parentIdField}\\\``;
+            const cWhereExpr = isUuid ? 'c.id = UUID_TO_BIN(:id, 1)' : 'c.id = :id';
             return `
 
   /**
    * Get the owner ID of a resource by its ID (via parent entity).
    * Used for pre-mutation authorization checks.
    */
-  async getResourceOwner(id: number): Promise<number | null> {
+  async getResourceOwner(id: ${idTs}): Promise<${idTs} | null> {
     const result = await this.db.query(
-      \`SELECT p.ownerId FROM \\\`\${this.tableName}\\\` c INNER JOIN \\\`${parentTable}\\\` p ON p.id = c.\\\`${parentIdField}\\\` WHERE c.id = :id AND c.deletedAt IS NULL\`,
+      \`SELECT ${ownerSelect} FROM \\\`\${this.tableName}\\\` c INNER JOIN \\\`${parentTable}\\\` p ON ${joinExpr} WHERE ${cWhereExpr} AND c.deletedAt IS NULL\`,
       { id }
     );
 
     if (result.success && result.data && result.data.length > 0) {
-      return result.data[0].ownerId as number;
+      return result.data[0].ownerId as ${idTs};
     }
     return null;
   }`;
@@ -505,35 +552,109 @@ class StoreGenerator {
    * Get the owner ID of a resource by its ID.
    * Used for pre-mutation authorization checks.
    */
-  async getResourceOwner(id: number): Promise<number | null> {
+  async getResourceOwner(id: ${idTs}): Promise<${idTs} | null> {
     const result = await this.db.query(
-      \`SELECT ownerId FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deletedAt IS NULL\`,
+      \`SELECT ${ownerSelectSimple} FROM \\\`\${this.tableName}\\\` WHERE ${whereExpr} AND deletedAt IS NULL\`,
       { id }
     );
 
     if (result.success && result.data && result.data.length > 0) {
-      return result.data[0].ownerId as number;
+      return result.data[0].ownerId as ${idTs};
     }
     return null;
   }`;
     }
+    generateIdHelpers() {
+        if (this.identifiers === 'nanoid') {
+            return `
+  private generateNanoId(size = 21): string {
+    const alphabet = "useABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+    let id = "";
+    const bytes = randomBytes(size);
+
+    for (let i = 0; i < size; i++) {
+      // We use a bitwise AND with 63 because 63 is 00111111 in binary.
+      // This maps any byte to a value between 0 and 63.
+      id += alphabet[bytes[i] & 63];
+    }
+
+    return id;
+  }
+`;
+        }
+        return '';
+    }
+    generateInsertIdVariables() {
+        switch (this.identifiers) {
+            case 'uuid':
+                return {
+                    preLine: '    const newId = randomUUID();',
+                    dataLine: '      id: newId,\n',
+                    successCond: '',
+                    getId: ''
+                };
+            case 'nanoid':
+                return {
+                    preLine: '    const newId = this.generateNanoId();',
+                    dataLine: '      id: newId,\n',
+                    successCond: '',
+                    getId: ''
+                };
+            default:
+                return {
+                    preLine: '',
+                    dataLine: '',
+                    successCond: ' && result.insertId',
+                    getId: 'const newId = typeof result.insertId === \'string\' ? parseInt(result.insertId, 10) : result.insertId;'
+                };
+        }
+    }
+    generateWhereIdExpr() {
+        return this.identifiers === 'uuid' ? 'id = UUID_TO_BIN(:id, 1)' : 'id = :id';
+    }
+    generateIdParamExpr() {
+        // The ", 1" in UUID_TO_BIN(:id, 1) is a literal in the SQL string, NOT a JS params key.
+        // The params object always uses just { id }, so this expression is always empty.
+        return '';
+    }
+    generateRowIdExpr() {
+        return this.identifiers === 'uuid' ? 'row.id' : 'row.id';
+    }
+    generateCryptoImport() {
+        if (this.identifiers === 'uuid')
+            return `\nimport { randomUUID } from 'crypto';`;
+        if (this.identifiers === 'nanoid')
+            return `\nimport { randomBytes } from 'crypto';`;
+        return '';
+    }
     generateStore(modelName, aggregateConfig, childInfo) {
         const tableName = modelName.toLowerCase();
         const fields = Object.entries(aggregateConfig.fields);
         // Sort fields for rowToModel to match entity constructor order (required first, optional second)
         const sortedFields = this.sortFieldsForConstructor(fields);
         const fieldNamesStr = this.generateFieldNamesStr(fields, childInfo);
+        const idVars = this.generateInsertIdVariables();
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         const variables = {
             ENTITY_NAME: modelName,
             TABLE_NAME: tableName,
+            ID_TYPE: idTs,
             ROW_FIELDS: this.generateRowFields(fields, childInfo),
             FIELD_NAMES: fieldNamesStr,
+            ROW_ID_EXPR: this.generateRowIdExpr(),
+            WHERE_ID_EXPR: this.generateWhereIdExpr(),
+            ID_PARAM_EXPR: this.generateIdParamExpr(),
             ROW_TO_MODEL_MAPPING: this.generateRowToModelMapping(modelName, sortedFields, childInfo),
+            INSERT_ID_PRE_LOGIC: idVars.preLine,
+            INSERT_ID_DATA: idVars.dataLine,
             INSERT_DATA_MAPPING: this.generateInsertDataMapping(fields, childInfo),
+            INSERT_SUCCESS_COND: idVars.successCond,
+            INSERT_GET_ID: idVars.getId,
             UPDATE_DATA_MAPPING: this.generateUpdateDataMapping(fields),
             UPDATE_FIELDS_ARRAY: this.generateUpdateFieldsArray(fields),
             VALUE_OBJECT_IMPORTS: this.generateValueObjectImports(fields),
             AGGREGATE_REF_IMPORTS: this.generateAggregateRefImports(modelName, fields),
+            ID_HELPERS: this.generateIdHelpers(),
             LIST_METHODS: this.generateListMethods(modelName, fieldNamesStr, childInfo),
             GET_BY_PARENT_ID_METHOD: this.generateGetByParentIdMethod(modelName, fields, childInfo),
             GET_RESOURCE_OWNER_METHOD: this.generateGetResourceOwnerMethod(childInfo)
@@ -552,12 +673,14 @@ class StoreGenerator {
             ENTITY_IMPORT_ITEMS: entityImportItems.join(', '),
             ROW_INTERFACE: rowInterface,
             STORE_CLASS: storeClass,
+            CRYPTO_IMPORT: this.generateCryptoImport(),
             VALUE_OBJECT_IMPORTS: variables.VALUE_OBJECT_IMPORTS,
             AGGREGATE_REF_IMPORTS: variables.AGGREGATE_REF_IMPORTS
         });
     }
-    generateFromConfig(config) {
+    generateFromConfig(config, identifiers = 'numeric') {
         const result = {};
+        this.identifiers = identifiers;
         // First, collect all value object names and configs
         this.availableValueObjects.clear();
         if (config.domain.valueObjects) {
@@ -582,16 +705,16 @@ class StoreGenerator {
         }
         return result;
     }
-    generateFromYamlFile(yamlFilePath) {
+    generateFromYamlFile(yamlFilePath, identifiers = 'numeric') {
         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 domain.aggregates structure.');
         }
-        return this.generateFromConfig(config);
+        return this.generateFromConfig(config, identifiers);
     }
-    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
-        const storesByModel = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const storesByModel = this.generateFromYamlFile(yamlFilePath, identifiers);
         const storesDir = path.join(moduleDir, 'infrastructure', 'stores');
         fs.mkdirSync(storesDir, { recursive: true });
         for (const [modelName, code] of Object.entries(storesByModel)) {

package/dist/generators/templates/data/appYamlTemplate

@@ -3,5 +3,5 @@ providers:
 config:
   database: mysql
   styling: bootstrap
-  identifiers: id
+  identifiers: numeric
 modules: {}

package/dist/generators/templates/storeTemplates.d.ts

@@ -2,4 +2,4 @@ export declare const storeTemplates: {
     rowInterface: string;
     storeClass: string;
 };
-export declare const storeFileTemplate = "import { Injectable } from '../../../../system';\nimport { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}\n\n{{ROW_INTERFACE}}\n\n{{STORE_CLASS}}\n";
+export declare const storeFileTemplate = "import { Injectable } from '../../../../system';\nimport { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport type { ISqlProvider } from '@currentjs/provider-mysql';{{CRYPTO_IMPORT}}{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}\n\n{{ROW_INTERFACE}}\n\n{{STORE_CLASS}}\n";

package/dist/generators/templates/storeTemplates.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.storeFileTemplate = exports.storeTemplates = void 0;
 exports.storeTemplates = {
     rowInterface: `export interface {{ENTITY_NAME}}Row {
-  id: number;
+  id: {{ID_TYPE}};
 {{ROW_FIELDS}}
   createdAt: string;
   updatedAt: string;
@@ -25,20 +25,20 @@ export class {{ENTITY_NAME}}Store {
   private ensureParsed(value: any): any {
     return typeof value === 'string' ? JSON.parse(value) : value;
   }
-
+{{ID_HELPERS}}
   private rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
     return new {{ENTITY_NAME}}(
-      row.id,
+      {{ROW_ID_EXPR}},
 {{ROW_TO_MODEL_MAPPING}}
     );
   }
 
 {{LIST_METHODS}}
 
-  async getById(id: number): Promise<{{ENTITY_NAME}} | null> {
+  async getById(id: {{ID_TYPE}}): Promise<{{ENTITY_NAME}} | null> {
     const result = await this.db.query(
-      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deletedAt IS NULL\`,
-      { id }
+      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE {{WHERE_ID_EXPR}} AND deletedAt IS NULL\`,
+      { id{{ID_PARAM_EXPR}} }
     );
 
     if (result.success && result.data && result.data.length > 0) {
@@ -49,8 +49,9 @@ export class {{ENTITY_NAME}}Store {
 
   async insert(entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
     const now = new Date();
+{{INSERT_ID_PRE_LOGIC}}
     const data: Partial<{{ENTITY_NAME}}Row> = {
-{{INSERT_DATA_MAPPING}},
+{{INSERT_ID_DATA}}{{INSERT_DATA_MAPPING}},
       createdAt: this.toMySQLDatetime(now),
       updatedAt: this.toMySQLDatetime(now)
     };
@@ -64,15 +65,15 @@ export class {{ENTITY_NAME}}Store {
       cleanData
     );
 
-    if (result.success && result.insertId) {
-      const newId = typeof result.insertId === 'string' ? parseInt(result.insertId, 10) : result.insertId;
+    if (result.success{{INSERT_SUCCESS_COND}}) {
+      {{INSERT_GET_ID}}
       return this.getById(newId) as Promise<{{ENTITY_NAME}}>;
     }
 
     throw new Error('Failed to insert {{ENTITY_NAME}}');
   }
 
-  async update(id: number, entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
+  async update(id: {{ID_TYPE}}, entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
     const now = new Date();
     const rawData: Partial<{{ENTITY_NAME}}Row> = {
 {{UPDATE_DATA_MAPPING}},
@@ -85,8 +86,8 @@ export class {{ENTITY_NAME}}Store {
       .map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
 
     const result = await this.db.query(
-      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updatedAt = :updatedAt WHERE id = :id\`,
-      { ...cleanData, id }
+      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updatedAt = :updatedAt WHERE {{WHERE_ID_EXPR}}\`,
+      { ...cleanData, id{{ID_PARAM_EXPR}} }
     );
 
     if (result.success) {
@@ -96,20 +97,20 @@ export class {{ENTITY_NAME}}Store {
     throw new Error('Failed to update {{ENTITY_NAME}}');
   }
 
-  async softDelete(id: number): Promise<boolean> {
+  async softDelete(id: {{ID_TYPE}}): Promise<boolean> {
     const now = new Date();
     const result = await this.db.query(
-      \`UPDATE \\\`\${this.tableName}\\\` SET deletedAt = :deletedAt WHERE id = :id\`,
-      { deletedAt: this.toMySQLDatetime(now), id }
+      \`UPDATE \\\`\${this.tableName}\\\` SET deletedAt = :deletedAt WHERE {{WHERE_ID_EXPR}}\`,
+      { deletedAt: this.toMySQLDatetime(now), id{{ID_PARAM_EXPR}} }
     );
 
     return result.success;
   }
 
-  async hardDelete(id: number): Promise<boolean> {
+  async hardDelete(id: {{ID_TYPE}}): Promise<boolean> {
     const result = await this.db.query(
-      \`DELETE FROM \\\`\${this.tableName}\\\` WHERE id = :id\`,
-      { id }
+      \`DELETE FROM \\\`\${this.tableName}\\\` WHERE {{WHERE_ID_EXPR}}\`,
+      { id{{ID_PARAM_EXPR}} }
     );
 
     return result.success;
@@ -119,7 +120,7 @@ export class {{ENTITY_NAME}}Store {
 };
 exports.storeFileTemplate = `import { Injectable } from '../../../../system';
 import { {{ENTITY_IMPORT_ITEMS}} } from '../../domain/entities/{{ENTITY_NAME}}';
-import type { ISqlProvider } from '@currentjs/provider-mysql';{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}
+import type { ISqlProvider } from '@currentjs/provider-mysql';{{CRYPTO_IMPORT}}{{VALUE_OBJECT_IMPORTS}}{{AGGREGATE_REF_IMPORTS}}
 
 {{ROW_INTERFACE}}
 

package/dist/generators/useCaseGenerator.d.ts

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

package/dist/generators/useCaseGenerator.js

@@ -44,6 +44,7 @@ const typeUtils_1 = require("../utils/typeUtils");
 class UseCaseGenerator {
     constructor() {
         this.availableAggregates = new Map();
+        this.identifiers = 'numeric';
     }
     generateUseCaseMethod(modelName, actionName, useCaseConfig) {
         const methodName = actionName;
@@ -100,7 +101,7 @@ class UseCaseGenerator {
         }).join('\n');
         const returnStatement = '\n    return result;';
         const methodParams = actionName === 'list'
-            ? `input: ${inputType}, ownerId?: number`
+            ? `input: ${inputType}, ownerId?: ${(0, configTypes_1.idTsType)(this.identifiers)}`
             : `input: ${inputType}`;
         return `  async ${methodName}(${methodParams}): Promise<${returnType}> {
 ${handlerCalls}${returnStatement}
@@ -108,12 +109,13 @@ ${handlerCalls}${returnStatement}
     }
     generateGetResourceOwnerMethod(modelName) {
         const serviceVar = `${modelName.toLowerCase()}Service`;
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         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> {
+  async getResourceOwner(id: ${idTs}): Promise<${idTs} | null> {
     return await this.${serviceVar}.getResourceOwner(id);
   }`;
     }
@@ -151,9 +153,10 @@ export class ${className} {
 ${methods}${getResourceOwnerMethod}
 }`;
     }
-    generateFromConfig(config) {
+    generateFromConfig(config, identifiers = 'numeric') {
         var _a;
         const result = {};
+        this.identifiers = identifiers;
         // Collect all aggregates to know which are roots
         this.availableAggregates.clear();
         if ((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) {
@@ -167,16 +170,16 @@ ${methods}${getResourceOwnerMethod}
         });
         return result;
     }
-    generateFromYamlFile(yamlFilePath) {
+    generateFromYamlFile(yamlFilePath, identifiers = 'numeric') {
         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);
+        return this.generateFromConfig(config, identifiers);
     }
-    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
-        const useCasesByModel = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const useCasesByModel = this.generateFromYamlFile(yamlFilePath, identifiers);
         const useCasesDir = path.join(moduleDir, 'application', 'useCases');
         fs.mkdirSync(useCasesDir, { recursive: true });
         for (const [modelName, code] of Object.entries(useCasesByModel)) {

package/dist/types/configTypes.d.ts

@@ -1,6 +1,9 @@
 /**
  * Type definitions for the Clean Architecture module configuration
  */
+export type IdentifierType = 'numeric' | 'uuid' | 'nanoid';
+export declare function normalizeIdentifierType(value: string): IdentifierType;
+export declare function idTsType(identifiers: IdentifierType): 'number' | 'string';
 export interface FieldDefinition {
     type: string;
     constraints?: {

package/dist/types/configTypes.js

@@ -3,7 +3,22 @@
  * Type definitions for the Clean Architecture module configuration
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIdentifierType = normalizeIdentifierType;
+exports.idTsType = idTsType;
 exports.isValidModuleConfig = isValidModuleConfig;
+function normalizeIdentifierType(value) {
+    const lower = value.toLowerCase();
+    if (lower === 'id' || lower === 'numeric')
+        return 'numeric';
+    if (lower === 'uuid')
+        return 'uuid';
+    if (lower === 'nanoid')
+        return 'nanoid';
+    throw new Error(`Unknown identifier type: "${value}". Expected: numeric, uuid, or nanoid`);
+}
+function idTsType(identifiers) {
+    return identifiers === 'numeric' ? 'number' : 'string';
+}
 // Type guard to validate module config (domain + useCases)
 function isValidModuleConfig(config) {
     return config && typeof config === 'object' && 'domain' in config && 'useCases' in config;

package/dist/utils/commandUtils.d.ts

@@ -28,7 +28,7 @@ export interface ModuleEntryResolved {
     path: string;
     database: string;
     styling: string;
-    identifiers: string;
+    identifiers: import('../types/configTypes').IdentifierType;
 }
 export declare function getModuleEntries(config: AppConfig): ModuleEntryResolved[];
 export declare function shouldIncludeModule(moduleYamlRel: string, moduleName?: string): boolean;

package/dist/utils/commandUtils.js

@@ -51,9 +51,10 @@ const serviceGenerator_1 = require("../generators/serviceGenerator");
 const controllerGenerator_1 = require("../generators/controllerGenerator");
 const storeGenerator_1 = require("../generators/storeGenerator");
 const templateGenerator_1 = require("../generators/templateGenerator");
+const configTypes_1 = require("../types/configTypes");
 const DEFAULT_DATABASE = 'mysql';
 const DEFAULT_STYLING = 'bootstrap';
-const DEFAULT_IDENTIFIERS = 'id';
+const DEFAULT_IDENTIFIERS = 'numeric';
 function loadAppConfig(yamlPath) {
     const raw = fs.readFileSync(yamlPath, 'utf8');
     const parsed = (0, yaml_1.parse)(raw);
@@ -81,7 +82,8 @@ function getModuleEntries(config) {
     const global = config.config || {};
     const database = (_a = global.database) !== null && _a !== void 0 ? _a : DEFAULT_DATABASE;
     const styling = (_b = global.styling) !== null && _b !== void 0 ? _b : DEFAULT_STYLING;
-    const identifiers = (_c = global.identifiers) !== null && _c !== void 0 ? _c : DEFAULT_IDENTIFIERS;
+    const rawIdentifiers = (_c = global.identifiers) !== null && _c !== void 0 ? _c : DEFAULT_IDENTIFIERS;
+    const identifiers = (0, configTypes_1.normalizeIdentifierType)(rawIdentifiers);
     const globalConfig = { database, styling, identifiers };
     return Object.entries(config.modules).map(([name, entry]) => {
         var _a, _b, _c;
@@ -90,7 +92,7 @@ function getModuleEntries(config) {
             path: entry.path,
             database: (_a = entry.database) !== null && _a !== void 0 ? _a : globalConfig.database,
             styling: (_b = entry.styling) !== null && _b !== void 0 ? _b : globalConfig.styling,
-            identifiers: (_c = entry.identifiers) !== null && _c !== void 0 ? _c : globalConfig.identifiers
+            identifiers: (0, configTypes_1.normalizeIdentifierType)((_c = entry.identifiers) !== null && _c !== void 0 ? _c : globalConfig.identifiers)
         });
     });
 }

package/dist/utils/migrationUtils.d.ts

@@ -1,4 +1,4 @@
-import { AggregateConfig, AggregateFieldConfig } from '../types/configTypes';
+import { AggregateConfig, AggregateFieldConfig, IdentifierType } from '../types/configTypes';
 export interface SchemaState {
     aggregates: Record<string, AggregateConfig>;
     version: string;
@@ -21,7 +21,9 @@ export interface ForeignKeyInfo {
     REFERENCED_TABLE_NAME: string;
     REFERENCED_COLUMN_NAME: string;
 }
-export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
+export declare function getIdColumnDefinition(idType?: IdentifierType): string;
+export declare function getFkColumnType(idType?: IdentifierType): string;
+export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>, availableValueObjects?: Set<string>, identifiers?: IdentifierType): string;
 /** Table name matches the store convention: singular lowercase aggregate name. */
 export declare function getTableName(aggregateName: string): string;
 export declare function getForeignKeyFieldName(fieldName: string): string;
@@ -31,15 +33,15 @@ export declare function isRelationshipField(fieldType: string, availableAggregat
  * Used to determine parent ID column names for child entity tables.
  */
 export declare function buildChildToParentMap(aggregates: Record<string, AggregateConfig>): Map<string, string>;
-export declare function generateCreateTableSQL(name: string, aggregate: AggregateConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>, parentIdField?: string): string;
+export declare function generateCreateTableSQL(name: string, aggregate: AggregateConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>, parentIdField?: string, identifiers?: IdentifierType): string;
 export declare function generateDropTableSQL(tableName: string): string;
-export declare function generateAddColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
+export declare function generateAddColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>, identifiers?: IdentifierType): string;
 export declare function generateDropColumnSQL(tableName: string, columnName: string): string;
-export declare function generateModifyColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
+export declare function generateModifyColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>, identifiers?: IdentifierType): string;
 export declare function loadSchemaState(stateFilePath: string): SchemaState | null;
 export declare function saveSchemaState(stateFilePath: string, state: SchemaState): void;
 export declare function loadMigrationLog(logFilePath: string): MigrationLog;
 export declare function saveMigrationLog(logFilePath: string, log: MigrationLog): void;
-export declare function compareSchemas(oldState: SchemaState | null, newAggregates: Record<string, AggregateConfig>, availableValueObjects?: Set<string>): string[];
+export declare function compareSchemas(oldState: SchemaState | null, newAggregates: Record<string, AggregateConfig>, availableValueObjects?: Set<string>, identifiers?: IdentifierType): string[];
 export declare function generateTimestamp(): string;
 export declare function getMigrationFileName(timestamp: string): string;