@currentjs/gen 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.5.1] - 2026-02-28
+
+- fixes pack:
+- aggregate references
+- layout setting in module config
+- SPA layout mismatch bug (if a page uses other layout, its loaded inside current one)
+- local provider imports bug
+- types in generated services (was any)
+- access control issues
+
 ## [0.5.0] – 2026-02-26
 
 So many changes were made that we skipped version 0.4:

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,10 +205,10 @@ 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};

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;

package/dist/generators/serviceGenerator.js

@@ -49,13 +49,146 @@ class ServiceGenerator {
     mapType(yamlType) {
         return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates);
     }
-    generateListHandler(modelName, storeName) {
-        return `  async list(page: number = 1, limit: number = 20): Promise<{ items: ${modelName}[]; total: number; page: number; limit: number }> {
+    getDefaultHandlerReturnType(actionName, modelName) {
+        switch (actionName) {
+            case 'create':
+            case 'get':
+            case 'update':
+                return modelName;
+            case 'delete':
+                return '{ success: boolean; message: string }';
+            case 'list':
+                return `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+            default:
+                return modelName;
+        }
+    }
+    buildHandlerContextMap(modelName, useCases) {
+        const contextMap = new Map();
+        Object.entries(useCases).forEach(([actionName, useCaseConfig]) => {
+            const inputDtoType = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+            let useCaseReturnType;
+            if (useCaseConfig.output === 'void') {
+                useCaseReturnType = '{ success: boolean; message: string }';
+            }
+            else if (actionName === 'list') {
+                useCaseReturnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+            }
+            else {
+                useCaseReturnType = modelName;
+            }
+            useCaseConfig.handlers.forEach((handler, index) => {
+                const isFirst = index === 0;
+                const isLast = index === useCaseConfig.handlers.length - 1;
+                let prevHandlerReturnType = null;
+                if (!isFirst) {
+                    const prevHandler = useCaseConfig.handlers[index - 1];
+                    if (prevHandler.startsWith('default:')) {
+                        prevHandlerReturnType = this.getDefaultHandlerReturnType(prevHandler.replace('default:', ''), modelName);
+                    }
+                    else {
+                        prevHandlerReturnType = modelName;
+                    }
+                }
+                const context = {
+                    actionName,
+                    index,
+                    isFirst,
+                    isLast,
+                    prevHandlerReturnType,
+                    inputDtoType,
+                    useCaseReturnType,
+                    inputConfig: useCaseConfig.input
+                };
+                const existing = contextMap.get(handler) || [];
+                existing.push(context);
+                contextMap.set(handler, existing);
+            });
+        });
+        return contextMap;
+    }
+    deriveInputType(contexts) {
+        const inputTypes = [...new Set(contexts.map(c => c.inputDtoType))];
+        return inputTypes.join(' | ');
+    }
+    deriveCustomHandlerTypes(contexts, modelName) {
+        const inputTypes = [...new Set(contexts.map(c => c.inputDtoType))];
+        const resultTypeParts = new Set();
+        contexts.forEach(c => {
+            if (c.isFirst) {
+                resultTypeParts.add('null');
+            }
+            if (c.prevHandlerReturnType) {
+                resultTypeParts.add(c.prevHandlerReturnType);
+            }
+        });
+        const returnTypeParts = new Set();
+        contexts.forEach(c => {
+            if (c.isLast) {
+                returnTypeParts.add(c.useCaseReturnType);
+            }
+            else {
+                returnTypeParts.add(modelName);
+            }
+        });
+        return {
+            inputType: inputTypes.join(' | '),
+            resultType: [...resultTypeParts].join(' | '),
+            returnType: [...returnTypeParts].join(' | ')
+        };
+    }
+    getInputDtoFields(inputConfig, aggregateConfig, childInfo) {
+        const fields = new Set();
+        if (!inputConfig)
+            return fields;
+        if (!inputConfig.identifier && !inputConfig.partial) {
+            fields.add(childInfo ? childInfo.parentIdField : 'ownerId');
+        }
+        if (inputConfig.from) {
+            let fieldNames = Object.keys(aggregateConfig.fields)
+                .filter(f => !aggregateConfig.fields[f].auto && f !== 'id');
+            if (inputConfig.pick && inputConfig.pick.length > 0) {
+                fieldNames = fieldNames.filter(f => inputConfig.pick.includes(f));
+            }
+            if (inputConfig.omit && inputConfig.omit.length > 0) {
+                fieldNames = fieldNames.filter(f => !inputConfig.omit.includes(f));
+            }
+            fieldNames.forEach(f => fields.add(f));
+        }
+        if (inputConfig.add) {
+            Object.keys(inputConfig.add).forEach(f => fields.add(f));
+        }
+        return fields;
+    }
+    computeDtoFieldsForHandler(contexts, aggregateConfig, childInfo) {
+        const fieldSets = contexts.map(ctx => this.getInputDtoFields(ctx.inputConfig, aggregateConfig, childInfo));
+        if (fieldSets.length === 0) {
+            return new Set(Object.keys(aggregateConfig.fields).filter(f => !aggregateConfig.fields[f].auto && f !== 'id'));
+        }
+        const result = new Set(fieldSets[0]);
+        for (let i = 1; i < fieldSets.length; i++) {
+            for (const field of result) {
+                if (!fieldSets[i].has(field)) {
+                    result.delete(field);
+                }
+            }
+        }
+        return result;
+    }
+    generateListHandler(modelName, storeName, hasPagination) {
+        const returnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+        if (hasPagination) {
+            return `  async list(page: number = 1, limit: number = 20, ownerId?: number): Promise<${returnType}> {
     const [items, total] = await Promise.all([
-      this.${storeName}.getAll(page, limit),
-      this.${storeName}.count()
+      this.${storeName}.getPaginated(page, limit, ownerId),
+      this.${storeName}.count(ownerId)
     ]);
     return { items, total, page, limit };
+  }`;
+        }
+        return `  async list(ownerId?: number): Promise<${returnType}> {
+    const items = await this.${storeName}.getAll(ownerId);
+    return { items, total: items.length, page: 1, limit: items.length };
   }`;
     }
     generateGetHandler(modelName, storeName, entityLower) {
@@ -67,35 +200,60 @@ class ServiceGenerator {
     return ${entityLower};
   }`;
     }
-    generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo) {
+    generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo, inputType, dtoFields) {
         const firstArgField = childInfo ? childInfo.parentIdField : 'ownerId';
         const fields = Object.entries(aggregateConfig.fields)
             .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
             .sort((a, b) => {
-            const aRequired = a[1].required !== false;
-            const bRequired = b[1].required !== false;
+            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 && !aIsAggRef;
+            const bRequired = b[1].required !== false && !bIsAggRef;
             if (aRequired === bRequired)
                 return 0;
             return aRequired ? -1 : 1;
         });
-        const fieldArgs = fields.map(([fieldName]) => `input.${fieldName}`).join(', ');
+        const fieldArgs = fields.map(([fieldName, fieldConfig]) => {
+            if (!dtoFields.has(fieldName)) {
+                return 'undefined';
+            }
+            if ((0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates)) {
+                return `input.${fieldName} != null ? ({ id: input.${fieldName} } as unknown as ${fieldConfig.type}) : undefined`;
+            }
+            if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                const enumTypeName = `${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                return `input.${fieldName} as ${enumTypeName}`;
+            }
+            return `input.${fieldName}`;
+        }).join(', ');
         const constructorArgs = `input.${firstArgField}, ${fieldArgs}`;
