@currentjs/gen 0.3.2 → 0.5.1

package/dist/utils/diResolver.d.ts

@@ -0,0 +1,32 @@
+export interface ConstructorParam {
+    name: string;
+    type: string;
+}
+export interface ClassInfo {
+    className: string;
+    filePath: string;
+    isController: boolean;
+    isInjectable: boolean;
+    constructorParams: ConstructorParam[];
+}
+export interface InstantiationStep {
+    className: string;
+    varName: string;
+    importPath: string;
+    constructorArgs: string[];
+    isController: boolean;
+}
+export declare function parseClassFile(filePath: string): ClassInfo | null;
+export declare function scanModuleClasses(moduleDir: string): ClassInfo[];
+/**
+ * @param classes - All discovered @Injectable and @Controller classes
+ * @param providerVarByType - Default mapping from interface type to variable name (e.g., ISqlProvider -> dbMysql)
+ * @param classProviderVar - Per-class override for provider variable (className -> varName).
+ *   Used when different modules use different database providers.
+ * @param srcDir - Absolute path to src/ directory (for computing relative import paths)
+ */
+export declare function buildInstantiationOrder(classes: ClassInfo[], providerVarByType: Map<string, string>, classProviderVar: Map<string, string>, srcDir: string): InstantiationStep[];
+export declare function resolveProviderImport(importSpec: string, appTsDir: string): {
+    importPath: string;
+    className: string;
+};

package/dist/utils/diResolver.js

@@ -0,0 +1,204 @@
+"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.parseClassFile = parseClassFile;
+exports.scanModuleClasses = scanModuleClasses;
+exports.buildInstantiationOrder = buildInstantiationOrder;
+exports.resolveProviderImport = resolveProviderImport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const INJECTABLE_RE = /@Injectable\s*\(/;
+const CONTROLLER_RE = /@Controller\s*\(/;
+const EXPORT_CLASS_RE = /export\s+class\s+(\w+)/;
+const CONSTRUCTOR_PARAMS_RE = /constructor\s*\(([^)]*)\)/s;
+const PARAM_RE = /(?:private|protected|public)\s+(\w+)\s*:\s*([A-Za-z_]\w*)/g;
+function parseClassFile(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const classMatch = content.match(EXPORT_CLASS_RE);
+    if (!classMatch)
+        return null;
+    const isInjectable = INJECTABLE_RE.test(content);
+    const isController = CONTROLLER_RE.test(content);
+    if (!isInjectable && !isController)
+        return null;
+    const className = classMatch[1];
+    const constructorParams = [];
+    const ctorMatch = content.match(CONSTRUCTOR_PARAMS_RE);
+    if (ctorMatch) {
+        const paramsSrc = ctorMatch[1].replace(/\n/g, ' ');
+        let match;
+        const paramRe = new RegExp(PARAM_RE.source, PARAM_RE.flags);
+        while ((match = paramRe.exec(paramsSrc))) {
+            constructorParams.push({ name: match[1], type: match[2] });
+        }
+    }
+    return { className, filePath, isController, isInjectable, constructorParams };
+}
+function walkTsFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkTsFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.ts')) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+function scanModuleClasses(moduleDir) {
+    const tsFiles = walkTsFiles(moduleDir);
+    const classes = [];
+    for (const file of tsFiles) {
+        const info = parseClassFile(file);
+        if (info)
+            classes.push(info);
+    }
+    return classes;
+}
+/**
+ * @param classes - All discovered @Injectable and @Controller classes
+ * @param providerVarByType - Default mapping from interface type to variable name (e.g., ISqlProvider -> dbMysql)
+ * @param classProviderVar - Per-class override for provider variable (className -> varName).
+ *   Used when different modules use different database providers.
+ * @param srcDir - Absolute path to src/ directory (for computing relative import paths)
+ */
+function buildInstantiationOrder(classes, providerVarByType, classProviderVar, srcDir) {
+    const classMap = new Map();
+    for (const cls of classes) {
+        if (!classMap.has(cls.className)) {
+            classMap.set(cls.className, cls);
+        }
+    }
+    const graph = new Map();
+    for (const cls of classMap.values()) {
+        const deps = [];
+        for (const param of cls.constructorParams) {
+            if (classMap.has(param.type)) {
+                deps.push(param.type);
+            }
+        }
+        graph.set(cls.className, deps);
+    }
+    const sorted = topologicalSort(graph);
+    const steps = [];
+    const varNames = new Map();
+    for (const className of sorted) {
+        const cls = classMap.get(className);
+        const varName = className.charAt(0).toLowerCase() + className.slice(1);
+        varNames.set(className, varName);
+        const constructorArgs = [];
+        for (const param of cls.constructorParams) {
+            if (classProviderVar.has(className) && providerVarByType.has(param.type)) {
+                constructorArgs.push(classProviderVar.get(className));
+            }
+            else if (providerVarByType.has(param.type)) {
+                constructorArgs.push(providerVarByType.get(param.type));
+            }
+            else if (varNames.has(param.type)) {
+                constructorArgs.push(varNames.get(param.type));
+            }
+        }
+        const relPath = path.relative(srcDir, cls.filePath)
+            .replace(/\\/g, '/')
+            .replace(/\.ts$/, '');
+        const importPath = relPath.startsWith('.') ? relPath : `./${relPath}`;
+        steps.push({
+            className,
+            varName,
+            importPath,
+            constructorArgs,
+            isController: cls.isController
+        });
+    }
+    return steps;
+}
+function topologicalSort(graph) {
+    const visited = new Set();
+    const visiting = new Set();
+    const result = [];
+    function visit(node) {
+        if (visited.has(node))
+            return;
+        if (visiting.has(node)) {
+            throw new Error(`Circular dependency detected involving: ${node}`);
+        }
+        visiting.add(node);
+        const deps = graph.get(node) || [];
+        for (const dep of deps) {
+            if (graph.has(dep)) {
+                visit(dep);
+            }
+        }
+        visiting.delete(node);
+        visited.add(node);
+        result.push(node);
+    }
+    for (const node of graph.keys()) {
+        visit(node);
+    }
+    return result;
+}
+function resolveProviderImport(importSpec, appTsDir) {
+    const baseName = importSpec.split('/').pop() || 'provider';
+    const className = baseName
+        .replace(/^[^a-zA-Z_]*/g, '')
+        .split(/[-_]/)
+        .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('');
+    const isLocal = importSpec.startsWith('.') || importSpec.startsWith('/');
+    if (isLocal) {
+        const absPath = path.resolve(appTsDir, importSpec);
+        let relPath = path.relative(appTsDir, absPath).replace(/\\/g, '/');
+        if (!relPath.startsWith('.'))
+            relPath = `./${relPath}`;
+        return { importPath: relPath, className };
+    }
+    return { importPath: importSpec, className };
+}

