@currentjs/gen 0.5.4 → 0.5.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.5.6] - 2026-04-08
+
+- database identifier types (numeric, uuid, nanoid)
+
+## [0.5.5] - 2026-04-07
+
+- data access layer generation fixes and improvements
+
 ## [0.5.4] - 2026-04-07
 
 - Array and union value objects

package/README.md

@@ -492,6 +492,8 @@ Collects all aggregate definitions from module YAMLs, compares them against the
 
 The migration file contains `CREATE TABLE`, `ALTER TABLE ADD/MODIFY/DROP COLUMN`, and `DROP TABLE` statements as needed. Foreign keys, indexes, and standard timestamp columns (`created_at`, `updated_at`, `deleted_at`) are handled automatically.
 
+The SQL types of primary keys and foreign keys are determined by the `config.identifiers` setting in `app.yaml`.
+
 After generating the file, the schema state is updated so the next `migrate commit` only produces a diff of subsequent changes.
 
 ### `migrate push` *(not yet implemented)*

package/dist/commands/generateAll.js

@@ -81,18 +81,19 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
         const moduleDir = path.dirname(moduleYamlPath);
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.blue(`\nGenerating module: ${path.basename(moduleDir)}`));
+        const identifiers = entry.identifiers;
         // eslint-disable-next-line no-await-in-loop
-        await domainGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        await domainGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts, identifiers);
         // eslint-disable-next-line no-await-in-loop
-        await dtoGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        await dtoGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts, identifiers);
         // eslint-disable-next-line no-await-in-loop
-        await useCaseGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        await useCaseGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts, identifiers);
         // eslint-disable-next-line no-await-in-loop
-        await serviceGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        await serviceGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts, identifiers);
         // eslint-disable-next-line no-await-in-loop
-        await storeGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        await storeGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts, identifiers);
         // eslint-disable-next-line no-await-in-loop
-        await controllerGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        await controllerGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts, identifiers);
         // eslint-disable-next-line no-await-in-loop
         await templateGen.generateAndSaveFiles(moduleYamlPath, moduleDir, { force: opts === null || opts === void 0 ? void 0 : opts.force, skipOnConflict: opts === null || opts === void 0 ? void 0 : opts.skip, onlyIfMissing: !(opts === null || opts === void 0 ? void 0 : opts.withTemplates) });
         // Find srcDir by probing upward for app.ts

package/dist/commands/migrateCommit.js

@@ -42,12 +42,16 @@ const cliUtils_1 = require("../utils/cliUtils");
 const commandUtils_1 = require("../utils/commandUtils");
 const configTypes_1 = require("../types/configTypes");
 const migrationUtils_1 = require("../utils/migrationUtils");