-        return `  async create(input: any): Promise<${modelName}> {
+        return `  async create(input: ${inputType}): Promise<${modelName}> {
     const ${entityLower} = new ${modelName}(0, ${constructorArgs});
     return await this.${storeName}.insert(${entityLower});
   }`;
     }
-    generateUpdateHandler(modelName, storeName, aggregateConfig) {
+    generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields) {
         const setterCalls = Object.entries(aggregateConfig.fields)
-            .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
-            .map(([fieldName]) => {
+            .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id' && dtoFields.has(fieldName))
+            .map(([fieldName, fieldConfig]) => {
             const methodName = `set${(0, typeUtils_1.capitalize)(fieldName)}`;
+            if ((0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates)) {
+                return `    if (input.${fieldName} !== undefined) {
+      existing${modelName}.${methodName}(input.${fieldName} != null ? ({ id: input.${fieldName} } as unknown as ${fieldConfig.type}) : undefined);
+    }`;
+            }
+            if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                const enumTypeName = `${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                return `    if (input.${fieldName} !== undefined) {
+      existing${modelName}.${methodName}(input.${fieldName} as ${enumTypeName});
+    }`;
+            }
             return `    if (input.${fieldName} !== undefined) {
       existing${modelName}.${methodName}(input.${fieldName});
     }`;
         })
             .join('\n');
-        return `  async update(id: number, input: any): Promise<${modelName}> {
+        return `  async update(id: number, input: ${inputType}): Promise<${modelName}> {
     const existing${modelName} = await this.${storeName}.getById(id);
     if (!existing${modelName}) {
       throw new Error('${modelName} not found');
@@ -115,29 +273,30 @@ ${setterCalls}
     return { success: true, message: '${modelName} deleted successfully' };
   }`;
     }
-    generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo) {
+    generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo, inputType, dtoFields, listConfig) {
+        var _a;
         const entityLower = modelName.toLowerCase();
         const storeName = `${entityLower}Store`;
         switch (actionName) {
             case 'list':
-                return this.generateListHandler(modelName, storeName);
+                return this.generateListHandler(modelName, storeName, (_a = listConfig === null || listConfig === void 0 ? void 0 : listConfig.hasPagination) !== null && _a !== void 0 ? _a : true);
             case 'get':
                 return this.generateGetHandler(modelName, storeName, entityLower);
             case 'create':
-                return this.generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo);
+                return this.generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo, inputType, dtoFields);
             case 'update':
-                return this.generateUpdateHandler(modelName, storeName, aggregateConfig);
+                return this.generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields);
             case 'delete':
                 return this.generateDeleteHandler(modelName, storeName);
             default:
-                return `  async ${actionName}(input: any): Promise<any> {
+                return `  async ${actionName}(input: ${inputType}): Promise<${modelName}> {
     // TODO: Implement default ${actionName} handler
     throw new Error('Not implemented');
   }`;
         }
     }