package/dist/utils/typeUtils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared type mapping and string utilities used across generators.
+ */
+export interface TypeMapping {
+    [key: string]: string;
+}
+/** Standard YAML type to TypeScript (domain) type mapping. */
+export declare const TYPE_MAPPING: Record<string, string>;
+/** Store-specific: YAML type to DB row TypeScript type (e.g. datetime -> string). */
+export declare const ROW_TYPE_MAPPING: Record<string, string>;
+export declare function capitalize(str: string): string;
+/**
+ * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ */
+export declare function mapType(yamlType: string, aggregates?: Set<string> | Map<string, unknown>, valueObjects?: Set<string> | Map<string, unknown>): string;
+/**
+ * Check if a YAML field type references another aggregate entity.
+ */
+export declare function isAggregateReference(yamlType: string, aggregates?: Set<string> | Map<string, unknown>): boolean;
+/**
+ * Map a YAML type to the store row TypeScript type (value objects become string).
+ */
+export declare function mapRowType(yamlType: string, valueObjects?: Set<string> | Map<string, unknown>): string;

package/dist/utils/typeUtils.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Shared type mapping and string utilities used across generators.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROW_TYPE_MAPPING = exports.TYPE_MAPPING = void 0;
+exports.capitalize = capitalize;
+exports.mapType = mapType;
+exports.isAggregateReference = isAggregateReference;
+exports.mapRowType = mapRowType;
+/** Standard YAML type to TypeScript (domain) type mapping. */
+exports.TYPE_MAPPING = {
+    string: 'string',
+    number: 'number',
+    integer: 'number',
+    decimal: 'number',
+    boolean: 'boolean',
+    datetime: 'Date',
+    date: 'Date',
+    id: 'number',
+    json: 'any',
+    array: 'any[]',
+    object: 'object',
+    enum: 'string'
+};
+/** Store-specific: YAML type to DB row TypeScript type (e.g. datetime -> string). */
+exports.ROW_TYPE_MAPPING = {
+    string: 'string',
+    number: 'number',
+    integer: 'number',
+    decimal: 'number',
+    boolean: 'boolean',
+    datetime: 'string',
+    date: 'string',
+    id: 'number',
+    json: 'string',
+    array: 'string',
+    object: 'string',
+    enum: 'string'
+};
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ */
+function mapType(yamlType, aggregates, valueObjects) {
+    var _a;
+    if (aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType))
+        return yamlType;
+    const capitalizedType = capitalize(yamlType);
+    if (valueObjects) {
+        const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
+        if (has)
+            return capitalizedType;
+    }
+    return (_a = exports.TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'any';
+}
+/**
+ * Check if a YAML field type references another aggregate entity.
+ */
+function isAggregateReference(yamlType, aggregates) {
+    return !!(aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType));
+}
+/**
+ * Map a YAML type to the store row TypeScript type (value objects become string).
+ */
+function mapRowType(yamlType, valueObjects) {
+    var _a;
+    if (valueObjects) {
+        const capitalizedType = capitalize(yamlType);
+        const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
+        if (has)
+            return 'string';
+    }
+    return (_a = exports.ROW_TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'string';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@currentjs/gen",
-  "version": "0.3.2",
+  "version": "0.5.1",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",
@@ -29,8 +29,12 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && npm run copy-templates",
     "copy-templates": "mkdir -p dist/generators/templates/data && cp src/generators/templates/data/* dist/generators/templates/data/",
-    "clean": "rm -rf dist",
-    "prepack": "npm run build"
+    "clean": "rm -rf dist dist-test",
+    "prepack": "npm run build",
+    "test:build": "tsc -p tsconfig.test.json && mkdir -p dist-test/src/generators/templates/data && cp src/generators/templates/data/* dist-test/src/generators/templates/data/",
+    "test": "npm run test:build && node --test dist-test/tests/unit/*.test.js",
+    "test:integration": "npm run test:build && node --test dist-test/tests/integration/*.test.js",
+    "test:all": "npm run test:build && node --test dist-test/tests/unit/*.test.js dist-test/tests/integration/*.test.js"
   },
   "engines": {
     "node": ">=18"

package/dist/generators/domainModelGenerator.d.ts

@@ -1,41 +0,0 @@
-interface FieldConfig {
-    name: string;
-    type: string;
-    required?: boolean;
-    unique?: boolean;
-    auto?: boolean;
-    displayFields?: string[];
-}
-interface ModelConfig {
-    name: string;
-    fields: FieldConfig[];
-}
-type ModuleConfig = {
-    models: ModelConfig[];
-};
-type AppConfig = {
-    modules: Record<string, ModuleConfig>;
-} | ModuleConfig;
-export declare class DomainModelGenerator {
-    private typeMapping;
-    private availableModels;
-    private getDefaultValue;
-    private mapType;
-    private setAvailableModels;
-    private getRelatedModelImports;
-    private generateConstructorParameter;
-    private isRelationshipField;
-    private getForeignKeyFieldName;
-    private generateForeignKeyParameter;
-    private generateSetterMethods;
-    private sortFieldsByRequired;
-    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

@@ -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/templates/controllerTemplates.d.ts

@@ -1,43 +0,0 @@
-export declare const controllerTemplates: {
-    controllerClass: string;
-    controllerMethod: string;
-    userExtraction: string;
-    methodImplementations: {
-        list: string;
-        get: string;
-        create: string;
-        update: string;
-        delete: string;
-        empty: string;
-    };
-    responseFormats: {
-        list: string;
-        get: string;
-        create: string;
-        update: string;
-        delete: string;
-    };
-    statusCodes: {
-        list: {
-            success: number;
-            error: number;
-        };
-        get: {
-            success: number;
-            error: number;
-        };
-        create: {
-            success: number;
-            error: number;
-        };
-        update: {
-            success: number;
-            error: number;
-        };
-        delete: {
-            success: number;
-            error: number;
-        };
-    };
-};
-export declare const controllerFileTemplate = "import { {{ENTITY_NAME}} } from '../../domain/entities/{{ENTITY_NAME}}';\nimport { {{ENTITY_NAME}}Service } from '../../application/services/{{ENTITY_NAME}}Service';\nimport { {{ENTITY_NAME}}DTO } from '../../application/validation/{{ENTITY_NAME}}Validation';{{JWT_IMPORT}}\nimport { Get, Post, Put, Patch, Delete, Controller, Render } from '@currentjs/router';\nimport type { IContext } from '@currentjs/router';\n\n{{CONTROLLER_CLASS}}";