@currentjs/gen 0.1.1

package/dist/generators/controllerGenerator.js

@@ -0,0 +1,280 @@
+"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.ControllerGenerator = void 0;
+const yaml_1 = require("yaml");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const controllerTemplates_1 = require("./templates/controllerTemplates");
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const constants_1 = require("../utils/constants");
+class ControllerGenerator {
+    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 = {};
+        Object.keys(moduleConfig.actions).forEach(action => {
+            actionPermissions[action] = [];
+        });
+        moduleConfig.permissions.forEach(permission => {
+            permission.actions.forEach(action => {
+                if (actionPermissions[action]) {
+                    actionPermissions[action].push(permission.role);
+                }
+            });
+        });
+        return actionPermissions;
+    }
+    shouldGenerateMethod(action, roles) {
+        return !roles.includes('none');
+    }
+    needsUserParam(roles) {
+        return roles.length > 0 && !roles.includes('all');
+    }
+    getHttpMethodName(_httpMethod, action) {
+        return action;
+    }
+    getHttpDecorator(httpMethod) {
+        switch ((httpMethod || 'GET').toUpperCase()) {
+            case 'GET':
+                return 'Get';
+            case 'POST':
+                return 'Post';
+            case 'PUT':
+                return 'Put';
+            case 'PATCH':
+                return 'Patch';
+            case 'DELETE':
+                return 'Delete';
+            default:
+                return 'Get';
+        }
+    }
+    generateMethodImplementation(action, entityName, hasUserParam) {
+        const template = controllerTemplates_1.controllerTemplates.methodImplementations[action];
+        if (!template) {
+            return `    // TODO: Implement ${action} method\n    return {} as any;`;
+        }
+        const userExtraction = hasUserParam ? controllerTemplates_1.controllerTemplates.userExtraction : '';
+        const userParam = hasUserParam ? ', user' : '';
+        return template
+            .replace(/{{ENTITY_NAME}}/g, entityName)
+            .replace(/{{ENTITY_LOWER}}/g, entityName.toLowerCase())
+            .replace(/{{USER_EXTRACTION}}/g, userExtraction)
+            .replace(/{{USER_PARAM}}/g, userParam);
+    }
+    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;
+    }
+    generateControllerMethod(endpoint, entityName, roles, hasPermissions, kind) {
+        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 returnType = this.getReturnType(endpoint.action, entityName);
+        const renderDecorator = kind === 'web' && endpoint.view
+            ? `\n  @Render("${endpoint.view}"${endpoint.layout ? `, "${endpoint.layout}"` : ', "main_view"'})`
+            : '';
+        const variables = {
+            METHOD_NAME: methodName,
+            HTTP_DECORATOR: httpDecorator,
+            ENDPOINT_PATH: endpoint.path,
+            METHOD_IMPLEMENTATION: methodImplementation,
+            RETURN_TYPE: returnType,
+            RENDER_DECORATOR: renderDecorator
+        };
+        return this.replaceTemplateVars(controllerTemplates_1.controllerTemplates.controllerMethod, variables);
+    }
+    getWebMethodName(endpoint) {
+        const base = this.getHttpMethodName(endpoint.method, endpoint.action);
+        const suffix = this.getPathSuffix(endpoint.path);
+        return `${base}${suffix}`;
+    }
+    getPathSuffix(routePath) {
+        if (!routePath || routePath === '/')
+            return 'Index';
+        const segments = routePath.split('/').filter(Boolean);
+        const parts = segments.map(seg => {
+            if (seg.startsWith(':')) {
+                const name = seg.slice(1);
+                return 'By' + name.charAt(0).toUpperCase() + name.slice(1);
+            }
+            const cleaned = seg.replace(/[^a-zA-Z0-9]+/g, ' ')
+                .split(' ')
+                .filter(Boolean)
+                .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+                .join('');
+            return cleaned || 'Index';
+        });
+        return parts.join('');
+    }
+    getReturnType(action, entityName) {
+        switch (action) {
+            case 'list':
+                return `${entityName}[]`;
+            case 'get':
+            case 'create':
+            case 'update':
+            case 'empty':
+                return entityName;
+            case 'delete':
+                return '{ success: boolean; message: string }';
+            default:
+                return 'any';
+        }
+    }
+    generateController(moduleName, moduleConfig, hasGlobalPermissions, kind) {
+        if (!moduleConfig.models || moduleConfig.models.length === 0) {
+            return '';
+        }
+        const isApi = kind === 'api';
+        const cfgRaw = isApi ? moduleConfig.api : moduleConfig.routes;
+        let cfg = cfgRaw;
+        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}`,
+                    endpoints: [
+                        { path: '/', action: 'list', method: 'GET', view: `${entityLower}List` },
+                        { path: '/:id', action: 'get', method: 'GET', view: `${entityLower}Detail` },
+                        { path: '/create', action: 'empty', method: 'GET', view: `${entityLower}Create` },
+                        { path: '/:id/edit', action: 'get', method: 'GET', view: `${entityLower}Update` }
+                    ]
+                };
+            }
+            else {
+                // Force GET for all web endpoints; forms should submit to API using custom form handling
+                cfg = {
+                    prefix: cfgRaw.prefix || `/${entityLower}`,
+                    endpoints: (cfgRaw.endpoints || []).map(e => ({ ...e, method: 'GET' }))
+                };
+            }
+        }
+        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(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);
+        })
+            .join('\n\n');
+        const controllerClass = this.replaceTemplateVars(controllerTemplates_1.controllerTemplates.controllerClass, {
+            CONTROLLER_NAME: `${entityName}${isApi ? 'ApiController' : 'WebController'}`,
+            ENTITY_NAME: entityName,
+            ENTITY_LOWER: entityLower,
+            CONTROLLER_BASE: controllerBase,
+            CONTROLLER_METHODS: controllerMethods
+        });
+        return this.replaceTemplateVars(controllerTemplates_1.controllerFileTemplate, {
+            ENTITY_NAME: entityName,
+            JWT_IMPORT: '',
+            CONTROLLER_CLASS: controllerClass
+        });
+    }
+    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]) => {
+                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;
+            });
+        }
+        else {
+            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;
+        }
+        return result;
+    }
+    async generateAndSaveFiles(yamlFilePath = constants_1.COMMON_FILES.APP_YAML, outputDir = 'infrastructure', opts) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        const hasGlobalPermissions = this.hasPermissions(config);
+        const controllers = this.generateFromYamlFile(yamlFilePath);
+        const generatedControllerPaths = [];
+        const controllersDir = path.join(outputDir, 'controllers');
+        fs.mkdirSync(controllersDir, { recursive: true });
+        for (const [moduleName, controllerCode] of Object.entries(controllers)) {
+            const fileName = `${moduleName}Controller.ts`;
+            const filePath = path.join(controllersDir, fileName);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, controllerCode, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+            generatedControllerPaths.push(filePath);
+        }
+        // eslint-disable-next-line no-console
+        console.log('\n' + colors_1.colors.green('Controller files generated successfully!') + '\n');
+        return generatedControllerPaths;
+    }
+}
+exports.ControllerGenerator = ControllerGenerator;

package/dist/generators/domainModelGenerator.d.ts

@@ -0,0 +1,33 @@
+interface FieldConfig {
+    name: string;
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    auto?: boolean;
+}
+interface ModelConfig {
+    name: string;
+    fields: FieldConfig[];
+}
+type ModuleConfig = {
+    models: ModelConfig[];
+};
+type AppConfig = {
+    modules: Record<string, ModuleConfig>;
+} | ModuleConfig;
+export declare class DomainModelGenerator {
+    private typeMapping;
+    private getDefaultValue;
+    private mapType;
+    private generateConstructorParameter;
+    private generateSetterMethods;
+    generateModel(modelConfig: ModelConfig): string;
+    generateModels(models: ModelConfig[]): string;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateFromConfig(config: AppConfig): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, outputDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}
+export {};

package/dist/generators/domainModelGenerator.js

@@ -0,0 +1,175 @@
+"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.DomainModelGenerator = 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");
+class DomainModelGenerator {
+    constructor() {
+        this.typeMapping = {
+            string: 'string',
+            number: 'number',
+            boolean: 'boolean',
+            datetime: 'Date',
+            json: 'any',
+            array: 'any[]',
+            object: 'object'
+        };
+    }
+    getDefaultValue(type) {
+        switch (type) {
+            case 'datetime':
+                return 'new Date()';
+            case 'string':
+                return "''";
+            case 'number':
+                return '0';
+            case 'boolean':
+                return 'false';
+            case 'array':
+                return '[]';
+            case 'object':
+            case 'json':
+                return '{}';
+            default:
+                return 'undefined';
+        }
+    }
+    mapType(yamlType) {
+        return this.typeMapping[yamlType] || 'any';
+    }
+    generateConstructorParameter(field) {
+        const tsType = this.mapType(field.type);
+        const isOptional = !field.required && !field.auto;
+        const hasDefault = field.auto;
+        let param = `public ${field.name}`;
+        if (isOptional && !hasDefault) {
+            param += '?';
+        }
+        param += `: ${tsType}`;
+        if (hasDefault) {
+            param += ` = ${this.getDefaultValue(field.type)}`;
+        }
+        return param;
+    }
+    generateSetterMethods(modelConfig) {
+        const setterMethods = [];
+        modelConfig.fields.forEach(field => {
+            if (!field.auto && field.name !== 'id') {
+                const tsType = this.mapType(field.type);
+                const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
+                const setter = `
+    ${methodName}(${field.name}: ${tsType}): void {
+        this.${field.name} = ${field.name};
+    }`;
+                setterMethods.push(setter);
+            }
+        });
+        return setterMethods.join('\n');
+    }
+    generateModel(modelConfig) {
+        const className = modelConfig.name;
+        // Always add id field first
+        const constructorParams = ['public id: number'];
+        // Process other fields
+        modelConfig.fields.forEach(field => {
+            constructorParams.push(this.generateConstructorParameter(field));
+        });
+        const constructorParamsStr = constructorParams.join(',\n        ');
+        const setterMethods = this.generateSetterMethods(modelConfig);
+        return `export class ${className} {
+    public constructor(
+        ${constructorParamsStr}
+    ) { }
+${setterMethods}
+}`;
+    }
+    generateModels(models) {
+        return models.map(model => this.generateModel(model)).join('\n\n');
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        const result = {};
+        if (config.modules) {
+            const app = config;
+            Object.values(app.modules).forEach(moduleConfig => {
+                if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    moduleConfig.models.forEach(m => {
+                        result[m.name] = this.generateModel(m);
+                    });
+                }
+            });
+        }
+        else if (config.models) {
+            const module = config;
+            module.models.forEach(m => {
+                result[m.name] = this.generateModel(m);
+            });
+        }
+        return result;
+    }
+    generateFromConfig(config) {
+        const result = {};
+        if (config.modules) {
+            Object.values(config.modules).forEach(moduleConfig => {
+                if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    moduleConfig.models.forEach(m => {
+                        result[m.name] = this.generateModel(m);
+                    });
+                }
+            });
+        }
+        else if (config.models) {
+            config.models.forEach(m => {
+                result[m.name] = this.generateModel(m);
+            });
+        }
+        return result;
+    }
+    async generateAndSaveFiles(yamlFilePath, outputDir, opts) {
+        const codeByEntity = this.generateFromYamlFile(yamlFilePath);
+        await Promise.all(Object.entries(codeByEntity).map(([entity, code]) => {
+            const filePath = path.join(outputDir, `${entity}.ts`);
+            return (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('Domain model files generated successfully!') + '\n');
+    }
+}
+exports.DomainModelGenerator = DomainModelGenerator;

package/dist/generators/serviceGenerator.d.ts

@@ -0,0 +1,39 @@
+interface ActionConfig {
+    handlers: string[];
+}
+interface PermissionConfig {
+    role: string;
+    actions: string[];
+}
+interface ModelConfig {
+    name: string;
+    fields: any[];
+}
+type ModuleConfig = {
+    models?: ModelConfig[];
+    actions?: Record<string, ActionConfig>;
+    permissions?: PermissionConfig[];
+};
+export declare class ServiceGenerator {
+    private hasPermissions;
+    private getActionPermissions;
+    private generatePermissionCheck;
+    private getResourceIdForAction;
+    private generateMethodParams;
+    private generateReturnType;
+    private generateMethodImplementation;
+    private extractFunctionName;
+    private getMethodCallParams;
+    private generateConstructorArgs;
+    private generateUpdateSetterCalls;
+    private replaceTemplateVars;
+    private generateServiceMethod;
+    generateService(moduleName: string, moduleConfig: ModuleConfig, hasGlobalPermissions: boolean): string;
+    private generateCustomImports;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath?: string, outputDir?: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}
+export {};