@currentjs/gen 0.5.0 → 0.5.2

package/dist/commands/createModule.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const cliUtils_1 = require("../utils/cliUtils");
 const yaml_1 = require("yaml");
+const colors_1 = require("../utils/colors");
 function moduleYamlTemplate(moduleName) {
     const entityName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
     const lower = moduleName.charAt(0).toLowerCase() + moduleName.slice(1);
@@ -226,4 +227,16 @@ function handleCreateModule(name) {
         appConfig.modules[moduleKey] = { path: moduleYamlRel };
     }
     fs.writeFileSync(appYamlPath, (0, yaml_1.stringify)(appConfig), 'utf8');
+    const output = `
+${colors_1.colors.green(`Module ${colors_1.colors.bold(name)} has been created`)}
+
+Run command ${colors_1.colors.green(colors_1.colors.bold(`current create model ${name}:modelname`))}
+  where ${colors_1.colors.italic(colors_1.colors.yellow('modelname'))} is name of the model in your module.
+At the end, that command will suggest you to create CRUD actions for the model and further steps.
+You can run this command as many times as needed.
+
+Alternatively, you may consider modifying module's config manually, and then run ${colors_1.colors.bold(colors_1.colors.green('current generate'))}
+  ${colors_1.colors.gray('config:')} ${colors_1.colors.cyan(colors_1.colors.italic(moduleYamlFile))}
+`;
+    console.log(output);
 }

package/dist/commands/generateAll.d.ts

@@ -1,4 +1,5 @@
 export declare function handleGenerateAll(yamlPathArg?: string, _outArg?: string, moduleName?: string, opts?: {
     force?: boolean;
     skip?: boolean;
+    withTemplates?: boolean;
 }): Promise<void>;

package/dist/commands/generateAll.js

@@ -94,7 +94,7 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
         // eslint-disable-next-line no-await-in-loop
         await controllerGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
         // eslint-disable-next-line no-await-in-loop
-        await templateGen.generateAndSaveFiles(moduleYamlPath, moduleDir, opts);
+        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
         let probeDir = moduleDir;
         let srcDir = null;

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function handleInit(rawName?: string): void;

package/dist/commands/{createApp.js → init.js}

@@ -33,11 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCreateApp = handleCreateApp;
+exports.handleInit = handleInit;
 const path = __importStar(require("path"));
 const cliUtils_1 = require("../utils/cliUtils");
 const appTemplates_1 = require("../generators/templates/appTemplates");
