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

package/test/pmb-preset.js

@@ -0,0 +1,127 @@
+const assert = require('assert/strict');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+const YAML = require('yaml');
+const { extractPmbPreset } = require('../src/presets/pmb-test');
+const { validateProxyRoutes } = require('../src/config/proxy-routes');
+const cli = path.resolve(__dirname, '../cli.js');
+
+function hash(directory) {
+  return fs.readdirSync(directory).sort().map(name => {
+    const file = path.join(directory, name);
+    return fs.statSync(file).isDirectory() ? [name, hash(file)] : [name, crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')];
+  });
+}
+
+async function test() {
+  const temp = await fs.mkdtemp(path.join(os.tmpdir(), 'crudforge-preset-test-'));
+  const source = path.join(temp, 'source');
+  const app = path.join(temp, 'app');
+  const registry = path.join(temp, 'registry/crudforge/presets/pmb-test');
+  const env = { ...process.env, XDG_CONFIG_HOME: path.join(temp, 'registry'),
+    KEYCLOAK_ADMIN_USERNAME: 'ENV_USER_SENTINEL', KEYCLOAK_ADMIN_PASSWORD: 'ENV_PASSWORD_SENTINEL' };
+  const write = (file, content) => fs.outputFileSync(path.join(source, file), typeof content === 'string' ? content : JSON.stringify(content));
+  function run(cwd, args, success = true) {
+    const result = spawnSync(process.execPath, [cli, ...args], { cwd, env, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    assert.equal(result.status === 0, success, result.stdout + result.stderr);
+    return result.stdout + result.stderr;
+  }
+  try {
+    write('angular.json', { projects: { pmb: { architect: {
+      build: { configurations: { development: { fileReplacements: [{ replace: 'src/environments/environment.ts', with: 'src/environments/environment.development.ts' }] } } },
+      serve: { configurations: { development: { proxyConfig: 'proxy.dev.conf.json' } } },
+    } } } });
+    write('package.json', { scripts: { dev: 'ng serve --configuration development --proxy-config proxy.dev.conf.json --port=4217' } });
+    write('src/environments/environment.development.ts', `export const environment = {
+      useMockAuth: false, kcRealm: 'PMB-FIXTURE', kcClientId: 'public-client', kcClientSecret: '',
+      sso: '/realms/PMB-FIXTURE/protocol/openid-connect/token', kcUrl: '/realms/PMB-FIXTURE/protocol/openid-connect',
+      apiBaseUrl: '/', keycloakBaseUrl: '', sessionIdleTimeoutMs: 15 * 60 * 1000,
+      kcSpecialClientSecret: 'SECRET_SENTINEL', dadMockAuth: { password: 'PASSWORD_SENTINEL' },
+      neverExecute: (() => { throw new Error('source must not execute'); })(),
+    };`);
+    const proxy = {
+      '/realms': { target: 'http://localhost:30100', changeOrigin: true },
+      '/api/v1': { target: 'http://localhost:30100', changeOrigin: true, headers: { Authorization: 'TOKEN_SENTINEL' } },
+      '/pmb-referenceModule': { target: 'http://localhost:30101', secure: false, changeOrigin: false, ws: true,
+        pathRewrite: { '^/pmb-referenceModule': '/pmb-reference-module' } },
+      '/services/pmb-reference-module': { target: 'http://localhost:30101', pathRewrite: { '^/services/pmb-reference-module': '/pmb-reference-module' } },
+      '/services': { target: 'http://localhost:30102', pathRewrite: { '^/services': '' } },
+    };
+    write('proxy.dev.conf.json', proxy);
+    write('src/app/core/auth/auth.service.ts', `const SIGN_IN_OIDC_SCOPE = 'openid';
+      const ACCESS_TOKEN_EXPIRY_PROBE_INTERVAL_MS = 30 * 1000;
+      body.set('grant_type', 'password'); body.set('grant_type', 'refresh_token');
+      body.set('client_id', config.clientId); const logout = '/logout';`);
+    write('src/app/core/auth/auth.interceptor.ts', "headers.delete('X-Tenant-ID'); const bearer = `Bearer ${token}`;");
+    write('src/app/core/auth/access-control.service.ts', "readonly isUserAdmin = computed<boolean>(() => { return roles.some(role => role === 'PMB_ADMIN');\n});");
+    const entity = 'src/app/domains/admin/modules/apps/micro-functions/referenceModule/entities/province';
+    write(entity + '/province.model.ts', `export interface IProvince {
+      id?: number; index?: String | null; provinceCode?: String | null; provinceName?: String | null; isActive?: boolean | null;
+      createdBy?: String | null; createdDate?: dayjs.Dayjs | null; lastModifiedBy?: String | null; lastModifiedDate?: dayjs.Dayjs | null;
+    }`);
+    write(entity + '/service/province.service.ts', "protected resourceUrl = '/pmb-referenceModule/api/provinces';");
+    const sourceBefore = hash(source);
+    run(temp, ['init', app, '--preset', 'pmb-test', '--source', source]);
+    assert.deepEqual(hash(source), sourceBefore);
+    assert.deepEqual(fs.readdirSync(app).sort(), ['config', 'gdl']);
+    assert(fs.existsSync(path.join(registry, 'metadata.json')));
+    const input = fs.readFileSync(path.join(app, 'config/crudforge.config.yml'), 'utf8');
+    const config = YAML.parse(input);
+    const loaded = await require('../src/config/load-config').loadConfig(app, null, { projectPaths: true });
+    assert.deepEqual(loaded.config.auth.adminRoles, ['PMB_ADMIN']);
+    assert.equal(config.auth.realm, 'PMB-FIXTURE');
+    assert.equal(config.auth.session.idleTimeoutMs, 900000);
+    assert.equal(config.devServer.port, 4217);
+    assert.deepEqual(config.auth.adminRoles, ['PMB_ADMIN']);
+    assert.equal(config.auth.provision.enabled, false);
+    assert(!input.includes(source));
+    assert(!/SENTINEL/.test(input));
+    const beforeDuplicate = hash(registry);
+    run(temp, ['init', path.join(temp, 'duplicate'), '--preset', 'pmb-test', '--source', source], false);
+    assert.deepEqual(hash(registry), beforeDuplicate);
+    assert(!fs.existsSync(path.join(temp, 'duplicate')));
+
+    // Deleting the application and even removing the source does not lose the preset.
+    fs.removeSync(app);
+    fs.renameSync(source, source + '-offline');
+    run(temp, ['init', app, '--preset', 'pmb-test']);
+    assert.equal(fs.readFileSync(path.join(app, 'config/crudforge.config.yml'), 'utf8'), input);
+    run(app, ['generate']);
+    const generatedProxy = fs.readJsonSync(path.join(app, 'proxy.dev.conf.json'));
+    assert.equal(generatedProxy['/services/keycloak-admin'].pathRewrite['^/services/keycloak-admin'], '');
+    assert.equal(generatedProxy['/pmb-referenceModule'].changeOrigin, false);
+    assert.equal(generatedProxy['/pmb-referenceModule'].ws, true);
+    assert(Object.keys(generatedProxy).indexOf('/services/keycloak-admin') < Object.keys(generatedProxy).indexOf('/services'));
+    assert(!generatedProxy['/api/v1'].headers);
+    const service = fs.readFileSync(path.join(app, 'src/app/domains/admin/modules/apps/micro-functions/pmb-reference-module/entities/province/service/province.service.ts'), 'utf8');
+    assert(service.includes('/services/pmb-reference-module/api/provinces'));
+    const signIn = fs.readFileSync(path.join(app, 'src/app/domains/auth/features/sign-in/sign-in.ts'), 'utf8');
+    assert(!/SENTINEL/.test(signIn));
+    assert(signIn.includes("password: ''"));
+    assert.equal(fs.readJsonSync(path.join(app, 'angular.json')).projects.fuse.architect.serve.configurations.development.port, 4217);
+    assert.equal(fs.readFileSync(path.join(app, 'config/crudforge.config.yml'), 'utf8'), input);
+    assert(!fs.existsSync(path.join(app, 'src/app/core/user-management/user-management.routes.ts')));
+
+    fs.renameSync(source + '-offline', source);
+    proxy['/pmb-referenceModule'].target = 'http://localhost:30200';
+    write('proxy.dev.conf.json', proxy);
+    run(temp, ['preset', 'refresh', 'pmb-test', '--source', source]);
+    assert.equal(YAML.parse(fs.readFileSync(path.join(registry, 'config.yml'), 'utf8')).api.services['pmb-reference-module'].target, 'http://localhost:30200');
+    assert.equal(YAML.parse(fs.readFileSync(path.join(registry, 'config.yml'), 'utf8')).proxy.routes['/services/pmb-reference-module'].target, 'http://localhost:30200');
+    assert(fs.readdirSync(path.dirname(registry)).some(name => name.startsWith('pmb-test.backup-')));
+    assert.equal(fs.readFileSync(path.join(app, 'config/crudforge.config.yml'), 'utf8'), input);
+    const beforeFailedRefresh = hash(registry);
+    write('src/environments/environment.development.ts', 'export const environment = loadEnvironment();');
+    run(temp, ['preset', 'refresh', 'pmb-test', '--source', source], false);
+    assert.deepEqual(hash(registry), beforeFailedRefresh);
+    assert.throws(() => extractPmbPreset(source), /statically read/);
+    assert.throws(() => validateProxyRoutes({ '/api': { target: 'http://user:secret@localhost' } }), /without credentials/);
+    assert.throws(() => validateProxyRoutes({ '/api': { target: 'http://localhost', headers: {} } }), /unsupported option/);
+    console.log('PMB preset tests passed: extraction, source preservation, reuse, refresh/backup, secret exclusion, routing, and generation.');
+  } finally { await fs.remove(temp); }
+}
+
+test().catch(error => { console.error(error); process.exitCode = 1; });

package/test/project-workflow.js

@@ -0,0 +1,111 @@
+const assert = require('assert/strict');
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+const YAML = require('yaml');
+const cli = path.resolve(__dirname, '../cli.js');
+
+function run(cwd, args, succeeds = true) {
+  const result = spawnSync(process.execPath, [cli, ...args], { cwd, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  const output = result.stdout + result.stderr;
+  assert.equal(result.status === 0, succeeds, output);
+  return output;
+}
+
+function snapshot(dir) {
+  return Object.fromEntries(fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
+    const file = path.join(dir, entry.name);
+    if (entry.isDirectory()) return Object.entries(snapshot(file)).map(([key, value]) => [entry.name + '/' + key, value]);
+    return [[entry.name, crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')]];
+  }));
+}
+
+async function test() {
+  const sandbox = await fs.mkdtemp(path.join(os.tmpdir(), 'crudforge-workflow-test-'));
+  try {
+    const project = path.join(sandbox, 'project with spaces');
+    run(sandbox, ['init', project]);
+    assert.deepEqual(Object.keys(snapshot(project)).sort(), ['config/crudforge.config.yml', 'gdl/example.gdl']);
+    const configPath = path.join(project, 'config/crudforge.config.yml');
+    const schemaPath = path.join(project, 'gdl/example.gdl');
+    const config = YAML.parse(fs.readFileSync(configPath, 'utf8'));
+    assert.equal(config.input.file, './gdl/example.gdl');
+    assert.equal(config.output.directory, '.');
+    const original = snapshot(project);
+    run(sandbox, ['init', project], false);
+    assert.deepEqual(snapshot(project), original);
+    run(project, ['generate', '--dry-run']);
+    assert.deepEqual(snapshot(project), original);
+
+    const validConfig = fs.readFileSync(configPath, 'utf8');
+    for (const invalid of ['input: [', 'null', 'fuse: true', 'output:\n  directory: 42',
+      'output:\n  overwritePolicy: invalid', 'input:\n  file: missing.gdl']) {
+      fs.writeFileSync(configPath, invalid);
+      const before = snapshot(project);
+      const message = run(project, ['generate'], false);
+      assert(message.includes(configPath) || message.includes('missing.gdl'), message);
+      assert.deepEqual(snapshot(project), before);
+    }
+    fs.writeFileSync(configPath, validConfig);
+    const validGdl = fs.readFileSync(schemaPath, 'utf8');
+    fs.writeFileSync(schemaPath, 'entity Book {\n  nonexistent title\n}\n');
+    const invalidSchema = snapshot(project);
+    assert(run(project, ['generate'], false).includes(schemaPath));
+    assert.deepEqual(snapshot(project), invalidSchema);
+    fs.writeFileSync(schemaPath, validGdl);
+    run(sandbox, ['generate', '--preferences', 'missing.yml'], false);
+
+    // Generated settings and inputs must remain portable after moving the project.
+    const moved = path.join(sandbox, 'relocated');
+    fs.renameSync(project, moved);
+    run(sandbox, ['generate', '--preferences', path.join(moved, 'config/crudforge.config.yml')]);
+    assert(fs.existsSync(path.join(moved, 'angular.json')));
+    assert(fs.existsSync(path.join(moved, 'package.json')));
+    assert(fs.existsSync(path.join(moved, 'src/app/domains/admin/modules/apps/micro-functions/book-service/entities/book/book.model.ts')));
+    assert.equal(fs.readFileSync(path.join(moved, 'config/crudforge.config.yml'), 'utf8'), validConfig);
+    assert.equal(fs.readFileSync(path.join(moved, 'gdl/example.gdl'), 'utf8'), validGdl);
+    assert.equal(YAML.parse(fs.readFileSync(path.join(moved, '.crudforge/config.yaml'), 'utf8')).input.file, 'gdl/example.gdl');
+
+    const packagePath = path.join(moved, 'package.json');
+    const customized = fs.readFileSync(packagePath, 'utf8') + '\n';
+    fs.writeFileSync(packagePath, customized);
+    const beforeConflict = snapshot(moved);
+    assert(run(moved, ['generate'], false).includes(packagePath));
+    assert.deepEqual(snapshot(moved), beforeConflict);
+    run(moved, ['generate', '--overwrite-policy', 'ask'], false);
+    assert.deepEqual(snapshot(moved), beforeConflict);
+    run(moved, ['generate', '--overwrite-policy', 'skip']);
+    assert.equal(fs.readFileSync(packagePath, 'utf8'), customized);
+    run(moved, ['generate', '--overwrite-policy', 'overwrite']);
+    assert.notEqual(fs.readFileSync(packagePath, 'utf8'), customized);
+    assert.equal(fs.readFileSync(path.join(moved, 'config/crudforge.config.yml'), 'utf8'), validConfig);
+    assert.equal(fs.readFileSync(path.join(moved, 'gdl/example.gdl'), 'utf8'), validGdl);
+
+    const model = path.join(moved, 'src/app/domains/admin/modules/apps/micro-functions/book-service/entities/book/book.model.ts');
+    fs.writeFileSync(model, fs.readFileSync(model, 'utf8').replace(
+      '// cforge-custom-code-start:model-additions',
+      '// cforge-custom-code-start:model-additions\nexport const custom = 123;'));
+    run(moved, ['generate', '--overwrite-policy', 'merge']);
+    assert(fs.readFileSync(model, 'utf8').includes('export const custom = 123;'));
+
+    const image = path.join(moved, 'public/images/logo/logo.png');
+    fs.writeFileSync(image, Buffer.from([0, 1, 2]));
+    const beforeBinaryConflict = snapshot(moved);
+    run(moved, ['generate', '--overwrite-policy', 'merge'], false);
+    assert.deepEqual(snapshot(moved), beforeBinaryConflict);
+
+    const legacy = path.join(sandbox, 'legacy');
+    fs.ensureDirSync(legacy);
+    run(legacy, ['init-config']);
+    run(legacy, ['validate', 'example.gdl']);
+    run(legacy, ['generate', 'example.gdl', 'output', '--microservice', 'book-service']);
+    assert(fs.existsSync(path.join(legacy, 'output/entities/book/book.model.ts')));
+    console.log('Project workflow passed: init, edit, relocate, validate, generate, dry-run, conflict policies, and legacy CLI.');
+  } finally {
+    await fs.remove(sandbox);
+  }
+}
+
+test().catch(error => { console.error(error); process.exitCode = 1; });

package/test/quality-features.js

@@ -0,0 +1,250 @@
+const assert = require("node:assert/strict"),
+  fs = require("fs-extra"),
+  os = require("os"),
+  path = require("path"),
+  http = require("http");
+const { analyzeSchema } = require("../src/validator/diagnostics");
+const { diagnose, probe } = require("../src/commands/doctor");
+const { generateFromSource } = require("../src");
+const { generateProject } = require("../src/generator/project-output");
+const { spawnSync } = require("child_process");
+(async () => {
+  const root = await fs.mkdtemp(
+    path.join(os.tmpdir(), "crudforge-quality-regression-"),
+  );
+  try {
+    const invalid = [
+      ["entity A {\n string a\n string a\n}", "field-collision"],
+      ["entity A {\n thing a\n}", "unknown-type"],
+      ["entity A {\n string a min(3)\n}", "invalid-rule"],
+      [
+        "entity A {\n string a\n}\nrelationship ManyToOne {\n A{b} to Missing\n}",
+        "missing-entity",
+      ],
+      ["@SoftDelete entity A {\n string a\n}", "unsupported-annotation"],
+      ["entity A-B {\n string a\n}", "invalid-name"],
+      [
+        "entity FooBar {\n string a\n}\nentity Foo_Bar {\n string a\n}",
+        "output-collision",
+      ],
+      [
+        "enum State { X, X }\nentity A {\n State state\n}",
+        "duplicate-enum-value",
+      ],
+      [
+        "entity A {\n long bId\n}\nentity B {\n string name\n}\nrelationship ManyToOne {\n A{b} to B\n}",
+        "relationship-collision",
+      ],
+      ["entity A {\n string a", "syntax"],
+    ];
+    for (const [source, code] of invalid) {
+      const result = analyzeSchema(source, { isGdl: true, file: "input.gdl" });
+      assert.ok(
+        result.diagnostics.some((d) => d.code === code),
+        JSON.stringify(result),
+      );
+      assert.ok(
+        result.diagnostics.every(
+          (d) => d.file && d.line && d.column && d.suggestion,
+        ),
+      );
+    }
+    const valid =
+      "enum State { ACTIVE, INACTIVE }\nentity Item {\n string title required\n State state\n int quantity min(-2) max(10)\n}";
+    for (const kind of ["go-duck", "jhipster", "custom"]) {
+      const result = analyzeSchema(valid, {
+        isGdl: true,
+        config: { backend: { kind } },
+      });
+      assert.equal(
+        result.diagnostics.filter((d) => d.severity === "error").length,
+        0,
+      );
+      assert.ok(
+        result.diagnostics.some((d) => d.code === "backend-unverified"),
+      );
+    }
+    const input = path.join(root, "input.gdl");
+    await fs.writeFile(input, invalid[0][0]);
+    const cli = spawnSync(
+      process.execPath,
+      [path.resolve("cli.js"), "validate", input, "--json"],
+      { encoding: "utf8", cwd: root },
+    );
+    assert.equal(cli.status, 1);
+    assert.equal(JSON.parse(cli.stdout).ok, false);
+    const configPath = path.join(root, "crudforge.config.yml");
+    await fs.writeFile(
+      configPath,
+      "input:\n  file: input.gdl\n  type: gdl\nfuse:\n  enabled: true\n  cleanLayout: true\n  includePrebuilt: false\ngenerate:\n  globals:\n    tests: true\ntesting:\n  ci: true\napi:\n  microservice: example\n",
+    );
+    const output = path.join(root, "app");
+    const generateJson = spawnSync(
+      process.execPath,
+      [
+        path.resolve("cli.js"),
+        "generate",
+        input,
+        output,
+        "--preferences",
+        configPath,
+        "--json",
+        "--yes",
+      ],
+      { encoding: "utf8", cwd: root },
+    );
+    assert.equal(generateJson.status, 1);
+    assert.equal(JSON.parse(generateJson.stdout).ok, false);
+    const patternSchema =
+      "entity Item {\n string code required pattern(^[A-Z]{2}[0-9]{2}$) // code label\n}";
+    const patternResult = analyzeSchema(patternSchema, { isGdl: true });
+    assert.equal(
+      patternResult.parsed.entities[0].fields[0].fieldValidateRules[1],
+      "pattern(^[A-Z]{2}[0-9]{2}$)",
+    );
+    assert.equal(
+      patternResult.parsed.entities[0].fields[0].comment,
+      "code label",
+    );
+
+    await assert.rejects(
+      generateFromSource(invalid[0][0], {
+        fileType: "gdl",
+        configPath,
+        outputDirectory: output,
+      }),
+      /field-collision/,
+    );
+    assert.equal(await fs.pathExists(output), false);
+    await fs.writeFile(input, valid);
+    const result = await generateFromSource(valid, {
+      fileType: "gdl",
+      configPath,
+      outputDirectory: output,
+    });
+    for (const file of [
+      "tests/generated/smoke.spec.cjs",
+      "tests/generated/mock.cjs",
+      ".github/workflows/crudforge-smoke.yml",
+    ])
+      assert.ok(await fs.pathExists(path.join(output, file)));
+    assert.equal(await fs.pathExists(path.join(output, "tests/custom")), false);
+    const custom = path.join(output, "tests/custom/my.spec.cjs");
+    await fs.outputFile(custom, "// developer-owned");
+    const managed = path.join(output, "tests/generated/smoke.spec.cjs");
+    await fs.appendFile(managed, "\n// changed by developer");
+    result.config.output.overwritePolicy = "fail";
+    await assert.rejects(
+      generateProject(result.parsed, result.config),
+      /conflict|Existing/i,
+    );
+    assert.equal(await fs.readFile(custom, "utf8"), "// developer-owned");
+    assert.ok(
+      (await fs.readFile(managed, "utf8")).includes("changed by developer"),
+    );
+    const mock = await fs.readFile(
+      path.join(output, "tests/generated/mock.cjs"),
+      "utf8",
+    );
+    assert.match(mock, /route\.abort\(['"]blockedbyclient['"]\)/);
+    const pw = await fs.readFile(
+      path.join(output, "tests/generated/playwright.config.cjs"),
+      "utf8",
+    );
+    assert.match(pw, /reuseExistingServer:\s*false/);
+    assert.match(pw, /serviceWorkers:\s*['"]block['"]/);
+    const ciCode = await fs.readFile(
+      path.join(output, "tests/generated/ci.cjs"),
+      "utf8",
+    );
+    for (const [manager, version, flag] of [
+      ["npm", "10", "ci"],
+      ["pnpm", "10", "--frozen-lockfile"],
+      ["yarn", "1.22.0", "--frozen-lockfile"],
+      ["yarn", "4.0.0", "--immutable"],
+    ]) {
+      let called;
+      const locks = {
+        npm: "package-lock.json",
+        pnpm: "pnpm-lock.yaml",
+        yarn: "yarn.lock",
+      };
+      require("vm").runInNewContext(ciCode, {
+        process: { argv: ["node", "ci.cjs", "install"], platform: "linux" },
+        require: (name) =>
+          name === "fs"
+            ? { existsSync: (file) => file === locks[manager] }
+            : name === "child_process"
+              ? {
+                  execFileSync: (cmd, args) => {
+                    called = { cmd, args };
+                  },
+                }
+              : { packageManager: manager + "@" + version },
+      });
+      assert.equal(called.cmd, manager);
+      assert.ok(called.args.includes(flag));
+    }
+    const workflow = require("yaml").parse(
+      await fs.readFile(
+        path.join(output, ".github/workflows/crudforge-smoke.yml"),
+        "utf8",
+      ),
+    );
+    assert.ok(
+      workflow.jobs.smoke.steps.some(
+        (step) => step.run === "node tests/generated/ci.cjs build",
+      ),
+    );
+    assert.deepEqual(
+      (await fs.readJson(path.join(output, "tsconfig.smoke.json"))).files,
+      ["src/main.ts"],
+    );
+    const diagnosed = await diagnose({ cwd: root, nodeVersion: "18.0.0" });
+    assert.ok(
+      diagnosed.checks.some((c) => c.id === "node" && c.status === "fail"),
+    );
+    assert.ok(
+      diagnosed.checks.some((c) => c.id === "live" && c.status === "pass"),
+    );
+    await fs.writeFile(configPath, "password: secret-do-not-print\ninput: [");
+    const malformed = await diagnose({ cwd: root });
+    assert.equal(malformed.ok, false);
+    assert.ok(!JSON.stringify(malformed).includes("secret-do-not-print"));
+    const server = http.createServer((req, res) => {
+      if (req.url === "/timeout") return;
+      res.writeHead(Number(req.url.slice(1)) || 200);
+      res.end();
+    });
+    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    const base = "http://127.0.0.1:" + server.address().port;
+    try {
+      for (const status of [200, 401, 403, 500]) {
+        const result = await probe(base + "/" + status, 500);
+        assert.equal(
+          result.status,
+          status === 200 ? "pass" : status < 500 ? "warning" : "fail",
+        );
+      }
+      const start = Date.now();
+      const timed = await probe(base + "/timeout", 100);
+      assert.match(timed.message, /timed out/);
+      assert.ok(Date.now() - start < 1500);
+      assert.equal(
+        (await probe("http://user:password@localhost/health")).status,
+        "fail",
+      );
+    } finally {
+      server.closeAllConnections?.();
+      await new Promise((r) => server.close(r));
+    }
+    console.log(
+      "Quality feature regressions passed: diagnostics, CLI JSON, fail-fast output, backend labels, generated tests/CI, custom preservation, local doctor and bounded live probes.",
+    );
+  } finally {
+    await fs.remove(root);
+  }
+})().catch((e) => {
+  console.error(e);
+  process.exitCode = 1;
+});

package/test/verify-commands.js

@@ -0,0 +1,83 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+async function verifyCommands() {
+  console.log('🧪 Starting CRUDForge CLI Commands Verification Tests...');
+
+  const cwd = process.cwd();
+  const cliPath = path.join(__dirname, '..', 'cli.js');
+  const tmpDir = path.join(__dirname, 'tmp-cli');
+  
+  // Clean up
+  await fs.remove(tmpDir);
+  await fs.ensureDir(tmpDir);
+
+  try {
+    console.log('🧪 Testing "crud-forge init-config"...');
+    execSync(`node ${cliPath} init-config`, { cwd: tmpDir, stdio: 'inherit' });
+
+    // Verify files created
+    const configExists = await fs.pathExists(path.join(tmpDir, 'crudforge.config.yml'));
+    const jdlExists = await fs.pathExists(path.join(tmpDir, 'example.jdl'));
+    const gdlExists = await fs.pathExists(path.join(tmpDir, 'example.gdl'));
+
+    if (!configExists || !jdlExists || !gdlExists) {
+      throw new Error('❌ init-config failed: Did not create all expected files.');
+    }
+    console.log('✅ init-config generated files successfully.');
+
+    console.log('🧪 Testing "crud-forge validate <file>"...');
+    execSync(`node ${cliPath} validate example.jdl`, { cwd: tmpDir, stdio: 'inherit' });
+    console.log('✅ validate passed on valid JDL.');
+
+    console.log('🧪 Testing Granular Configuration Entity-Only Generation...');
+    // We modify the generated config to turn off models and list components
+    const configPath = path.join(tmpDir, 'crudforge.config.yml');
+    let configStr = await fs.readFile(configPath, 'utf8');
+    
+    // Disable models and list components
+    configStr = configStr.replace('models: true', 'models: false');
+    configStr = configStr.replace('list: true', 'list: false');
+    
+    // Ensure fuse is disabled
+    configStr = configStr.replace('enabled: true', 'enabled: false');
+    
+    await fs.writeFile(configPath, configStr);
+
+    const outDir = path.join(tmpDir, 'output');
+    
+    // Run generation
+    execSync(`node ${cliPath} example.jdl ${outDir} -m test-service`, { cwd: tmpDir, stdio: 'inherit' });
+
+    // Verify models were skipped
+    const bookModelExists = await fs.pathExists(path.join(outDir, 'entities', 'book', 'book.model.ts'));
+    if (bookModelExists) {
+      throw new Error('❌ Granular configuration failed: Generated book.model.ts even though config.generate.models is false.');
+    }
+
+    // Verify list component was skipped
+    const bookListExists = await fs.pathExists(path.join(outDir, 'entities', 'book', 'components', 'presentation', 'list', 'book-list.component.ts'));
+    if (bookListExists) {
+      throw new Error('❌ Granular configuration failed: Generated book-list.component.ts even though config.generate.components.list is false.');
+    }
+    
+    // Verify services still generated
+    const bookServiceExists = await fs.pathExists(path.join(outDir, 'entities', 'book', 'service', 'book.service.ts'));
+    if (!bookServiceExists) {
+      throw new Error('❌ Granular configuration failed: Missing book.service.ts, which should have generated.');
+    }
+
+    console.log('✅ Granular entity-only generation behaves correctly (skips excluded files).');
+
+    console.log('🎉 SUCCESS: All Command Verification Tests Passed!');
+  } finally {
+    // Cleanup tmp dir
+    await fs.remove(tmpDir);
+  }
+}
+
+verifyCommands().catch(err => {
+  console.error(err.message || err);
+  process.exit(1);
+});