@currentjs/gen 0.5.0 → 0.5.1

package/dist/generators/domainModelGenerator.js

@@ -1,242 +0,0 @@
-"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'
-        };
-        this.availableModels = new Set();
-    }
-    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) {
-        // Check if this is a known model (relationship)
-        if (this.availableModels.has(yamlType)) {
-            return yamlType;
-        }
-        return this.typeMapping[yamlType] || 'any';
-    }
-    setAvailableModels(models) {
-        this.availableModels.clear();
-        models.forEach(model => {
-            this.availableModels.add(model.name);
-        });
-    }
-    getRelatedModelImports(modelConfig) {
-        const imports = [];
-        modelConfig.fields.forEach(field => {
-            if (this.availableModels.has(field.type) && field.type !== modelConfig.name) {
-                imports.push(`import { ${field.type} } from './${field.type}';`);
-            }
-        });
-        return imports;
-    }
-    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;
-    }
-    isRelationshipField(field) {
-        return this.availableModels.has(field.type);
-    }
-    getForeignKeyFieldName(field) {
-        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
-        return field.name + 'Id';
-    }
-    generateForeignKeyParameter(field) {
-        const foreignKeyName = this.getForeignKeyFieldName(field);
-        const isOptional = !field.required && !field.auto;
-        let param = `public ${foreignKeyName}`;
-        if (isOptional) {
-            param += '?';
-        }
-        param += ': number';
-        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)}`;
-                // For all fields (including relationships), generate simple setter
-                // Domain model doesn't care about FKs - that's infrastructure concern
-                const isOptional = !field.required && !field.auto;
-                const setter = `
-    ${methodName}(${field.name}: ${tsType}${isOptional ? ' | undefined' : ''}): void {
-        this.${field.name} = ${field.name};
-    }`;
-                setterMethods.push(setter);
-            }
-        });
-        return setterMethods.join('\n');
-    }
-    sortFieldsByRequired(fields) {
-        // Sort fields: required fields first, then optional fields
-        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
-        });
-    }
-    generateModel(modelConfig) {
-        const className = modelConfig.name;
-        // Always add id field first
-        const constructorParams = ['public id: number'];
-        // Sort fields to put required fields before optional ones
-        const sortedFields = this.sortFieldsByRequired(modelConfig.fields);
-        // Process other fields
-        sortedFields.forEach(field => {
-            // For relationship fields, only add the relationship object (not FK)
-            // Domain model works with objects only - FK is infrastructure concern
-            constructorParams.push(this.generateConstructorParameter(field));
-        });
-        const constructorParamsStr = constructorParams.join(',\n        ');
-        const setterMethods = this.generateSetterMethods(modelConfig);
-        // Generate imports for related models
-        const imports = this.getRelatedModelImports(modelConfig);
-        const importsStr = imports.length > 0 ? imports.join('\n') + '\n\n' : '';
-        return `${importsStr}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) {
-                    // Set available models for relationship detection
-                    this.setAvailableModels(moduleConfig.models);
-                    moduleConfig.models.forEach(m => {
-                        result[m.name] = this.generateModel(m);
-                    });
-                }
-            });
-        }
-        else if (config.models) {
-            const module = config;
-            // Set available models for relationship detection
-            this.setAvailableModels(module.models);
-            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) {
-                    // Set available models for relationship detection
-                    this.setAvailableModels(moduleConfig.models);
-                    moduleConfig.models.forEach(m => {
-                        result[m.name] = this.generateModel(m);
-                    });
-                }
-            });
-        }
-        else if (config.models) {
-            const module = config;
-            // Set available models for relationship detection
-            this.setAvailableModels(module.models);
-            module.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/newControllerGenerator.d.ts

@@ -1,55 +0,0 @@
-import { NewModuleConfig } from '../types/configTypes';
-export declare class NewControllerGenerator {
-    private capitalize;
-    private getHttpDecorator;
-    private parseUseCase;
-    /**
-     * Normalize auth config to an array of roles
-     */
-    private normalizeAuth;
-    /**
-     * Check if auth config includes owner permission
-     */
-    private hasOwnerAuth;
-    /**
-     * 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
-     */
-    private generateAuthCheck;
-    /**
-     * 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.
-     */
-    private generatePostFetchOwnerCheck;
-    /**
-     * 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
-     */
-    private generatePreMutationOwnerCheck;
-    private generateApiEndpointMethod;
-    private generateWebPageMethod;
-    private generateOnSuccessHandler;
-    private generateOnErrorHandler;
-    /**
-     * 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).
-     */
-    private sortRoutesBySpecificity;
-    private generateApiController;
-    private generateWebController;
-    generateFromConfig(config: NewModuleConfig): Record<string, string>;
-    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
-    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
-        force?: boolean;
-        skipOnConflict?: boolean;
-    }): Promise<string[]>;
-}