@currentjs/gen 0.3.2 → 0.5.1

package/dist/generators/serviceGenerator.js

@@ -37,640 +37,417 @@ exports.ServiceGenerator = void 0;
 const yaml_1 = require("yaml");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const serviceTemplates_1 = require("./templates/serviceTemplates");
 const generationRegistry_1 = require("../utils/generationRegistry");
 const colors_1 = require("../utils/colors");
-const constants_1 = require("../utils/constants");
+const configTypes_1 = require("../types/configTypes");
+const childEntityUtils_1 = require("../utils/childEntityUtils");
+const typeUtils_1 = require("../utils/typeUtils");
 class ServiceGenerator {
     constructor() {
-        this.availableModels = new Set();
+        this.availableAggregates = new Map();
     }
-    setAvailableModels(models) {
-        this.availableModels.clear();
-        models.forEach(model => {
-            this.availableModels.add(model.name);
-        });
-    }
-    isRelationshipField(field) {
-        return this.availableModels.has(field.type);
-    }
-    getForeignKeyFieldName(field) {
-        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
-        return field.name + 'Id';
-    }
-    hasPermissions(config) {
-        if (config.modules) {
-            return Object.values(config.modules).some(module => module.permissions && module.permissions.length > 0);
-        }
-        const module = config;
-        return !!(module.permissions && module.permissions.length > 0);
-    }
-    getActionPermissions(moduleName, moduleConfig) {
-        if (!moduleConfig.permissions || !moduleConfig.actions) {
-            return {};
-        }
-        const actionPermissions = {};
-        // Initialize all actions with empty permissions
-        Object.keys(moduleConfig.actions).forEach(action => {
-            actionPermissions[action] = [];
-        });
-        // Fill in permissions for each action
-        (moduleConfig.permissions || []).forEach(permission => {
-            (permission.actions || []).forEach(action => {
-                if (actionPermissions[action]) {
-                    actionPermissions[action].push(permission.role);
-                }
-            });
-        });
-        return actionPermissions;
-    }
-    generatePermissionCheck(action, roles, entityName) {
-        if (roles.length === 0 || roles.includes('all')) {
-            return '';
-        }
-        if (roles.includes('none')) {
-            return "    throw new Error('This action is not permitted');";
-        }
-        const nonOwnerRoles = roles.filter(role => !['all', 'none', 'owner'].includes(role));
-        const rolesArray = nonOwnerRoles.map(role => `'${role}'`).join(', ');
-        // Special-case: list action with owner → rely on store-level filtering; only enforce static role checks for other roles
-        if (action === 'list' && roles.includes('owner')) {
-            if (nonOwnerRoles.length === 0) {
-                return '';
-            }
-            return serviceTemplates_1.serviceTemplates.permissionCheck
-                .replace(/{{REQUIRED_ROLES}}/g, roles.join(', '))
-                .replace(/{{ACTION_NAME}}/g, action)
-                .replace(/{{ROLES_ARRAY}}/g, rolesArray);
-        }
-        // For resource-based owner permission (non-list), fetch resource first and verify ownership
-        if (roles.includes('owner')) {
-            const isResourceBased = ['get', 'update', 'delete'].includes(action);
-            if (!isResourceBased) {
-                // Not a resource-based action; fall back to static role checks only (if any non-owner roles)
-                if (nonOwnerRoles.length === 0) {
-                    return '';
-                }
-                return serviceTemplates_1.serviceTemplates.permissionCheck
-                    .replace(/{{REQUIRED_ROLES}}/g, roles.join(', '))
-                    .replace(/{{ACTION_NAME}}/g, action)
-                    .replace(/{{ROLES_ARRAY}}/g, rolesArray);
-            }
-            const entityLower = entityName.toLowerCase();
-            const resourceIdParam = this.getResourceIdForAction(action);
-            const notFoundMessage = `${entityName} not found`;
-            // If there are additional roles besides owner, allow them to bypass owner check
-            const maybeRoleBypass = nonOwnerRoles.length > 0
-                ? `    const allowedRoles = [${rolesArray}];
-    if (allowedRoles.includes(user.role)) {
-      // Explicit role allowed; skip owner check
-    } else {
-      const ${entityLower} = await this.${entityLower}Store.getById(${resourceIdParam});
-      if (!${entityLower}) {
-        throw new Error('${notFoundMessage}');
-      }
-      if ((${entityLower} as any).userId !== user.id) {
-        throw new Error('You can only access your own resources');
-      }
-    }`
-                : `    const ${entityLower} = await this.${entityLower}Store.getById(${resourceIdParam});
-    if (!${entityLower}) {
-      throw new Error('${notFoundMessage}');
+    mapType(yamlType) {
+        return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates);
     }
-    if ((${entityLower} as any).userId !== user.id) {
-      throw new Error('You can only access your own resources');
-    }`;
-            return maybeRoleBypass;
-        }
-        // Static role check for non-owner roles
-        return serviceTemplates_1.serviceTemplates.permissionCheck
-            .replace(/{{REQUIRED_ROLES}}/g, roles.join(', '))
-            .replace(/{{ACTION_NAME}}/g, action)
-            .replace(/{{ROLES_ARRAY}}/g, rolesArray);
-    }
-    getResourceIdForAction(action) {
-        switch (action) {
-            case 'get':
-            case 'update':
-            case 'delete':
-                return 'id';
-            default:
-                return 'id';
-        }
-    }
-    generateMethodParams(action, entityName) {
-        const entityParam = `${entityName.toLowerCase()}Data`;
-        switch (action) {
-            case 'list':
-                return 'page: number = 1, limit: number = 10';
-            case 'get':
-            case 'getById':
-                return 'id: number';
+    getDefaultHandlerReturnType(actionName, modelName) {
+        switch (actionName) {
             case 'create':
-                return `${entityParam}: ${entityName}DTO`;
-            case 'update':
-                return `id: number, ${entityParam}: ${entityName}DTO`;
-            case 'delete':
-                return 'id: number';
-            default:
-                return '';
-        }
-    }
-    generateReturnType(action, entityName) {
-        switch (action) {
-            case 'list':
-                return `${entityName}[]`;
             case 'get':
-            case 'getById':
-            case 'create':
             case 'update':
-                return entityName;
+                return modelName;
             case 'delete':
                 return '{ success: boolean; message: string }';
+            case 'list':
+                return `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
             default:
-                return 'void';
+                return modelName;
         }
     }
-    generateMethodImplementation(action, entityName, handlers, moduleName, roles, moduleConfig) {
-        if (!handlers || handlers.length === 0) {
-            return `// TODO: Implement ${action} method`;
-        }
-        const implementations = [];
-        const entityLower = entityName.toLowerCase();
-        handlers.forEach(handler => {
-            var _a, _b;
-            // Handle new explicit format: modelname:default:action or modelname:custommethod
-            if (handler.includes(':')) {
-                const parts = handler.split(':');
-                if (parts.length === 3 && parts[1] === 'default') {
-                    // Format: modelname:default:action
-                    const [modelName, , actionName] = parts;
-                    // Check if this handler applies to current model
-                    if (modelName.toLowerCase() === entityLower || modelName === entityName) {
-                        const template = serviceTemplates_1.serviceTemplates.defaultImplementations[actionName];
-                        if (template) {
-                            let processedTemplate = template
-                                .replace(/{{ENTITY_NAME}}/g, entityName)
-                                .replace(/{{ENTITY_LOWER}}/g, entityLower);
-                            // Handle constructor args for create action
-                            if (actionName === 'create') {
-                                const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
-                                const constructorArgs = this.generateConstructorArgs(moduleConfig, entityName);
-                                if (relationshipLoading) {
-                                    // Insert relationship loading before the entity creation
-                                    processedTemplate = relationshipLoading + '\n    ' + processedTemplate;
-                                }
-                                processedTemplate = processedTemplate.replace(/{{CONSTRUCTOR_ARGS}}/g, constructorArgs);
-                            }
-                            // Handle setter calls for update action
-                            if (actionName === 'update') {
-                                const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName, true);
-                                processedTemplate = processedTemplate.replace(/{{UPDATE_SETTER_CALLS}}/g, setterCalls);
-                            }
-                            // Special-case: list action with only owner role → fetch by userId
-                            if (actionName === 'list') {
-                                const onlyOwner = roles.length > 0 && roles.every(r => r === 'owner');
-                                if (onlyOwner) {
-                                    processedTemplate = `const ${entityLower}s = await this.${entityLower}Store.getAllByUserId(user.id, page, limit);\n    return ${entityLower}s;`;
-                                }
-                            }
-                            implementations.push(processedTemplate);
-                        }
-                        else {
-                            implementations.push(`// TODO: Implement default ${actionName} method for ${entityName}`);
-                        }
-                    }
-                    else {
-                        // Cross-model default call
-                        const targetModel = (_a = moduleConfig.models) === null || _a === void 0 ? void 0 : _a.find(m => m.name.toLowerCase() === modelName.toLowerCase() || m.name === modelName);
-                        if (targetModel) {
-                            const targetServiceVar = `${targetModel.name.toLowerCase()}Service`;
-                            const customImpl = `// Cross-model call to ${targetModel.name}Service
-    const result = await this.${targetServiceVar}.${actionName}(${this.getMethodCallParams(action)});
-    return result;`;
-                            implementations.push(customImpl);
-                        }
-                        else {
-                            implementations.push(`// TODO: Model ${modelName} not found for handler ${handler}`);
-                        }
-                    }
-                }
-                else if (parts.length === 2) {
-                    // Format: modelname:custommethod  
-                    const [modelName, methodName] = parts;
-                    // Check if this handler applies to current model
-                    if (modelName.toLowerCase() === entityLower || modelName === entityName) {
-                        // Same model - this indicates a custom method should be implemented in this service
-                        implementations.push(`// TODO: Implement custom ${methodName} method for ${entityName}`);
+    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 {
-                        // Cross-model custom call
-                        const targetModel = (_b = moduleConfig.models) === null || _b === void 0 ? void 0 : _b.find(m => m.name.toLowerCase() === modelName.toLowerCase() || m.name === modelName);
-                        if (targetModel) {
-                            const targetServiceVar = `${targetModel.name.toLowerCase()}Service`;
-                            const customImpl = `// Cross-model call to ${targetModel.name}Service
-    const result = await this.${targetServiceVar}.${methodName}(${this.getMethodCallParams(action)});
-    return result;`;
-                            implementations.push(customImpl);
-                        }
-                        else {
-                            implementations.push(`// TODO: Model ${modelName} not found for handler ${handler}`);
-                        }
+                        prevHandlerReturnType = modelName;
                     }
                 }
-                else {
-                    implementations.push(`// TODO: Invalid handler format ${handler}. Use modelname:default:action or modelname:custommethod`);
-                }
-            }
-            else {
-                implementations.push(`// TODO: Invalid handler format ${handler}. Use modelname:default:action or modelname:custommethod`);
-            }
+                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 implementations.join('\n    ');
-    }
-    extractFunctionName(filePath) {
-        const parts = filePath.split('/');
-        const fileName = parts[parts.length - 1];
-        return fileName;
+        return contextMap;
     }
-    getMethodCallParams(action) {
-        switch (action) {
-            case 'list':
-                return 'page, limit';
-            case 'get':
-                return 'id';
-            case 'create':
-                return 'userData';
-            case 'update':
-                return 'id, updates';
-            case 'delete':
-                return 'id';
-            default:
-                return '/* custom params */';
-        }
+    deriveInputType(contexts) {
+        const inputTypes = [...new Set(contexts.map(c => c.inputDtoType))];
+        return inputTypes.join(' | ');
     }
-    sortFieldsByRequired(fields) {
-        // Sort fields: required fields first, then optional fields
-        // This must match the order used in domainModelGenerator
-        return [...fields].sort((a, b) => {
-            const aRequired = a.required !== false && !a.auto;
-            const bRequired = b.required !== false && !b.auto;
-            if (aRequired === bRequired) {
-                return 0; // Keep original order if both have same required status
+    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);
             }
-            return aRequired ? -1 : 1; // Required fields come first
         });
-    }
-    generateConstructorArgs(moduleConfig, entityName) {
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
-            return '';
-        }
-        // Find the correct model by entityName instead of always using first model
-        const model = moduleConfig.models.find((m) => m.name === entityName) || moduleConfig.models[0];
-        const entityLower = entityName.toLowerCase();
-        // Sort fields to match the constructor parameter order
-        const sortedFields = this.sortFieldsByRequired(model.fields);
-        const args = [];
-        sortedFields
-            .filter(field => !field.auto && field.name !== 'id')
-            .forEach(field => {
-            // For relationship fields, reference the loaded object variable
-            if (this.isRelationshipField(field)) {
-                args.push(`${field.name}Object`);
+        const returnTypeParts = new Set();
+        contexts.forEach(c => {
+            if (c.isLast) {
+                returnTypeParts.add(c.useCaseReturnType);
             }
             else {
-                args.push(`${entityLower}Data.${field.name}`);
+                returnTypeParts.add(modelName);
             }
         });
-        return args.join(', ');
+        return {
+            inputType: inputTypes.join(' | '),
+            resultType: [...resultTypeParts].join(' | '),
+            returnType: [...returnTypeParts].join(' | ')
+        };
     }
-    generateRelationshipLoading(moduleConfig, entityName) {
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
-            return '';
+    getInputDtoFields(inputConfig, aggregateConfig, childInfo) {
+        const fields = new Set();
+        if (!inputConfig)
+            return fields;
+        if (!inputConfig.identifier && !inputConfig.partial) {
+            fields.add(childInfo ? childInfo.parentIdField : 'ownerId');
         }
-        const model = moduleConfig.models.find((m) => m.name === entityName) || moduleConfig.models[0];
-        const entityLower = entityName.toLowerCase();
-        const relationshipFields = model.fields.filter(f => this.isRelationshipField(f));
-        if (relationshipFields.length === 0) {
-            return '';
-        }
-        const loadingCode = relationshipFields.map(field => {
-            const foreignKeyName = this.getForeignKeyFieldName(field);
-            const relatedModel = field.type;
-            const relatedModelLower = relatedModel.toLowerCase();
-            const varName = `${field.name}Object`;
-            if (field.required) {
-                return `const ${varName} = await this.${relatedModelLower}Store.getById(${entityLower}Data.${foreignKeyName});
-    if (!${varName}) {
-      throw new Error('${relatedModel} not found with id ' + ${entityLower}Data.${foreignKeyName});
-    }`;
+        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));
             }
-            else {
-                return `const ${varName} = ${entityLower}Data.${foreignKeyName} 
-      ? await this.${relatedModelLower}Store.getById(${entityLower}Data.${foreignKeyName})
-      : null;`;
+            if (inputConfig.omit && inputConfig.omit.length > 0) {
+                fieldNames = fieldNames.filter(f => !inputConfig.omit.includes(f));
             }
-        }).join('\n    ');
-        return '    // Load relationship objects\n    ' + loadingCode;
+            fieldNames.forEach(f => fields.add(f));
+        }
+        if (inputConfig.add) {
+            Object.keys(inputConfig.add).forEach(f => fields.add(f));
+        }
+        return fields;
     }
-    generateUpdateSetterCalls(moduleConfig, entityName, includeRelationshipLoading = false) {
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
-            return '';
+    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'));
         }
-        // Find the correct model by entityName instead of always using first model
-        const model = moduleConfig.models.find(m => m.name === entityName) || moduleConfig.models[0];
-        const entityLower = entityName.toLowerCase();
-        let code = '';
-        // Add relationship loading if requested
-        if (includeRelationshipLoading) {
-            const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
-            if (relationshipLoading) {
-                code = relationshipLoading + '\n    ';
+        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);
+                }
             }
         }
-        const setterCalls = model.fields
-            .filter(field => !field.auto && field.name !== 'id')
-            .map(field => {
-            // For relationship fields, set the loaded object
-            if (this.isRelationshipField(field)) {
-                const foreignKeyName = this.getForeignKeyFieldName(field);
-                const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
-                return `if (${entityLower}Data.${foreignKeyName} !== undefined) {
-      existing${entityName}.${methodName}(${field.name}Object);
+        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}.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) {
+        return `  async get(id: number): Promise<${modelName}> {
+    const ${entityLower} = await this.${storeName}.getById(id);
+    if (!${entityLower}) {
+      throw new Error('${modelName} not found');
+    }
+    return ${entityLower};
+  }`;
+    }
+    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 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, 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: ${inputType}): Promise<${modelName}> {
+    const ${entityLower} = new ${modelName}(0, ${constructorArgs});
+    return await this.${storeName}.insert(${entityLower});
+  }`;
+    }
+    generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields) {
+        const setterCalls = Object.entries(aggregateConfig.fields)
+            .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);
     }`;
             }
-            else {
-                const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
-                return `if (${entityLower}Data.${field.name} !== undefined) {
-      existing${entityName}.${methodName}(${entityLower}Data.${field.name});
+            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 code + setterCalls;
+            .join('\n');
+        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');
     }
-    replaceTemplateVars(template, variables) {
-        let result = template;
-        Object.entries(variables).forEach(([key, value]) => {
-            const regex = new RegExp(`{{${key}}}`, 'g');
-            result = result.replace(regex, String(value));
-        });
-        return result;
+    
+${setterCalls}
+    
+    return await this.${storeName}.update(id, existing${modelName});
+  }`;
     }
-    getServiceMethodName(action, entityName, handlers) {
-        const entityLower = entityName.toLowerCase();
-        // Find handler that applies to this model
-        const relevantHandler = handlers.find(h => {
-            const parts = h.split(':');
-            if (parts.length === 3 && parts[1] === 'default') {
-                const [modelName] = parts;
-                return modelName.toLowerCase() === entityLower || modelName === entityName;
-            }
-            else if (parts.length === 2) {
-                const [modelName] = parts;
-                return modelName.toLowerCase() === entityLower || modelName === entityName;
-            }
-            return false;
-        });
-        if (relevantHandler) {
-            const parts = relevantHandler.split(':');
-            if (parts.length === 3 && parts[1] === 'default') {
-                // Format: modelname:default:action -> use action name as method
-                return parts[2];
-            }
-            else if (parts.length === 2) {
-                // Format: modelname:custommethod -> use custom method name
-                return parts[1];
-            }
-        }
-        // Fallback to action name
-        return action;
+    generateDeleteHandler(modelName, storeName) {
+        return `  async delete(id: number): Promise<{ success: boolean; message: string }> {
+    const success = await this.${storeName}.softDelete(id);
+    if (!success) {
+      throw new Error('${modelName} not found or could not be deleted');
     }
-    generateHandlerMethod(handler, entityName, roles, hasPermissions, moduleConfig) {
-        const parts = handler.split(':');
-        if (parts.length < 2) {
-            return '';
-        }
-        let methodName;
-        let isDefault = false;
-        let actionName = '';
-        if (parts.length === 3 && parts[1] === 'default') {
-            // Format: modelname:default:action
-            actionName = parts[2];
-            methodName = actionName === 'getById' ? 'get' : actionName; // Use 'get' instead of 'getById'
-            isDefault = true;
-        }
-        else if (parts.length === 2) {
-            // Format: modelname:custommethod
-            methodName = parts[1];
-            isDefault = false;
+    return { success: true, message: '${modelName} deleted successfully' };
+  }`;
+    }
+    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, (_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, inputType, dtoFields);
+            case 'update':
+                return this.generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields);
+            case 'delete':
+                return this.generateDeleteHandler(modelName, storeName);
+            default:
+                return `  async ${actionName}(input: ${inputType}): Promise<${modelName}> {
+    // TODO: Implement default ${actionName} handler
+    throw new Error('Not implemented');
+  }`;
         }
-        else {
+    }
+    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
+    return result;
+  }`;
+    }
+    collectHandlers(useCases) {
+        const handlers = new Set();
+        Object.values(useCases).forEach(useCaseConfig => {
+            useCaseConfig.handlers.forEach(handler => {
+                handlers.add(handler);
+            });
+        });
+        return handlers;
+    }
+    generateListByParentMethod(modelName, childInfo) {
+        if (!childInfo)
             return '';
-        }
-        const entityLower = entityName.toLowerCase();
-        // Generate method parameters based on whether it's default or custom
-        let methodParams;
-        let returnType;
-        let methodImplementation;
-        if (isDefault) {
-            // For default handlers, use standard parameters
-            methodParams = this.generateMethodParams(actionName, entityName);
-            returnType = this.generateReturnType(actionName, entityName);
-            // Get the default implementation template
-            const template = serviceTemplates_1.serviceTemplates.defaultImplementations[actionName];
-            if (template) {
-                methodImplementation = template
-                    .replace(/{{ENTITY_NAME}}/g, entityName)
-                    .replace(/{{ENTITY_LOWER}}/g, entityLower);
-                // Handle constructor args for create action
-                if (actionName === 'create') {
-                    const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
-                    const constructorArgs = this.generateConstructorArgs(moduleConfig, entityName);
-                    if (relationshipLoading) {
-                        // Insert relationship loading before the entity creation
-                        methodImplementation = relationshipLoading + '\n    ' + methodImplementation;
-                    }
-                    methodImplementation = methodImplementation.replace(/{{CONSTRUCTOR_ARGS}}/g, constructorArgs);
-                }
-                // Handle setter calls for update action
-                if (actionName === 'update') {
-                    const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName, true);
-                    methodImplementation = methodImplementation.replace(/{{UPDATE_SETTER_CALLS}}/g, setterCalls);
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        return `
+  async listByParent(parentId: number): Promise<${modelName}[]> {
+    return await this.${storeVar}.getByParentId(parentId);
+  }`;
+    }
+    generateGetResourceOwnerMethod(modelName) {
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        return `
+  /**
+   * Get the owner ID of a resource by its ID.
+   * Used for pre-mutation authorization checks.
+   */
+  async getResourceOwner(id: number): Promise<number | null> {
+    return await this.${storeVar}.getResourceOwner(id);
+  }`;
+    }
+    generateService(modelName, useCases, aggregateConfig, childInfo) {
+        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:', '');
+                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));
                 }
-                // Special-case: list action with only owner role → fetch by userId
-                if (actionName === 'list') {
-                    const onlyOwner = roles.length > 0 && roles.every(r => r === 'owner');
-                    if (onlyOwner) {
-                        methodImplementation = `const ${entityLower}s = await this.${entityLower}Store.getAllByUserId(user.id, page, limit);\n    return ${entityLower}s;`;
+                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 {
-                methodImplementation = `// TODO: Implement default ${actionName} method for ${entityName}`;
+                const { inputType, resultType, returnType } = this.deriveCustomHandlerTypes(contexts, modelName);
+                contexts.forEach(c => dtoTypes.add(c.inputDtoType));
+                methods.push(this.generateCustomHandlerMethod(modelName, handler, resultType, inputType, returnType));
             }
-        }
-        else {
-            // For custom handlers, use result and context parameters
-            methodParams = 'result: any, context: any';
-            returnType = 'any';
-            methodImplementation = `// TODO: Implement custom ${methodName} method for ${entityName}`;
-        }
-        const permissionCheck = isDefault ? this.generatePermissionCheck(actionName, roles, entityName) : '';
-        const hasUserParam = roles.length > 0 && !roles.includes('all');
-        const variables = {
-            METHOD_NAME: methodName,
-            METHOD_PARAMS: methodParams,
-            USER_PARAM: hasUserParam ? ', user: AuthenticatedUser' : '',
-            RETURN_TYPE: returnType,
-            PERMISSION_CHECK: permissionCheck,
-            METHOD_IMPLEMENTATION: methodImplementation
-        };
-        return this.replaceTemplateVars(serviceTemplates_1.serviceTemplates.serviceMethod, variables);
-    }
-    generateServiceForModel(model, moduleName, moduleConfig, hasGlobalPermissions) {
-        if (!moduleConfig.actions) {
-            return '';
-        }
-        const entityName = model.name;
-        const entityLower = entityName.toLowerCase();
-        const actionPermissions = this.getActionPermissions(moduleName, moduleConfig);
-        const hasPermissions = !!(hasGlobalPermissions && moduleConfig.permissions && moduleConfig.permissions.length > 0);
-        // Collect all unique handlers for this model
-        const modelHandlers = new Set();
-        Object.entries(moduleConfig.actions || {}).forEach(([action, actionConfig]) => {
-            const handlers = actionConfig.handlers || [];
-            handlers.forEach(handler => {
-                // Only include handlers that apply to this model
-                if (handler.startsWith(`${entityLower}:`) || handler.startsWith(`${entityName}:`)) {
-                    modelHandlers.add(handler);
-                }
-            });
-        });
-        // Generate a method for each unique handler
-        const serviceMethods = Array.from(modelHandlers)
-            .map(handler => {
-            // Determine which actions use this handler to get permissions
-            const actionsUsingHandler = Object.entries(moduleConfig.actions || {})
-                .filter(([, actionConfig]) => (actionConfig.handlers || []).includes(handler))
-                .map(([action]) => action);
-            // Use permissions from the first action that uses this handler
-            const firstAction = actionsUsingHandler[0];
-            const roles = firstAction ? (actionPermissions[firstAction] || []) : [];
-            return this.generateHandlerMethod(handler, entityName, roles, hasPermissions, moduleConfig);
-        })
-            .filter(method => method) // Remove empty methods
-            .join('\n\n');
-        // Add foreign store constructor params
-        const foreignStoreParams = this.generateForeignStoreConstructorParams(model);
-        const serviceClass = this.replaceTemplateVars(serviceTemplates_1.serviceTemplates.serviceClass, {
-            ENTITY_NAME: entityName,
-            ENTITY_LOWER: entityLower,
-            AUTH_SERVICE_PARAM: foreignStoreParams,
-            SERVICE_METHODS: serviceMethods
         });
-        const customImports = this.generateCustomImports(moduleConfig);
-        const foreignStoreImports = this.generateForeignStoreImports(model);
-        return this.replaceTemplateVars(serviceTemplates_1.serviceFileTemplate, {
-            ENTITY_NAME: entityName,
-            PERMISSIONS_IMPORT: hasPermissions ? "\nimport type { AuthenticatedUser } from '@currentjs/router';" : '',
-            CUSTOM_IMPORTS: customImports + foreignStoreImports,
-            SERVICE_CLASS: serviceClass
-        });
-    }
-    generateService(moduleName, moduleConfig, hasGlobalPermissions) {
-        // Legacy method for backward compatibility - use first model
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
-            return '';
+        const listByParentMethod = this.generateListByParentMethod(modelName, childInfo);
+        if (listByParentMethod) {
+            methods.push(listByParentMethod);
         }
-        return this.generateServiceForModel(moduleConfig.models[0], moduleName, moduleConfig, hasGlobalPermissions);
-    }
-    generateForeignStoreImports(model) {
-        const relationshipFields = model.fields.filter(f => this.isRelationshipField(f));
-        if (relationshipFields.length === 0) {
-            return '';
+        const getResourceOwnerMethod = this.generateGetResourceOwnerMethod(modelName);
+        if (getResourceOwnerMethod) {
+            methods.push(getResourceOwnerMethod);
         }
-        const imports = relationshipFields.map(field => {
-            const relatedModel = field.type;
-            return `import { ${relatedModel}Store } from '../../infrastructure/stores/${relatedModel}Store';`;
-        });
-        return '\n' + imports.join('\n');
+        // 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 { ${entityImports} } from '../../domain/entities/${modelName}';${aggRefImportStr}${dtoImportStr}
+import { ${storeName} } from '../../infrastructure/stores/${storeName}';
+
+/**
+ * Service layer for ${modelName}
+ * Contains business logic handlers that can be composed in use cases
+ */
+@Injectable()
+export class ${serviceName} {
+  constructor(
+    private ${storeVar}: ${storeName}
+  ) {}
+
+${methods.join('\n\n')}
+}`;
     }
-    generateForeignStoreConstructorParams(model) {
-        const relationshipFields = model.fields.filter(f => this.isRelationshipField(f));
-        if (relationshipFields.length === 0) {
-            return '';
+    generateFromConfig(config) {
+        const result = {};
+        // Collect all aggregates
+        if (config.domain.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
+                this.availableAggregates.set(name, aggConfig);
+            });
         }
-        const params = relationshipFields.map(field => {
-            const relatedModel = field.type;
-            const relatedModelLower = relatedModel.toLowerCase();
-            return `,\n    private ${relatedModelLower}Store: ${relatedModel}Store`;
-        });
-        return params.join('');
-    }
-    generateCustomImports(moduleConfig) {
-        if (!moduleConfig.actions)
-            return '';
-        const imports = [];
-        Object.values(moduleConfig.actions).forEach(actionConfig => {
-            if (actionConfig.handlers) {
-                actionConfig.handlers.forEach(handler => {
-                    if (handler.startsWith(constants_1.PATH_PATTERNS.MODULES_DIRECTIVE)) {
-                        const functionName = this.extractFunctionName(handler);
-                        const importPath = handler.replace(constants_1.PATH_PATTERNS.MODULES_DIRECTIVE, '../../');
-                        imports.push(`import ${functionName} from '${importPath}';`);
-                    }
-                });
+        const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
+        // Generate a Service file for each model
+        Object.entries(config.useCases).forEach(([modelName, useCases]) => {
+            const aggregateConfig = this.availableAggregates.get(modelName);
+            if (!aggregateConfig) {
+                console.warn(`Warning: No aggregate found for model ${modelName}`);
+                return;
             }
+            const childInfo = childEntityMap.get(modelName);
+            result[modelName] = this.generateService(modelName, useCases, aggregateConfig, childInfo);
         });
-        return imports.length > 0 ? '\n' + imports.join('\n') : '';
+        return result;
     }
     generateFromYamlFile(yamlFilePath) {
         const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
         const config = (0, yaml_1.parse)(yamlContent);
-        const result = {};
-        const hasGlobalPermissions = this.hasPermissions(config);
-        if (config.modules) {
-            Object.entries(config.modules).forEach(([moduleName, moduleConfig]) => {
-                if (moduleConfig.models && moduleConfig.models.length > 0) {
-                    // Set available models for relationship detection
-                    this.setAvailableModels(moduleConfig.models);
-                    // Generate a service for each model
-                    moduleConfig.models.forEach(model => {
-                        const serviceCode = this.generateServiceForModel(model, moduleName, moduleConfig, hasGlobalPermissions);
-                        if (serviceCode) {
-                            result[model.name] = serviceCode;
-                        }
-                    });
-                }
-            });
+        if (!(0, configTypes_1.isValidModuleConfig)(config)) {
+            throw new Error('Configuration does not match new module format. Expected useCases structure.');
         }
-        else {
-            const moduleName = 'Module';
-            const moduleConfig = config;
-            if (moduleConfig.models && moduleConfig.models.length > 0) {
-                // Set available models for relationship detection
-                this.setAvailableModels(moduleConfig.models);
-                // Generate a service for each model
-                moduleConfig.models.forEach(model => {
-                    const serviceCode = this.generateServiceForModel(model, moduleName, moduleConfig, hasGlobalPermissions);
-                    if (serviceCode) {
-                        result[model.name] = serviceCode;
-                    }
-                });
-            }
-        }
-        return result;
+        return this.generateFromConfig(config);
     }
-    async generateAndSaveFiles(yamlFilePath = constants_1.COMMON_FILES.APP_YAML, outputDir = 'application', opts) {
-        const services = this.generateFromYamlFile(yamlFilePath);
-        const servicesDir = path.join(outputDir, 'services');
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const servicesByModel = this.generateFromYamlFile(yamlFilePath);
+        const servicesDir = path.join(moduleDir, 'application', 'services');
         fs.mkdirSync(servicesDir, { recursive: true });
-        for (const [moduleName, serviceCode] of Object.entries(services)) {
-            const fileName = `${moduleName}Service.ts`;
-            const filePath = path.join(servicesDir, fileName);
+        for (const [modelName, code] of Object.entries(servicesByModel)) {
+            const filePath = path.join(servicesDir, `${modelName}Service.ts`);
             // eslint-disable-next-line no-await-in-loop
-            await (0, generationRegistry_1.writeGeneratedFile)(filePath, serviceCode, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, code, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
         }
         // eslint-disable-next-line no-console
         console.log('\n' + colors_1.colors.green('Service files generated successfully!') + '\n');