@currentjs/gen 0.5.5 → 0.5.7

package/dist/generators/serviceGenerator.js

@@ -45,6 +45,7 @@ const typeUtils_1 = require("../utils/typeUtils");
 class ServiceGenerator {
     constructor() {
         this.availableAggregates = new Map();
+        this.identifiers = 'numeric';
     }
     mapType(yamlType) {
         return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates);
@@ -177,8 +178,9 @@ class ServiceGenerator {
     }
     generateListHandler(modelName, storeName, hasPagination) {
         const returnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         if (hasPagination) {
-            return `  async list(page: number = 1, limit: number = 20, ownerId?: number): Promise<${returnType}> {
+            return `  async list(page: number = 1, limit: number = 20, ownerId?: ${idTs}): Promise<${returnType}> {
     const [items, total] = await Promise.all([
       this.${storeName}.getPaginated(page, limit, ownerId),
       this.${storeName}.count(ownerId)
@@ -186,13 +188,14 @@ class ServiceGenerator {
     return { items, total, page, limit };
   }`;
         }
-        return `  async list(ownerId?: number): Promise<${returnType}> {
+        return `  async list(ownerId?: ${idTs}): Promise<${returnType}> {
     const items = await this.${storeName}.getAll(ownerId);
     return { items, total: items.length, page: 1, limit: items.length };
   }`;
     }
     generateGetHandler(modelName, storeName, entityLower) {
-        return `  async get(id: number): Promise<${modelName}> {
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+        return `  async get(id: ${idTs}): Promise<${modelName}> {
     const ${entityLower} = await this.${storeName}.getById(id);
     if (!${entityLower}) {
       throw new Error('${modelName} not found');
@@ -227,12 +230,14 @@ class ServiceGenerator {
             return `input.${fieldName}`;
         }).join(', ');
         const constructorArgs = `input.${firstArgField}, ${fieldArgs}`;
+        const idPlaceholder = this.identifiers === 'numeric' ? '0' : "''";
         return `  async create(input: ${inputType}): Promise<${modelName}> {
-    const ${entityLower} = new ${modelName}(0, ${constructorArgs});
+    const ${entityLower} = new ${modelName}(${idPlaceholder}, ${constructorArgs});
     return await this.${storeName}.insert(${entityLower});
   }`;
     }
-    generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields) {
+    generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields, _identifiers) {
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         const setterCalls = Object.entries(aggregateConfig.fields)
             .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id' && dtoFields.has(fieldName))
             .map(([fieldName, fieldConfig]) => {
@@ -253,7 +258,7 @@ class ServiceGenerator {
     }`;
         })
             .join('\n');
-        return `  async update(id: number, input: ${inputType}): Promise<${modelName}> {
+        return `  async update(id: ${idTs}, input: ${inputType}): Promise<${modelName}> {
     const existing${modelName} = await this.${storeName}.getById(id);
     if (!existing${modelName}) {
       throw new Error('${modelName} not found');
@@ -265,7 +270,8 @@ ${setterCalls}
   }`;
     }
     generateDeleteHandler(modelName, storeName) {
-        return `  async delete(id: number): Promise<{ success: boolean; message: string }> {
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+        return `  async delete(id: ${idTs}): Promise<{ success: boolean; message: string }> {
     const success = await this.${storeName}.softDelete(id);
     if (!success) {
       throw new Error('${modelName} not found or could not be deleted');
@@ -316,19 +322,21 @@ ${setterCalls}
         if (!childInfo)
             return '';
         const storeVar = `${modelName.toLowerCase()}Store`;
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         return `
-  async listByParent(parentId: number): Promise<${modelName}[]> {
+  async listByParent(parentId: ${idTs}): Promise<${modelName}[]> {
     return await this.${storeVar}.getByParentId(parentId);
   }`;
     }
     generateGetResourceOwnerMethod(modelName) {
         const storeVar = `${modelName.toLowerCase()}Store`;
+        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.
    */
-  async getResourceOwner(id: number): Promise<number | null> {
+  async getResourceOwner(id: ${idTs}): Promise<${idTs} | null> {
     return await this.${storeVar}.getResourceOwner(id);
   }`;
     }
@@ -411,8 +419,9 @@ export class ${serviceName} {
 ${methods.join('\n\n')}
 }`;
     }
-    generateFromConfig(config) {
+    generateFromConfig(config, identifiers = 'numeric') {
         const result = {};
+        this.identifiers = identifiers;
         // Collect all aggregates
         if (config.domain.aggregates) {
             Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
@@ -432,16 +441,16 @@ ${methods.join('\n\n')}
         });
         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 servicesByModel = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const servicesByModel = this.generateFromYamlFile(yamlFilePath, identifiers);
         const servicesDir = path.join(moduleDir, 'application', 'services');
         fs.mkdirSync(servicesDir, { recursive: true });
         for (const [modelName, code] of Object.entries(servicesByModel)) {

package/dist/generators/storeGenerator.d.ts

@@ -1,7 +1,8 @@
-import { ModuleConfig } from '../types/configTypes';
+import { ModuleConfig, IdentifierType } from '../types/configTypes';
 export declare class StoreGenerator {
     private availableValueObjects;
     private availableAggregates;
+    private identifiers;
     private isAggregateField;
     private isValueObjectType;
     private isArrayVoType;
@@ -51,11 +52,17 @@ export declare class StoreGenerator {
     private generateListMethods;
     private generateGetByParentIdMethod;
     private generateGetResourceOwnerMethod;
+    private generateIdHelpers;
+    private generateInsertIdVariables;
+    private generateWhereIdExpr;
+    private generateIdParamExpr;
+    private generateRowIdExpr;
+    private generateCryptoImport;
     private generateStore;
-    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/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>;
 }