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

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@team-codeme/crud-forge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "A modern, configurable JDL/GDL-to-Angular code generator supporting Angular 17+ standalone architecture, centralized developer preferences, and strict type safety.",
+  "main": "src/index.js",
+  "bin": {
+    "crudforge": "./cli.js",
+    "crud-forge": "./cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://crudforge.teamcodeme.com/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FayyazAbdulla/crudforge-cli.git"
+  },
+  "scripts": {
+    "test": "node test/verify.js && node test/micro-functions-layout.js && node test/project-workflow.js && node test/pmb-preset.js && node test/quality-features.js",
+    "test:field-preferences": "node test/field-preferences.js",
+    "e2e:prepare:field-profile": "node scripts/e2e-prepare-field-profile.js",
+    "test:ui-state": "node test/list-state.js",
+    "test:auth": "node test/auth-interceptor.js",
+    "postinstall": "node scripts/postinstall.js",
+    "e2e:prepare": "node scripts/e2e-prepare.js",
+    "e2e:prepare:clean": "node scripts/e2e-prepare.js --clean",
+    "e2e:serve": "node scripts/e2e-serve.js",
+    "e2e:prepare:iam": "node scripts/e2e-prepare-iam.js",
+    "e2e:prepare:iam:clean": "node scripts/e2e-prepare-iam.js --clean",
+    "e2e:serve:iam": "node scripts/e2e-serve-iam.js",
+    "e2e:prepare:iam:live": "node scripts/e2e-prepare-iam-live.js",
+    "e2e:prepare:iam:live:clean": "node scripts/e2e-prepare-iam-live.js --clean",
+    "e2e:serve:iam:live": "node scripts/e2e-serve-iam-live.js",
+    "test:e2e": "npx playwright test",
+    "test:e2e:iam": "npx playwright test --config=playwright.iam.config.js",
+    "test:e2e:iam:live": "npx playwright test --config=playwright.iam-live.config.js",
+    "test:e2e:install": "npx playwright install chromium",
+    "test:performance": "node test/performance-generation.js",
+    "test:quality": "node test/quality-features.js"
+  },
+  "dependencies": {
+    "ejs": "^3.1.8",
+    "fs-extra": "^10.1.0",
+    "inquirer": "^8.2.4",
+    "lodash": "^4.17.21",
+    "semver": "^7.8.5",
+    "yaml": "^2.2.1",
+    "yargs": "^17.5.1"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.63.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "author": "Abdulla Fayyaz",
+  "license": "MIT"
+}

package/playwright.config.js