-function handleCreateApp(rawName) {
+function handleInit(rawName) {
     const targetRoot = rawName ? (0, cliUtils_1.toAbsolute)(rawName) : process.cwd();
     (0, cliUtils_1.ensureDir)(targetRoot);
     // Basic structure using constants

package/dist/commands/migrateCommit.js

@@ -39,70 +39,41 @@ const path = __importStar(require("path"));
 const yaml_1 = require("yaml");
 const colors_1 = require("../utils/colors");
 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 collectModelsFromYaml(yamlPath) {
-    const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-    const config = (0, yaml_1.parse)(yamlContent);
-    const projectRoot = path.dirname(yamlPath);
-    const allModels = [];
+function collectAggregatesFromModules(appYamlPath) {
+    const appConfig = (0, commandUtils_1.loadAppConfig)(appYamlPath);
+    const moduleEntries = (0, commandUtils_1.getModuleEntries)(appConfig);
+    const projectRoot = path.dirname(appYamlPath);
+    const allAggregates = {};
     const sources = [];
-    // Check if it's a module YAML (has models directly)
-    if (config.models) {
-        allModels.push(...config.models);
-        sources.push(`app.yaml (${config.models.length} model(s))`);
-    }
-    // App YAML: modules as Record<string, { path }> — resolve path and read module YAML for .models
-    if (config.modules && typeof config.modules === 'object' && !Array.isArray(config.modules)) {
-        let moduleCount = 0;
-        for (const entry of Object.values(config.modules)) {
-            const modulePath = entry.path;
-            if (!modulePath)
-                continue;
-            const moduleYamlPath = path.isAbsolute(modulePath)
-                ? modulePath
-                : path.resolve(projectRoot, modulePath);
-            if (fs.existsSync(moduleYamlPath)) {
-                const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
-                const moduleConfig = (0, yaml_1.parse)(moduleYamlContent);
-                if (moduleConfig.models) {
-                    allModels.push(...moduleConfig.models);
-                    moduleCount++;
-                }
-            }
-        }
-        if (moduleCount > 0) {
-            sources.push(`app.yaml modules section (${moduleCount} module(s))`);
-        }
-    }
-    // Also check for module YAMLs in src/modules/*/module.yaml (as fallback)
-    const modulesDir = path.join(projectRoot, 'src', 'modules');
-    if (fs.existsSync(modulesDir)) {
-        const moduleFolders = fs.readdirSync(modulesDir).filter(f => {
-            const stat = fs.statSync(path.join(modulesDir, f));
-            return stat.isDirectory();
-        });
-        let moduleYamlCount = 0;
-        for (const moduleFolder of moduleFolders) {
-            const moduleYamlPath = path.join(modulesDir, moduleFolder, 'module.yaml');
-            if (fs.existsSync(moduleYamlPath)) {
-                const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
-                const moduleConfig = (0, yaml_1.parse)(moduleYamlContent);
-                if (moduleConfig.models) {
-                    allModels.push(...moduleConfig.models);
-                    moduleYamlCount++;
-                }
-            }
+    for (const entry of moduleEntries) {
+        const moduleYamlPath = path.isAbsolute(entry.path)
+            ? entry.path
+            : path.resolve(projectRoot, entry.path);
+        if (!fs.existsSync(moduleYamlPath)) {
+            // eslint-disable-next-line no-console
+            console.warn(colors_1.colors.yellow(`   Module YAML not found: ${moduleYamlPath}`));
+            continue;
         }
-        if (moduleYamlCount > 0) {
-            sources.push(`src/modules/*/module.yaml (${moduleYamlCount} module(s))`);
+        const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
+        const moduleConfig = (0, yaml_1.parse)(moduleYamlContent);
+        if (!(0, configTypes_1.isValidModuleConfig)(moduleConfig)) {
+            // eslint-disable-next-line no-console
+            console.warn(colors_1.colors.yellow(`   Skipping ${moduleYamlPath}: not a valid module config (missing domain/useCases)`));
+            continue;
         }
+        const aggregates = moduleConfig.domain.aggregates;
+        const count = Object.keys(aggregates).length;
+        Object.assign(allAggregates, aggregates);
+        sources.push(`${entry.name} (${count} aggregate(s))`);
     }
-    // Log sources
     if (sources.length > 0) {
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.gray(`   Sources: ${sources.join(', ')}`));
     }
-    return allModels;
+    return allAggregates;
 }
 function handleMigrateCommit(yamlPath) {
     try {
@@ -116,24 +87,21 @@ function handleMigrateCommit(yamlPath) {
         console.log(colors_1.colors.gray(`   Project root: ${projectRoot}`));
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.gray(`   Migrations dir: ${migrationsDir}`));
-        // Ensure migrations directory exists
         if (!fs.existsSync(migrationsDir)) {
             fs.mkdirSync(migrationsDir, { recursive: true });
             // eslint-disable-next-line no-console
             console.log(colors_1.colors.green(`   ✓ Created migrations directory`));
         }
-        // Collect all models from YAML files
         // eslint-disable-next-line no-console
-        console.log(colors_1.colors.cyan('\n📋 Collecting models from all modules...'));
-        const currentModels = collectModelsFromYaml(resolvedYamlPath);
-        if (currentModels.length === 0) {
+        console.log(colors_1.colors.cyan('\n📋 Collecting aggregates from all modules...'));
+        const currentAggregates = collectAggregatesFromModules(resolvedYamlPath);
+        if (Object.keys(currentAggregates).length === 0) {
             // eslint-disable-next-line no-console
-            console.log(colors_1.colors.yellow('⚠️  No models found in YAML configuration.'));
+            console.log(colors_1.colors.yellow('⚠️  No aggregates found in module configuration.'));
             return;
         }
         // eslint-disable-next-line no-console
-        console.log(colors_1.colors.green(`✓ Found ${currentModels.length} model(s): ${currentModels.map(m => m.name).join(', ')}`));
-        // Load previous state
+        console.log(colors_1.colors.green(`✓ Found ${Object.keys(currentAggregates).length} aggregate(s): ${Object.keys(currentAggregates).join(', ')}`));
         const oldState = (0, migrationUtils_1.loadSchemaState)(stateFilePath);
         if (oldState) {
             // eslint-disable-next-line no-console
@@ -143,16 +111,14 @@ function handleMigrateCommit(yamlPath) {
             // eslint-disable-next-line no-console
             console.log(colors_1.colors.cyan('📖 No previous schema state found - will generate initial migration'));
         }
-        // Compare schemas and generate SQL
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.cyan('\n🔍 Comparing schemas...'));
-        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentModels);
+        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentAggregates);
         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.'));
             return;
         }
-        // Generate migration file
         const timestamp = (0, migrationUtils_1.generateTimestamp)();
         const migrationFileName = (0, migrationUtils_1.getMigrationFileName)(timestamp);
         const migrationFilePath = path.join(migrationsDir, migrationFileName);
@@ -163,9 +129,8 @@ function handleMigrateCommit(yamlPath) {
 `;
         const migrationContent = migrationHeader + sqlStatements.join('\n');
         fs.writeFileSync(migrationFilePath, migrationContent);
-        // Update state file
         const newState = {
-            models: currentModels,
+            aggregates: currentAggregates,
             version: timestamp,
             timestamp: new Date().toISOString()
         };

package/dist/generators/controllerGenerator.d.ts

@@ -43,6 +43,13 @@ export declare class ControllerGenerator {
      * meant for static routes (e.g. /create).
      */
     private sortRoutesBySpecificity;
+    /**
+     * Resolve layout from YAML value.
+     * - undefined => use fallback (if provided)
+     * - "none" or "" => no layout
+     * - other values => use explicit layout name
+     */
+    private resolveLayout;
     private generateApiController;
     private generateWebController;
     generateFromConfig(config: ModuleConfig): Record<string, string>;

package/dist/generators/controllerGenerator.js

@@ -244,18 +244,26 @@ class ControllerGenerator {
     }
 `;
     }
-    generateApiEndpointMethod(endpoint, resourceName, childInfo) {
+    generateApiEndpointMethod(endpoint, resourceName, useCasesConfig, childInfo) {
+        var _a;
         const { model, action } = this.parseUseCase(endpoint.useCase);
         const methodName = action;
         const decorator = this.getHttpDecorator(endpoint.method);
         const useCaseVar = `${model.toLowerCase()}UseCase`;
         const inputClass = `${model}${(0, typeUtils_1.capitalize)(action)}Input`;
         const outputClass = `${model}${(0, typeUtils_1.capitalize)(action)}Output`;
+        const useCaseDef = (_a = useCasesConfig[model]) === null || _a === void 0 ? void 0 : _a[action];
+        const isVoidOutput = !(useCaseDef === null || useCaseDef === void 0 ? void 0 : useCaseDef.output) || useCaseDef.output === 'void';
         const dtoImports = new Set();
+        const voidOutputDtos = new Set();
         dtoImports.add(`${model}${(0, typeUtils_1.capitalize)(action)}`);
+        if (isVoidOutput) {
+            voidOutputDtos.add(`${model}${(0, typeUtils_1.capitalize)(action)}`);
+        }
         // Generate auth check (pre-fetch)
         const authCheck = this.generateAuthCheck(endpoint.auth);
         const authLine = authCheck ? `\n    ${authCheck}\n` : '';
+        const hasOwner = this.hasOwnerAuth(endpoint.auth);
         // Build parsing logic
         // For create: root gets ownerId from user, child gets parentId from URL params
         let parseLogic;
@@ -282,7 +290,6 @@ class ControllerGenerator {
         // Generate owner checks:
         // - For mutations (update, delete): PRE-mutation check (before operation)
         // - For reads (get): POST-fetch check (after fetching)
-        const hasOwner = this.hasOwnerAuth(endpoint.auth);
         const isMutation = action === 'update' || action === 'delete';
         const isRead = action === 'get';
         // Pre-mutation owner check for write operations
@@ -295,22 +302,25 @@ class ControllerGenerator {
             : '';
         // Generate output transformation based on action
         let outputTransform;
-        if (action === 'list') {
-            outputTransform = `return ${outputClass}.from(result);`;
-        }
-        else if (action === 'delete') {
+        if (isVoidOutput || action === 'delete') {
             outputTransform = `return result;`;
         }
+        else if (action === 'list') {
+            outputTransform = `return ${outputClass}.from(result);`;
+        }
         else {
             outputTransform = `return ${outputClass}.from(result);`;
         }
+        const useCaseArgs = (hasOwner && action === 'list')
+            ? 'input, context.request.user?.id as number'
+            : 'input';
         const method = `  @${decorator}('${endpoint.path}')
   async ${methodName}(context: IContext): Promise<any> {${authLine}
     ${parseLogic}${preMutationOwnerCheck}
-    const result = await this.${useCaseVar}.${action}(input);${postFetchOwnerCheck}
+    const result = await this.${useCaseVar}.${action}(${useCaseArgs});${postFetchOwnerCheck}
     ${outputTransform}
   }`;
-        return { method, dtoImports };
+        return { method, dtoImports, voidOutputDtos };
     }
     generateWebPageMethod(page, resourceName, layout, methodIndex, childInfo, withChildChildren) {
         const method = page.method || 'GET';
@@ -333,12 +343,16 @@ class ControllerGenerator {
         const authLine = authCheck ? `\n    ${authCheck}\n` : '';
         // For GET requests with views (display pages)
         if (method === 'GET' && page.view) {
-            const renderDecorator = `\n  @Render("${page.view}", "${layout}")`;
+            const pageLayout = this.resolveLayout(page.layout, layout);
+            const renderDecorator = pageLayout
+                ? `\n  @Render("${page.view}", "${pageLayout}")`
+                : `\n  @Render("${page.view}")`;
             if (page.useCase) {
                 const { model, action } = this.parseUseCase(page.useCase);
                 const useCaseVar = `${model.toLowerCase()}UseCase`;
                 const inputClass = `${model}${(0, typeUtils_1.capitalize)(action)}Input`;
                 dtoImports.add(`${model}${(0, typeUtils_1.capitalize)(action)}`);
+                const hasOwner = this.hasOwnerAuth(page.auth);
                 let parseLogic;
                 if (page.path.includes(':id')) {
                     parseLogic = `const input = ${inputClass}.parse({ id: context.request.parameters.id });`;
@@ -349,8 +363,6 @@ class ControllerGenerator {
                 else {
                     parseLogic = `const input = ${inputClass}.parse({});`;
                 }
-                // Generate post-fetch owner check for GET pages (reads only)
-                const hasOwner = this.hasOwnerAuth(page.auth);
                 const isReadAction = action === 'get' || action === 'list';
                 const postFetchOwnerCheck = (hasOwner && isReadAction)
                     ? this.generatePostFetchOwnerCheck(page.auth, 'result', useCaseVar, childInfo)
@@ -374,12 +386,15 @@ class ControllerGenerator {
                 else {
                     returnExpr = 'result';
                 }
+                const useCaseArgs = (hasOwner && action === 'list')
+                    ? 'input, context.request.user?.id as number'
+                    : 'input';
                 const loadChildCode = loadChildBlocks.length ? '\n    ' + loadChildBlocks.join('\n    ') + '\n    ' : '';
                 const methodCode = `${renderDecorator}
   @${decorator}('${page.path}')
   async ${methodName}(context: IContext): Promise<any> {${authLine}
     ${parseLogic}
-    const result = await this.${useCaseVar}.${action}(input);${postFetchOwnerCheck}${loadChildCode}
+    const result = await this.${useCaseVar}.${action}(${useCaseArgs});${postFetchOwnerCheck}${loadChildCode}
     return ${returnExpr};
   }`;
                 return { method: methodCode, dtoImports };
@@ -491,26 +506,49 @@ class ControllerGenerator {
             return aParamCount - bParamCount;
         });
     }
-    generateApiController(resourceName, prefix, endpoints, childInfo) {
+    /**
+     * Resolve layout from YAML value.
+     * - undefined => use fallback (if provided)
+     * - "none" or "" => no layout
+     * - other values => use explicit layout name
+     */
+    resolveLayout(layout, fallback) {
+        if (layout === undefined) {
+            return fallback;
+        }
+        const normalized = layout.trim();
+        if (!normalized || normalized.toLowerCase() === 'none') {
+            return undefined;
+        }
+        return normalized;
+    }
+    generateApiController(resourceName, prefix, endpoints, useCasesConfig, childInfo) {
         const controllerName = `${resourceName}ApiController`;
         // Determine which use cases and DTOs are referenced
         const useCaseModels = new Set();
         const allDtoImports = new Set();
+        const allVoidOutputDtos = new Set();
         const methods = [];
         const sortedEndpoints = this.sortRoutesBySpecificity(endpoints);
         sortedEndpoints.forEach(endpoint => {
             const { model } = this.parseUseCase(endpoint.useCase);
             useCaseModels.add(model);
-            const { method, dtoImports } = this.generateApiEndpointMethod(endpoint, resourceName, childInfo);
+            const { method, dtoImports, voidOutputDtos } = this.generateApiEndpointMethod(endpoint, resourceName, useCasesConfig, childInfo);
             methods.push(method);
             dtoImports.forEach(d => allDtoImports.add(d));
+            voidOutputDtos.forEach(d => allVoidOutputDtos.add(d));
         });
         // Generate imports
         const useCaseImports = Array.from(useCaseModels)
             .map(model => `import { ${model}UseCase } from '../../application/useCases/${model}UseCase';`)
             .join('\n');
         const dtoImportStatements = Array.from(allDtoImports)
-            .map(dto => `import { ${dto}Input, ${dto}Output } from '../../application/dto/${dto}';`)
+            .map(dto => {
+            if (allVoidOutputDtos.has(dto)) {
+                return `import { ${dto}Input } from '../../application/dto/${dto}';`;
+            }
+            return `import { ${dto}Input, ${dto}Output } from '../../application/dto/${dto}';`;
+        })
             .join('\n');
         // Generate constructor parameters
         const constructorParams = Array.from(useCaseModels)
@@ -602,7 +640,7 @@ ${methods.join('\n\n')}
         if (config.api) {
             Object.entries(config.api).forEach(([resourceName, resourceConfig]) => {
                 const childInfo = childEntityMap.get(resourceName);
-                const code = this.generateApiController(resourceName, resourceConfig.prefix, resourceConfig.endpoints, childInfo);
+                const code = this.generateApiController(resourceName, resourceConfig.prefix, resourceConfig.endpoints, config.useCases, childInfo);
                 result[`${resourceName}Api`] = code;
             });
         }
@@ -610,7 +648,8 @@ ${methods.join('\n\n')}
         if (config.web) {
             Object.entries(config.web).forEach(([resourceName, resourceConfig]) => {
                 const childInfo = childEntityMap.get(resourceName);
-                const code = this.generateWebController(resourceName, resourceConfig.prefix, resourceConfig.layout || 'main_view', resourceConfig.pages, config, childInfo);
+                const moduleLayout = this.resolveLayout(resourceConfig.layout, 'main_view');
+                const code = this.generateWebController(resourceName, resourceConfig.prefix, moduleLayout, resourceConfig.pages, config, childInfo);
                 result[`${resourceName}Web`] = code;
             });
         }

package/dist/generators/domainLayerGenerator.js

@@ -146,7 +146,14 @@ class DomainLayerGenerator {
         })
             .filter((imp, idx, arr) => arr.indexOf(imp) === idx) // dedupe
             .join('\n');
-        const imports = [entityImports, valueObjectImports].filter(Boolean).join('\n');
+        // Generate imports for aggregate references in fields (e.g. idea: { type: Idea })
+        const aggregateRefImports = fields
+            .filter(([, fieldConfig]) => (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates) &&
+            fieldConfig.type !== name)
+            .map(([, fieldConfig]) => `import { ${fieldConfig.type} } from './${fieldConfig.type}';`)
+            .filter((imp, idx, arr) => arr.indexOf(imp) === idx)
+            .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'];
         if (childInfo) {
@@ -157,9 +164,12 @@ class DomainLayerGenerator {
         }
         // Sort fields: required first, then optional
         // Fields are required by default unless required: false
+        // Aggregate references are always treated as optional (store can't populate them from FK alone)
         const sortedFields = fields.sort((a, b) => {
-            const aRequired = a[1].required !== false && !a[1].auto;
-            const bRequired = b[1].required !== false && !b[1].auto;
+            const aIsAggRef = (0, typeUtils_1.isAggregateReference)(a[1].type, this.availableAggregates);
+            const bIsAggRef = (0, typeUtils_1.isAggregateReference)(b[1].type, this.availableAggregates);
+            const aRequired = a[1].required !== false && !a[1].auto && !aIsAggRef;
+            const bRequired = b[1].required !== false && !b[1].auto && !bIsAggRef;
             if (aRequired === bRequired)
                 return 0;
             return aRequired ? -1 : 1;
@@ -176,9 +186,9 @@ class DomainLayerGenerator {
             }
         });
         sortedFields.forEach(([fieldName, fieldConfig]) => {
+            const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
             const tsType = enumTypeNames[fieldName] || this.mapType(fieldConfig.type);
-            // Fields are required by default, only optional if explicitly set to required: false
-            const isOptional = fieldConfig.required === false;
+            const isOptional = fieldConfig.required === false || isAggRef;
             const hasDefault = fieldConfig.auto;
             let param = `public ${fieldName}`;
             if (isOptional && !hasDefault) {
@@ -195,22 +205,55 @@ class DomainLayerGenerator {
         const setterMethods = sortedFields
             .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
             .map(([fieldName, fieldConfig]) => {
+            const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
             const tsType = enumTypeNames[fieldName] || this.mapType(fieldConfig.type);
             const methodName = `set${(0, typeUtils_1.capitalize)(fieldName)}`;
-            // Fields are required by default, only optional if explicitly set to required: false
-            const isOptional = fieldConfig.required === false;
+            const isOptional = fieldConfig.required === false || isAggRef;
             return `
     ${methodName}(${fieldName}: ${tsType}${isOptional ? ' | undefined' : ''}): void {
         this.${fieldName} = ${fieldName};
     }`;
         })
             .join('\n');
+        // Generate validation logic from field constraints
+        // we don't use constraints at models, since we use DTOs (use cases) for validation
+        // Model – is a place not for validation, but for business logic!
+        // kept this code for reference
+        /*
+        const validations: string[] = [];
+        sortedFields.forEach(([fieldName, fieldConfig]) => {
+          const { constraints } = fieldConfig;
+          if (!constraints) return;
+    
+          if (constraints.min !== undefined) {
+            validations.push(`        if (this.${fieldName} < ${constraints.min}) {
+                throw new Error('${name}.${fieldName} must be at least ${constraints.min}');
+            }`);
+          }
+          if (constraints.max !== undefined) {
+            validations.push(`        if (this.${fieldName} > ${constraints.max}) {
+                throw new Error('${name}.${fieldName} must be at most ${constraints.max}');
+            }`);
+          }
+          if (constraints.pattern) {
+            validations.push(`        if (!/${constraints.pattern}/.test(String(this.${fieldName}))) {
+                throw new Error('${name}.${fieldName} does not match required pattern');
+            }`);
+          }
+        });
+    
+        const constructorBody = validations.length > 0
+          ? `\n        this.validate();\n    }\n\n    private validate(): void {\n${validations.join('\n')}\n    }`
+          : ' }';
+        */
+        const constructorBody = '';
         const rootComment = config.root ? '// Aggregate Root\n' : '';
         const enumTypeDefsCode = enumTypeDefinitions.length > 0 ? enumTypeDefinitions.join('\n') + '\n\n' : '';
         return `${imports ? imports + '\n\n' : ''}${enumTypeDefsCode}${rootComment}export class ${name} {
     public constructor(
         ${constructorParamsStr}
-    ) { }
+    ) {${constructorBody}
+    }
 ${setterMethods}
 }`;
     }

package/dist/generators/dtoGenerator.js

@@ -171,15 +171,17 @@ class DtoGenerator {
             fieldsToInclude.forEach(([fieldName, fieldConfig]) => {
                 if (fieldName === 'id' || fieldConfig.auto)
                     return;
-                const tsType = this.mapType(fieldConfig.type);
-                // Fields are required by default unless partial or required: false
-                const isRequired = !inputConfig.partial && fieldConfig.required !== false;
+                const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
+                const tsType = isAggRef ? 'number' : this.mapType(fieldConfig.type);
+                const effectiveFieldType = isAggRef ? 'number' : 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 ? '' : '?';
                 fieldDeclarations.push(`  readonly ${fieldName}${optional}: ${tsType};`);
                 constructorParams.push(`${fieldName}${optional}: ${tsType}`);
                 constructorAssignments.push(`    this.${fieldName} = ${fieldName};`);
-                validationChecks.push(...this.getValidationCode(fieldName, fieldConfig.type, isRequired));
-                fieldTransforms.push(`      ${fieldName}: ${this.getTransformCode(fieldName, fieldConfig.type)}`);
+                validationChecks.push(...this.getValidationCode(fieldName, effectiveFieldType, isRequired));
+                fieldTransforms.push(`      ${fieldName}: ${this.getTransformCode(fieldName, effectiveFieldType)}`);
             });
         }
         // Handle filters
@@ -267,12 +269,15 @@ ${transformsStr}
             fieldsToInclude.forEach(([fieldName, fieldConfig]) => {
                 if (fieldName === 'id')
                     return;
-                const tsType = this.mapType(fieldConfig.type);
-                const isOptional = fieldConfig.required === false;
+                const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
+                const tsType = isAggRef ? 'number' : this.mapType(fieldConfig.type);
+                const isOptional = fieldConfig.required === false || isAggRef;
                 const optional = isOptional ? '?' : '';
                 fieldDeclarations.push(`  readonly ${fieldName}${optional}: ${tsType};`);
                 constructorParams.push(`${fieldName}${optional}: ${tsType}`);
-                fromMappings.push(`      ${fieldName}: entity.${fieldName}`);
+                fromMappings.push(isAggRef
+                    ? `      ${fieldName}: entity.${fieldName}?.id`
+                    : `      ${fieldName}: entity.${fieldName}`);
             });
         }
         // Handle includes (nested objects)

package/dist/generators/serviceGenerator.d.ts

@@ -2,6 +2,12 @@ import { ModuleConfig } from '../types/configTypes';
 export declare class ServiceGenerator {
     private availableAggregates;
     private mapType;
+    private getDefaultHandlerReturnType;
+    private buildHandlerContextMap;
+    private deriveInputType;
+    private deriveCustomHandlerTypes;
+    private getInputDtoFields;
+    private computeDtoFieldsForHandler;
     private generateListHandler;
     private generateGetHandler;
     private generateCreateHandler;