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

package/src/commands/generate.js

@@ -0,0 +1,301 @@
+const path = require('path');
+const fs = require('fs-extra');
+const inquirer = require('inquirer');
+const { loadConfig } = require('../config/load-config');
+const { parseJdl } = require('../parser/jdl-parser');
+const { parseGdl } = require('../parser/gdl-parser');
+const { generateProject: runGenerator } = require('../generator/project-output');
+const colors = require('../utils/colors');
+const branding = require('../utils/branding');
+
+async function generateCommand(jdlFile, outputFolder, options = {}) {
+  const cwd = process.cwd();
+  const startTime = Date.now();
+
+  // 1. Load preferences
+  const projectMode = !jdlFile;
+  const { config, configPath, projectRoot } = await loadConfig(cwd, options.preferences, {
+    required: projectMode, projectPaths: projectMode,
+  });
+  const { resolveInputSources } = require('../config/input-sources');
+
+  // CLI positional file overrides config; otherwise use input.sources[] or input.file.
+  let inputSources;
+  if (jdlFile) {
+    const resolved = path.resolve(cwd, jdlFile);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+      throw new Error(`Input file not found: "${resolved}".`);
+    }
+    if (!/\.(gdl|jdl)$/i.test(resolved)) throw new Error(`Unsupported schema "${resolved}". Use .gdl or .jdl.`);
+    const type = path.extname(resolved).slice(1).toLowerCase();
+    const folder =
+      String(config.fuse?.folderType || '').trim() || (type === 'gdl' ? 'micro-functions' : 'microservice');
+    inputSources = [
+      {
+        name: folder,
+        file: resolved,
+        type,
+        microservice: String(config.api?.microservice || '').trim(),
+        folder,
+      },
+    ];
+  } else {
+    inputSources = resolveInputSources(config, projectRoot);
+    if (!inputSources.length) {
+      throw new Error(
+        `Missing schema input in "${configPath}". Set input.file or input.sources[{ name, file, microservice }].`
+      );
+    }
+  }
+
+  for (const source of inputSources) {
+    if (!fs.existsSync(source.file) || !fs.statSync(source.file).isFile()) {
+      throw new Error(
+        `Input file not found: "${source.file}" (service "${source.name}"). Update input.sources / input.file.`
+      );
+    }
+    if (!/\.(gdl|jdl)$/i.test(source.file)) {
+      throw new Error(`Unsupported schema "${source.file}". Use .gdl or .jdl.`);
+    }
+  }
+
+  // Keep legacy single-file fields populated for embed/docs/tools.
+  config.input.file = inputSources[0].file;
+  config.input.type = inputSources[0].type;
+  config._inputSources = inputSources;
+
+  if (configPath) {
+    console.log(colors.cyan(`🔵 Loaded configuration preferences from: ${configPath}`));
+  } else {
+    console.log(colors.dim(`🔵 No configuration file found. Using default developer preferences.`));
+  }
+  if (inputSources.length > 1) {
+    console.log(
+      colors.cyan(
+        `🔵 Multi-service schemas: ${inputSources.map((s) => `${s.name} (${path.basename(s.file)})`).join(', ')}`
+      )
+    );
+  }
+
+  // Display banner dynamically based on configuration preferences
+  branding.printBanner(config);
+
+  // Override configuration using CLI arguments if provided
+  if (outputFolder) {
+    config.output.directory = path.isAbsolute(outputFolder) 
+      ? outputFolder 
+      : path.resolve(cwd, outputFolder);
+  }
+  
+  if (options.fuse) {
+    config.fuse = config.fuse || {};
+    config.fuse.enabled = true;
+  }
+  if (options.fusePath) {
+    config.fuse = config.fuse || {};
+    config.fuse.starterPackPath = path.isAbsolute(options.fusePath)
+      ? options.fusePath
+      : path.resolve(cwd, options.fusePath);
+  }
+  if (options.cleanLayout) {
+    config.fuse = config.fuse || {};
+    config.fuse.cleanLayout = true;
+  }
+  if (options.sidebarTheme) {
+    config.fuse = config.fuse || {};
+    config.fuse.sidebarTheme = options.sidebarTheme;
+  }
+  if (options.folderType) {
+    config.fuse = config.fuse || {};
+    config.fuse.folderType = options.folderType;
+    if (jdlFile || !config.input.sources?.length) inputSources[0].folder = options.folderType;
+  }
+  
+  if (options.microservice) {
+    config.api.microservice = options.microservice;
+  }
+
+  if (options.dryRun) {
+    config.dryRun = true;
+  }
+
+  if (options.overwritePolicy) {
+    if (!config.output) config.output = {};
+    config.output.overwritePolicy = options.overwritePolicy;
+  }
+
+  // Prompt for microservice when any source still lacks one (global or per-source).
+  const missingMs = inputSources.filter((s) => !s.microservice);
+  if (missingMs.length) {
+    if (!config.api.microservice) {
+      if (!process.stdout.isTTY || options.yes) {
+        throw new Error(
+          `Set api.microservice or each input.sources[].microservice in "${configPath || 'your configuration'}" (or pass --microservice <name>).`
+        );
+      }
+      const answers = await inquirer.prompt([{
+        type: 'input',
+        name: 'microservice',
+        message: 'Enter microservice identifier for API resource paths (e.g. keycloak-service):',
+        validate: (input) => (input.trim().length > 0 ? true : 'Microservice name cannot be blank.'),
+      }]);
+      config.api.microservice = answers.microservice;
+    }
+    for (const source of missingMs) {
+      source.microservice = config.api.microservice;
+    }
+  }
+  if (!config.api.microservice && inputSources[0]?.microservice) {
+    config.api.microservice = inputSources[0].microservice;
+  }
+
+  // When services are configured, confirm which proxy file(s) to update (unless set / --yes).
+  config.api = config.api || {};
+  config.proxy = config.proxy || {};
+  const serviceKeys = config.api.services && typeof config.api.services === 'object'
+    ? Object.keys(config.api.services).filter((k) => k && config.api.services[k])
+    : [];
+  if (
+    config.fuse?.enabled !== false &&
+    serviceKeys.length > 0 &&
+    process.stdout.isTTY &&
+    !options.yes &&
+    !options.proxyWrite
+  ) {
+    const current = String(config.proxy.write || 'both').toLowerCase();
+    const answers = await inquirer.prompt([{
+      type: 'list',
+      name: 'proxyWrite',
+      message: 'Update which Fuse proxy config for api.services / Keycloak?',
+      default: ['both', 'prod', 'dev'].includes(current) ? current : 'both',
+      choices: [
+        { name: 'Both (proxy.conf.json + proxy.dev.conf.json)', value: 'both' },
+        { name: 'Prod only (proxy.conf.json)', value: 'prod' },
+        { name: 'Dev only (proxy.dev.conf.json)', value: 'dev' },
+      ],
+    }]);
+    config.proxy.write = answers.proxyWrite;
+  }
+  if (options.proxyWrite) {
+    config.proxy.write = String(options.proxyWrite).trim().toLowerCase();
+  }
+
+  // 2. Parse one or more schema files and merge (tag entities with their service source).
+  const { requireValidSchema, formatDiagnostics } = require('../validator/diagnostics');
+  const parsedData = { entities: [], enums: [], relationships: [] };
+  const entityOwners = new Map();
+  const allDiagnostics = [];
+
+  for (const source of inputSources) {
+    const isGdl = source.type === 'gdl' || source.file.toLowerCase().endsWith('.gdl');
+    const fileContent = fs.readFileSync(source.file, 'utf8');
+    const checked = requireValidSchema(fileContent, { file: source.file, isGdl, config });
+    if (checked.diagnostics.length) {
+      allDiagnostics.push(...checked.diagnostics);
+      console.warn(formatDiagnostics(checked.diagnostics));
+    }
+    const chunk = checked.parsed || { entities: [], enums: [], relationships: [] };
+    for (const entity of chunk.entities || []) {
+      const key = String(entity.name || '').toLowerCase();
+      if (entityOwners.has(key)) {
+        throw new Error(
+          `Entity "${entity.name}" is defined in both "${entityOwners.get(key)}" and "${source.file}". Rename one or split carefully.`
+        );
+      }
+      entityOwners.set(key, source.file);
+      entity.sourceName = source.name;
+      entity.microservice = source.microservice;
+      entity.folderName = source.folder;
+      parsedData.entities.push(entity);
+    }
+    for (const en of chunk.enums || []) {
+      en.sourceName = source.name;
+      en.microservice = source.microservice;
+      en.folderName = source.folder;
+      if (config.fuse?.enabled || !parsedData.enums.some((existing) => existing.name === en.name)) {
+        parsedData.enums.push(en);
+      }
+    }
+    parsedData.relationships.push(...(chunk.relationships || []));
+  }
+
+  if (!parsedData.entities.length) {
+    throw new Error(
+      `No entities found in schema(s): ${inputSources.map((s) => s.file).join(', ')}. Add a valid entity and retry.`
+    );
+  }
+  const checked = { diagnostics: allDiagnostics, parsed: parsedData };
+  const resolvedJdlFile = inputSources[0].file;
+
+  const { applyDeveloperKeycloakOptions } = require('./keycloak-options');
+  await applyDeveloperKeycloakOptions(config, options, { cwd: projectRoot });
+
+  if (config.auth) {
+    const { stripSecretsForGenerate, deriveAuthUrls } = require('../config/auth-config');
+    deriveAuthUrls(config.auth);
+    config.auth = stripSecretsForGenerate(config.auth);
+  }
+
+  // 3. Generate outputs
+  console.log(colors.cyan(`🚀 Executing generator engine...`));
+  const stats = await runGenerator(parsedData, config, { configPath, inputPath: resolvedJdlFile, options });
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+  
+  console.log('\\n');
+  branding.printBanner(config);
+  
+  if (stats.dryRun) {
+    console.log(colors.yellow(colors.bold(`  🔍 DRY RUN PREVIEW: No files were modified on disk.\\n`)));
+    
+    const newFiles = stats.dryRunReport.newFiles;
+    if (newFiles.length > 0) {
+      console.log(colors.green(colors.bold(`  Proposed New Files (${newFiles.length}):`)));
+      newFiles.forEach(file => {
+        console.log(colors.green(`    [NEW] ${file.path}`));
+        const preview = file.content.split(/\r?\n/).slice(0, 3).map(l => `      + ${l}`).join('\n');
+        console.log(colors.dim(preview));
+        if (file.content.split(/\\r?\\n/).length > 3) {
+          console.log(colors.dim('      + ...'));
+        }
+      });
+      console.log();
+    }
+
+    const modifiedFiles = stats.dryRunReport.modifiedFiles;
+    if (modifiedFiles.length > 0) {
+      console.log(colors.yellow(colors.bold(`  Proposed File Modifications (${modifiedFiles.length}):`)));
+      const { formatDiff, colorizeDiff } = require('../utils/diff');
+      modifiedFiles.forEach(file => {
+        console.log(colors.yellow(`    [MODIFIED] ${file.path}`));
+        const diffLines = formatDiff(file.oldContent, file.content);
+        const colorDiff = colorizeDiff(diffLines);
+        const indentedDiff = colorDiff.split('\\n').map(l => `      \${l}`).join('\\n');
+        console.log(indentedDiff);
+      });
+      console.log();
+    } else if (newFiles.length === 0) {
+      console.log(colors.dim('  No file changes proposed. Output is identical to existing files on disk.\\n'));
+    }
+
+    console.log(`  ${colors.bold('Output Directory:')} ${colors.cyan(config.output.directory)}`);
+    console.log(`  ${colors.bold('Entities Inspected:')} ${colors.yellow(stats.entityCount)}`);
+    console.log(`  ${colors.bold('Proposed Writes:')} ${colors.yellow(newFiles.length + modifiedFiles.length)}`);
+    console.log(`  ${colors.bold('Elapsed Time:')} ${colors.yellow(elapsed + 's')}\n`);
+  } else {
+    console.log(colors.green(colors.bold(`  🎉 SUCCESS: Generation Completed Successfully!\\n`)));
+    console.log(`  ${colors.bold('Output Directory:')} ${colors.cyan(config.output.directory)}`);
+    console.log(`  ${colors.bold('Entities Processed:')} ${colors.yellow(stats.entityCount)}`);
+    console.log(`  ${colors.bold('Files Generated:')} ${colors.yellow(stats.fileCount)}`);
+    console.log(`  ${colors.bold('Elapsed Time:')} ${colors.yellow(elapsed + 's')}\n`);
+    
+    console.log(colors.bold('  Suggested Next Steps:'));
+    console.log(colors.dim(`    1. Navigate to your project folder.`));
+    console.log(colors.dim(`    2. Run ${colors.cyan('npm install')} to install dependencies.`));
+    console.log(colors.dim(`    3. ${colors.cyan(`npm run dev -- --port ${config.devServer?.port || 4200}`)} → http://localhost:${config.devServer?.port || 4200}\n`));
+    branding.printSuccessFooter();
+  }
+  return {stats,diagnostics:checked.diagnostics};
+}
+
+module.exports = { generateCommand };

