@currentjs/gen 0.5.5 → 0.5.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.5.7] - 2026-04-08
+
+- HTTP errors in generated controllers
+
+## [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

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

@@ -43,12 +43,15 @@ const commandUtils_1 = require("../utils/commandUtils");
 const configTypes_1 = require("../types/configTypes");
 const migrationUtils_1 = require("../utils/migrationUtils");
 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
@@ -79,7 +82,7 @@ function collectSchemaFromModules(appYamlPath) {
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.gray(`   Sources: ${sources.join(', ')}`));
     }
-    return { aggregates: allAggregates, valueObjects: allValueObjects };
+    return { aggregates: allAggregates, valueObjects: allValueObjects, identifiers };
 }
 function handleMigrateCommit(yamlPath) {
     try {
@@ -100,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 { aggregates: currentAggregates, valueObjects: currentValueObjects } = collectSchemaFromModules(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.'));
@@ -119,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, currentValueObjects);
+        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.'));

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;
     /**
@@ -10,6 +11,11 @@ export declare class ControllerGenerator {
      * Check if auth config includes owner permission
      */
     private hasOwnerAuth;
+    /**
+     * Determine which HTTP error classes from @currentjs/router are needed
+     * based on the auth configs of all endpoints in a controller.
+     */
+    private getNeededHttpErrorImports;
     /**
      * Generate pre-fetch authentication/authorization check code.
      * This runs before fetching the entity and validates authentication and role-based access.
@@ -52,10 +58,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';
@@ -75,6 +78,28 @@ class ControllerGenerator {
         const roles = this.normalizeAuth(auth);
         return roles.includes(constants_1.AUTH_ROLES.OWNER);
     }
+    /**
+     * Determine which HTTP error classes from @currentjs/router are needed
+     * based on the auth configs of all endpoints in a controller.
+     */
+    getNeededHttpErrorImports(auths) {
+        const needed = new Set();
+        for (const auth of auths) {
+            const roles = this.normalizeAuth(auth);
+            if (roles.length === 0 || (roles.length === 1 && roles[0] === constants_1.AUTH_ROLES.ALL))
+                continue;
+            needed.add('UnauthorizedError');
+            const roleChecks = roles.filter(r => r !== constants_1.AUTH_ROLES.OWNER && r !== constants_1.AUTH_ROLES.ALL && r !== constants_1.AUTH_ROLES.AUTHENTICATED);
+            if (roleChecks.length > 0) {
+                needed.add('ForbiddenError');
+            }
+            if (roles.includes(constants_1.AUTH_ROLES.OWNER)) {
+                needed.add('ForbiddenError');
+                needed.add('NotFoundError');
+            }
+        }
+        return Array.from(needed).sort();
+    }
     /**
      * Generate pre-fetch authentication/authorization check code.
      * This runs before fetching the entity and validates authentication and role-based access.
@@ -89,14 +114,14 @@ class ControllerGenerator {
         // If only 'authenticated' is specified
         if (roles.length === 1 && roles[0] === constants_1.AUTH_ROLES.AUTHENTICATED) {
             return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }`;
         }
         // If only 'owner' is specified - just require authentication here
         // (owner check happens post-fetch)
         if (roles.length === 1 && roles[0] === constants_1.AUTH_ROLES.OWNER) {
             return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }`;
         }
         // Filter out 'owner' and 'all' for role checks (owner is checked post-fetch)
@@ -108,16 +133,16 @@ class ControllerGenerator {
             if (roleChecks.length === 0) {
                 // Only owner (and maybe authenticated) - just require auth
                 return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }`;
             }
             if (roleChecks.length === 1 && !hasOwner) {
                 // Single role check
                 return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }
     if (context.request.user.role !== '${roleChecks[0]}') {
-      throw new Error('${constants_1.AUTH_ERRORS.INSUFFICIENT_PERMISSIONS}: ${roleChecks[0]} role required');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.INSUFFICIENT_PERMISSIONS}: ${roleChecks[0]} role required');
     }`;
             }
             // Multiple roles OR owner - use OR logic
@@ -126,22 +151,22 @@ class ControllerGenerator {
             if (hasOwner) {
                 // With owner: require auth, role check will be combined with owner check post-fetch
                 return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }`;
             }
             // Multiple roles without owner - check if user has ANY of the roles
             const roleConditions = roleChecks.map(r => `context.request.user.role === '${r}'`).join(' || ');
             return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }
     if (!(${roleConditions})) {
-      throw new Error('${constants_1.AUTH_ERRORS.INSUFFICIENT_PERMISSIONS}: one of [${roleChecks.join(', ')}] role required');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.INSUFFICIENT_PERMISSIONS}: one of [${roleChecks.join(', ')}] role required');
     }`;
         }
         // Only 'authenticated' in the mix
         if (hasAuthenticated) {
             return `if (!context.request.user) {
-      throw new Error('${constants_1.AUTH_ERRORS.REQUIRED}');
+      throw new UnauthorizedError('${constants_1.AUTH_ERRORS.REQUIRED}');
     }`;
         }
         return '';
@@ -165,10 +190,10 @@ class ControllerGenerator {
     // Owner validation (post-fetch for reads, via parent)
     const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(${resultVar}.id);
     if (resourceOwnerId === null) {
-      throw new Error('Resource not found');
+      throw new NotFoundError('Resource not found');
     }
     if (resourceOwnerId !== context.request.user?.id) {
-      throw new Error('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
     }`;
             }
             const bypassConditions = bypassRoles.map(r => `context.request.user?.role === '${r}'`).join(' || ');
@@ -176,12 +201,12 @@ class ControllerGenerator {
     // Owner validation (post-fetch for reads, via parent, bypassed for: ${bypassRoles.join(', ')})
     const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(${resultVar}.id);
     if (resourceOwnerId === null) {
-      throw new Error('Resource not found');
+      throw new NotFoundError('Resource not found');
     }
     const isOwner = resourceOwnerId === context.request.user?.id;
     const hasPrivilegedRole = ${bypassConditions};
     if (!isOwner && !hasPrivilegedRole) {
-      throw new Error('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
     }`;
         }
         // Root entity: result has ownerId
@@ -189,7 +214,7 @@ class ControllerGenerator {
             return `
     // Owner validation (post-fetch for reads)
     if (${resultVar}.ownerId !== context.request.user?.id) {
-      throw new Error('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
     }`;
         }
         const bypassConditions = bypassRoles.map(r => `context.request.user?.role === '${r}'`).join(' || ');
@@ -198,7 +223,7 @@ class ControllerGenerator {
     const isOwner = ${resultVar}.ownerId === context.request.user?.id;
     const hasPrivilegedRole = ${bypassConditions};
     if (!isOwner && !hasPrivilegedRole) {
-      throw new Error('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
     }`;
     }
     /**
@@ -222,10 +247,10 @@ class ControllerGenerator {
     // Pre-mutation owner validation
     const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(input.id);
     if (resourceOwnerId === null) {
-      throw new Error('Resource not found');
+      throw new NotFoundError('Resource not found');
     }
     if (resourceOwnerId !== context.request.user?.id) {
-      throw new Error('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
     }
 `;
         }
@@ -235,12 +260,12 @@ class ControllerGenerator {
     // Pre-mutation owner validation (bypassed for: ${bypassRoles.join(', ')})
     const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(input.id);
     if (resourceOwnerId === null) {
-      throw new Error('Resource not found');
+      throw new NotFoundError('Resource not found');
     }
     const isOwner = resourceOwnerId === context.request.user?.id;
     const hasPrivilegedRole = ${bypassConditions};
     if (!isOwner && !hasPrivilegedRole) {
-      throw new Error('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
+      throw new ForbiddenError('${constants_1.AUTH_ERRORS.ACCESS_DENIED}');
     }
 `;
     }
@@ -278,7 +303,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 +454,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 {
@@ -554,7 +581,9 @@ class ControllerGenerator {
         const constructorParams = Array.from(useCaseModels)
             .map(model => `private ${model.toLowerCase()}UseCase: ${model}UseCase`)
             .join(',\n    ');
-        return `import { Controller, Get, Post, Put, Delete, type IContext } from '@currentjs/router';
+        const errorImports = this.getNeededHttpErrorImports(sortedEndpoints.map(e => e.auth));
+        const routerImports = ['Controller', 'Get', 'Post', 'Put', 'Delete', 'type IContext', ...errorImports].join(', ');
+        return `import { ${routerImports} } from '@currentjs/router';
 ${useCaseImports}
 ${dtoImportStatements}
 
@@ -621,7 +650,9 @@ ${methods.join('\n\n')}
     ${constructorParams.join(',\n    ')}
   ) {}`
             : 'constructor() {}';
-        return `import { Controller, Get, Post, Render, type IContext } from '@currentjs/router';
+        const errorImports = this.getNeededHttpErrorImports(sortedPages.map(p => p.auth));
+        const routerImports = ['Controller', 'Get', 'Post', 'Render', 'type IContext', ...errorImports].join(', ');
+        return `import { ${routerImports} } from '@currentjs/router';
 ${useCaseImports}
 ${serviceImports.join('\n')}
 ${dtoImportStatements}
@@ -633,8 +664,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 +687,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>;
 }