@currentjs/gen 0.2.2 → 0.3.0

package/dist/commands/generateAll.js

@@ -87,6 +87,7 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
     const storeGen = new storeGenerator_1.StoreGenerator();
     const tplGen = new templateGenerator_1.TemplateGenerator();
     const initsBySrcDir = new Map();
+    const moduleConfigByFolder = new Map(); // Cache module configs by folder name
     // Run modules sequentially to avoid overlapping interactive prompts
     for (const moduleYamlRel of filteredModules) {
         const moduleYamlPath = path.isAbsolute(moduleYamlRel)
@@ -98,6 +99,11 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
             continue;
         }
         const moduleDir = path.dirname(moduleYamlPath);
+        const moduleFolderName = path.basename(moduleDir);
+        // Parse and cache module config for dependency detection
+        const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
+        const moduleConfig = (0, yaml_1.parse)(moduleYamlContent);
+        moduleConfigByFolder.set(moduleFolderName, moduleConfig);
         // Output folders inside module structure
         const domainOut = path.join(moduleDir, 'domain', 'entities');
         const appOut = path.join(moduleDir, 'application');
@@ -131,6 +137,50 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
         if (!srcDir)
             continue;
         const list = (_b = initsBySrcDir.get(srcDir)) !== null && _b !== void 0 ? _b : [];
+        // First, add entries for all models in this module (even without controllers)
+        // This ensures dependency stores are initialized
+        if (moduleConfig && moduleConfig.models) {
+            const m = moduleYamlPath.match(/modules\/([^/]+)\//);
+            const moduleFolder = m ? m[1] : path.basename(moduleDir);
+            for (const model of moduleConfig.models) {
+                const entityName = model.name;
+                const entityVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+                // Check if we already have an entry for this entity
+                if (list.find(x => x.entityName === entityName)) {
+                    continue; // Skip if already added via controller
+                }
+                const storeImportPath = `${constants_1.PATH_PATTERNS.MODULES_RELATIVE}${moduleFolder}/${constants_1.PATH_PATTERNS.INFRASTRUCTURE}/${constants_1.PATH_PATTERNS.STORES}/${entityName}${constants_1.GENERATOR_SUFFIXES.STORE}`;
+                const serviceImportPath = `${constants_1.PATH_PATTERNS.MODULES_RELATIVE}${moduleFolder}/${constants_1.PATH_PATTERNS.APPLICATION}/${constants_1.PATH_PATTERNS.SERVICES}/${entityName}${constants_1.GENERATOR_SUFFIXES.SERVICE}`;
+                // Detect dependencies
+                const storeDeps = [];
+                const serviceDeps = [];
+                if (model.fields) {
+                    model.fields.forEach((field) => {
+                        const isRelationship = moduleConfig.models.some((m) => m.name === field.type);
+                        if (isRelationship) {
+                            storeDeps.push(field.type);
+                            serviceDeps.push(field.type);
+                        }
+                    });
+                }
+                // Add a minimal init entry (no controller, just for dependency resolution)
+                const init = {
+                    ctrlName: '', // No controller
+                    entityName,
+                    entityVar,
+                    importController: '',
+                    importStore: `import { ${entityName}Store } from '${storeImportPath}';`,
+                    importService: `import { ${entityName}Service } from '${serviceImportPath}';`,
+                    importAuth: undefined,
+                    wiring: [],
+                    registration: '',
+                    storeDependencies: storeDeps,
+                    serviceDependencies: serviceDeps
+                };
+                list.push(init);
+            }
+        }
+        // Then process controllers
         for (const filePath of generatedControllers) {
             const rel = path
                 .relative(srcDir, filePath)
@@ -151,25 +201,52 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
                 continue;
             const storeImportPath = `${constants_1.PATH_PATTERNS.MODULES_RELATIVE}${moduleFolder}/${constants_1.PATH_PATTERNS.INFRASTRUCTURE}/${constants_1.PATH_PATTERNS.STORES}/${entityName}${constants_1.GENERATOR_SUFFIXES.STORE}`;
             const serviceImportPath = `${constants_1.PATH_PATTERNS.MODULES_RELATIVE}${moduleFolder}/${constants_1.PATH_PATTERNS.APPLICATION}/${constants_1.PATH_PATTERNS.SERVICES}/${entityName}${constants_1.GENERATOR_SUFFIXES.SERVICE}`;
-            //const authImportPath = `./modules/${moduleFolder}/application/auth/AuthService`;
-            // const hasAuth = true;//fs.existsSync(path.join(srcDir, authImportPath + '.ts'));
-            const init = {
-                ctrlName,
-                entityName,
-                entityVar,
-                importController: `import { ${ctrlName} } from '${importPath}';`,
-                importStore: `import { ${entityName}Store } from '${storeImportPath}';`,
-                importService: `import { ${entityName}Service } from '${serviceImportPath}';`,
-                importAuth: undefined, //hasAuth ? `import { AuthService } from '${authImportPath}';` : undefined,
-                wiring: [
-                    `const ${entityVar}Store = new ${entityName}Store(db);`,
-                    `const ${entityVar}Service = new ${entityName}Service(${entityVar}Store);`
-                ],
-                registration: `new ${ctrlName}(${entityVar}Service)`
-            };
-            // Avoid duplicates by controller (keep both Api/Web), dedupe wiring later by entityName
-            if (!list.find((x) => x.ctrlName === init.ctrlName))
-                list.push(init);
+            // Look up the correct module config for this controller
+            const controllerModuleConfig = moduleConfigByFolder.get(moduleFolder);
+            // Detect store and service dependencies from module config
+            const storeDeps = [];
+            const serviceDeps = [];
+            if (controllerModuleConfig && controllerModuleConfig.models) {
+                const model = controllerModuleConfig.models.find((m) => m.name === entityName);
+                if (model && model.fields) {
+                    model.fields.forEach((field) => {
+                        // Check if this field is a relationship (type is another model name)
+                        const isRelationship = controllerModuleConfig.models.some((m) => m.name === field.type);
+                        if (isRelationship) {
+                            storeDeps.push(field.type);
+                            serviceDeps.push(field.type);
+                        }
+                    });
+                }
+            }
+            // Check if we already have a base entry for this entity (from all models)
+            const existingEntry = list.find(x => x.entityName === entityName && !x.ctrlName);
+            if (existingEntry) {
+                // Update existing entry to add controller info
+                existingEntry.ctrlName = ctrlName;
+                existingEntry.importController = `import { ${ctrlName} } from '${importPath}';`;
+                existingEntry.registration = `new ${ctrlName}(${entityVar}Service)`;
+                // Keep the dependencies we already detected
+            }
+            else {
+                // Create new entry with controller
+                const init = {
+                    ctrlName,
+                    entityName,
+                    entityVar,
+                    importController: `import { ${ctrlName} } from '${importPath}';`,
+                    importStore: `import { ${entityName}Store } from '${storeImportPath}';`,
+                    importService: `import { ${entityName}Service } from '${serviceImportPath}';`,
+                    importAuth: undefined,
+                    wiring: [],
+                    registration: `new ${ctrlName}(${entityVar}Service)`,
+                    storeDependencies: storeDeps,
+                    serviceDependencies: serviceDeps
+                };
+                if (!list.find((x) => x.ctrlName === init.ctrlName)) {
+                    list.push(init);
+                }
+            }
         }
         initsBySrcDir.set(srcDir, list);
         await storeGen.generateAndSaveFiles(moduleYamlPath, infraOut, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skip) });