package/src/commands/init-config.js

@@ -0,0 +1,310 @@
+const fs = require('fs-extra');
+const path = require('path');
+const colors = require('../utils/colors');
+
+const exampleJdl = `
+entity Book {
+  title String required
+  description TextBlob
+  publicationDate LocalDate
+  price BigDecimal
+}
+
+entity Author {
+  firstName String required
+  lastName String required
+}
+
+relationship OneToMany {
+  Author{book} to Book{author}
+}
+`;
+
+const exampleGdl = `entity Book {
+  string title required
+  bigDecimal price
+}
+`;
+
+const defaultConfigYml = `
+# CRUDForge CLI Configuration
+project:
+  name: CRUDForge App
+  description: Angular Material CRUD generated by CRUDForge
+  repositoryUrl: ""
+
+input:
+  type: "gdl"
+  file: ""
+  # Multi-service example (uncomment and point at your GDL/JDL files):
+  # sources:
+  #   - name: identity-access
+  #     file: ./GDL/identity-access.gdl
+  #     microservice: identity-access-module
+  #   - name: inventory
+  #     file: ./GDL/inventory.gdl
+  #     microservice: inventory-service
+  sources: []
+
+output:
+  directory: "./generated-app"
+  structure: "entity-folder"
+  embedConfig: true
+  teamPack:
+    enabled: true
+    cursorAgents: true
+    codexAgents: true
+    antigravityAgents: true
+    vscodeExtensions: true
+  aiDocs:
+    enabled: true
+
+git:
+  enabled: true
+
+preset: "crud"
+dryRun: false
+validation: true
+
+branding:
+  banner: true
+  bannerColor: "green"
+
+fuse:
+  rendering: spa # spa (Nginx) | ssr (Node server)
+  enabled: false
+  routesFile: "src/app/domains/admin/routes.ts"
+  navigationFile: "src/app/domains/admin/layout/data/navigation.ts"
+  cleanLayout: false
+  includePrebuilt: true
+  folderType: ""
+  theme:
+    scheme: "system"
+    primary: "#0D1E3A"
+    error: "#dc2626"
+
+generate:
+  models: true
+  services: true
+  formServices: true
+  routes: true
+  enums: true
+  relationships: true
+  components:
+    list: true
+    card: true
+    detail: true
+  forms:
+    form: true
+    formPage: true
+    update: true
+    validators: true
+    mappers: true
+  interaction:
+    actions: true
+    filter: true
+  globals:
+    constants: true
+    tests: false
+    sharedAssets: true
+  registrations:
+    navigation: true
+    routes: true
+
+ui:
+  framework: "material"
+  useSkeletonLoading: true
+  viewMode: "table"
+  formMode: "sidebar"
+  searchMode: "field"
+  cardBreakpointPx: 640
+  gridCols:
+    mobile: 1
+    tablet: 2
+    desktop: 3
+  styling:
+    snackbarSuccessColor: "#16a34a"
+    snackbarErrorColor: "#dc2626"
+
+api:
+  baseUrl: "/api"
+  microservice: ""
+  endpointStyle: "kebab-plural"
+  dateLibrary: "dayjs"
+  responseType: "http-response"
+  # Backend modules → environment.services + proxy targets
+  # identityaccessmodule: "http://62.84.188.166:30084"
+  services: {}
+
+# both | prod (proxy.conf.json) | dev (proxy.dev.conf.json)
+proxy:
+  write: both
+
+fields:
+  # Exact entity and field names from your GDL/JDL. Only String/TextBlob fields.
+  # entities:
+  #   Province:
+  #     fields:
+  #       referenceCode: { inputFormat: uppercase }
+  #       email: { inputFormat: lowercase }
+  #       description: { inputFormat: none }
+  entities: {}
+  audit:
+    enabled: true
+    hideInForms: true
+    hideInFilters: true
+    hideInSearch: true
+    hideInLists: true
+    showInDetail: true
+    names:
+      - createdBy
+      - createdDate
+      - lastModifiedBy
+      - lastModifiedDate
+  technical:
+    enabled: true
+    names:
+      - debug
+      - refType
+      - refId
+  formatting:
+    dateMediumFormat: "medium"
+    numberFormat: "1.0-2"
+    stringCase: "default"
+
+formBehavior:
+  uppercaseInputs: false
+  updateOn: "change"
+  showErrorMessages: true
+  autoFocusFirstInput: true
+
+# Keycloak — set provider: keycloak and fill serverUrl / clientId / adminServiceUrl.
+# Put KEYCLOAK_ADMIN_USERNAME and KEYCLOAK_ADMIN_PASSWORD in a local .env (never commit).
+# generate never provisions — use crudforge bootstrap when provision.enabled is true.
+auth:
+  provider: none
+  serverUrl: ""
+  realm: CRUD-FORDGE
+  clientId: ""
+  clientSecret: ""
+  issuerUrl: ""
+  tokenUrl: ""
+  adminBaseUrl: /auth
+  useMockAuth: false
+  adminRoles:
+    - ROLE_ADMIN
+    - ADMIN
+    - ROLE_SUPER_ADMIN
+  sessionIdleTimeoutMs: 0
+  session:
+    idleTimeoutMs: 0
+    persistAcrossReload: true
+    crossTabSync: true
+    refreshOnFocus: true
+    statusProbeIntervalMs: 60000
+  disabledAccount:
+    enabled: false
+    countdownSeconds: 20
+    message: "Your account has been disabled. Please contact your administrator."
+    sound: false
+  forwardedProto: ""
+  provision:
+    enabled: false
+    dryRun: false
+    adapter: admin-service
+    adminServiceUrl: ""
+    adminUsernameEnv: KEYCLOAK_ADMIN_USERNAME
+    adminPasswordEnv: KEYCLOAK_ADMIN_PASSWORD
+    tokenClientId: admin-cli
+    clientId: ""
+    clientName: ""
+    publicClient: true
+    directAccessGrantsEnabled: true
+    redirectUris: []
+    webOrigins: []
+    roles: []
+    users: []
+    resetExistingPasswords: false
+    stateFile: ".crudforge/provision-state.json"
+
+iam:
+  enabled: false
+  users: true
+  roles: true
+  rolePermissions: true
+  userAccess: true
+  userPermissions: true
+  inheritance: true
+  screens: []
+`;
+
+async function initConfig() {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, 'crudforge.config.yml');
+  const jdlPath = path.join(cwd, 'example.jdl');
+  const gdlPath = path.join(cwd, 'example.gdl');
+
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, defaultConfigYml.trim());
+    console.log(colors.green(`✅ Created default configuration file: ${configPath}`));
+  } else {
+    console.log(colors.yellow(`⚠️ Configuration file already exists at ${configPath}. Skipping creation.`));
+  }
+
+  if (!fs.existsSync(jdlPath)) {
+    fs.writeFileSync(jdlPath, exampleJdl.trim());
+    console.log(colors.green(`✅ Created example JDL file: ${jdlPath}`));
+  }
+
+  if (!fs.existsSync(gdlPath)) {
+    fs.writeFileSync(gdlPath, exampleGdl.trim());
+    console.log(colors.green(`✅ Created example GDL file: ${gdlPath}`));
+  }
+}
+
+async function initProject(directory, options = {}) {
+  const YAML = require('yaml');
+  const projectRoot = path.resolve(directory);
+  if (await fs.pathExists(projectRoot)) {
+    if (!(await fs.stat(projectRoot)).isDirectory() || (await fs.readdir(projectRoot)).length) {
+      throw new Error(`Project path "${projectRoot}" is not empty. Choose a new or empty directory; existing files are preserved.`);
+    }
+  }
+  if (options.source && !options.preset) throw new Error('--source requires --preset pmb-test.');
+  let preset;
+  if (options.preset) {
+    const { presetDirectory, importPreset, loadPreset } = require('../presets/store');
+    const registry = presetDirectory(options.preset);
+    const relative = path.relative(projectRoot, registry);
+    if (!relative || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative))) {
+      throw new Error(`Preset storage must be outside the generated project: ${registry}`);
+    }
+    preset = options.source
+      ? await importPreset(options.preset, options.source)
+      : await loadPreset(options.preset);
+    console.log(`Using preset: ${registry}`);
+  }
+  const config = YAML.parse(defaultConfigYml);
+  config.project.name = path.basename(projectRoot);
+  config.input = { file: './gdl/example.gdl', type: 'gdl' };
+  config.output.directory = '.';
+  config.output.overwritePolicy = 'fail';
+  config.fuse.enabled = true;
+  config.fuse.cleanLayout = true;
+  config.fuse.includePrebuilt = false;
+  config.api.microservice = 'book-service';
+  if (preset) {
+    require('lodash').mergeWith(config, preset.config, (_current, incoming) => Array.isArray(incoming) ? incoming : undefined);
+    config.project.name = path.basename(projectRoot);
+  }
+  const configPath = path.join(projectRoot, 'config/crudforge.config.yml');
+  const gdlPath = path.join(projectRoot, 'gdl/example.gdl');
+  await fs.ensureDir(path.dirname(configPath));
+  await fs.ensureDir(path.dirname(gdlPath));
+  await fs.writeFile(configPath, '# Project paths are relative to the project root, not config/.\n' + YAML.stringify(config), { flag: 'wx' });
+  await fs.writeFile(gdlPath, preset?.gdl || exampleGdl, { flag: 'wx' });
+  console.log(`Initialized project inputs in ${projectRoot}\nEdit: ${configPath}\nEdit: ${gdlPath}\n\nNext:\n  cd ${JSON.stringify(projectRoot)}\n  crudforge generate`);
+  if (preset) console.log(`After generation:\n  npm install\n  npm run dev -- --port ${config.devServer.port}\nOpen http://localhost:${config.devServer.port}/auth/sign-in and enter your PMB login. Backend access is not yet verified.`);
+}
+
+module.exports = { initConfig, initProject };