@currentjs/gen 0.3.2 → 0.5.0

package/dist/generators/serviceGenerator.js

@@ -37,640 +37,221 @@ 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);
-        });
+    mapType(yamlType) {
+        return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates);
     }
-    isRelationshipField(field) {
-        return this.availableModels.has(field.type);
+    generateListHandler(modelName, storeName) {
+        return `  async list(page: number = 1, limit: number = 20): Promise<{ items: ${modelName}[]; total: number; page: number; limit: number }> {
+    const [items, total] = await Promise.all([
+      this.${storeName}.getAll(page, limit),
+      this.${storeName}.count()
+    ]);
+    return { items, total, page, limit };
+  }`;
     }
-    getForeignKeyFieldName(field) {
-        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
-        return field.name + 'Id';
+    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');
     }
-    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);
+    return ${entityLower};
+  }`;
     }
-    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] = [];
+    generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo) {
+        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;
+            if (aRequired === bRequired)
+                return 0;
+            return aRequired ? -1 : 1;
         });
-        // 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}');
+        const fieldArgs = fields.map(([fieldName]) => `input.${fieldName}`).join(', ');
+        const constructorArgs = `input.${firstArgField}, ${fieldArgs}`;
+        return `  async create(input: any): Promise<${modelName}> {
+    const ${entityLower} = new ${modelName}(0, ${constructorArgs});
+    return await this.${storeName}.insert(${entityLower});
+  }`;
     }
-    if ((${entityLower} as any).userId !== user.id) {
-      throw new Error('You can only access your own resources');
+    generateUpdateHandler(modelName, storeName, aggregateConfig) {
+        const setterCalls = Object.entries(aggregateConfig.fields)
+            .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
+            .map(([fieldName]) => {
+            const methodName = `set${(0, typeUtils_1.capitalize)(fieldName)}`;
+            return `    if (input.${fieldName} !== undefined) {
+      existing${modelName}.${methodName}(input.${fieldName});
     }`;
-            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';
-            case 'create':
-                return `${entityParam}: ${entityName}DTO`;
-            case 'update':
-                return `id: number, ${entityParam}: ${entityName}DTO`;
-            case 'delete':
-                return 'id: number';
-            default:
-                return '';
-        }
+        })
+            .join('\n');
+        return `  async update(id: number, input: any): Promise<${modelName}> {
+    const existing${modelName} = await this.${storeName}.getById(id);
+    if (!existing${modelName}) {
+      throw new Error('${modelName} not found');
     }
-    generateReturnType(action, entityName) {
-        switch (action) {
-            case 'list':
-                return `${entityName}[]`;
-            case 'get':
-            case 'getById':
-            case 'create':
-            case 'update':
-                return entityName;
-            case 'delete':
-                return '{ success: boolean; message: string }';
-            default:
-                return 'void';
-        }
+    
+${setterCalls}
+    
+    return await this.${storeName}.update(id, existing${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}`);
-                    }
-                    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}`);
-                        }
-                    }
-                }
-                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`);
-            }
-        });
-        return implementations.join('\n    ');
+    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');
     }
-    extractFunctionName(filePath) {
-        const parts = filePath.split('/');
-        const fileName = parts[parts.length - 1];
-        return fileName;
+    return { success: true, message: '${modelName} deleted successfully' };
+  }`;
     }
-    getMethodCallParams(action) {
-        switch (action) {
+    generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo) {
+        const entityLower = modelName.toLowerCase();
+        const storeName = `${entityLower}Store`;
+        switch (actionName) {
             case 'list':
-                return 'page, limit';
+                return this.generateListHandler(modelName, storeName);
             case 'get':
-                return 'id';
+                return this.generateGetHandler(modelName, storeName, entityLower);
             case 'create':
-                return 'userData';
+                return this.generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo);
             case 'update':
-                return 'id, updates';
+                return this.generateUpdateHandler(modelName, storeName, aggregateConfig);
             case 'delete':
-                return 'id';
+                return this.generateDeleteHandler(modelName, storeName);
             default:
-                return '/* custom params */';
+                return `  async ${actionName}(input: any): Promise<any> {
+    // TODO: Implement default ${actionName} handler
+    throw new Error('Not implemented');
+  }`;
         }
     }
-    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
-            }
-            return aRequired ? -1 : 1; // Required fields come first
-        });
+    generateCustomHandlerMethod(modelName, handlerName) {
+        return `  async ${handlerName}(result: any, input: any): Promise<any> {
+    // TODO: Implement custom ${handlerName} handler
+    // This method receives the result from the previous handler (or null if first)
+    // and the input context
+    return result;
+  }`;
     }
-    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`);
-            }
-            else {
-                args.push(`${entityLower}Data.${field.name}`);
-            }
+    collectHandlers(useCases) {
+        const handlers = new Set();
+        Object.values(useCases).forEach(useCaseConfig => {
+            useCaseConfig.handlers.forEach(handler => {
+                handlers.add(handler);
+            });
         });
-        return args.join(', ');
-    }
-    generateRelationshipLoading(moduleConfig, entityName) {
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
-            return '';
-        }
-        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});
-    }`;
-            }
-            else {
-                return `const ${varName} = ${entityLower}Data.${foreignKeyName} 
-      ? await this.${relatedModelLower}Store.getById(${entityLower}Data.${foreignKeyName})
-      : null;`;
-            }
-        }).join('\n    ');
-        return '    // Load relationship objects\n    ' + loadingCode;
+        return handlers;
     }
-    generateUpdateSetterCalls(moduleConfig, entityName, includeRelationshipLoading = false) {
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
+    generateListByParentMethod(modelName, childInfo) {
+        if (!childInfo)
             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();
-        let code = '';
-        // Add relationship loading if requested
-        if (includeRelationshipLoading) {
-            const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
-            if (relationshipLoading) {
-                code = relationshipLoading + '\n    ';
-            }
-        }
-        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);
-    }`;
-            }
-            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});
-    }`;
-            }
-        })
-            .join('\n    ');
-        return code + setterCalls;
-    }
-    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;
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        return `
+  async listByParent(parentId: number): Promise<${modelName}[]> {
+    return await this.${storeVar}.getByParentId(parentId);
+  }`;
     }
-    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;
+    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);
+  }`;
     }
-    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;
-        }
-        else {
-            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);
-                }
-                // 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;`;
-                    }
-                }
+    generateService(modelName, useCases, aggregateConfig, childInfo) {
+        const serviceName = `${modelName}Service`;
+        const storeName = `${modelName}Store`;
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        // Collect all unique handlers
+        const handlers = this.collectHandlers(useCases);
+        // Generate methods for each handler
+        const methods = [];
+        handlers.forEach(handler => {
+            if (handler.startsWith('default:')) {
+                const actionName = handler.replace('default:', '');
+                methods.push(this.generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo));
             }
             else {
-                methodImplementation = `// TODO: Implement default ${actionName} method for ${entityName}`;
+                methods.push(this.generateCustomHandlerMethod(modelName, handler));
             }
-        }
-        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');
+        return `import { Injectable } from '../../../../system';
+import { ${modelName} } from '../../domain/entities/${modelName}';
+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');