@@ -0,0 +1,29 @@
+const { defineConfig, devices } = require('@playwright/test');
+
+module.exports = defineConfig({
+  testDir: './e2e/tests',
+  testIgnore: ['iam-pack.spec.js', 'iam-live.spec.js', 'field-profile.spec.js'],
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 1 : 0,
+  workers: 1,
+  reporter: [['list'], ['html', { open: 'never' }]],
+  use: {
+    baseURL: 'http://127.0.0.1:4200',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'off',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+  webServer: {
+    command: 'npm run e2e:serve',
+    url: 'http://127.0.0.1:4200',
+    reuseExistingServer: !process.env.CI,
+    timeout: 180_000,
+  },
+});

package/playwright.field-profile.config.js

@@ -0,0 +1,6 @@
+const { defineConfig } = require('@playwright/test');
+module.exports = defineConfig({
+  testDir: './e2e/tests', testMatch: 'field-profile.spec.js', workers: 1,
+  use: { baseURL: process.env.CRUDFORGE_UI_TEST_URL || 'http://127.0.0.1:4201', headless: true,
+    channel: process.env.CRUDFORGE_BROWSER_CHANNEL || undefined },
+});

package/playwright.iam-live.config.js

@@ -0,0 +1,31 @@
+const { defineConfig, devices } = require('@playwright/test');
+
+module.exports = defineConfig({
+  testDir: './e2e/tests',
+  testMatch: 'iam-live.spec.js',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: 0,
+  workers: 1,
+  reporter: [['list'], ['html', { open: 'never', outputFolder: 'playwright-report-iam-live' }]],
+  outputDir: 'test-results-iam-live',
+  use: {
+    baseURL: process.env.CRUDFORGE_LIVE_BASE_URL || 'http://127.0.0.1:4202',
+    trace: 'off',
+    screenshot: 'off',
+    video: 'off',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+  webServer: {
+    command: 'npm run e2e:serve:iam:live',
+    url: process.env.CRUDFORGE_LIVE_READY_URL
+      || `${process.env.CRUDFORGE_LIVE_BASE_URL || 'http://127.0.0.1:4202'}/auth/sign-in`,
+    reuseExistingServer: !process.env.CI,
+    timeout: 300_000,
+  },
+});

package/playwright.iam.config.js

@@ -0,0 +1,29 @@
+const { defineConfig, devices } = require('@playwright/test');
+
+module.exports = defineConfig({
+  testDir: './e2e/tests',
+  testMatch: 'iam-pack.spec.js',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 1 : 0,
+  workers: 1,
+  reporter: [['list'], ['html', { open: 'never', outputFolder: 'playwright-report-iam' }]],
+  use: {
+    baseURL: 'http://127.0.0.1:4201',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'off',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+  webServer: {
+    command: 'npm run e2e:serve:iam',
+    url: 'http://127.0.0.1:4201',
+    reuseExistingServer: !process.env.CI,
+    timeout: 180_000,
+  },
+});

package/playwright.list-state.config.js

@@ -0,0 +1,6 @@
+// Optional isolated-server configuration; avoids reusing a live PMB server on port 4200.
+const { defineConfig } = require('@playwright/test');
+module.exports = defineConfig({
+  testDir: './e2e/tests', testMatch: 'list-state.spec.js', workers: 1,
+  use: { baseURL: process.env.CRUDFORGE_UI_TEST_URL || 'http://127.0.0.1:4201', headless: true, channel: process.env.CRUDFORGE_BROWSER_CHANNEL || undefined },
+});

package/playwright.performance.config.js

@@ -0,0 +1 @@
+module.exports = { testDir: './e2e/tests', testMatch: ['generated-crud.spec.js', 'list-state.spec.js'], workers: 1, use: { baseURL: 'http://127.0.0.1:4203', channel: 'chrome', headless: true } };

package/run-config-tests.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Run from any directory. CI mode fails immediately on validation/test/build errors.
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$ROOT/scripts/run-config-tests.js" "$@"

package/scripts/e2e-paths.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+/** In-repo fallback when the external sandbox parent is absent (CI). */
+const IN_REPO_AREA = path.join(root, 'e2e');
+/**
+ * Default external QA sandbox (outside the generator repo).
+ * Keep in sync with DEFAULT_TESTING_AREA in test-run.sh.
+ */
+const DEFAULT_EXTERNAL_AREA =
+  process.env.CRUDFORGE_DEFAULT_TESTING_AREA ||
+  '/Users/abdulla/Work/CRUD-FORDGE-SETUP/crud-fordge-testing-area';
+
+/** Single generated Fuse app folder name under the testing area (never bare ".app"). */
+const EXTERNAL_APP_NAME = 'crudforge-app';
+/** In-repo historical e2e folder (kept for CI without an external sandbox). */
+const IN_REPO_APP_NAME = '.app';
+
+let envLoaded = false;
+
+function loadEnvHints() {
+  if (envLoaded) {
+    return;
+  }
+  envLoaded = true;
+  const envPath = process.env.CRUDFORGE_ENV_FILE || path.join(root, '.env.qa');
+  if (!fs.existsSync(envPath)) {
+    return;
+  }
+  try {
+    const { loadEnvFile } = require('../src/config/env-refs');
+    loadEnvFile(envPath);
+  } catch {
+    // Ignore malformed/missing env; callers may set vars explicitly.
+  }
+}
+
+function testingArea() {
+  loadEnvHints();
+  if (process.env.CRUDFORGE_TESTING_AREA) {
+    return path.resolve(process.env.CRUDFORGE_TESTING_AREA);
+  }
+  if (process.env.CRUDFORGE_USE_IN_REPO_E2E === '1') {
+    return IN_REPO_AREA;
+  }
+  // Prefer the external sandbox whenever CRUD-FORDGE-SETUP (or the area itself) exists.
+  const parent = path.dirname(DEFAULT_EXTERNAL_AREA);
+  if (fs.existsSync(DEFAULT_EXTERNAL_AREA) || fs.existsSync(parent)) {
+    return DEFAULT_EXTERNAL_AREA;
+  }
+  return IN_REPO_AREA;
+}
+
+function isExternalTestingArea() {
+  return path.resolve(testingArea()) !== path.resolve(IN_REPO_AREA);
+}
+
+function defaultAppSubdir() {
+  return isExternalTestingArea() ? EXTERNAL_APP_NAME : IN_REPO_APP_NAME;
+}
+
+/**
+ * One Fuse app root for mock CRUD, mock IAM, and live IAM.
+ * Override with CRUDFORGE_E2E_APP_DIR.
+ */
+function appDir() {
+  loadEnvHints();
+  if (process.env.CRUDFORGE_E2E_APP_DIR) {
+    return path.resolve(process.env.CRUDFORGE_E2E_APP_DIR);
+  }
+  const name = process.env.CRUDFORGE_E2E_APP_NAME || defaultAppSubdir();
+  return path.join(testingArea(), name);
+}
+
+module.exports = {
+  root,
+  DEFAULT_EXTERNAL_AREA,
+  IN_REPO_AREA,
+  testingArea,
+  isExternalTestingArea,
+  EXTERNAL_APP_NAME,
+  IN_REPO_APP_NAME,
+  appDir,
+  // Aliases so older prepare/serve scripts keep working during transition
+  crudAppDir: appDir,
+  iamAppDir: appDir,
+  iamLiveAppDir: appDir,
+};

package/scripts/e2e-prepare-field-profile.js

@@ -0,0 +1,17 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { generateFromSource } = require('../src');
+const root = path.resolve(__dirname, '..');
+(async () => {
+  const output = path.resolve(process.env.CRUDFORGE_E2E_APP_DIR || path.join(root, 'e2e/.field-profile'));
+  const fixture = path.join(root, 'test/fixtures/field-profile.gdl');
+  await generateFromSource(await fs.readFile(fixture, 'utf8'), {
+    filePath: fixture, configPath: path.join(root, 'e2e/crudforge.field-profile.yml'), outputDirectory: output,
+    fuse: { starterPackPath: path.join(root, 'fuse-starter-pack/fuse-v21.1') },
+  });
+  const modules = path.join(root, 'e2e/.app/node_modules');
+  if (!await fs.pathExists(path.join(output, 'node_modules')) && await fs.pathExists(modules)) {
+    await fs.symlink(modules, path.join(output, 'node_modules'), 'dir');
+  }
+  console.log(`Fixture ready: ${output}. Install dependencies if needed, then run npx ng serve --port 4201 from that folder.`);
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/e2e-prepare-iam-live.js

@@ -0,0 +1,135 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { generateFromSource } = require('../src/index');
+const { loadEnvFile } = require('../src/config/env-refs');
+const { root, appDir } = require('./e2e-paths');
+
+const outDir = appDir();
+const fixturePath = path.join(root, 'test', 'fixtures', 'mock.jdl');
+const configPath = path.join(root, 'e2e', 'crudforge.iam-live.yml');
+
+/** Hardcoded QA — Keycloak Admin Service middleware only (no native :30080). */
+const QA = {
+  /** Middleware fronts /realms (OIDC) + /api/v1 (admin). */
+  adminServiceUrl: 'http://62.84.188.166:31740',
+  realm: 'CRUD-FORDGE',
+  clientId: 'crudforge-client-QA',
+  forwardedProto: 'https',
+};
+
+function loadQaEnv() {
+  const envPath = process.env.CRUDFORGE_ENV_FILE || path.join(root, '.env.qa');
+  if (fs.existsSync(envPath)) {
+    loadEnvFile(envPath);
+  }
+  process.env.CRUDFORGE_KC_ADMIN_SERVICE_URL = QA.adminServiceUrl;
+  process.env.CRUDFORGE_KC_SERVER_URL = QA.adminServiceUrl;
+  process.env.CRUDFORGE_KC_REALM = QA.realm;
+  process.env.CRUDFORGE_KC_CLIENT_ID = QA.clientId;
+  process.env.CRUDFORGE_KC_FORWARDED_PROTO = QA.forwardedProto;
+}
+
+async function prepare() {
+  loadQaEnv();
+  const gateway = process.env.CRUDFORGE_KC_ADMIN_SERVICE_URL || QA.adminServiceUrl;
+  if (!gateway) {
+    throw new Error('CRUDFORGE_KC_ADMIN_SERVICE_URL is required for live IAM prepare.');
+  }
+
+  const clean = process.argv.includes('--clean');
+  if (clean) {
+    await fs.remove(outDir);
+  }
+
+  await fs.ensureDir(path.dirname(outDir));
+
+  const jdlContent = await fs.readFile(fixturePath, 'utf8');
+  console.log(`Generating Fuse IAM LIVE app into ${outDir} (useMockAuth: false) ...`);
+  console.log(`  Admin service: ${gateway} realm=${process.env.CRUDFORGE_KC_REALM} client=${process.env.CRUDFORGE_KC_CLIENT_ID}`);
+  await generateFromSource(jdlContent, {
+    filePath: fixturePath,
+    configPath,
+    outputDirectory: outDir,
+    microservice: 'book-service',
+    fuse: {
+      enabled: true,
+      starterPackPath: path.join(root, 'fuse-starter-pack', 'fuse-v21.1'),
+      cleanLayout: true,
+      includePrebuilt: false,
+    },
+    mock: { enabled: true, recordsPerEntity: 12 },
+    auth: {
+      provider: 'keycloak',
+      useMockAuth: false,
+      serverUrl: gateway,
+      realm: process.env.CRUDFORGE_KC_REALM || QA.realm,
+      clientId: process.env.CRUDFORGE_KC_CLIENT_ID || QA.clientId,
+      forwardedProto: process.env.CRUDFORGE_KC_FORWARDED_PROTO || QA.forwardedProto,
+      adminBaseUrl: '',
+      provision: {
+        enabled: false,
+        adapter: 'admin-service',
+        adminServiceUrl: gateway,
+      },
+    },
+    iam: { enabled: true },
+    proxy: { write: 'both' },
+  });
+
+  const envFile = path.join(outDir, 'src/environments/environment.ts');
+  const envText = await fs.readFile(envFile, 'utf8');
+  if (envText.includes('useMockAuth: true')) {
+    throw new Error('Live prepare produced useMockAuth: true. Aborting.');
+  }
+  if (!envText.includes("kcClientId: 'crudforge-client-QA'") && !envText.includes(process.env.CRUDFORGE_KC_CLIENT_ID)) {
+    throw new Error('Live prepare missing expected kcClientId in environment.ts.');
+  }
+  if (!envText.includes('/realms/')) {
+    throw new Error('Live prepare must use proxied /realms/... token URL (not /auth/realms/...).');
+  }
+  if (envText.includes('kcClientSecret') || envText.includes(':30080')) {
+    throw new Error('Live prepare must not emit secrets or native Keycloak :30080.');
+  }
+  if (!envText.includes("kcAdminServiceUrl: '/services/keycloak-admin'") || !envText.includes('useKeycloakAdminService: true')) {
+    throw new Error('Live prepare must enable Keycloak Admin Service relative URL.');
+  }
+
+  const proxyPath = path.join(outDir, 'proxy.dev.conf.json');
+  const proxy = JSON.parse(await fs.readFile(proxyPath, 'utf8'));
+  if (!proxy['/realms'] || !String(proxy['/realms'].target || '').includes('31740')) {
+    throw new Error('Live prepare missing /realms proxy to Keycloak Admin Service :31740.');
+  }
+  if (proxy['/admin/realms'] || String(JSON.stringify(proxy)).includes(':30080')) {
+    throw new Error('Live prepare must not proxy native Keycloak :30080 /admin/realms.');
+  }
+  if (!proxy['/services/keycloak-admin'] || !String(proxy['/services/keycloak-admin'].target || '').includes('31740')) {
+    throw new Error('Live prepare missing /services/keycloak-admin → :31740.');
+  }
+
+  const appModules = path.join(outDir, 'node_modules');
+  const legacyModules = path.join(root, 'e2e', '.app', 'node_modules');
+  if (!fs.existsSync(appModules) && fs.existsSync(legacyModules)) {
+    await fs.symlink(legacyModules, appModules, 'dir');
+    console.log(`Linked node_modules from ${legacyModules}`);
+  }
+  if (!fs.existsSync(appModules)) {
+    const install = spawnSync('npm', ['install', '--no-fund', '--no-audit'], {
+      cwd: outDir,
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+    });
+    if (install.status !== 0) {
+      throw new Error(`npm install failed in ${outDir}.`);
+    }
+  }
+
+  console.log('IAM LIVE app ready (Keycloak Admin Service :31740).');
+  console.log('  Sign in with: crud / crud');
+  console.log('  Serve: npm run e2e:serve:iam:live  →  http://127.0.0.1:4202/auth/sign-in');
+}
+
+prepare().catch((error) => {
+  console.error(error.message || error);
+  process.exit(1);
+});

package/scripts/e2e-prepare-iam.js

@@ -0,0 +1,65 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { generateFromSource } = require('../src/index');
+const { root, appDir } = require('./e2e-paths');
+
+const outDir = appDir();
+const fixturePath = path.join(root, 'test', 'fixtures', 'mock.jdl');
+const configPath = path.join(root, 'e2e', 'crudforge.iam.yml');
+
+async function prepare() {
+  const clean = process.argv.includes('--clean');
+  if (clean) {
+    await fs.remove(outDir);
+  }
+
+  await fs.ensureDir(path.dirname(outDir));
+
+  const jdlContent = await fs.readFile(fixturePath, 'utf8');
+  console.log(`Generating Fuse IAM mock app into ${outDir} ...`);
+  await generateFromSource(jdlContent, {
+    filePath: fixturePath,
+    configPath,
+    outputDirectory: outDir,
+    microservice: 'book-service',
+    fuse: {
+      enabled: true,
+      starterPackPath: path.join(root, 'fuse-starter-pack', 'fuse-v21.1'),
+      cleanLayout: true,
+      includePrebuilt: false,
+    },
+    mock: { enabled: true, recordsPerEntity: 12 },
+    auth: {
+      provider: 'keycloak',
+      useMockAuth: true,
+    },
+    iam: { enabled: true },
+  });
+
+  const appModules = path.join(outDir, 'node_modules');
+  const legacyModules = path.join(root, 'e2e', '.app', 'node_modules');
+  if (!fs.existsSync(appModules) && fs.existsSync(legacyModules)) {
+    await fs.symlink(legacyModules, appModules, 'dir');
+    console.log(`Linked node_modules from ${legacyModules}`);
+  }
+
+  if (!fs.existsSync(appModules)) {
+    console.log('Installing generated IAM app dependencies...');
+    const install = spawnSync('npm', ['install', '--no-fund', '--no-audit'], {
+      cwd: outDir,
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+    });
+    if (install.status !== 0) {
+      throw new Error(`npm install failed in ${outDir}.`);
+    }
+  }
+
+  console.log('IAM E2E app ready. Start it with: npm run e2e:serve:iam');
+}
+
+prepare().catch((error) => {
+  console.error(error.message || error);
+  process.exit(1);
+});

package/scripts/e2e-prepare.js

@@ -0,0 +1,72 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { generateFromSource } = require('../src/index');
+const { root, appDir } = require('./e2e-paths');
+
+const outDir = appDir();
+const fixturePath = path.join(root, 'test', 'fixtures', 'mock.jdl');
+const configPath = path.join(root, 'e2e', 'crudforge.e2e.yml');
+
+async function prepare() {
+  const clean = process.argv.includes('--clean');
+  if (clean) {
+    await fs.remove(outDir);
+  }
+
+  await fs.ensureDir(path.dirname(outDir));
+
+  const jdlContent = await fs.readFile(fixturePath, 'utf8');
+  console.log(`Generating Fuse mock app into ${outDir} ...`);
+  await generateFromSource(jdlContent, {
+    filePath: fixturePath,
+    configPath,
+    outputDirectory: outDir,
+    microservice: 'book-service',
+    fuse: {
+      enabled: true,
+      starterPackPath: path.join(root, 'fuse-starter-pack', 'fuse-v21.1'),
+      cleanLayout: true,
+      includePrebuilt: false,
+    },
+    mock: { enabled: true, recordsPerEntity: 12 },
+    ui: { formMode: 'sidebar', viewMode: 'table', searchMode: 'field' },
+  });
+
+  if (!fs.existsSync(path.join(outDir, 'node_modules'))) {
+    const legacyModules = path.join(root, 'e2e', '.app', 'node_modules');
+    if (outDir !== path.join(root, 'e2e', '.app') && fs.existsSync(legacyModules)) {
+      await fs.symlink(legacyModules, path.join(outDir, 'node_modules'), 'dir');
+      console.log(`Linked node_modules from ${legacyModules}`);
+    }
+  }
+
+  if (!fs.existsSync(path.join(outDir, 'node_modules'))) {
+    console.log('Installing generated app dependencies (first run only)...');
+    const install = spawnSync('npm', ['install', '--no-fund', '--no-audit'], {
+      cwd: outDir,
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+    });
+    if (install.status !== 0) {
+      throw new Error(`npm install failed in ${outDir}. Install Node 24+ and retry.`);
+    }
+  }
+
+  spawnSync(
+    'npm',
+    ['install-scripts', 'approve', 'esbuild', '@parcel/watcher', 'lmdb', 'msgpackr-extract', 'unrs-resolver', 'fsevents'],
+    { cwd: outDir, stdio: 'ignore', shell: process.platform === 'win32' }
+  );
+  const esbuildInstall = path.join(outDir, 'node_modules', 'esbuild', 'install.js');
+  if (fs.existsSync(esbuildInstall)) {
+    spawnSync('node', [esbuildInstall], { cwd: outDir, stdio: 'ignore' });
+  }
+
+  console.log('E2E app ready. Start it with: npm run e2e:serve');
+}
+
+prepare().catch((error) => {
+  console.error(error.message || error);
+  process.exit(1);
+});

package/scripts/e2e-serve-iam-live.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { appDir } = require('./e2e-paths');
+
+const outDir = appDir();
+
+if (!fs.existsSync(path.join(outDir, 'angular.json'))) {
+  console.error(`${outDir} is missing. Run: npm run e2e:prepare:iam:live (or ./test-run.sh live)`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(path.join(outDir, 'node_modules'))) {
+  console.error(`${outDir} has no node_modules. Run: npm run e2e:prepare:iam:live`);
+  process.exit(1);
+}
+
+const child = spawn(
+  'npx',
+  ['ng', 'serve', '--configuration=development', '--host=127.0.0.1', '--port=4202'],
+  {
+    cwd: outDir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  }
+);
+
+child.on('exit', (code) => process.exit(code ?? 1));

package/scripts/e2e-serve-iam.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { appDir } = require('./e2e-paths');
+
+const outDir = appDir();
+
+if (!fs.existsSync(path.join(outDir, 'angular.json'))) {
+  console.error(`${outDir} is missing. Run: npm run e2e:prepare:iam (or ./test-run.sh mock)`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(path.join(outDir, 'node_modules'))) {
+  console.error(`${outDir} has no node_modules. Run: npm run e2e:prepare:iam`);
+  process.exit(1);
+}
+
+const child = spawn(
+  'npx',
+  ['ng', 'serve', '--configuration=mock', '--host=127.0.0.1', '--port=4201'],
+  {
+    cwd: outDir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  }
+);
+
+child.on('exit', (code) => process.exit(code ?? 1));

package/scripts/e2e-serve.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { appDir } = require('./e2e-paths');
+
+const outDir = appDir();
+
+if (!fs.existsSync(path.join(outDir, 'angular.json'))) {
+  console.error(`${outDir} is missing. Run: npm run e2e:prepare (or ./test-run.sh mock)`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(path.join(outDir, 'node_modules'))) {
+  console.error(`${outDir} has no node_modules. Run: npm run e2e:prepare`);
+  process.exit(1);
+}
+
+const child = spawn(
+  'npx',
+  ['ng', 'serve', '--configuration=mock', '--host=127.0.0.1', '--port=4200'],
+  {
+    cwd: outDir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  }
+);
+
+child.on('exit', (code) => process.exit(code ?? 1));

package/scripts/performance/generate.js

@@ -0,0 +1,17 @@
+const fs = require('fs-extra');
+const path = require('path');
+const generatorRoot = path.resolve(process.env.CRUDFORGE_GENERATOR_ROOT || path.join(__dirname, '../..'));
+const { generateFromSource } = require(path.join(generatorRoot, 'src'));
+(async () => {
+ const destination = path.resolve(process.argv[2]);
+ for(const size of ['small','large']) {
+  const fixture = path.resolve(__dirname, '../../test/fixtures/performance', size+'.gdl');
+  const output = path.join(destination,size);
+  await generateFromSource(await fs.readFile(fixture,'utf8'), {
+   configPath:path.resolve(__dirname,'../../test/fixtures/performance/config.yml'), filePath:fixture, outputDirectory:output,
+   fuse:{starterPackPath:path.join(generatorRoot,'fuse-starter-pack/fuse-v21.1')},
+  });
+  const modules=path.resolve(process.env.CRUDFORGE_BENCH_MODULES || path.join(__dirname,'../../e2e/.app/node_modules'));
+  if(!await fs.pathExists(path.join(output,'node_modules'))) await fs.symlink(modules,path.join(output,'node_modules'),'dir');
+ }
+})().catch(e=>{console.error(e);process.exitCode=1;});