@currentjs/gen 0.3.2 → 0.5.0

package/dist/generators/newControllerGenerator.js

@@ -0,0 +1,644 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewControllerGenerator = void 0;
+const yaml_1 = require("yaml");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const configTypes_1 = require("../types/configTypes");
+const childEntityUtils_1 = require("../utils/childEntityUtils");
+class NewControllerGenerator {
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    getHttpDecorator(method) {
+        switch (method.toUpperCase()) {
+            case 'GET': return 'Get';
+            case 'POST': return 'Post';
+            case 'PUT': return 'Put';
+            case 'PATCH': return 'Patch';
+            case 'DELETE': return 'Delete';
+            default: return 'Get';
+        }
+    }
+    parseUseCase(useCase) {
+        const [model, action] = useCase.split(':');
+        return { model, action };
+    }
+    /**
+     * Normalize auth config to an array of roles
+     */
+    normalizeAuth(auth) {
+        if (!auth)
+            return [];
+        if (Array.isArray(auth))
+            return auth;
+        return [auth];
+    }
+    /**
+     * Check if auth config includes owner permission
+     */
+    hasOwnerAuth(auth) {
+        const roles = this.normalizeAuth(auth);
+        return roles.includes('owner');
+    }
+    /**
+     * Generate pre-fetch authentication/authorization check code.
+     * This runs before fetching the entity and validates authentication and role-based access.
+     * @param auth - The auth requirement: 'all', 'authenticated', 'owner', role names, or array of roles
+     * @returns Code string for the auth check, or empty string if no check needed
+     */
+    generateAuthCheck(auth) {
+        const roles = this.normalizeAuth(auth);
+        if (roles.length === 0 || (roles.length === 1 && roles[0] === 'all')) {
+            return ''; // No check needed - public access
+        }
+        // If only 'authenticated' is specified
+        if (roles.length === 1 && roles[0] === 'authenticated') {
+            return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }`;
+        }
+        // If only 'owner' is specified - just require authentication here
+        // (owner check happens post-fetch)
+        if (roles.length === 1 && roles[0] === 'owner') {
+            return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }`;
+        }
+        // Filter out 'owner' and 'all' for role checks (owner is checked post-fetch)
+        const roleChecks = roles.filter(r => r !== 'owner' && r !== 'all' && r !== 'authenticated');
+        const hasOwner = roles.includes('owner');
+        const hasAuthenticated = roles.includes('authenticated');
+        // If we have role checks or owner, we need authentication
+        if (roleChecks.length > 0 || hasOwner) {
+            if (roleChecks.length === 0) {
+                // Only owner (and maybe authenticated) - just require auth
+                return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }`;
+            }
+            if (roleChecks.length === 1 && !hasOwner) {
+                // Single role check
+                return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }
+    if (context.request.user.role !== '${roleChecks[0]}') {
+      throw new Error('Insufficient permissions: ${roleChecks[0]} role required');
+    }`;
+            }
+            // Multiple roles OR owner - use OR logic
+            // If owner is included, we can't fully check here (post-fetch), so we just require auth
+            // and mark that owner check should happen later
+            if (hasOwner) {
+                // With owner: require auth, role check will be combined with owner check post-fetch
+                return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }`;
+            }
+            // Multiple roles without owner - check if user has ANY of the roles
+            const roleConditions = roleChecks.map(r => `context.request.user.role === '${r}'`).join(' || ');
+            return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }
+    if (!(${roleConditions})) {
+      throw new Error('Insufficient permissions: one of [${roleChecks.join(', ')}] role required');
+    }`;
+        }
+        // Only 'authenticated' in the mix
+        if (hasAuthenticated) {
+            return `if (!context.request.user) {
+      throw new Error('Authentication required');
+    }`;
+        }
+        return '';
+    }
+    /**
+     * Generate post-fetch authorization check for owner validation.
+     * This runs after fetching the entity and validates ownership.
+     * Used for READ operations (get, list) where we check after fetch.
+     * For child entities, uses getResourceOwner() since result has no ownerId.
+     */
+    generatePostFetchOwnerCheck(auth, resultVar = 'result', useCaseVar, childInfo) {
+        const roles = this.normalizeAuth(auth);
+        if (!roles.includes('owner')) {
+            return ''; // No owner check needed
+        }
+        const bypassRoles = roles.filter(r => r !== 'owner' && r !== 'all' && r !== 'authenticated');
+        // Child entities don't have ownerId on result; resolve via getResourceOwner
+        if (childInfo && useCaseVar) {
+            if (bypassRoles.length === 0) {
+                return `
+    // Owner validation (post-fetch for reads, via parent)
+    const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(${resultVar}.id);
+    if (resourceOwnerId === null) {
+      throw new Error('Resource not found');
+    }
+    if (resourceOwnerId !== context.request.user?.id) {
+      throw new Error('Access denied: you do not own this resource');
+    }`;
+            }
+            const bypassConditions = bypassRoles.map(r => `context.request.user?.role === '${r}'`).join(' || ');
+            return `
+    // Owner validation (post-fetch for reads, via parent, bypassed for: ${bypassRoles.join(', ')})
+    const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(${resultVar}.id);
+    if (resourceOwnerId === null) {
+      throw new Error('Resource not found');
+    }
+    const isOwner = resourceOwnerId === context.request.user?.id;
+    const hasPrivilegedRole = ${bypassConditions};
+    if (!isOwner && !hasPrivilegedRole) {
+      throw new Error('Access denied: you do not own this resource');
+    }`;
+        }
+        // Root entity: result has ownerId
+        if (bypassRoles.length === 0) {
+            return `
+    // Owner validation (post-fetch for reads)
+    if (${resultVar}.ownerId !== context.request.user?.id) {
+      throw new Error('Access denied: you do not own this resource');
+    }`;
+        }
+        const bypassConditions = bypassRoles.map(r => `context.request.user?.role === '${r}'`).join(' || ');
+        return `
+    // Owner validation (post-fetch for reads, bypassed for: ${bypassRoles.join(', ')})
+    const isOwner = ${resultVar}.ownerId === context.request.user?.id;
+    const hasPrivilegedRole = ${bypassConditions};
+    if (!isOwner && !hasPrivilegedRole) {
+      throw new Error('Access denied: you do not own this resource');
+    }`;
+    }
+    /**
+     * Generate pre-mutation authorization check for owner validation.
+     * This runs BEFORE the mutation to prevent unauthorized changes.
+     * Used for WRITE operations (update, delete).
+     * @param auth - The auth requirement
+     * @param useCaseVar - The use case variable name
+     * @returns Code string for the pre-mutation owner check, or empty string if not needed
+     */
+    generatePreMutationOwnerCheck(auth, useCaseVar = 'useCase') {
+        const roles = this.normalizeAuth(auth);
+        if (!roles.includes('owner')) {
+            return ''; // No owner check needed
+        }
+        // Get non-owner roles for the bypass check
+        const bypassRoles = roles.filter(r => r !== 'owner' && r !== 'all' && r !== 'authenticated');
+        if (bypassRoles.length === 0) {
+            // Only owner - strict ownership check
+            return `
+    // Pre-mutation owner validation
+    const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(input.id);
+    if (resourceOwnerId === null) {
+      throw new Error('Resource not found');
+    }
+    if (resourceOwnerId !== context.request.user?.id) {
+      throw new Error('Access denied: you do not own this resource');
+    }
+`;
+        }
+        // Owner OR other roles - bypass if user has a privileged role
+        const bypassConditions = bypassRoles.map(r => `context.request.user?.role === '${r}'`).join(' || ');
+        return `
+    // Pre-mutation owner validation (bypassed for: ${bypassRoles.join(', ')})
+    const resourceOwnerId = await this.${useCaseVar}.getResourceOwner(input.id);
+    if (resourceOwnerId === null) {
+      throw new Error('Resource not found');
+    }
+    const isOwner = resourceOwnerId === context.request.user?.id;
+    const hasPrivilegedRole = ${bypassConditions};
+    if (!isOwner && !hasPrivilegedRole) {
+      throw new Error('Access denied: you do not own this resource');
+    }
+`;
+    }
+    generateApiEndpointMethod(endpoint, resourceName, childInfo) {
+        const { model, action } = this.parseUseCase(endpoint.useCase);
+        const methodName = action;
+        const decorator = this.getHttpDecorator(endpoint.method);
+        const useCaseVar = `${model.toLowerCase()}UseCase`;
+        const inputClass = `${model}${this.capitalize(action)}Input`;
+        const outputClass = `${model}${this.capitalize(action)}Output`;
+        const dtoImports = new Set();
+        dtoImports.add(`${model}${this.capitalize(action)}`);
+        // Generate auth check (pre-fetch)
+        const authCheck = this.generateAuthCheck(endpoint.auth);
+        const authLine = authCheck ? `\n    ${authCheck}\n` : '';
+        // Build parsing logic
+        // For create: root gets ownerId from user, child gets parentId from URL params
+        let parseLogic;
+        if (action === 'list') {
+            parseLogic = `const input = ${inputClass}.parse(context.request.parameters);`;
+        }
+        else if (action === 'get' || action === 'delete') {
+            parseLogic = `const input = ${inputClass}.parse({ id: context.request.parameters.id });`;
+        }
+        else if (action === 'create') {
+            if (childInfo) {
+                parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ${childInfo.parentIdField}: context.request.parameters.${childInfo.parentIdField} });`;
+            }
+            else {
+                parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ownerId: context.request.user?.id });`;
+            }
+        }
+        else if (action === 'update') {
+            parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, id: context.request.parameters.id });`;
+        }
+        else {
+            parseLogic = `const input = ${inputClass}.parse(context.request.body || {});`;
+        }
+        // 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
+        const preMutationOwnerCheck = (hasOwner && isMutation)
+            ? this.generatePreMutationOwnerCheck(endpoint.auth, useCaseVar)
+            : '';
+        // Post-fetch owner check for read operations only
+        const postFetchOwnerCheck = (hasOwner && isRead)
+            ? this.generatePostFetchOwnerCheck(endpoint.auth, 'result', useCaseVar, childInfo)
+            : '';
+        // Generate output transformation based on action
+        let outputTransform;
+        if (action === 'list') {
+            outputTransform = `return ${outputClass}.from(result);`;
+        }
+        else if (action === 'delete') {
+            outputTransform = `return result;`;
+        }
+        else {
+            outputTransform = `return ${outputClass}.from(result);`;
+        }
+        const method = `  @${decorator}('${endpoint.path}')
+  async ${methodName}(context: IContext): Promise<any> {${authLine}
+    ${parseLogic}${preMutationOwnerCheck}
+    const result = await this.${useCaseVar}.${action}(input);${postFetchOwnerCheck}
+    ${outputTransform}
+  }`;
+        return { method, dtoImports };
+    }
+    generateWebPageMethod(page, resourceName, layout, methodIndex, childInfo, withChildChildren) {
+        const method = page.method || 'GET';
+        const decorator = this.getHttpDecorator(method);
+        const dtoImports = new Set();
+        // Generate unique method name by appending method type for POST routes
+        const pathSegments = page.path.split('/').filter(Boolean);
+        let baseMethodName = pathSegments.length === 0
+            ? 'index'
+            : pathSegments.map((seg, idx) => {
+                if (seg.startsWith(':')) {
+                    return 'By' + this.capitalize(seg.slice(1));
+                }
+                return idx === 0 ? seg : this.capitalize(seg);
+            }).join('');
+        // Append method suffix for POST to avoid duplicates
+        const methodName = method === 'POST' ? `${baseMethodName}Submit` : baseMethodName;
+        // Generate auth check (pre-fetch)
+        const authCheck = this.generateAuthCheck(page.auth);
+        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}")`;
+            if (page.useCase) {
+                const { model, action } = this.parseUseCase(page.useCase);
+                const useCaseVar = `${model.toLowerCase()}UseCase`;
+                const inputClass = `${model}${this.capitalize(action)}Input`;
+                dtoImports.add(`${model}${this.capitalize(action)}`);
+                let parseLogic;
+                if (page.path.includes(':id')) {
+                    parseLogic = `const input = ${inputClass}.parse({ id: context.request.parameters.id });`;
+                }
+                else if (action === 'list') {
+                    parseLogic = `const input = ${inputClass}.parse(context.request.parameters);`;
+                }
+                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)
+                    : '';
+                // For get + withChild: load child entities and merge into result for template
+                const loadChildBlocks = [];
+                let returnExpr;
+                if (childInfo) {
+                    returnExpr = `{ ...result, ${childInfo.parentIdField}: context.request.parameters.${childInfo.parentIdField} }`;
+                }
+                else if ((withChildChildren === null || withChildChildren === void 0 ? void 0 : withChildChildren.length) && action === 'get') {
+                    const childKeys = [];
+                    for (const child of withChildChildren) {
+                        const childVar = child.childEntityName.charAt(0).toLowerCase() + child.childEntityName.slice(1);
+                        const childItemsKey = `${childVar}Items`;
+                        childKeys.push(childItemsKey);
+                        loadChildBlocks.push(`const ${childItemsKey} = await this.${childVar}Service.listByParent(result.id);`);
+                    }
+                    returnExpr = `{ ...result, ${childKeys.map(k => `${k}: ${k}`).join(', ')} }`;
+                }
+                else {
+                    returnExpr = 'result';
+                }
+                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}
+    return ${returnExpr};
+  }`;
+                return { method: methodCode, dtoImports };
+            }
+            else {
+                // No use case - just render view (e.g. create form)
+                // Child entities need the parent ID from URL params for link rendering
+                const emptyFormData = childInfo
+                    ? `{ formData: {}, ${childInfo.parentIdField}: context.request.parameters.${childInfo.parentIdField} }`
+                    : '{ formData: {} }';
+                const methodCode = `${renderDecorator}
+  @${decorator}('${page.path}')
+  async ${methodName}(context: IContext): Promise<any> {${authLine}
+    return ${emptyFormData};
+  }`;
+                return { method: methodCode, dtoImports };
+            }
+        }
+        else if (method === 'POST' && page.useCase) {
+            // POST request - form submission
+            const { model, action } = this.parseUseCase(page.useCase);
+            const useCaseVar = `${model.toLowerCase()}UseCase`;
+            const inputClass = `${model}${this.capitalize(action)}Input`;
+            dtoImports.add(`${model}${this.capitalize(action)}`);
+            let parseLogic;
+            if (page.path.includes(':id')) {
+                parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, id: context.request.parameters.id });`;
+            }
+            else if (action === 'create') {
+                if (childInfo) {
+                    parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ${childInfo.parentIdField}: context.request.parameters.${childInfo.parentIdField} });`;
+                }
+                else {
+                    parseLogic = `const input = ${inputClass}.parse({ ...context.request.body, ownerId: context.request.user?.id });`;
+                }
+            }
+            else {
+                parseLogic = `const input = ${inputClass}.parse(context.request.body);`;
+            }
+            // Generate PRE-mutation owner check for update/delete actions (POST requests)
+            const hasOwner = this.hasOwnerAuth(page.auth);
+            const isMutation = action === 'update' || action === 'delete';
+            const preMutationOwnerCheck = (hasOwner && isMutation)
+                ? this.generatePreMutationOwnerCheck(page.auth, useCaseVar)
+                : '';
+            // Handle onSuccess and onError strategies
+            const onSuccessHandler = this.generateOnSuccessHandler(page);
+            const onErrorHandler = this.generateOnErrorHandler(page);
+            const methodCode = `  @${decorator}('${page.path}')
+  async ${methodName}(context: IContext): Promise<any> {${authLine}
+    try {
+      ${parseLogic}${preMutationOwnerCheck}
+      const result = await this.${useCaseVar}.${action}(input);
+      ${onSuccessHandler}
+      return { success: true, data: result };
+    } catch (error) {
+      ${onErrorHandler}
+      throw error;
+    }
+  }`;
+            return { method: methodCode, dtoImports };
+        }
+        const methodCode = `  @${decorator}('${page.path}')
+  async ${methodName}(context: IContext): Promise<any> {
+    // TODO: Implement ${methodName}
+    return {};
+  }`;
+        return { method: methodCode, dtoImports };
+    }
+    generateOnSuccessHandler(page) {
+        if (!page.onSuccess)
+            return '// Success';
+        const handlers = [];
+        if (page.onSuccess.toast) {
+            handlers.push(`// Toast: ${page.onSuccess.toast}`);
+        }
+        if (page.onSuccess.redirect) {
+            const redirectPath = page.onSuccess.redirect.replace(':id', '${result.id}');
+            handlers.push(`// Redirect: ${redirectPath}`);
+        }
+        if (page.onSuccess.back) {
+            handlers.push('// Navigate back');
+        }
+        return handlers.join('\n      ') || '// Success';
+    }
+    generateOnErrorHandler(page) {
+        if (!page.onError)
+            return '// Error occurred';
+        const handlers = [];
+        if (page.onError.stay) {
+            handlers.push('// Stay on page');
+        }
+        if (page.onError.toast) {
+            handlers.push(`// Error toast: ${page.onError.toast}`);
+        }
+        return handlers.join('\n      ') || '// Error occurred';
+    }
+    /**
+     * Sort routes so static paths are registered before parameterized ones.
+     * This prevents parameterized routes (e.g. /:id) from catching requests
+     * meant for static routes (e.g. /create).
+     */
+    sortRoutesBySpecificity(routes) {
+        return [...routes].sort((a, b) => {
+            const aSegments = a.path.split('/').filter(Boolean);
+            const bSegments = b.path.split('/').filter(Boolean);
+            const aParamCount = aSegments.filter(s => s.startsWith(':')).length;
+            const bParamCount = bSegments.filter(s => s.startsWith(':')).length;
+            return aParamCount - bParamCount;
+        });
+    }
+    generateApiController(resourceName, prefix, endpoints, childInfo) {
+        const controllerName = `${resourceName}ApiController`;
+        // Determine which use cases and DTOs are referenced
+        const useCaseModels = new Set();
+        const allDtoImports = 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);
+            methods.push(method);
+            dtoImports.forEach(d => allDtoImports.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}';`)
+            .join('\n');
+        // Generate constructor parameters
+        const constructorParams = Array.from(useCaseModels)
+            .map(model => `private ${model.toLowerCase()}UseCase: ${model}UseCase`)
+            .join(',\n    ');
+        return `import { Controller, Get, Post, Put, Delete, type IContext } from '@currentjs/router';
+${useCaseImports}
+${dtoImportStatements}
+
+@Controller('${prefix}')
+export class ${controllerName} {
+  constructor(
+    ${constructorParams}
+  ) {}
+
+${methods.join('\n\n')}
+}`;
+    }
+    generateWebController(resourceName, prefix, layout, pages, config, childInfo) {
+        const controllerName = `${resourceName}WebController`;
+        // Child entities of this resource (for withChild). Only root entities can have withChild.
+        const withChildChildren = childInfo ? [] : (0, childEntityUtils_1.getChildrenOfParent)(config, resourceName);
+        // Determine which use cases and DTOs are referenced
+        const useCaseModels = new Set();
+        const allDtoImports = new Set();
+        const methods = [];
+        const sortedPages = this.sortRoutesBySpecificity(pages);
+        sortedPages.forEach((page, index) => {
+            var _a, _b;
+            if (page.useCase) {
+                const { model } = this.parseUseCase(page.useCase);
+                useCaseModels.add(model);
+            }
+            const { model, action } = page.useCase ? this.parseUseCase(page.useCase) : { model: '', action: '' };
+            const useCaseWithChild = model && action && ((_b = (_a = config.useCases[model]) === null || _a === void 0 ? void 0 : _a[action]) === null || _b === void 0 ? void 0 : _b.withChild) === true;
+            const withChildForThisPage = useCaseWithChild && action === 'get' && withChildChildren.length > 0 ? withChildChildren : undefined;
+            const { method, dtoImports } = this.generateWebPageMethod(page, resourceName, layout, index, childInfo, withChildForThisPage);
+            methods.push(method);
+            dtoImports.forEach(d => allDtoImports.add(d));
+        });
+        // Determine if any page actually uses withChild (only then inject child services)
+        const needsChildServices = withChildChildren.length > 0 && sortedPages.some(page => {
+            var _a, _b;
+            if (!page.useCase)
+                return false;
+            const { model: m, action: a } = this.parseUseCase(page.useCase);
+            return a === 'get' && ((_b = (_a = config.useCases[m]) === null || _a === void 0 ? void 0 : _a[a]) === null || _b === void 0 ? void 0 : _b.withChild) === true;
+        });
+        // Constructor: use cases + child entity services when withChild is actually used
+        const serviceImports = [];
+        const constructorParams = [];
+        Array.from(useCaseModels).forEach(model => {
+            constructorParams.push(`private ${model.toLowerCase()}UseCase: ${model}UseCase`);
+        });
+        if (needsChildServices) {
+            withChildChildren.forEach(child => {
+                const childVar = child.childEntityName.charAt(0).toLowerCase() + child.childEntityName.slice(1);
+                serviceImports.push(`import { ${child.childEntityName}Service } from '../../application/services/${child.childEntityName}Service';`);
+                constructorParams.push(`private ${childVar}Service: ${child.childEntityName}Service`);
+            });
+        }
+        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 } from '../../application/dto/${dto}';`)
+            .join('\n');
+        const constructorBlock = constructorParams.length > 0
+            ? `constructor(
+    ${constructorParams.join(',\n    ')}
+  ) {}`
+            : 'constructor() {}';
+        return `import { Controller, Get, Post, Render, type IContext } from '@currentjs/router';
+${useCaseImports}
+${serviceImports.join('\n')}
+${dtoImportStatements}
+
+@Controller('${prefix}')
+export class ${controllerName} {
+  ${constructorBlock}
+
+${methods.join('\n\n')}
+}`;
+    }
+    generateFromConfig(config) {
+        const result = {};
+        const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
+        // Generate API controllers
+        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);
+                result[`${resourceName}Api`] = code;
+            });
+        }
+        // Generate Web controllers
+        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);
+                result[`${resourceName}Web`] = code;
+            });
+        }
+        return result;
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        if (!(0, configTypes_1.isNewModuleConfig)(config)) {
+            throw new Error('Configuration does not match new module format. Expected domain/useCases/api/web structure.');
+        }
+        return this.generateFromConfig(config);
+    }
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const controllersByName = this.generateFromYamlFile(yamlFilePath);
+        const controllersDir = path.join(moduleDir, 'infrastructure', 'controllers');
+        fs.mkdirSync(controllersDir, { recursive: true });
+        const generatedPaths = [];
+        for (const [name, code] of Object.entries(controllersByName)) {
+            const filePath = path.join(controllersDir, `${name}Controller.ts`);
+            // eslint-disable-next-line no-await-in-loop
+            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) });
+            generatedPaths.push(filePath);
+        }
+        // eslint-disable-next-line no-console
+        console.log('\n' + colors_1.colors.green('Controller files generated successfully!') + '\n');
+        return generatedPaths;
+    }
+}
+exports.NewControllerGenerator = NewControllerGenerator;

package/dist/generators/newServiceGenerator.d.ts

@@ -0,0 +1,19 @@
+import { NewModuleConfig } from '../types/configTypes';
+export declare class NewServiceGenerator {
+    private typeMapping;
+    private availableAggregates;
+    private mapType;
+    private capitalize;
+    private generateDefaultHandlerMethod;
+    private generateCustomHandlerMethod;
+    private collectHandlers;
+    private generateListByParentMethod;
+    private generateGetResourceOwnerMethod;
+    private generateService;
+    generateFromConfig(config: NewModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}