@currentjs/gen 0.5.4 → 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);
@@ -130,7 +131,7 @@ class StoreGenerator {
         const voFields = Object.keys(voConfig.fields);
         if (voFields.length > 1) {
             const voArgs = voFields.map(f => `parsed.${f}`).join(', ');
-            return `      row.${fieldName} ? (() => { const parsed = JSON.parse(row.${fieldName}); return new ${voName}(${voArgs}); })() : undefined`;
+            return `      row.${fieldName} ? (() => { const parsed = this.ensureParsed(row.${fieldName}); return new ${voName}(${voArgs}); })() : undefined`;
         }
         if (voFields.length === 1) {
             const singleFieldType = voConfig.fields[voFields[0]];
@@ -141,7 +142,7 @@ class StoreGenerator {
             }
             return `      row.${fieldName} ? new ${voName}(row.${fieldName}) : undefined`;
         }
-        return `      row.${fieldName} ? new ${voName}(...Object.values(JSON.parse(row.${fieldName}))) : undefined`;
+        return `      row.${fieldName} ? new ${voName}(...Object.values(this.ensureParsed(row.${fieldName}))) : undefined`;
     }
     /** Deserialization for an array-of-VOs field. */
     generateArrayVoDeserialization(fieldName, voName, voConfig) {
@@ -149,7 +150,7 @@ class StoreGenerator {
         const itemArgs = voFields.length > 0
             ? voFields.map(f => `item.${f}`).join(', ')
             : '...Object.values(item)';
-        return `      row.${fieldName} ? (JSON.parse(row.${fieldName}) as any[]).map((item: any) => new ${voName}(${itemArgs})) : []`;
+        return `      row.${fieldName} ? (this.ensureParsed(row.${fieldName}) as any[]).map((item: any) => new ${voName}(${itemArgs})) : []`;
     }
     /** Deserialization for a union-of-VOs field. Uses _type discriminator. */
     generateUnionVoDeserialization(fieldName, unionVoNames, unionVoConfigs) {
@@ -161,7 +162,7 @@ class StoreGenerator {
                 : '...Object.values(parsed)';
             return `if (parsed._type === '${voName}') return new ${voName}(${args});`;
         }).join(' ');
-        return `      row.${fieldName} ? (() => { const parsed = JSON.parse(row.${fieldName}); ${cases} return undefined; })() : undefined`;
+        return `      row.${fieldName} ? (() => { const parsed = this.ensureParsed(row.${fieldName}); ${cases} return undefined; })() : undefined`;
     }
     /** Serialization for an array-of-union-VOs field. Each element tagged with _type discriminator. */
     generateArrayUnionVoSerialization(fieldName, unionVoNames) {
@@ -181,7 +182,7 @@ class StoreGenerator {
                 : '...Object.values(item)';
             return `if (item._type === '${voName}') return new ${voName}(${args});`;
         }).join(' ');
-        return `      row.${fieldName} ? (JSON.parse(row.${fieldName}) as any[]).map((item: any) => { ${cases} return undefined; }) : []`;
+        return `      row.${fieldName} ? (this.ensureParsed(row.${fieldName}) as any[]).map((item: any) => { ${cases} return undefined; }) : []`;
     }
     /** Single line for datetime conversion: toDate (row->model) or toMySQL (entity->row). */
     generateDatetimeConversion(fieldName, direction) {
@@ -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 = [];
@@ -233,7 +252,7 @@ class StoreGenerator {
             }
             // Handle aggregate reference - create stub from FK
             if (this.isAggregateField(fieldConfig)) {
-                result.push(`      row.${fieldName}_id != null ? ({ id: row.${fieldName}_id } as unknown as ${fieldType}) : undefined`);
+                result.push(`      row.${fieldName}Id != null ? ({ id: row.${fieldName}Id } as unknown as ${fieldType}) : undefined`);
                 return;
             }
             // Handle datetime/date conversion
@@ -283,7 +302,7 @@ class StoreGenerator {
                     result.push(this.generateValueObjectDeserialization(fieldName, voName, voConfig));
                 }
                 else {
-                    result.push(`      row.${fieldName} ? new ${voName}(...Object.values(JSON.parse(row.${fieldName}))) : undefined`);
+                    result.push(`      row.${fieldName} ? new ${voName}(...Object.values(this.ensureParsed(row.${fieldName}))) : undefined`);
                 }
                 return;
             }