-    generateCustomHandlerMethod(modelName, handlerName) {
-        return `  async ${handlerName}(result: any, input: any): Promise<any> {
+    generateCustomHandlerMethod(modelName, handlerName, resultType, inputType, returnType) {
+        return `  async ${handlerName}(result: ${resultType}, input: ${inputType}): Promise<${returnType}> {
     // TODO: Implement custom ${handlerName} handler
     // This method receives the result from the previous handler (or null if first)
     // and the input context
@@ -177,17 +336,41 @@ ${setterCalls}
         const serviceName = `${modelName}Service`;
         const storeName = `${modelName}Store`;
         const storeVar = `${modelName.toLowerCase()}Store`;
+        // Build handler-to-context map for type inference
+        const handlerContextMap = this.buildHandlerContextMap(modelName, useCases);
         // Collect all unique handlers
         const handlers = this.collectHandlers(useCases);
+        // Collect DTO types needed for imports
+        const dtoTypes = new Set();
+        const enumTypeNames = new Set();
         // Generate methods for each handler
         const methods = [];
         handlers.forEach(handler => {
+            var _a, _b;
+            const contexts = handlerContextMap.get(handler) || [];
             if (handler.startsWith('default:')) {
                 const actionName = handler.replace('default:', '');
-                methods.push(this.generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo));
+                const inputType = this.deriveInputType(contexts);
+                const dtoFields = this.computeDtoFieldsForHandler(contexts, aggregateConfig, childInfo);
+                if (actionName !== 'list' && actionName !== 'get' && actionName !== 'delete') {
+                    contexts.forEach(c => dtoTypes.add(c.inputDtoType));
+                }
+                if (actionName === 'create' || actionName === 'update') {
+                    for (const [fieldName, fieldConfig] of Object.entries(aggregateConfig.fields)) {
+                        if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0 && dtoFields.has(fieldName)) {
+                            enumTypeNames.add(`${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`);
+                        }
+                    }
+                }
+                const listConfig = actionName === 'list'
+                    ? { hasPagination: !!((_b = (_a = contexts[0]) === null || _a === void 0 ? void 0 : _a.inputConfig) === null || _b === void 0 ? void 0 : _b.pagination) }
+                    : undefined;
+                methods.push(this.generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo, inputType, dtoFields, listConfig));
             }
             else {
-                methods.push(this.generateCustomHandlerMethod(modelName, handler));
+                const { inputType, resultType, returnType } = this.deriveCustomHandlerTypes(contexts, modelName);
+                contexts.forEach(c => dtoTypes.add(c.inputDtoType));
+                methods.push(this.generateCustomHandlerMethod(modelName, handler, resultType, inputType, returnType));
             }
         });
         const listByParentMethod = this.generateListByParentMethod(modelName, childInfo);
@@ -198,8 +381,21 @@ ${setterCalls}
         if (getResourceOwnerMethod) {
             methods.push(getResourceOwnerMethod);
         }
+        // Collect imports for aggregate reference types used in fields
+        const aggRefImports = Object.entries(aggregateConfig.fields)
+            .filter(([, fc]) => (0, typeUtils_1.isAggregateReference)(fc.type, this.availableAggregates) && fc.type !== modelName)
+            .map(([, fc]) => `import { ${fc.type} } from '../../domain/entities/${fc.type}';`)
+            .filter((imp, idx, arr) => arr.indexOf(imp) === idx);
+        const aggRefImportStr = aggRefImports.length > 0 ? '\n' + aggRefImports.join('\n') : '';
+        // Generate DTO import statements
+        const dtoImports = [...dtoTypes].map(dtoType => {
+            const fileSuffix = dtoType.replace(modelName, '').replace('Input', '');
+            return `import { ${dtoType} } from '../dto/${modelName}${fileSuffix}';`;
+        }).join('\n');
+        const dtoImportStr = dtoImports ? '\n' + dtoImports : '';
+        const entityImports = [modelName, ...enumTypeNames].join(', ');
         return `import { Injectable } from '../../../../system';
-import { ${modelName} } from '../../domain/entities/${modelName}';
+import { ${entityImports} } from '../../domain/entities/${modelName}';${aggRefImportStr}${dtoImportStr}
 import { ${storeName} } from '../../infrastructure/stores/${storeName}';
 
 /**