@currentjs/gen 0.1.2 → 0.2.1

package/dist/commands/createModule.js

@@ -50,6 +50,7 @@ function moduleYamlTemplate(moduleName) {
         ],
         api: {
             prefix: `/api/${lower}`,
+            model: entityName,
             endpoints: [
                 { method: 'GET', path: '/', action: 'list' },
                 { method: 'GET', path: '/:id', action: 'get' },
@@ -60,6 +61,7 @@ function moduleYamlTemplate(moduleName) {
         },
         routes: {
             prefix: `/${lower}`,
+            model: entityName,
             strategy: ['back', 'toast'],
             endpoints: [
                 //bug: the order of the endpoints is important (to fix it in the router)
@@ -70,11 +72,11 @@ function moduleYamlTemplate(moduleName) {
             ]
         },
         actions: {
-            list: { handlers: ['default:list'] },
-            get: { handlers: ['default:getById'] },
-            create: { handlers: ['default:create'] },
-            update: { handlers: ['default:update'] },
-            delete: { handlers: ['default:delete'] }
+            list: { handlers: [`${entityName}:default:list`] },
+            get: { handlers: [`${entityName}:default:get`] },
+            create: { handlers: [`${entityName}:default:create`] },
+            update: { handlers: [`${entityName}:default:update`] },
+            delete: { handlers: [`${entityName}:default:delete`] }
         },
         permissions: []
     };

package/dist/generators/controllerGenerator.d.ts

@@ -5,12 +5,15 @@ export declare class ControllerGenerator {
     private needsUserParam;
     private getHttpMethodName;
     private getHttpDecorator;
+    private getMethodCallParams;
+    private generateParameterExtractions;
     private generateMethodImplementation;
     private replaceTemplateVars;
     private generateControllerMethod;
     private getWebMethodName;
     private getPathSuffix;
     private getReturnType;
+    private generateControllerForModel;
     private generateController;
     generateFromYamlFile(yamlFilePath: string): Record<string, string>;
     generateAndSaveFiles(yamlFilePath?: string, outputDir?: string, opts?: {

package/dist/generators/controllerGenerator.js

@@ -91,7 +91,92 @@ class ControllerGenerator {
                 return 'Get';
         }
     }
-    generateMethodImplementation(action, entityName, hasUserParam) {
+    getMethodCallParams(action, entityName) {
+        const dtoType = entityName ? `${entityName}DTO` : 'any';
+        switch (action) {
+            case 'list':
+                return 'page, limit';
+            case 'get':
+            case 'getById':
+                return 'id';
+            case 'create':
+                return `context.request.body as ${dtoType}`;
+            case 'update':
+                return `id, context.request.body as ${dtoType}`;
+            case 'delete':
+                return 'id';
+            default:
+                return '/* custom params */';
+        }
+    }
+    generateParameterExtractions(action) {
+        switch (action) {
+            case 'list':
+                return `
+    // Extract pagination from URL parameters
+    const page = parseInt(context.request.parameters.page as string) || 1;
+    const limit = parseInt(context.request.parameters.limit as string) || 10;`;
+            case 'get':
+            case 'getById':
+            case 'update':
+            case 'delete':
+                return `
+    const id = parseInt(context.request.parameters.id as string);
+    if (isNaN(id)) {
+      throw new Error('Invalid ID parameter');
+    }`;
+            case 'create':
+                return ''; // No additional parameter extraction needed for create
+            default:
+                return '';
+        }
+    }
+    generateMethodImplementation(action, entityName, hasUserParam, actions) {
+        // Check if we have action handlers
+        if (actions && actions[action] && actions[action].handlers) {
+            const handlers = actions[action].handlers;
+            const entityLower = entityName.toLowerCase();
+            // Filter handlers that apply to this model
+            const modelHandlers = handlers.filter(h => h.startsWith(`${entityLower}:`) || h.startsWith(`${entityName}:`));
+            if (modelHandlers.length === 0) {
+                return `// TODO: No valid handlers found for action ${action}. Use ${entityName}:default:${action} or ${entityName}:customMethodName format.`;
+            }
+            const userExtraction = hasUserParam ? controllerTemplates_1.controllerTemplates.userExtraction : '';
+            const userParam = hasUserParam ? ', user' : '';
+            // Generate parameter extraction based on action type
+            const paramExtractions = this.generateParameterExtractions(action);
+            // Generate step-by-step calls for each handler
+            const handlerCalls = modelHandlers.map((handler, index) => {
+                const parts = handler.split(':');
+                let methodName;
+                let params;
+                if (parts.length === 3 && parts[1] === 'default') {
+                    // Format: modelname:default:action
+                    const actionName = parts[2];
+                    methodName = actionName === 'getById' ? 'get' : actionName; // Use 'get' instead of 'getById'
+                    // For default handlers, use extracted parameters
+                    params = this.getMethodCallParams(actionName, entityName) + userParam;
+                }
+                else if (parts.length === 2) {
+                    // Format: modelname:custommethod
+                    methodName = parts[1];
+                    // For custom handlers, pass result from previous handler (or null) and context
+                    const prevResult = index === 0 ? 'null' : `result${index}`;
+                    params = `${prevResult}, context${userParam}`;
+                }
+                else {
+                    return `// Invalid handler format: ${handler}`;
+                }
+                const isLast = index === modelHandlers.length - 1;
+                const resultVar = isLast ? 'result' : `result${index + 1}`;
+                return `const ${resultVar} = await this.${entityLower}Service.${methodName}(${params});`;
+            }).join('\n    ');
+            // For multiple handlers, return the last result
+            const returnStatement = '\n    return result;';
+            return `${userExtraction}${paramExtractions}
+    ${handlerCalls}${returnStatement}`;
+        }
+        // Fallback to existing template lookup
         const template = controllerTemplates_1.controllerTemplates.methodImplementations[action];
         if (!template) {
             return `    // TODO: Implement ${action} method\n    return {} as any;`;
@@ -112,11 +197,11 @@ class ControllerGenerator {
         });
         return result;
     }
-    generateControllerMethod(endpoint, entityName, roles, hasPermissions, kind) {
+    generateControllerMethod(endpoint, entityName, roles, hasPermissions, kind, actions) {
         const methodName = kind === 'web' ? this.getWebMethodName(endpoint) : this.getHttpMethodName(endpoint.method, endpoint.action);
         const httpDecorator = kind === 'web' ? 'Get' : this.getHttpDecorator(endpoint.method);
         const needsUser = this.needsUserParam(roles);
-        const methodImplementation = this.generateMethodImplementation(endpoint.action, entityName, needsUser);
+        const methodImplementation = this.generateMethodImplementation(endpoint.action, entityName, needsUser, actions);
         const returnType = this.getReturnType(endpoint.action, entityName);
         const renderDecorator = kind === 'web' && endpoint.view
             ? `\n  @Render("${endpoint.view}"${endpoint.layout ? `, "${endpoint.layout}"` : ', "main_view"'})`
@@ -169,17 +254,27 @@ class ControllerGenerator {
                 return 'any';
         }
     }
-    generateController(moduleName, moduleConfig, hasGlobalPermissions, kind) {
-        if (!moduleConfig.models || moduleConfig.models.length === 0) {
-            return '';
-        }
+    generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, kind) {
+        var _a;
         const isApi = kind === 'api';
         const cfgRaw = isApi ? moduleConfig.api : moduleConfig.routes;
         let cfg = cfgRaw;
+        const entityName = model.name;
+        const entityLower = entityName.toLowerCase();
+        // Determine if we should generate a controller for this model
+        const configModel = (cfg === null || cfg === void 0 ? void 0 : cfg.model) || (moduleConfig.models && moduleConfig.models[0] ? moduleConfig.models[0].name : null);
+        const topLevelMatches = !configModel || configModel === entityName || configModel.toLowerCase() === entityLower;
+        // Also check if any endpoints specifically target this model
+        const hasEndpointForThisModel = ((_a = cfg === null || cfg === void 0 ? void 0 : cfg.endpoints) === null || _a === void 0 ? void 0 : _a.some(endpoint => {
+            const endpointModel = endpoint.model || configModel;
+            return endpointModel === entityName || (endpointModel === null || endpointModel === void 0 ? void 0 : endpointModel.toLowerCase()) === entityLower;
+        })) || false;
+        const shouldGenerateForThisModel = topLevelMatches || hasEndpointForThisModel;
+        if (!shouldGenerateForThisModel) {
+            return '';
+        }
         if (!isApi) {
             // Ensure sensible defaults for Web routes: list, detail, create (empty), edit (get)
-            const entityName = moduleConfig.models[0].name;
-            const entityLower = entityName.toLowerCase();
             if (!cfgRaw || !cfgRaw.endpoints || cfgRaw.endpoints.length === 0) {
                 cfg = {
                     prefix: `/${entityLower}`,
@@ -201,19 +296,22 @@ class ControllerGenerator {
         }
         if (!cfg)
             return '';
-        const entityName = moduleConfig.models[0].name;
-        const entityLower = entityName.toLowerCase();
         const controllerBase = (cfg.prefix || `/${isApi ? 'api/' : ''}${entityLower}`).replace(/\/$/, '');
         const actionPermissions = this.getActionPermissions(moduleName, moduleConfig);
         const hasPermissions = hasGlobalPermissions && !!(moduleConfig.permissions && moduleConfig.permissions.length > 0);
-        const controllerMethods = (cfg.endpoints || [])
+        // Filter endpoints that apply to this model
+        const modelEndpoints = (cfg.endpoints || []).filter(endpoint => {
+            const endpointModel = endpoint.model || (cfg === null || cfg === void 0 ? void 0 : cfg.model) || (moduleConfig.models && moduleConfig.models[0] ? moduleConfig.models[0].name : null);
+            return endpointModel === entityName || (endpointModel === null || endpointModel === void 0 ? void 0 : endpointModel.toLowerCase()) === entityLower;
+        });
+        const controllerMethods = modelEndpoints
             .filter(endpoint => {
             const roles = actionPermissions[endpoint.action] || [];
             return this.shouldGenerateMethod(endpoint.action, roles);
         })
             .map(endpoint => {
             const roles = actionPermissions[endpoint.action] || [];
-            return this.generateControllerMethod(endpoint, entityName, roles, hasPermissions, kind);
+            return this.generateControllerMethod(endpoint, entityName, roles, hasPermissions, kind, moduleConfig.actions);
         })
             .join('\n\n');
         const controllerClass = this.replaceTemplateVars(controllerTemplates_1.controllerTemplates.controllerClass, {
@@ -229,6 +327,13 @@ class ControllerGenerator {
             CONTROLLER_CLASS: controllerClass
         });
     }
+    generateController(moduleName, moduleConfig, hasGlobalPermissions, kind) {
+        // Legacy method for backward compatibility - use first model
+        if (!moduleConfig.models || moduleConfig.models.length === 0) {
+            return '';
+        }
+        return this.generateControllerForModel(moduleConfig.models[0], moduleName, moduleConfig, hasGlobalPermissions, kind);
+    }
     generateFromYamlFile(yamlFilePath) {
         const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
         const config = (0, yaml_1.parse)(yamlContent);
@@ -236,24 +341,33 @@ class ControllerGenerator {
         const hasGlobalPermissions = this.hasPermissions(config);
         if (config.modules) {
             Object.entries(config.modules).forEach(([moduleName, moduleConfig]) => {
-                const entityName = moduleConfig.models && moduleConfig.models[0] ? moduleConfig.models[0].name : 'Module';
-                const apiControllerCode = this.generateController(moduleName, moduleConfig, hasGlobalPermissions, 'api');
-                if (apiControllerCode)
-                    result[`${entityName}Api`] = apiControllerCode;
-                const webControllerCode = this.generateController(moduleName, moduleConfig, hasGlobalPermissions, 'web');
-                if (webControllerCode)
-                    result[`${entityName}Web`] = webControllerCode;
+                if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    // Generate controllers for each model
+                    moduleConfig.models.forEach(model => {
+                        const apiControllerCode = this.generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, 'api');
+                        if (apiControllerCode)
+                            result[`${model.name}Api`] = apiControllerCode;
+                        const webControllerCode = this.generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, 'web');
+                        if (webControllerCode)
+                            result[`${model.name}Web`] = webControllerCode;
+                    });
+                }
             });
         }
         else {
+            const moduleName = 'Module';
             const moduleConfig = config;
-            const moduleName = moduleConfig.models && moduleConfig.models[0] ? moduleConfig.models[0].name : 'Module';
-            const apiControllerCode = this.generateController(moduleName, moduleConfig, hasGlobalPermissions, 'api');
-            if (apiControllerCode)
-                result[`${moduleName}Api`] = apiControllerCode;
-            const webControllerCode = this.generateController(moduleName, moduleConfig, hasGlobalPermissions, 'web');
-            if (webControllerCode)
-                result[`${moduleName}Web`] = webControllerCode;
+            if (moduleConfig.models && moduleConfig.models.length > 0) {
+                // Generate controllers for each model
+                moduleConfig.models.forEach(model => {
+                    const apiControllerCode = this.generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, 'api');
+                    if (apiControllerCode)
+                        result[`${model.name}Api`] = apiControllerCode;
+                    const webControllerCode = this.generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, 'web');
+                    if (webControllerCode)
+                        result[`${model.name}Web`] = webControllerCode;
+                });
+            }
         }
         return result;
     }

package/dist/generators/serviceGenerator.d.ts

@@ -27,7 +27,9 @@ export declare class ServiceGenerator {
     private generateConstructorArgs;
     private generateUpdateSetterCalls;
     private replaceTemplateVars;
-    private generateServiceMethod;
+    private getServiceMethodName;
+    private generateHandlerMethod;
+    generateServiceForModel(model: ModelConfig, moduleName: string, moduleConfig: ModuleConfig, hasGlobalPermissions: boolean): string;
     generateService(moduleName: string, moduleConfig: ModuleConfig, hasGlobalPermissions: boolean): string;
     private generateCustomImports;
     generateFromYamlFile(yamlFilePath: string): Record<string, string>;