@team-codeme/crud-forge 0.0.0-stage → 1.0.0

package/src/generator/index.js

@@ -0,0 +1,874 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ejs = require('ejs');
+const _ = require('lodash');
+
+const { entityFolder: outputEntityFolder, serviceFolder, relativeEntityPath } = require('./entity-layout');
+const { isKeycloakAuthEnabled } = require('./auth-pack');
+
+const helpers = {
+  patternExpression: require('../validator/pattern').patternExpression,
+  toKebabCase: (str) => _.kebabCase(str),
+  toCamelCase: (str) => _.camelCase(str),
+  toPascalCase: (str) => _.upperFirst(_.camelCase(str)),
+};
+
+/**
+ * Executes code generation for all entities and enums.
+ * @param {object} parsedData - Entities, enums, and relationships.
+ * @param {object} config - Configuration preferences.
+ */
+async function generate(parsedData, config) {
+  require('../config/field-preferences').validateFieldPreferences(config, parsedData.entities, config._configPath || 'fields configuration');
+  if (config.auth) {
+    const { stripSecretsForGenerate, deriveAuthUrls } = require('../config/auth-config');
+    deriveAuthUrls(config.auth);
+    config.auth = stripSecretsForGenerate(config.auth);
+  }
+
+  const { entities, enums, relationships } = parsedData;
+  if (config.testing?.ci && !config.generate?.globals?.tests) throw new Error('testing.ci requires generate.globals.tests: true.');
+  if (config.generate?.globals?.tests) {
+    if (!config.fuse?.enabled) throw new Error('generate.globals.tests requires fuse.enabled.');
+    if (config.generate.components.list === false || config.generate.forms.form === false || config.generate.routes === false) throw new Error('Generated smoke tests require list components, forms and routes.');
+    for (const entity of entities) for (const field of entity.fields) require('./application-tests').fixtureValue(field, enums, config.testing?.fixtures?.[entity.name]?.[field.fieldName]);
+  }
+  const outputDir = config.output.directory;
+
+  const isGdl = config.fileType === 'gdl' || (config.input?.file && String(config.input.file).endsWith('.gdl'));
+  const defaultFolderName = config.fuse?.folderType || (isGdl ? 'micro-functions' : 'microservice');
+  // Prefer first multi-source folder when present; single-file mode keeps micro-functions / microservice.
+  const folderName =
+    (Array.isArray(config._inputSources) && config._inputSources[0]?.folder) || defaultFolderName;
+
+  // Validate and copy Fuse starter pack if enabled
+  if (config.fuse && config.fuse.enabled) {
+    const starterPackPath = config.fuse.starterPackPath || '/Users/abdulla/Documents/HC/crudforge-cli/fuse-starter-pack/fuse-v21.1';
+    if (!fs.existsSync(starterPackPath)) {
+      throw new Error(`Fuse Starter Pack Error: Source path "${starterPackPath}" does not exist.`);
+    }
+    const routesFilePath = path.join(starterPackPath, config.fuse.routesFile || 'src/app/domains/admin/routes.ts');
+    const navFilePath = path.join(starterPackPath, config.fuse.navigationFile || 'src/app/domains/admin/layout/data/navigation.ts');
+    if (!fs.existsSync(routesFilePath)) {
+      throw new Error(`Fuse Starter Pack Error: Required routes file "${routesFilePath}" does not exist.`);
+    }
+    if (!fs.existsSync(navFilePath)) {
+      throw new Error(`Fuse Starter Pack Error: Required navigation file "${navFilePath}" does not exist.`);
+    }
+
+    if (!config.dryRun) {
+      console.log(`  -> Scaffolding Fuse Angular project from: ${starterPackPath}`);
+      const filterFn = (src, dest) => {
+        const basename = path.basename(src);
+        if (['node_modules', '.git', '.angular', '.DS_Store'].includes(basename)) return false;
+        const relativeFile = path.relative(starterPackPath, src).replace(/\\/g, '/');
+        if ((config.fuse.rendering || 'spa') === 'spa' && ['src/main.server.ts', 'src/server.ts', 'src/app/app.config.server.ts', 'src/app/app.routes.server.ts'].includes(relativeFile)) return false;
+        
+        if (config.fuse?.includePrebuilt === false) {
+          const relativeSrc = path.relative(starterPackPath, src).replace(/\\/g, '/');
+          const prebuiltPaths = [
+            'src/app/domains/admin/modules/apps',
+            'src/app/domains/admin/modules/dashboards',
+            'src/app/domains/admin/modules/documentation'
+          ];
+          if (prebuiltPaths.some(p => relativeSrc === p || relativeSrc.startsWith(p + '/'))) {
+            return false;
+          }
+        }
+        return true;
+      };
+      fs.copySync(starterPackPath, outputDir, { filter: filterFn });
+      cleanupStaleKeycloakArtifacts(outputDir, config);
+    }
+  }
+
+  if (!config.dryRun) {
+    fs.ensureDirSync(outputDir);
+  }
+  let fileCount = 0;
+
+  const dryRunReport = {
+    newFiles: [],
+    modifiedFiles: []
+  };
+
+  const conflicts = [];
+  const { stampGeneratedBanner } = require('./generated-banner');
+
+  const writeOrPreview = (filePath, rawContent) => {
+    const content = stampGeneratedBanner(filePath, rawContent);
+    const relativePath = path.relative(outputDir, filePath);
+    const exists = fs.existsSync(filePath);
+
+    if (config.dryRun) {
+      if (exists) {
+        const existingContent = fs.readFileSync(filePath, 'utf8');
+        if (existingContent !== content) {
+          dryRunReport.modifiedFiles.push({
+            path: relativePath,
+            content: content,
+            oldContent: existingContent
+          });
+        }
+      } else {
+        dryRunReport.newFiles.push({
+          path: relativePath,
+          content: content
+        });
+      }
+      return;
+    }
+
+    // Standard run with Overwrite Policy
+    const policy = config.output?.overwritePolicy || 'overwrite';
+
+    if (exists) {
+      const existingContent = fs.readFileSync(filePath, 'utf8');
+      if (existingContent === content) {
+        return; // Identical, no changes
+      }
+
+      if (policy === 'skip') {
+        console.log(`  ⚠️  Skipped (protected): ${relativePath}`);
+        return;
+      }
+
+      if (policy === 'fail') {
+        throw new Error(`Conflict Error: File "${relativePath}" already exists and differs. Aborting generation.`);
+      }
+
+      if (policy === 'merge') {
+        const { mergeContent } = require('../utils/merger');
+        const merged = mergeContent(existingContent, content);
+        if (merged !== existingContent) {
+          fs.ensureDirSync(path.dirname(filePath));
+          fs.writeFileSync(filePath, merged);
+          console.log(`  ✨ Merged custom changes: ${relativePath}`);
+          fileCount++;
+        }
+        return;
+      }
+
+      if (policy === 'ask') {
+        conflicts.push({
+          filePath,
+          relativePath,
+          content,
+          oldContent: existingContent
+        });
+        return;
+      }
+
+      // Default: 'overwrite'
+      fs.ensureDirSync(path.dirname(filePath));
+      fs.writeFileSync(filePath, content);
+      fileCount++;
+    } else {
+      fs.ensureDirSync(path.dirname(filePath));
+      fs.writeFileSync(filePath, content);
+      fileCount++;
+    }
+  };
+
+  const templatesDir = path.join(__dirname, '..', 'templates', 'angular');
+
+  // Helper to map type mappings in JS for template pre-parsing (fallback)
+  const getTsType = (jdlType) => {
+    const typeMappings = {
+      String: 'string',
+      Integer: 'number',
+      Long: 'number',
+      BigDecimal: 'number',
+      Float: 'number',
+      Double: 'number',
+      Boolean: 'boolean',
+      LocalDate: 'dayjs.Dayjs',
+      Instant: 'dayjs.Dayjs',
+      ZonedDateTime: 'dayjs.Dayjs',
+      TextBlob: 'string',
+      UUID: 'string',
+    };
+    return typeMappings[jdlType] || jdlType;
+  };
+
+  // Keep the module skeleton even when enums are absent or generation is disabled.
+  // A placeholder survives staged publishing and Git, which omit empty folders.
+  if (config.fuse?.enabled) {
+    const modules = new Set([
+      ...entities.map(entity => serviceFolder(entity, config)),
+      ...(config._inputSources || []).map(source => serviceFolder({
+        folderName: source.folder, sourceName: source.name, microservice: source.microservice,
+      }, config)),
+    ]);
+    for (const module of modules) {
+      writeOrPreview(path.join(outputDir, 'src/app/domains/admin/modules/apps', module, 'enum/.gitkeep'), '');
+    }
+  }
+
+  // 1. Generate Enums if enabled
+  if (config.generate.enums && enums.length > 0) {
+    const enumTemplatePath = path.join(templatesDir, 'enums', '_enum_.model.ts.ejs');
+
+    for (const enumDef of enums) {
+      const enumConfig = { 
+        ...helpers, 
+        enumDef, 
+        preferences: config 
+      };
+      console.log(`  -> Generating Enum: ${enumDef.name}`);
+      const fileContent = await ejs.renderFile(enumTemplatePath, { ...enumConfig, cache: true });
+      const outputFileName = `${helpers.toKebabCase(enumDef.name)}.model.ts`;
+      // CLI schemas carry enum ownership. Programmatic inputs without ownership
+      // place each enum in the modules that use it (unused enums in every module).
+      const users = entities.filter(entity => entity.fields.some(field => field.fieldType === enumDef.name));
+      const owners = enumDef.sourceName || enumDef.folderName || enumDef.microservice
+        ? [enumDef] : users.length ? users : entities;
+      const directories = config.fuse?.enabled
+        ? [...new Set(owners.map(owner => path.join(outputDir,
+          'src/app/domains/admin/modules/apps', serviceFolder(owner, config), 'enum')))]
+        : [path.join(outputDir, 'enums')];
+      for (const directory of directories) {
+        if (!config.dryRun) fs.ensureDirSync(directory);
+        writeOrPreview(path.join(directory, outputFileName), fileContent);
+      }
+    }
+  }
+
+  // 2. Hoist shared UI once for both supported output layouts.
+  const fuseShared = !!config.fuse?.enabled;
+  config.architecture = { ...(config.architecture || {}), centralizedSharedFolder: true };
+  if (config.generate.globals?.sharedAssets !== false) {
+    console.log(`  -> Generating Centralized Shared Folder...`);
+    const sharedBase = fuseShared
+      ? path.join(outputDir, 'src/app/domains/admin/modules/apps/shared')
+      : path.join(outputDir, 'shared');
+    const sharedDirectivesDir = path.join(sharedBase, 'directives');
+    const sharedComponentsDir = path.join(sharedBase, 'components');
+    const sharedStylesDir = path.join(sharedBase, 'styles');
+    const sharedBaseDir = path.join(sharedBase, 'base');
+
+    if (!config.dryRun) {
+      fs.ensureDirSync(sharedDirectivesDir);
+      fs.ensureDirSync(sharedComponentsDir);
+      fs.ensureDirSync(sharedStylesDir);
+      fs.ensureDirSync(sharedBaseDir);
+    }
+
+    const sharedLocals = { preferences: config, cache: true };
+    for (const name of ['input-format', 'input-format.directive']) {
+      writeOrPreview(path.join(sharedBaseDir, `${name}.ts`), await ejs.renderFile(path.join(templatesDir, `shared/base/${name}.ts.ejs`), sharedLocals));
+    }
+    const auditNamesContent = await ejs.renderFile(path.join(templatesDir, 'shared/base/audit-user-name.pipe.ts.ejs'), sharedLocals);
+    writeOrPreview(path.join(sharedBaseDir, 'audit-user-name.pipe.ts'), auditNamesContent);
+    const resizableTpl = path.join(templatesDir, 'shared', 'resizable.directive.ts.ejs');
+    const confirmTpl = path.join(templatesDir, 'shared', 'confirmation-dialog.component.ts.ejs');
+    const typedConfirmTpl = path.join(templatesDir, 'shared', 'confirm-with-input-dialog.component.ts.ejs');
+    const overlayTpl = path.join(templatesDir, 'shared', 'loading-overlay.component.ts.ejs');
+    const snackbarTpl = path.join(templatesDir, 'shared', 'snackbar-styles.css.ejs');
+    const baseListTpl = path.join(templatesDir, 'shared', 'base', 'base-list.component.ts.ejs');
+    const baseFilterTpl = path.join(templatesDir, 'shared', 'base', 'base-filter.component.ts.ejs');
+    const baseFormTpl = path.join(templatesDir, 'shared', 'base', 'base-form.component.ts.ejs');
+    const filterTypesTpl = path.join(templatesDir, 'shared', 'base', 'filter-types.ts.ejs');
+
+    const resizableContent = await ejs.renderFile(resizableTpl, sharedLocals);
+    const confirmContent = await ejs.renderFile(confirmTpl, sharedLocals);
+    const typedConfirmContent = await ejs.renderFile(typedConfirmTpl, sharedLocals);
+    const overlayContent = await ejs.renderFile(overlayTpl, sharedLocals);
+    const snackbarContent = await ejs.renderFile(snackbarTpl, sharedLocals);
+    const baseListContent = await ejs.renderFile(baseListTpl, sharedLocals);
+    const baseFilterContent = await ejs.renderFile(baseFilterTpl, sharedLocals);
+    const baseFormContent = await ejs.renderFile(baseFormTpl, sharedLocals);
+    const filterTypesContent = await ejs.renderFile(filterTypesTpl, sharedLocals);
+
+    writeOrPreview(path.join(sharedDirectivesDir, 'resizable.directive.ts'), resizableContent);
+    writeOrPreview(path.join(sharedComponentsDir, 'confirmation-dialog.component.ts'), confirmContent);
+    writeOrPreview(path.join(sharedComponentsDir, 'confirm-with-input-dialog.component.ts'), typedConfirmContent);
+    writeOrPreview(path.join(sharedComponentsDir, 'loading-overlay.component.ts'), overlayContent);
+    writeOrPreview(path.join(sharedStylesDir, 'snackbar-styles.css'), snackbarContent);
+    writeOrPreview(path.join(sharedStylesDir, 'list-styles.css'), await ejs.renderFile(path.join(templatesDir, 'shared/list-styles.css.ejs'), sharedLocals));
+    if (fuseShared) {
+      const styleFile = path.join(outputDir, 'src/styles/styles.css');
+      let styles = fs.readFileSync(styleFile, 'utf8');
+      for (const name of ['snackbar-styles', 'list-styles']) {
+        const reference = `../app/domains/admin/modules/apps/shared/styles/${name}.css`;
+        if (!styles.includes(reference)) styles += `\n@import '${reference}';\n`;
+      }
+      writeOrPreview(styleFile, styles);
+    }
+    writeOrPreview(path.join(sharedBaseDir, 'base-list.component.ts'), baseListContent);
+    writeOrPreview(path.join(sharedBaseDir, 'base-filter.component.ts'), baseFilterContent);
+    writeOrPreview(path.join(sharedBaseDir, 'base-form.component.ts'), baseFormContent);
+    writeOrPreview(path.join(sharedBaseDir, 'filter-types.ts'), filterTypesContent);
+  }
+
+  // 3. Generate Entities
+  for (const entity of entities) {
+    console.log(`  -> Generating Entity Components: ${entity.name}`);
+
+    // Pre-calculate ts types
+    entity.fields.forEach(field => {
+      field.tsType = getTsType(field.fieldType);
+    });
+
+    const entityKebab = helpers.toKebabCase(entity.name);
+    const entityFolder = entity.folderName || folderName;
+    const fieldPreferences = require('../config/field-preferences');
+    const entityConfig = {
+      ...helpers,
+      entity,
+      entityImportPath: (name) => relativeEntityPath(entity, entities.find(e => e.name === name) || { name }, config),
+      config,
+      preferences: config,
+      fieldSettings: fieldPreferences.entityFieldSettings(config, entity),
+      technicalFieldNames: fieldPreferences.technicalFieldNames(config),
+      isTechnicalField: (fieldName) => fieldPreferences.isTechnicalField(fieldName, config),
+      isHiddenFromUi: (fieldName, surface) => fieldPreferences.isHiddenFromUi(fieldName, config, surface),
+      iamAcl: isKeycloakAuthEnabled(config),
+      // Match navigation.ts ids (`micro-functions/region` or `identity-access/region`).
+      folderName: entityFolder,
+      entityScreenId: config.fuse?.enabled ? `${entityFolder}/${entityKebab}` : entityKebab,
+      relationships: relationships
+        .filter(rel => rel.from.name === entity.name)
+        .map(rel => ({
+          ...rel,
+          otherEntityName: rel.to.name,
+          otherEntityNamePascalCase: helpers.toPascalCase(rel.to.name),
+          otherEntityNamePlural: `${rel.to.name.toLowerCase()}s`,
+        })),
+    };
+
+    const entityBaseDir = config.fuse?.enabled
+      ? path.join(outputDir, 'src/app/domains/admin/modules/apps', outputEntityFolder(entity, config), helpers.toKebabCase(entity.name))
+      : path.join(outputDir, 'entities', helpers.toKebabCase(entity.name));
+    if (!config.dryRun) {
+      fs.ensureDirSync(entityBaseDir);
+    }
+
+    // List of templates to map
+    const templates = [
+      { template: '_entity_.settings.ts.ejs',    subfolder: 'settings',        outputPattern: 'settings.config.ts', enabled: true },
+      { template: '_entity_.model.ts.ejs',       subfolder: '',        outputPattern: '<%= entityName %>.model.ts', enabled: config.generate.models },
+      { template: '_entity_.routes.ts.ejs',      subfolder: '',        outputPattern: '<%= entityName %>.routes.ts', enabled: config.generate.routes },
+      { template: '_entity_.service.ts.ejs',     subfolder: 'service', outputPattern: '<%= entityName %>.service.ts', enabled: config.generate.services },
+      { template: '_entity_-form.service.ts.ejs',subfolder: 'components/forms/update',  outputPattern: '<%= entityName %>-form.service.ts', enabled: config.generate.formServices },
+      
+      // Standalone components
+      { template: '_entity_-form-page.component.ts.ejs',   subfolder: 'components/forms/form-page', outputPattern: '<%= entityName %>-form-page.component.ts', enabled: config.generate.forms.formPage },
+      { template: '_entity_-form-page.component.html.ejs', subfolder: 'components/forms/form-page', outputPattern: '<%= entityName %>-form-page.component.html', enabled: config.generate.forms.formPage },
+      { template: '_entity_-detail.component.ts.ejs',     subfolder: 'components/presentation/detail',    outputPattern: '<%= entityName %>-detail.component.ts', enabled: config.generate.components.detail },
+      { template: '_entity_-detail.component.html.ejs',   subfolder: 'components/presentation/detail',    outputPattern: '<%= entityName %>-detail.component.html', enabled: config.generate.components.detail },
+      { template: '_entity_-detail.component.css.ejs',    subfolder: 'components/presentation/detail',    outputPattern: '<%= entityName %>-detail.component.css', enabled: config.generate.components.detail },
+      { template: '_entity_-card.component.ts.ejs',         subfolder: 'components/presentation/card',      outputPattern: '<%= entityName %>-card.component.ts', enabled: config.generate.components.card },
+      { template: '_entity_-card.component.html.ejs',       subfolder: 'components/presentation/card',      outputPattern: '<%= entityName %>-card.component.html', enabled: config.generate.components.card },
+      { template: '_entity_-card.component.css.ejs',        subfolder: 'components/presentation/card',      outputPattern: '<%= entityName %>-card.component.css', enabled: config.generate.components.card },
+      { template: '_entity_-filter.component.ts.ejs',     subfolder: 'components/interaction/filter',    outputPattern: '<%= entityName %>-filter.component.ts', enabled: config.generate.interaction.filter },
+      { template: '_entity_-filter.component.html.ejs',   subfolder: 'components/interaction/filter',    outputPattern: '<%= entityName %>-filter.component.html', enabled: config.generate.interaction.filter },
+      { template: '_entity_-actions.component.ts.ejs',   subfolder: 'components/interaction/actions',   outputPattern: '<%= entityName %>-actions.component.ts', enabled: config.generate.interaction.actions },
+      { template: '_entity_-actions.component.html.ejs', subfolder: 'components/interaction/actions',   outputPattern: '<%= entityName %>-actions.component.html', enabled: config.generate.interaction.actions },
+      { template: '_entity_-form.component.ts.ejs',         subfolder: 'components/forms/form',      outputPattern: '<%= entityName %>-form.component.ts', enabled: config.generate.forms.form },
+      { template: '_entity_-form.component.html.ejs',       subfolder: 'components/forms/form',      outputPattern: '<%= entityName %>-form.component.html', enabled: config.generate.forms.form },
+      { template: '_entity_-list.component.ts.ejs',         subfolder: 'components/presentation/list',      outputPattern: '<%= entityName %>-list.component.ts', enabled: config.generate.components.list },
+      { template: '_entity_-list.component.html.ejs',       subfolder: 'components/presentation/list',      outputPattern: '<%= entityName %>-list.component.html', enabled: config.generate.components.list },
+      { template: '_entity_-list.component.scss.ejs',       subfolder: 'components/presentation/list',      outputPattern: '<%= entityName %>-list.component.scss', enabled: config.generate.components.list }
+    ];
+
+    for (const t of templates) {
+      if (t.enabled === false) continue;
+
+      let templatePath;
+      if (t.subfolder.startsWith('shared')) {
+        const subDirs = t.subfolder.split('/').slice(1); // remove 'shared'
+        templatePath = path.join(templatesDir, 'shared', ...subDirs, t.template);
+      } else {
+        templatePath = path.join(templatesDir, 'entity', t.subfolder, t.template);
+      }
+      const fileContent = await ejs.renderFile(templatePath, { ...entityConfig, cache: true });
+      
+      const finalSubfolder = t.subfolder ? path.join(entityBaseDir, t.subfolder) : entityBaseDir;
+      const outputFileName = ejs.render(t.outputPattern, { entityName: helpers.toKebabCase(entity.name) });
+      writeOrPreview(path.join(finalSubfolder, outputFileName), fileContent);
+    }
+
+    if (config.mock && config.mock.enabled) {
+      console.log(`  -> Generating Mock Data: ${entity.name}`);
+      const mockRecords = [];
+      const recordsCount = config.mock.recordsPerEntity || 10;
+      for (let i = 0; i < recordsCount; i++) {
+        const record = { id: i + 1 };
+        entity.fields.forEach(field => {
+          const type = field.fieldType;
+          if (['String', 'TextBlob', 'UUID'].includes(type)) {
+            record[field.fieldName] = `${config.mock.values?.stringPrefix || 'Mock '}${field.fieldName} ${i + 1}`;
+          } else if (['Integer', 'Long', 'BigDecimal', 'Float', 'Double'].includes(type)) {
+            const min = config.mock.values?.numberMin || 1;
+            record[field.fieldName] = min + i;
+          } else if (type === 'Boolean') {
+            record[field.fieldName] = config.mock.values?.booleanDefault !== undefined ? config.mock.values.booleanDefault : true;
+          } else if (['LocalDate', 'Instant', 'ZonedDateTime'].includes(type)) {
+            record[field.fieldName] = new Date().toISOString();
+          } else {
+            record[field.fieldName] = `Mock ${field.fieldName} ${i + 1}`;
+          }
+        });
+        mockRecords.push(record);
+      }
+      const mockFilePath = path.join(entityBaseDir, 'mock', 'data.ts');
+      const content = `export const mockData = ${JSON.stringify(mockRecords, null, 2)};\n`;
+      writeOrPreview(mockFilePath, content);
+    }
+  }
+
+  // Update Fuse routes and navigation files if enabled
+  if (config.fuse && config.fuse.enabled) {
+    console.log(`  -> Registering Fuse routes and navigation menu entries...`);
+    const routesRelativePath = config.fuse.routesFile || 'src/app/domains/admin/routes.ts';
+    const navRelativePath = config.fuse.navigationFile || 'src/app/domains/admin/layout/data/navigation.ts';
+
+    const routesFilePath = path.join(outputDir, routesRelativePath);
+    const navFilePath = path.join(outputDir, navRelativePath);
+
+    const backupFuseFile = (filePath) => {
+      if (config.dryRun || !fs.existsSync(filePath)) {
+        return;
+      }
+      const backupPath = `${filePath}.bak`;
+      if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(filePath, backupPath);
+      }
+    };
+
+    backupFuseFile(routesFilePath);
+    backupFuseFile(navFilePath);
+
+    // 1. Update Routes File
+    if (config.generate.registrations?.routes !== false && fs.existsSync(routesFilePath)) {
+
+
+      let content = fs.readFileSync(routesFilePath, 'utf8');
+
+      if (config.fuse?.includePrebuilt === false && !config.fuse?.cleanLayout) {
+        // Strip the Dashboards, General, and Documentation sections from routes.ts
+        content = content.replace(/\s*\/\/\s*-+\n\s*\/\/\s*(Dashboards|General|Documentation)\n\s*\/\/\s*-+\n(?:[\s\S]*?(?=\s*\/\/\s*-+|\s*\/\/\s*404|\]))/g, '\n');
+      }
+
+      const routesBlock = entities.map(entity => {
+        const kebabName = helpers.toKebabCase(entity.name);
+        return `      {\n        path: '${kebabName}',\n        loadChildren: () => import('./modules/apps/${outputEntityFolder(entity, config)}/${kebabName}/${kebabName}.routes'),\n      },`;
+      }).join('\n');
+
+      if (config.fuse.cleanLayout) {
+        let content = fs.readFileSync(routesFilePath, 'utf8').replace(/\r\n/g, '\n');
+        const childrenMatch = /children:\s*\[/.exec(content);
+        if (childrenMatch) {
+        const cleanChildrenBlock = `children: [
+        { path: '', pathMatch: 'full', redirectTo: '/auth/sign-in' },
+        {
+          path: 'welcome',
+          loadComponent: () => import('./modules/extras/welcome/welcome.component')
+        },
+        // cforge-routes-start
+${routesBlock}
+        // cforge-routes-end
+        {
+          path: '404',
+          pathMatch: 'full',
+          loadComponent: () => import('./modules/extras/error/features/error-page'),
+          data: { errorCode: 404, title: 'Page not found' }
+        },
+        { 
+          path: '**', 
+          loadComponent: () => import('./modules/extras/error/features/error-page'),
+          data: { errorCode: 404, title: 'Page not found' }
+        },
+      ]`;
+          const routesArrayEnd = content.indexOf('    ],\n  },\n];');
+          if (routesArrayEnd !== -1) {
+            const newContent = content.slice(0, childrenMatch.index) + cleanChildrenBlock + content.slice(routesArrayEnd + 6);
+            writeOrPreview(routesFilePath, newContent);
+          }
+        }
+      } else {
+        // Ensure markers exist
+        if (!content.includes('// cforge-routes-start') || !content.includes('// cforge-routes-end')) {
+          const childrenMatch = /children:\s*\[/.exec(content);
+          if (childrenMatch) {
+            const insertIndex = childrenMatch.index + childrenMatch[0].length;
+            content = content.slice(0, insertIndex) + '\n      // cforge-routes-start\n      // cforge-routes-end' + content.slice(insertIndex);
+          }
+        }
+
+        const startIdx = content.indexOf('// cforge-routes-start');
+        const endIdx = content.indexOf('// cforge-routes-end');
+
+        if (startIdx !== -1 && endIdx !== -1) {
+          const startMarker = '// cforge-routes-start';
+          const endMarker = '// cforge-routes-end';
+          const newContent = content.slice(0, startIdx + startMarker.length) + '\n' + routesBlock + '\n      ' + content.slice(endIdx);
+          writeOrPreview(routesFilePath, newContent);
+        }
+      }
+    }
+
+    // 2. Update Navigation File
+    if (config.generate.registrations?.navigation !== false && fs.existsSync(navFilePath)) {
+
+
+      let content = fs.readFileSync(navFilePath, 'utf8');
+
+      if (config.fuse?.includePrebuilt === false && !config.fuse?.cleanLayout) {
+        content = content.replace(/\s*{\s*id:\s*'(dashboards|general|extras|documentation)'[\s\S]*?(?=\s*{\s*id:\s*'(dashboards|general|extras|documentation)'|\s*\];)/g, '');
+      }
+
+      const groups = new Map();
+      for (const entity of entities) {
+        const entityFolder = entity.folderName || folderName;
+        const groupKey = entityFolder;
+        if (!groups.has(groupKey)) {
+          groups.set(groupKey, {
+            folder: entityFolder,
+            label:
+              entity.sourceName ||
+              (entityFolder === 'micro-functions'
+                ? 'Micro Functions'
+                : entityFolder === 'microservice'
+                  ? 'Microservice'
+                  : helpers.toPascalCase(entityFolder)),
+            items: [],
+          });
+        }
+        const entityConfig = (config.entities && config.entities[entity.name]) || {};
+        groups.get(groupKey).items.push({
+          id: `${entityFolder}/${helpers.toKebabCase(entity.name)}`,
+          label: entityConfig.label || helpers.toPascalCase(entity.name) + 's',
+          icon: entityConfig.icon || 'database',
+          route: entityConfig.route || `/admin/${helpers.toKebabCase(entity.name)}`,
+          order: entityConfig.order !== undefined ? entityConfig.order : 100,
+          permissions: entityConfig.permissions || null,
+        });
+      }
+
+      const navigationBlock = Array.from(groups.values())
+        .map((group) => {
+          group.items.sort((a, b) => {
+            if (a.order !== b.order) return a.order - b.order;
+            return a.label.localeCompare(b.label);
+          });
+          const formattedItems = group.items
+            .map((item) => {
+              let str = `        {\n`;
+              str += `          id: '${item.id}',\n`;
+              str += `          label: '${item.label}',\n`;
+              str += `          icon: '${item.icon}',\n`;
+              str += `          route: '${item.route}'`;
+              if (item.permissions) {
+                str += `,\n          meta: { permissions: ${JSON.stringify(item.permissions)} }`;
+              }
+              str += `\n        }`;
+              return str;
+            })
+            .join(',\n');
+          return `    {\n      id: '${group.folder}-group',\n      label: '${group.label}',\n      description: 'Generated CRUD Modules',\n      icon: 'database',\n      children: [\n${formattedItems}\n      ]\n    },`;
+        })
+        .join('\n');
+
+      if (config.fuse.cleanLayout) {
+        const normalized = content.replace(/\r\n/g, '\n');
+        const startArrayIdx = normalized.indexOf('export const NAVIGATION: NavigationItem[] = [');
+        if (startArrayIdx !== -1) {
+          const arrayEndIdx = normalized.lastIndexOf('];');
+          if (arrayEndIdx !== -1) {
+            const newContent = content.slice(0, startArrayIdx) + 'export const NAVIGATION: NavigationItem[] = [\n' + navigationBlock + '\n];' + content.slice(arrayEndIdx + 2);
+            writeOrPreview(navFilePath, newContent);
+          }
+        }
+      } else {
+        // Ensure markers exist
+        if (!content.includes('// cforge-navigation-start') || !content.includes('// cforge-navigation-end')) {
+          const navArrayMatch = /export const NAVIGATION: NavigationItem\[\] = \[/.exec(content);
+          if (navArrayMatch) {
+            const insertIndex = navArrayMatch.index + navArrayMatch[0].length;
+            content = content.slice(0, insertIndex) + '\n    // cforge-navigation-start\n    // cforge-navigation-end' + content.slice(insertIndex);
+          }
+        }
+
+        const startIdx = content.indexOf('// cforge-navigation-start');
+        const endIdx = content.indexOf('// cforge-navigation-end');
+
+        if (startIdx !== -1 && endIdx !== -1) {
+          const startMarker = '// cforge-navigation-start';
+          const endMarker = '// cforge-navigation-end';
+          const newContent = content.slice(0, startIdx + startMarker.length) + '\n' + navigationBlock + '\n    ' + content.slice(endIdx);
+          writeOrPreview(navFilePath, newContent);
+        }
+      }
+    }
+
+    // 3. Update Sign-In HTML File Branding (idempotent; starter already ships clean CRUDForge copy)
+    const signInFilePath = path.join(outputDir, 'src/app/domains/auth/features/sign-in/sign-in.html');
+    if (fs.existsSync(signInFilePath)) {
+      let html = fs.readFileSync(signInFilePath, 'utf8');
+      html = html.replace('alt="Fuse logo"', 'alt="CRUDForge logo"');
+      html = html.replace('Welcome to our community', 'Welcome to CRUDForge');
+      html = html.replace(
+        /Fuse helps developers to build organized[\s\S]*?application today\./,
+        'CRUDForge helps you to generate organized and well-structured Angular applications featuring robust standalone forms, presentation lists, and service collections.'
+      );
+      html = html.replace("More than 17k people joined us, it's your turn", 'Create code, generate apps, run instantly');
+      writeOrPreview(signInFilePath, html);
+    }
+
+    // 4. Layout modifications
+    const layoutFilePath = path.join(outputDir, 'src/app/domains/admin/layout/layout.ts');
+    if (fs.existsSync(layoutFilePath)) {
+      let content = fs.readFileSync(layoutFilePath, 'utf8').replace(/\r\n/g, '\n');
+      
+      if (config.fuse.cleanLayout) {
+        // Remove Banner
+        content = content.replace(/<!-- Banner -->[\s\S]*?<\/div>\s*<!-- Toolbar -->/, '<!-- Toolbar -->');
+        // Remove Language Switcher
+        content = content.replace('<language-switcher />', '');
+        // Remove Language Switcher Imports
+        content = content.replace('import { LanguageSwitcher } from \'@/app/domains/admin/layout/ui/language-switcher\';\n', '');
+        content = content.replace('LanguageSwitcher,\n', '');
+      }
+
+      // Apply sidebar theme
+      if (config.fuse.sidebarTheme === 'dark') {
+        content = content.replace('bg-white', 'scheme-dark');
+      }
+
+      writeOrPreview(layoutFilePath, content);
+    }
+
+    applyFuseTheme(outputDir, config, writeOrPreview);
+
+    require('./fuse-build').applyFuseBuild({ outputDir, config, writeOrPreview });
+
+    const { applyAccessControlToolsPack } = require('./access-control-tools');
+    const aclTools = applyAccessControlToolsPack({ outputDir, config, writeOrPreview });
+    if (aclTools.applied && !config.dryRun) {
+      console.log(`  -> Access-control tools packed at ${aclTools.dest}`);
+    }
+
+    const { applyAuthPack } = require('./auth-pack');
+    await applyAuthPack({ outputDir, config, writeOrPreview, folderName, entities });
+
+    const { applyFuseRuntimePack } = require('./fuse-runtime');
+    const runtime = applyFuseRuntimePack({ outputDir, config, writeOrPreview });
+    if (runtime.applied && !config.dryRun) {
+      const bits = [];
+      if (runtime.services) bits.push(`${runtime.services} service proxy(ies)`);
+      if (runtime.proxyFiles?.length) bits.push(`proxy: ${runtime.proxyFiles.join(', ')}`);
+      if (bits.length) {
+        console.log(`  -> Fuse runtime env/proxy updated (${bits.join('; ')})`);
+      }
+    }
+
+    if (config.fuse.cleanLayout) {
+      const sidebarFilePath = path.join(outputDir, 'src/app/domains/admin/layout/ui/sidebar.ts');
+      if (fs.existsSync(sidebarFilePath)) {
+        let content = fs.readFileSync(sidebarFilePath, 'utf8').replace(/\r\n/g, '\n');
+        // Remove Trial Alert Card
+        content = content.replace(/<!-- Sidebar notification -->[\s\S]*?<\/div>\s*<!-- Footer -->/, '<!-- Footer -->');
+        
+        // Remove Unused MatButton and MatIcon imports left over from the Trial Alert Card
+        content = content.replace('import { MatButton } from \'@angular/material/button\';\n', '');
+        content = content.replace('import { MatIcon } from \'@angular/material/icon\';\n', '');
+        content = content.replace('imports: [Navigation, User, MatButton, MatIcon],', 'imports: [Navigation, User],');
+
+        // Branding: wordmark logo already ships in fuse-starter; keep alt text consistent.
+        content = content.replace('alt="Fuse logo"', 'alt="CRUDForge logo"');
+        content = content.replace(/\/images\/logo\/logo\.jpeg/g, '/images/logo/logo.png');
+        writeOrPreview(sidebarFilePath, content);
+      }
+    }
+  }
+
+  writeOrPreview(path.join(outputDir, 'generator/README.md'),
+    fs.readFileSync(path.join(__dirname, '../templates/generator/README.md'), 'utf8'));
+  writeOrPreview(path.join(outputDir, 'generator/issues/.gitkeep'), '');
+
+  await require('./application-tests').applyApplicationTests({outputDir, config, parsedData, writeOrPreview});
+
+  // Embed config + AI docs (GO-DUCK-style) + keep-team agents + optional git remote.
+  if (config.fuse?.enabled) {
+    const { embedConfigInOutput } = require('./embed-config');
+    const { applyAiDocsPack } = require('./ai-docs');
+    const { applyTeamPack, initGitRepository } = require('./team-pack');
+    const embedded = embedConfigInOutput(outputDir, config, writeOrPreview);
+    if (embedded.written && !config.dryRun) {
+      console.log('  -> Embedded config/crudforge.config.yml');
+    }
+    const aiDocs = applyAiDocsPack({
+      outputDir,
+      config,
+      parsedData: { entities, enums, relationships },
+      writeOrPreview,
+    });
+    if (aiDocs.applied && aiDocs.files?.length && !config.dryRun) {
+      console.log('  -> Seeded AGENT_README.md + docs/ai/* + .crudforge/ (GO-DUCK-style)');
+    }
+    const team = applyTeamPack(outputDir, config, writeOrPreview);
+    if (team.applied && team.files?.length && !config.dryRun) {
+      console.log('  -> Seeded keep-team folders (.cursor/agents, .codex/agents, .agents, .vscode/extensions)');
+    }
+    const gitResult = initGitRepository(outputDir, config);
+    if (gitResult.dryRun) {
+      console.log(`  -> [dry-run] Would git init / set origin ${gitResult.wouldUse}`);
+    } else if (gitResult.initialized && gitResult.createdRemote) {
+      console.log(`  -> git remote origin → ${gitResult.url}`);
+    } else if (gitResult.warning) {
+      console.log(`  -> ${gitResult.warning}`);
+    }
+    ensureGeneratedGitignore(outputDir, writeOrPreview);
+  }
+
+  return { 
+    fileCount, 
+    entityCount: entities.length,
+    dryRun: !!config.dryRun,
+    dryRunReport: config.dryRun ? dryRunReport : null,
+    conflicts
+  };
+}
+
+function cleanupStaleKeycloakArtifacts(outputDir, config) {
+  // copySync does not delete leftovers. A prior IAM generate can leave
+  // src/app/core/auth + user-management while a non-Keycloak prepare
+  // overwrites environment.ts — that combo breaks ng serve (TS2339).
+  if (config.auth?.provider === 'keycloak') {
+    return;
+  }
+
+  const staleDirs = [
+    path.join(outputDir, 'src/app/core/auth'),
+    path.join(outputDir, 'src/app/core/user-management'),
+  ];
+  // Legacy location before IAM moved to core/
+  const appsRoot = path.join(outputDir, 'src/app/domains/admin/modules/apps');
+  if (fs.existsSync(appsRoot)) {
+    for (const entry of fs.readdirSync(appsRoot)) {
+      staleDirs.push(path.join(appsRoot, entry, 'identity'));
+    }
+  }
+
+  for (const dir of staleDirs) {
+    if (fs.existsSync(dir)) {
+      fs.removeSync(dir);
+      console.log(`  -> Removed stale Keycloak leftover: ${path.relative(outputDir, dir)}`);
+    }
+  }
+
+  const routesFilePath = path.join(outputDir, config.fuse?.routesFile || 'src/app/domains/admin/routes.ts');
+  if (fs.existsSync(routesFilePath)) {
+    let routes = fs.readFileSync(routesFilePath, 'utf8');
+    const before = routes;
+    routes = routes.replace(/\n\s*\{\s*path:\s*'user-management'[\s\S]*?\},?\n/g, '\n');
+    routes = routes.replace(/import\s*\{\s*AuthGuard\s*\}\s*from\s*'[^']+auth\.guard';\s*\n?/g, '');
+    routes = routes.replace(/import\s*\{\s*LandingGuard\s*\}\s*from\s*'[^']+landing\.guard';\s*\n?/g, '');
+    routes = routes.replace(/\n\s*canActivate:\s*\[AuthGuard\],\s*\n\s*canActivateChild:\s*\[AuthGuard\],/g, '');
+    routes = routes.replace(/\n\s*canActivate:\s*\[LandingGuard\],/g, '');
+    routes = routes.replace(/\n\s*\{\s*path:\s*'no-access'[\s\S]*?\},?\n/g, '\n');
+    if (routes !== before) {
+      fs.writeFileSync(routesFilePath, routes);
+    }
+  }
+
+  const appConfigPath = path.join(outputDir, 'src/app/app.config.ts');
+  if (fs.existsSync(appConfigPath)) {
+    let cfg = fs.readFileSync(appConfigPath, 'utf8');
+    const before = cfg;
+    cfg = cfg.replace(
+      /import\s*\{\s*provideHttpClient,\s*withFetch,\s*withInterceptors\s*\}\s*from\s*'@angular\/common\/http';/,
+      "import { provideHttpClient, withFetch } from '@angular/common/http';"
+    );
+    cfg = cfg.replace(/import\s*\{\s*authInterceptor\s*\}\s*from\s*'[^']+';\s*\n?/g, '');
+    cfg = cfg.replace(
+      'provideHttpClient(withFetch(), withInterceptors([authInterceptor]))',
+      'provideHttpClient(withFetch())'
+    );
+    if (cfg !== before) {
+      fs.writeFileSync(appConfigPath, cfg);
+    }
+  }
+
+  const noAccess = path.join(
+    outputDir,
+    'src/app/domains/admin/modules/extras/no-access/no-access.component.ts'
+  );
+  if (fs.existsSync(noAccess)) {
+    fs.removeSync(path.dirname(noAccess));
+  }
+}
+
+function ensureGeneratedGitignore(outputDir, writeOrPreview) {
+  const target = path.join(outputDir, '.gitignore');
+  const required = [
+    'node_modules/',
+    'dist/',
+    '.angular/',
+    '.env',
+    '.env.qa',
+    '.crudforge/provision-state.json',
+    '*.log',
+    '.DS_Store',
+  ];
+  let existing = '';
+  if (fs.existsSync(target)) {
+    existing = fs.readFileSync(target, 'utf8');
+  }
+  const lines = existing ? existing.replace(/\s+$/, '').split(/\r?\n/) : [];
+  // Prefer fine-grained provision-state ignore over ignoring all of .crudforge/
+  const filtered = lines.filter((line) => line.trim() !== '.crudforge/');
+  let changed = !existing || filtered.length !== lines.length;
+  const next = filtered.length ? filtered : lines;
+  for (const entry of required) {
+    if (!next.includes(entry)) {
+      next.push(entry);
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeOrPreview(target, `${next.join('\n')}\n`);
+  }
+}
+
+function applyFuseTheme(outputDir, config, writeOrPreview) {
+  const theme = config.fuse?.theme || {};
+  const primary = theme.primary || '#0D1E3A';
+  const error = theme.error || '#dc2626';
+  const scheme = theme.scheme || 'system';
+
+  const appTsPath = path.join(outputDir, 'src/app/app.ts');
+  if (fs.existsSync(appTsPath)) {
+    let content = fs.readFileSync(appTsPath, 'utf8').replace(/\r\n/g, '\n');
+    if (content.includes('export const fuseTheme')) {
+      content = content.replace(/scheme:\s*'[^']*'/, `scheme: '${scheme}'`);
+      content = content.replace(/primary:\s*'[^']*'/, `primary: '${primary}'`);
+      content = content.replace(/error:\s*'[^']*'/, `error: '${error}'`);
+    } else {
+      const lastImport = content.lastIndexOf('import ');
+      const lastImportEnd = lastImport === -1 ? 0 : content.indexOf('\n', lastImport) + 1;
+      const themeBlock = `import { ThemeConfig } from '@/app/core/theming/models/theming';\n\n/** Root Fuse theme. Change these values to recolor buttons, links, and Material accents. */\nexport const fuseTheme: ThemeConfig = {\n  scheme: '${scheme}',\n  primary: '${primary}',\n  error: '${error}',\n};\n\n`;
+      content = content.slice(0, lastImportEnd) + themeBlock + content.slice(lastImportEnd);
+    }
+    writeOrPreview(appTsPath, content);
+  }
+
+  const appConfigPath = path.join(outputDir, 'src/app/app.config.ts');
+  if (fs.existsSync(appConfigPath)) {
+    let content = fs.readFileSync(appConfigPath, 'utf8').replace(/\r\n/g, '\n');
+    if (!content.includes("import { fuseTheme }")) {
+      content = content.replace(
+        /import \{ routes \} from '\.\/app\.routes';/,
+        "import { fuseTheme } from './app';\nimport { routes } from './app.routes';"
+      );
+    }
+    content = content.replace(/provideTheming\(\{[\s\S]*?\}\)/, 'provideTheming(fuseTheme)');
+    writeOrPreview(appConfigPath, content);
+  }
+}
+
+module.exports = {
+  generate
+};