@@ -299,7 +318,7 @@ class StoreGenerator {
             const fieldType = fieldConfig.type;
             // Handle aggregate reference - extract FK id
             if (this.isAggregateField(fieldConfig)) {
-                result.push(`      ${fieldName}_id: entity.${fieldName}?.id`);
+                result.push(`      ${fieldName}Id: entity.${fieldName}?.id`);
                 return;
             }
             // Handle datetime/date - convert Date to MySQL DATETIME format
@@ -342,7 +361,7 @@ class StoreGenerator {
             .map(([fieldName, fieldConfig]) => {
             const fieldType = fieldConfig.type;
             if (this.isAggregateField(fieldConfig)) {
-                return `      ${fieldName}_id: entity.${fieldName}?.id`;
+                return `      ${fieldName}Id: entity.${fieldName}?.id`;
             }
             if (fieldType === 'datetime' || fieldType === 'date') {
                 return this.generateDatetimeConversion(fieldName, 'toMySQL');
@@ -371,7 +390,7 @@ class StoreGenerator {
             .join(',\n');
     }
     generateUpdateFieldsArray(fields) {
-        return JSON.stringify(fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : name));
+        return JSON.stringify(fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name));
     }
     generateValueObjectImports(fields) {
         const imports = [];
@@ -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
@@ -423,7 +448,7 @@ class StoreGenerator {
     const offset = (page - 1) * limit;${ownerFilter}
     const params: Record<string, any> = { limit: String(limit), offset: String(offset) };${ownerParamsSetup}
     const result = await this.db.query(
-      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL${ownerFilterRef} LIMIT :limit OFFSET :offset\`,
+      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef} LIMIT :limit OFFSET :offset\`,
       params
     );
 
@@ -432,10 +457,10 @@ 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 deleted_at IS NULL${ownerFilterRef}\`,
+      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef}\`,
       params
     );
 
@@ -444,10 +469,10 @@ 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 deleted_at IS NULL${ownerFilterRef}\`,
+      \`SELECT COUNT(*) as count FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef}\`,
       params
     );
 
@@ -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 deleted_at 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.deleted_at 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 deleted_at 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,11 +3,11 @@ 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}}
-  created_at: string;
-  updated_at: string;
-  deleted_at?: string;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }`,
     storeClass: `/**
  * Data access layer for {{ENTITY_NAME}}
@@ -22,19 +22,23 @@ export class {{ENTITY_NAME}}Store {
     return date.toISOString().slice(0, 19).replace('T', ' ');
   }
 
+  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 deleted_at 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) {
@@ -45,41 +49,45 @@ 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}},
-      created_at: this.toMySQLDatetime(now),
-      updated_at: this.toMySQLDatetime(now)
+{{INSERT_ID_DATA}}{{INSERT_DATA_MAPPING}},
+      createdAt: this.toMySQLDatetime(now),
+      updatedAt: this.toMySQLDatetime(now)
     };
 
-    const fieldsList = Object.keys(data).map(f => \`\\\`\${f}\\\`\`).join(', ');
-    const placeholders = Object.keys(data).map(f => \`:\${f}\`).join(', ');
+    const cleanData = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
+    const fieldsList = Object.keys(cleanData).map(f => \`\\\`\${f}\\\`\`).join(', ');
+    const placeholders = Object.keys(cleanData).map(f => \`:\${f}\`).join(', ');
 
     const result = await this.db.query(
       \`INSERT INTO \\\`\${this.tableName}\\\` (\${fieldsList}) VALUES (\${placeholders})\`,
-      data
+      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 data: Partial<{{ENTITY_NAME}}Row> & { id: number } = {
+    const rawData: Partial<{{ENTITY_NAME}}Row> = {
 {{UPDATE_DATA_MAPPING}},
-      updated_at: this.toMySQLDatetime(now),
-      id
+      updatedAt: this.toMySQLDatetime(now)
     };
 
-    const updateFields = {{UPDATE_FIELDS_ARRAY}}.map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
+    const cleanData = Object.fromEntries(Object.entries(rawData).filter(([, v]) => v !== undefined));
+    const updateFields = {{UPDATE_FIELDS_ARRAY}}
+      .filter(f => f in cleanData)
+      .map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
 
     const result = await this.db.query(
-      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updated_at = :updated_at WHERE id = :id\`,
-      data
+      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updatedAt = :updatedAt WHERE {{WHERE_ID_EXPR}}\`,
+      { ...cleanData, id{{ID_PARAM_EXPR}} }
     );
 
     if (result.success) {
@@ -89,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 deleted_at = :deleted_at WHERE id = :id\`,
-      { deleted_at: 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;
@@ -112,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?: {