-function collectAggregatesFromModules(appYamlPath) {
+function collectSchemaFromModules(appYamlPath) {
+    var _a, _b;
     const appConfig = (0, commandUtils_1.loadAppConfig)(appYamlPath);
     const moduleEntries = (0, commandUtils_1.getModuleEntries)(appConfig);
     const projectRoot = path.dirname(appYamlPath);
     const allAggregates = {};
+    const allValueObjects = new Set();
     const sources = [];
+    const rawIdentifiers = (_b = (_a = appConfig.config) === null || _a === void 0 ? void 0 : _a.identifiers) !== null && _b !== void 0 ? _b : 'numeric';
+    const identifiers = (0, configTypes_1.normalizeIdentifierType)(rawIdentifiers);
     for (const entry of moduleEntries) {
         const moduleYamlPath = path.isAbsolute(entry.path)
             ? entry.path
@@ -67,13 +71,18 @@ function collectAggregatesFromModules(appYamlPath) {
         const aggregates = moduleConfig.domain.aggregates;
         const count = Object.keys(aggregates).length;
         Object.assign(allAggregates, aggregates);
+        if (moduleConfig.domain.valueObjects) {
+            for (const voName of Object.keys(moduleConfig.domain.valueObjects)) {
+                allValueObjects.add(voName);
+            }
+        }
         sources.push(`${entry.name} (${count} aggregate(s))`);
     }
     if (sources.length > 0) {
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.gray(`   Sources: ${sources.join(', ')}`));
     }
-    return allAggregates;
+    return { aggregates: allAggregates, valueObjects: allValueObjects, identifiers };
 }
 function handleMigrateCommit(yamlPath) {
     try {
@@ -94,7 +103,7 @@ function handleMigrateCommit(yamlPath) {
         }
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.cyan('\n📋 Collecting aggregates from all modules...'));
-        const currentAggregates = collectAggregatesFromModules(resolvedYamlPath);
+        const { aggregates: currentAggregates, valueObjects: currentValueObjects, identifiers } = collectSchemaFromModules(resolvedYamlPath);
         if (Object.keys(currentAggregates).length === 0) {
             // eslint-disable-next-line no-console
             console.log(colors_1.colors.yellow('⚠️  No aggregates found in module configuration.'));
@@ -113,7 +122,7 @@ function handleMigrateCommit(yamlPath) {
         }
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.cyan('\n🔍 Comparing schemas...'));
-        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentAggregates);
+        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentAggregates, currentValueObjects, identifiers);
         if (sqlStatements.length === 0 || sqlStatements.every(s => s.trim() === '' || s.startsWith('--'))) {
             // eslint-disable-next-line no-console
             console.log(colors_1.colors.yellow('⚠️  No changes detected. Schema is up to date.'));
@@ -132,7 +141,7 @@ function handleMigrateCommit(yamlPath) {
         const newState = {
             aggregates: currentAggregates,
             version: timestamp,
-            timestamp: new Date().toISOString()
+            timestamp: new Date().toISOString(),
         };
         (0, migrationUtils_1.saveSchemaState)(stateFilePath, newState);
         // eslint-disable-next-line no-console

package/dist/generators/controllerGenerator.d.ts

@@ -1,5 +1,6 @@
-import { ModuleConfig } from '../types/configTypes';
+import { ModuleConfig, IdentifierType } from '../types/configTypes';
 export declare class ControllerGenerator {
+    private identifiers;
     private getHttpDecorator;
     private parseUseCase;
     /**
@@ -52,10 +53,10 @@ export declare class ControllerGenerator {
     private resolveLayout;
     private generateApiController;
     private generateWebController;
-    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<string[]>;
+    }, identifiers?: IdentifierType): Promise<string[]>;
 }

package/dist/generators/controllerGenerator.js

@@ -44,6 +44,9 @@ const childEntityUtils_1 = require("../utils/childEntityUtils");
 const typeUtils_1 = require("../utils/typeUtils");
 const constants_1 = require("../utils/constants");
 class ControllerGenerator {
+    constructor() {
+        this.identifiers = 'numeric';
+    }
     getHttpDecorator(method) {
         switch (method.toUpperCase()) {
             case 'GET': return 'Get';
@@ -278,7 +281,8 @@ class ControllerGenerator {
                 parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ${childInfo.parentIdField}: context.request.parameters.${childInfo.parentIdField} });`;
             }
             else {
-                parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ownerId: context.request.user?.id });`;
+                const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+                parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ownerId: context.request.user?.id as ${idTs} });`;
             }
         }
         else if (action === 'update') {
@@ -428,7 +432,8 @@ class ControllerGenerator {
                     parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ${childInfo.parentIdField}: context.request.parameters.${childInfo.parentIdField} });`;
                 }
                 else {
-                    parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ownerId: context.request.user?.id });`;
+                    const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+                    parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ownerId: context.request.user?.id as ${idTs} });`;
                 }
             }
             else {
@@ -633,8 +638,9 @@ export class ${controllerName} {
 ${methods.join('\n\n')}
 }`;
     }
-    generateFromConfig(config) {
+    generateFromConfig(config, identifiers = 'numeric') {
         const result = {};
+        this.identifiers = identifiers;
         const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
         // Generate API controllers
         if (config.api) {
@@ -655,16 +661,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 domain/useCases/api/web structure.');
         }
-        return this.generateFromConfig(config);
+        return this.generateFromConfig(config, identifiers);
     }
-    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
-        const controllersByName = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const controllersByName = this.generateFromYamlFile(yamlFilePath, identifiers);
         const controllersDir = path.join(moduleDir, 'infrastructure', 'controllers');
         fs.mkdirSync(controllersDir, { recursive: true });
         const generatedPaths = [];

package/dist/generators/domainLayerGenerator.d.ts

@@ -1,21 +1,22 @@
-import { ModuleConfig } from '../types/configTypes';
+import { ModuleConfig, IdentifierType } from '../types/configTypes';
 export declare class DomainLayerGenerator {
     private availableAggregates;
     private availableValueObjects;
+    private identifiers;
     private mapType;
     private getDefaultValue;
     private generateValueObject;
     private generateAggregate;
-    generateFromConfig(config: ModuleConfig): Record<string, {
+    generateFromConfig(config: ModuleConfig, identifiers?: IdentifierType): Record<string, {
         code: string;
         type: 'entity' | 'valueObject';
     }>;
-    generateFromYamlFile(yamlFilePath: string): Record<string, {
+    generateFromYamlFile(yamlFilePath: string, identifiers?: IdentifierType): Record<string, {
         code: string;
         type: 'entity' | 'valueObject';
     }>;
     generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
         force?: boolean;
         skipOnConflict?: boolean;
-    }): Promise<void>;
+    }, identifiers?: IdentifierType): Promise<void>;
 }

package/dist/generators/domainLayerGenerator.js

@@ -46,6 +46,7 @@ class DomainLayerGenerator {
     constructor() {
         this.availableAggregates = new Set();
         this.availableValueObjects = new Set();
+        this.identifiers = 'numeric';
     }
     mapType(yamlType) {
         return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates, this.availableValueObjects);
@@ -154,12 +155,13 @@ class DomainLayerGenerator {
             .join('\n');
         const imports = [entityImports, valueObjectImports, aggregateRefImports].filter(Boolean).join('\n');
         // Generate constructor parameters: id, then ownerId (root) or parentId field (child)
-        const constructorParams = ['public id: number'];
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+        const constructorParams = [`public id: ${idTs}`];
         if (childInfo) {
-            constructorParams.push(`public ${childInfo.parentIdField}: number`);
+            constructorParams.push(`public ${childInfo.parentIdField}: ${idTs}`);
         }
         else {
-            constructorParams.push('public ownerId: number');
+            constructorParams.push(`public ownerId: ${idTs}`);
         }
         // Sort fields: required first, then optional
         // Fields are required by default unless required: false
@@ -256,8 +258,9 @@ class DomainLayerGenerator {
 ${setterMethods}
 }`;
     }
-    generateFromConfig(config) {
+    generateFromConfig(config, identifiers = 'numeric') {
         const result = {};
+        this.identifiers = identifiers;
         // First pass: collect all aggregate and value object names
         if (config.domain.aggregates) {
             Object.keys(config.domain.aggregates).forEach(name => {
@@ -291,16 +294,16 @@ ${setterMethods}
         }
         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 codeByEntity = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const codeByEntity = this.generateFromYamlFile(yamlFilePath, identifiers);
         const entitiesDir = path.join(moduleDir, 'domain', 'entities');
         const valueObjectsDir = path.join(moduleDir, 'domain', 'valueObjects');
         fs.mkdirSync(entitiesDir, { recursive: true });

package/dist/generators/dtoGenerator.d.ts

@@ -1,7 +1,8 @@
-import { ModuleConfig } from '../types/configTypes';
+import { ModuleConfig, IdentifierType } from '../types/configTypes';
 export declare class DtoGenerator {
     private availableAggregates;
     private availableValueObjects;
+    private identifiers;
     private mapType;
     private isValueObjectType;
     private getValidationCode;
@@ -12,10 +13,10 @@ export declare class DtoGenerator {
      * Collect types that need to be imported for a use case DTO.
      */
     private collectRequiredImports;
-    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/dtoGenerator.js

@@ -46,6 +46,7 @@ class DtoGenerator {
     constructor() {
         this.availableAggregates = new Map();
         this.availableValueObjects = new Map();
+        this.identifiers = 'numeric';
     }
     mapType(yamlType) {
         return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates, this.availableValueObjects);
@@ -116,13 +117,17 @@ class DtoGenerator {
         // Handle identifier (for get, update, delete)
         if (inputConfig.identifier) {
             const fieldName = inputConfig.identifier;
-            fieldDeclarations.push(`  readonly ${fieldName}: number;`);
-            constructorParams.push(`${fieldName}: number`);
+            const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+            const idTransform = this.identifiers === 'numeric'
+                ? `typeof b.${fieldName} === 'string' ? parseInt(b.${fieldName}, 10) : b.${fieldName} as number`
+                : `b.${fieldName} as string`;
+            fieldDeclarations.push(`  readonly ${fieldName}: ${idTs};`);
+            constructorParams.push(`${fieldName}: ${idTs}`);
             constructorAssignments.push(`    this.${fieldName} = ${fieldName};`);
             validationChecks.push(`    if (b.${fieldName} === undefined || b.${fieldName} === null) {
       throw new Error('${fieldName} is required');
     }`);
-            fieldTransforms.push(`      ${fieldName}: typeof b.${fieldName} === 'string' ? parseInt(b.${fieldName}, 10) : b.${fieldName} as number`);
+            fieldTransforms.push(`      ${fieldName}: ${idTransform}`);
         }
         // Handle pagination
         if (inputConfig.pagination) {
@@ -158,21 +163,26 @@ class DtoGenerator {
             const isCreateAction = !inputConfig.identifier && !inputConfig.partial;
             if (isCreateAction) {
                 const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
-                fieldDeclarations.push(`  readonly ${ownerOrParentField}: number;`);
-                constructorParams.push(`${ownerOrParentField}: number`);
+                const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+                const ownerTransform = this.identifiers === 'numeric'
+                    ? `typeof b.${ownerOrParentField} === 'string' ? parseInt(b.${ownerOrParentField}, 10) : b.${ownerOrParentField} as number`
+                    : `b.${ownerOrParentField} as string`;
+                fieldDeclarations.push(`  readonly ${ownerOrParentField}: ${idTs};`);
+                constructorParams.push(`${ownerOrParentField}: ${idTs}`);
                 constructorAssignments.push(`    this.${ownerOrParentField} = ${ownerOrParentField};`);
                 validationChecks.push(`    if (b.${ownerOrParentField} === undefined || b.${ownerOrParentField} === null) {
       throw new Error('${ownerOrParentField} is required');
     }`);
-                fieldTransforms.push(`      ${ownerOrParentField}: typeof b.${ownerOrParentField} === 'string' ? parseInt(b.${ownerOrParentField}, 10) : b.${ownerOrParentField} as number`);
+                fieldTransforms.push(`      ${ownerOrParentField}: ${ownerTransform}`);
             }
             // Add fields
+            const aggIdTs = (0, configTypes_1.idTsType)(this.identifiers);
             fieldsToInclude.forEach(([fieldName, fieldConfig]) => {
                 if (fieldName === 'id' || fieldConfig.auto)
                     return;
                 const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
-                const tsType = isAggRef ? 'number' : this.mapType(fieldConfig.type);
-                const effectiveFieldType = isAggRef ? 'number' : fieldConfig.type;
+                const tsType = isAggRef ? aggIdTs : this.mapType(fieldConfig.type);
+                const effectiveFieldType = isAggRef ? (this.identifiers === 'numeric' ? 'number' : 'string') : fieldConfig.type;
                 // Aggregate references are always optional in DTOs; other fields default to required
                 const isRequired = !isAggRef && !inputConfig.partial && fieldConfig.required !== false;
                 const optional = isRequired ? '' : '?';
@@ -252,8 +262,9 @@ ${transformsStr}
         const fromMappings = [];
         // Always include id for entity outputs
         if (outputConfig.from) {
-            fieldDeclarations.push(`  readonly id: number;`);
-            constructorParams.push(`id: number`);
+            const idTs = (0, configTypes_1.idTsType)(this.identifiers);
+            fieldDeclarations.push(`  readonly id: ${idTs};`);
+            constructorParams.push(`id: ${idTs}`);
             fromMappings.push(`      id: entity.id`);
         }
         // Handle fields from aggregate (pick)
@@ -265,11 +276,12 @@ ${transformsStr}
                 fieldsToInclude = fieldsToInclude.filter(([fieldName]) => outputConfig.pick.includes(fieldName));
             }
             // Add fields
+            const idTs = (0, configTypes_1.idTsType)(this.identifiers);
             fieldsToInclude.forEach(([fieldName, fieldConfig]) => {
                 if (fieldName === 'id')
                     return;
                 const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
-                const tsType = isAggRef ? 'number' : this.mapType(fieldConfig.type);
+                const tsType = isAggRef ? idTs : this.mapType(fieldConfig.type);
                 const isOptional = fieldConfig.required === false || isAggRef;
                 const optional = isOptional ? '?' : '';
                 fieldDeclarations.push(`  readonly ${fieldName}${optional}: ${tsType};`);
@@ -447,8 +459,9 @@ ${mappingsStr}
         }
         return { valueObjects, entities };
     }
-    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]) => {
@@ -498,16 +511,16 @@ ${mappingsStr}
         });
         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 dtosByName = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const dtosByName = this.generateFromYamlFile(yamlFilePath, identifiers);
         const dtoDir = path.join(moduleDir, 'application', 'dto');
         fs.mkdirSync(dtoDir, { recursive: true });
         for (const [name, code] of Object.entries(dtosByName)) {

package/dist/generators/serviceGenerator.d.ts

@@ -1,6 +1,7 @@
-import { ModuleConfig } from '../types/configTypes';
+import { ModuleConfig, IdentifierType } from '../types/configTypes';
 export declare class ServiceGenerator {
     private availableAggregates;
+    private identifiers;
     private mapType;
     private getDefaultHandlerReturnType;
     private buildHandlerContextMap;
@@ -19,10 +20,10 @@ export declare class ServiceGenerator {
     private generateListByParentMethod;
     private generateGetResourceOwnerMethod;
     private generateService;
-    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/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>;
 }