@@ -232,12 +309,17 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
                 importLines.push(`import { ProviderMysql } from '@currentjs/provider-mysql';`);
             }
             for (const init of controllerInits) {
-                const maybe = [init.importController, init.importStore, init.importService];
+                const maybe = [init.importStore, init.importService];
+                // Only add controller import if entity has a controller
+                if (init.importController && init.importController.trim() !== '') {
+                    maybe.push(init.importController);
+                }
                 if (init.importAuth)
                     maybe.push(init.importAuth);
                 for (const line of maybe) {
-                    if (!appTs.includes(line) && !importLines.includes(line))
+                    if (line && line.trim() !== '' && !appTs.includes(line) && !importLines.includes(line)) {
                         importLines.push(line);
+                    }
                 }
             }
             if (importLines.length) {
@@ -249,20 +331,62 @@ async function handleGenerateAll(yamlPathArg, _outArg, moduleName, opts) {
                 if (toAdd.length)
                     appTs = toAdd.join('\n') + '\n' + appTs;
             }
-            // Compose fresh block content
+            // Compose fresh block content with dependency-aware ordering
             const wiringLines = [];
             // DB placeholder once
             wiringLines.push(ensureDbLine);
-            const wiredEntities = new Set();
-            for (const init of controllerInits) {
-                if (!wiredEntities.has(init.entityName)) {
-                    wiringLines.push(...init.wiring);
-                    wiredEntities.add(init.entityName);
+            // Deduplicate by entityName
+            const uniqueInits = Array.from(new Map(controllerInits.map(init => [init.entityName, init])).values());
+            // Sort entities by dependencies (entities with no deps first)
+            const sorted = [];
+            const processed = new Set();
+            const addEntity = (init) => {
+                if (processed.has(init.entityName))
+                    return;
+                // Process dependencies first
+                if (init.storeDependencies) {
+                    for (const depName of init.storeDependencies) {
+                        const depInit = uniqueInits.find(i => i.entityName === depName);
+                        if (depInit && !processed.has(depName)) {
+                            addEntity(depInit);
+                        }
+                    }
                 }
+                sorted.push(init);
+                processed.add(init.entityName);
+            };
+            uniqueInits.forEach(init => addEntity(init));
+            // Generate wiring for stores and services
+            for (const init of sorted) {
+                const entityVar = init.entityVar;
+                const entityName = init.entityName;
+                // Build store constructor parameters
+                const storeParams = ['db'];
+                if (init.storeDependencies && init.storeDependencies.length > 0) {
+                    init.storeDependencies.forEach(depName => {
+                        const depVar = depName.charAt(0).toLowerCase() + depName.slice(1);
+                        storeParams.push(`${depVar}Store`);
+                    });
+                }
+                // Build service constructor parameters
+                const serviceParams = [`${entityVar}Store`];
+                if (init.serviceDependencies && init.serviceDependencies.length > 0) {
+                    init.serviceDependencies.forEach(depName => {
+                        const depVar = depName.charAt(0).toLowerCase() + depName.slice(1);
+                        serviceParams.push(`${depVar}Store`);
+                    });
+                }
+                wiringLines.push(`const ${entityVar}Store = new ${entityName}Store(${storeParams.join(', ')});`);
+                wiringLines.push(`const ${entityVar}Service = new ${entityName}Service(${serviceParams.join(', ')});`);
             }
-            const registrations = controllerInits.map((i) => i.registration);
+            // Only include registrations for entities with controllers
+            const registrations = controllerInits
+                .filter(i => i.registration && i.registration.trim() !== '')
+                .map(i => i.registration);
             wiringLines.push('const controllers = [');
-            wiringLines.push(`  ${registrations.join(',\n  ')}`);
+            if (registrations.length > 0) {
+                wiringLines.push(`  ${registrations.join(',\n  ')}`);
+            }
             wiringLines.push('];');
             const startMarker = constants_1.GENERATOR_MARKERS.CONTROLLERS_START;
             const endMarker = constants_1.GENERATOR_MARKERS.CONTROLLERS_END;

package/dist/commands/migrateCommit.d.ts

@@ -0,0 +1 @@
+export declare function handleMigrateCommit(yamlPath?: string): void;

package/dist/commands/migrateCommit.js

@@ -0,0 +1,201 @@
+"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.handleMigrateCommit = handleMigrateCommit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+const colors_1 = require("../utils/colors");
+const cliUtils_1 = require("../utils/cliUtils");
+const migrationUtils_1 = require("../utils/migrationUtils");
+function collectModelsFromYaml(yamlPath) {
+    const yamlContent = fs.readFileSync(yamlPath, 'utf8');
+    const config = (0, yaml_1.parse)(yamlContent);
+    const projectRoot = path.dirname(yamlPath);
+    const allModels = [];
+    const sources = [];
+    // Check if it's a module YAML (has models directly)
+    if (config.models) {
+        allModels.push(...config.models);
+        sources.push(`app.yaml (${config.models.length} model(s))`);
+    }
+    // Check if it's an app YAML (has modules as array of paths)
+    if (config.modules && Array.isArray(config.modules)) {
+        let moduleCount = 0;
+        config.modules.forEach(moduleRef => {
+            // Handle both string and object format
+            const modulePath = typeof moduleRef === 'string' ? moduleRef : moduleRef.module;
+            const moduleYamlPath = path.isAbsolute(modulePath)
+                ? modulePath
+                : path.resolve(projectRoot, modulePath);
+            if (fs.existsSync(moduleYamlPath)) {
+                const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
+                const moduleConfig = (0, yaml_1.parse)(moduleYamlContent);
+                if (moduleConfig.models) {
+                    allModels.push(...moduleConfig.models);
+                    moduleCount++;
+                }
+            }
+        });
+        if (moduleCount > 0) {
+            sources.push(`app.yaml modules section (${moduleCount} module(s))`);
+        }
+    }
+    // Check if modules is an object (legacy format with models embedded)
+    else if (config.modules && typeof config.modules === 'object' && !Array.isArray(config.modules)) {
+        let moduleCount = 0;
+        Object.values(config.modules).forEach(moduleConfig => {
+            if (moduleConfig.models) {
+                allModels.push(...moduleConfig.models);
+                moduleCount++;
+            }
+        });
+        if (moduleCount > 0) {
+            sources.push(`app.yaml modules section (${moduleCount} module(s))`);
+        }
+    }
+    // Also check for module YAMLs in src/modules/*/module.yaml (as fallback)
+    const modulesDir = path.join(projectRoot, 'src', 'modules');
+    if (fs.existsSync(modulesDir)) {
+        const moduleFolders = fs.readdirSync(modulesDir).filter(f => {
+            const stat = fs.statSync(path.join(modulesDir, f));
+            return stat.isDirectory();
+        });
+        let moduleYamlCount = 0;
+        for (const moduleFolder of moduleFolders) {
+            const moduleYamlPath = path.join(modulesDir, moduleFolder, 'module.yaml');
+            if (fs.existsSync(moduleYamlPath)) {
+                const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
+                const moduleConfig = (0, yaml_1.parse)(moduleYamlContent);
+                if (moduleConfig.models) {
+                    allModels.push(...moduleConfig.models);
+                    moduleYamlCount++;
+                }
+            }
+        }
+        if (moduleYamlCount > 0) {
+            sources.push(`src/modules/*/module.yaml (${moduleYamlCount} module(s))`);
+        }
+    }
+    // Log sources
+    if (sources.length > 0) {
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.gray(`   Sources: ${sources.join(', ')}`));
+    }
+    return allModels;
+}
+function handleMigrateCommit(yamlPath) {
+    try {
+        const resolvedYamlPath = (0, cliUtils_1.resolveYamlPath)(yamlPath);
+        const projectRoot = path.dirname(resolvedYamlPath);
+        const migrationsDir = path.join(projectRoot, 'migrations');
+        const stateFilePath = path.join(migrationsDir, 'schema_state.yaml');
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.cyan('\n🔄 Running migration commit at application level...'));
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.gray(`   Project root: ${projectRoot}`));
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.gray(`   Migrations dir: ${migrationsDir}`));
+        // Ensure migrations directory exists
+        if (!fs.existsSync(migrationsDir)) {
+            fs.mkdirSync(migrationsDir, { recursive: true });
+            // eslint-disable-next-line no-console
+            console.log(colors_1.colors.green(`   ✓ Created migrations directory`));
+        }
+        // Collect all models from YAML files
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.cyan('\n📋 Collecting models from all modules...'));
+        const currentModels = collectModelsFromYaml(resolvedYamlPath);
+        if (currentModels.length === 0) {
+            // eslint-disable-next-line no-console
+            console.log(colors_1.colors.yellow('⚠️  No models found in YAML configuration.'));
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.green(`✓ Found ${currentModels.length} model(s): ${currentModels.map(m => m.name).join(', ')}`));
+        // Load previous state
+        const oldState = (0, migrationUtils_1.loadSchemaState)(stateFilePath);
+        if (oldState) {
+            // eslint-disable-next-line no-console
+            console.log(colors_1.colors.cyan(`📖 Previous schema state loaded (version: ${oldState.version})`));
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(colors_1.colors.cyan('📖 No previous schema state found - will generate initial migration'));
+        }
+        // Compare schemas and generate SQL
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.cyan('\n🔍 Comparing schemas...'));
+        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentModels);
+        if (sqlStatements.length === 0 || sqlStatements.every(s => s.trim() === '' || s.startsWith('--'))) {
+            // eslint-disable-next-line no-console
+            console.log(colors_1.colors.yellow('⚠️  No changes detected. Schema is up to date.'));
+            return;
+        }
+        // Generate migration file
+        const timestamp = (0, migrationUtils_1.generateTimestamp)();
+        const migrationFileName = (0, migrationUtils_1.getMigrationFileName)(timestamp);
+        const migrationFilePath = path.join(migrationsDir, migrationFileName);
+        const migrationHeader = `-- Migration: ${oldState ? 'Schema update' : 'Initial schema'}
+-- Created: ${new Date().toISOString().split('T')[0]}
+-- Timestamp: ${timestamp}
+
+`;
+        const migrationContent = migrationHeader + sqlStatements.join('\n');
+        fs.writeFileSync(migrationFilePath, migrationContent);
+        // Update state file
+        const newState = {
+            models: currentModels,
+            version: timestamp,
+            timestamp: new Date().toISOString()
+        };
+        (0, migrationUtils_1.saveSchemaState)(stateFilePath, newState);
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.green('\n✅ Migration created successfully!'));
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.gray(`   File: ${migrationFileName}`));
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.gray(`   Path: ${migrationFilePath}`));
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.gray(`   Location: Application-level migrations directory`));
+        // eslint-disable-next-line no-console
+        console.log(colors_1.colors.cyan('\n💡 Next step: Run "currentjs migrate push" to apply this migration to the database (not implemented yet).'));
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(colors_1.colors.red('❌ Error creating migration:'), error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}

package/dist/generators/controllerGenerator.d.ts

@@ -13,6 +13,13 @@ export declare class ControllerGenerator {
     private getWebMethodName;
     private getPathSuffix;
     private getReturnType;
+    /**
+     * Generate controller for a single config (api or routes)
+     */
+    private generateControllerForModelWithConfig;
+    /**
+     * Generate controller for a model (handles both single config and array) - Option D
+     */
     private generateControllerForModel;
     private generateController;
     generateFromYamlFile(yamlFilePath: string): Record<string, string>;

package/dist/generators/controllerGenerator.js

@@ -254,17 +254,18 @@ class ControllerGenerator {
                 return 'any';
         }
     }
-    generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, kind) {
+    /**
+     * Generate controller for a single config (api or routes)
+     */
+    generateControllerForModelWithConfig(model, moduleName, moduleConfig, cfg, 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
+        // Also check if any endpoints specifically target this model (Option A)
         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;
@@ -273,33 +274,10 @@ class ControllerGenerator {
         if (!shouldGenerateForThisModel) {
             return '';
         }
-        if (!isApi) {
-            // Ensure sensible defaults for Web routes: list, detail, create (empty), edit (get)
-            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 controllerBase = (cfg.prefix || `/${isApi ? 'api/' : ''}${entityLower}`).replace(/\/$/, '');
         const actionPermissions = this.getActionPermissions(moduleName, moduleConfig);
         const hasPermissions = hasGlobalPermissions && !!(moduleConfig.permissions && moduleConfig.permissions.length > 0);
-        // Filter endpoints that apply to this model
+        // Filter endpoints that apply to this model (Option A)
         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;
@@ -314,12 +292,65 @@ class ControllerGenerator {
             return this.generateControllerMethod(endpoint, entityName, roles, hasPermissions, kind, moduleConfig.actions);
         })
             .join('\n\n');
+        return controllerMethods;
+    }
+    /**
+     * Generate controller for a model (handles both single config and array) - Option D
+     */
+    generateControllerForModel(model, moduleName, moduleConfig, hasGlobalPermissions, kind) {
+        const isApi = kind === 'api';
+        const cfgRaw = isApi ? moduleConfig.api : moduleConfig.routes;
+        const entityName = model.name;
+        const entityLower = entityName.toLowerCase();
+        // Support both single config and array (Option D)
+        let configs = [];
+        if (!cfgRaw) {
+            // No config - generate defaults for web routes only
+            if (!isApi) {
+                configs = [{
+                        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 {
+                return '';
+            }
+        }
+        else if (Array.isArray(cfgRaw)) {
+            configs = cfgRaw;
+        }
+        else {
+            configs = [cfgRaw];
+        }
+        // For web routes, force GET method
+        if (!isApi) {
+            configs = configs.map(cfg => ({
+                ...cfg,
+                endpoints: (cfg.endpoints || []).map(e => ({ ...e, method: 'GET' }))
+            }));
+        }
+        // Generate methods from all configs
+        const allMethods = configs
+            .map(cfg => this.generateControllerForModelWithConfig(model, moduleName, moduleConfig, cfg, hasGlobalPermissions, kind))
+            .filter(methods => methods.trim() !== '')
+            .join('\n\n');
+        if (!allMethods.trim()) {
+            return '';
+        }
+        // Use the first config for controller base path (or default)
+        const firstConfig = configs[0];
+        const controllerBase = ((firstConfig === null || firstConfig === void 0 ? void 0 : firstConfig.prefix) || `/${isApi ? 'api/' : ''}${entityLower}`).replace(/\/$/, '');
         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
+            CONTROLLER_METHODS: allMethods
         });
         return this.replaceTemplateVars(controllerTemplates_1.controllerFileTemplate, {
             ENTITY_NAME: entityName,

package/dist/generators/domainModelGenerator.d.ts

@@ -4,6 +4,7 @@ interface FieldConfig {
     required?: boolean;
     unique?: boolean;
     auto?: boolean;
+    displayFields?: string[];
 }
 interface ModelConfig {
     name: string;
@@ -17,9 +18,15 @@ type AppConfig = {
 } | 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;