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

package/src/templates/fuse-packs/access-control-tools/scan-access-control.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * @deprecated Prefer access-control-sync.js
+ * Thin wrapper kept for existing docs / habits.
+ */
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const syncScript = path.join(__dirname, 'access-control-sync.js');
+const result = spawnSync(process.execPath, [syncScript, '--write', '--access-only'], {
+  stdio: 'inherit',
+});
+process.exit(result.status ?? 1);

package/src/templates/generator/README.md

@@ -0,0 +1,12 @@
+# Generator issues
+
+Agents and developers should record generator issues in the `issues/` folder beside this README.
+
+Create one Markdown file per issue with a descriptive filename. Include:
+
+- A description of the problem and the expected behavior.
+- Steps to reproduce, including the schema and configuration involved.
+- Relevant errors, generated file paths, or screenshots.
+- The issue status and any proposed or completed fix.
+
+Do not include credentials or other secrets in issue reports.

package/src/templates/testing/ci.cjs

@@ -0,0 +1,45 @@
+// Shared commands for GitHub Actions or any CI runner. No credentials are required.
+const fs = require("fs");
+const { execFileSync } = require("child_process");
+const pkg = require("../../package.json");
+const files = {
+  npm: "package-lock.json",
+  pnpm: "pnpm-lock.yaml",
+  yarn: "yarn.lock",
+};
+const locks = Object.keys(files).filter((manager) =>
+  fs.existsSync(files[manager]),
+);
+const manager = pkg.packageManager?.split("@")[0] || locks[0];
+if (locks.length !== 1 || manager !== locks[0])
+  throw Error(
+    "Keep exactly one lockfile matching package.json packageManager.",
+  );
+const command = process.argv[2];
+const args =
+  command === "browsers"
+    ? manager === "npm"
+      ? ["exec", "--", "playwright", "install", "--with-deps", "chromium"]
+      : ["exec", "playwright", "install", "--with-deps", "chromium"]
+    : command === "install"
+      ? manager === "npm"
+        ? ["ci"]
+        : manager === "pnpm"
+          ? ["install", "--frozen-lockfile"]
+          : [
+              "install",
+              pkg.packageManager?.startsWith("yarn@1.")
+                ? "--frozen-lockfile"
+                : "--immutable",
+            ]
+      : command === "build"
+        ? ["run", "build"]
+        : command === "test"
+          ? ["run", "test:smoke"]
+          : null;
+if (!args)
+  throw Error("Usage: node tests/generated/ci.cjs install|build|browsers|test");
+execFileSync(manager, args, {
+  stdio: "inherit",
+  shell: process.platform === "win32",
+});

package/src/templates/testing/mock.cjs

@@ -0,0 +1,149 @@
+const { test: base, expect } = require("@playwright/test");
+const schema = require("./schema.json");
+const test = base.extend({
+  backend: async ({ page, context }, use) => {
+    const rows = {},
+      writes = [],
+      blocked = [];
+    const errors = [];
+    page.on("pageerror", (error) => errors.push(error.message));
+    await page.routeWebSocket("**/*", (socket) => {
+      if (new URL(socket.url()).origin === "ws://127.0.0.1:4297")
+        socket.connectToServer();
+      else socket.close();
+    });
+    let fail = false,
+      delay = 0;
+    for (const entity of schema.entities)
+      rows[entity.name] = Array.from({ length: 12 }, (_, i) =>
+        Object.fromEntries([
+          ["id", i + 1],
+          ...entity.fields.map((f) => [f.fieldName, f.value]),
+        ]),
+      );
+    for (const entity of schema.entities)
+      for (const row of rows[entity.name])
+        for (const rel of entity.relationships) {
+          const target = { ...rows[rel.target][0] };
+          row[rel.field] = rel.many ? [target] : target;
+        }
+    await context.route("**/*", async (route) => {
+      const request = route.request(),
+        url = new URL(request.url());
+      const entity = schema.entities.find(
+        (e) => url.pathname === e.url || url.pathname.startsWith(e.url + "/"),
+      );
+      if (entity) {
+        if (delay) await new Promise((r) => setTimeout(r, delay));
+        if (fail)
+          return route.fulfill({
+            status: 503,
+            json: { message: "Synthetic service unavailable" },
+          });
+        const collection = rows[entity.name],
+          id = Number(url.pathname.split("/").pop()),
+          method = request.method();
+        if (method === "POST") {
+          const data = {
+            ...request.postDataJSON(),
+            id: Math.max(...collection.map((r) => r.id)) + 1,
+          };
+          collection.push(data);
+          writes.push({ method, data });
+          return route.fulfill({ status: 201, json: data });
+        }
+        if (method === "PUT") {
+          const data = request.postDataJSON();
+          const at = collection.findIndex((r) => r.id === id);
+          collection[at] = data;
+          writes.push({ method, data });
+          return route.fulfill({ json: data });
+        }
+        if (method === "DELETE") {
+          rows[entity.name] = collection.filter((r) => r.id !== id);
+          return route.fulfill({ status: 204 });
+        }
+        if (method !== "GET") return route.fulfill({ status: 405 });
+        if (Number.isFinite(id)) {
+          const row = collection.find((r) => r.id === id);
+          return route.fulfill({ status: row ? 200 : 404, json: row || {} });
+        }
+        const start =
+            Number(url.searchParams.get("page") || 0) *
+            Number(url.searchParams.get("size") || 10),
+          size = Number(url.searchParams.get("size") || 10);
+        return route.fulfill({
+          headers: { "X-Total-Count": String(collection.length) },
+          json: collection.slice(start, start + size),
+        });
+      }
+      if (schema.auth && url.pathname.endsWith("/token")) {
+        const claims = {
+          sub: "smoke-user",
+          name: "Smoke User",
+          email: "smoke@example.test",
+          exp: Math.floor(Date.now() / 1000) + 3600,
+          realm_access: { roles: ["ROLE_ADMIN"] },
+        };
+        return route.fulfill({
+          json: {
+            access_token:
+              "test." +
+              Buffer.from(JSON.stringify(claims)).toString("base64url") +
+              ".test",
+            refresh_token: "test-only",
+            expires_in: 3600,
+          },
+        });
+      }
+      if (schema.auth && url.pathname.endsWith("/logout"))
+        return route.fulfill({ status: 204 });
+      if (
+        schema.auth &&
+        (url.pathname.includes("/services/keycloak-admin/") ||
+          /^\/admin\/realms\/[^/]+\/(users\/smoke-user|roles\/[^/]+)$/.test(
+            url.pathname,
+          ))
+      )
+        return route.fulfill({
+          json: { id: "smoke-user", enabled: true, attributes: {} },
+        });
+      const local = url.origin === "http://127.0.0.1:4297";
+      const asset =
+        /^(\/src\/|\/@|\/node_modules\/|\/assets\/|\/fonts\/|\/images\/|\/favicon|\/styles|\/main|\/chunk|\/polyfills)/.test(
+          url.pathname,
+        );
+      if (local && (asset || request.resourceType() === "document"))
+        return route.continue();
+      blocked.push(url.pathname);
+      return route.abort("blockedbyclient");
+    });
+    async function login(page) {
+      await page.goto("/auth/sign-in");
+      const username = page.getByLabel("Username or email");
+      if (schema.auth) {
+        await username.fill("smoke");
+        await page
+          .getByLabel("Password", { exact: true })
+          .fill("synthetic-only");
+      }
+      await page.getByRole("button", { name: "Sign in", exact: true }).click();
+      await page.waitForURL(/\/admin/);
+    }
+    await use({
+      rows,
+      writes,
+      blocked,
+      login,
+      setFailure: (value) => {
+        fail = value;
+      },
+      setDelay: (value) => {
+        delay = value;
+      },
+    });
+    expect(errors).toEqual([]);
+    expect(blocked.filter((url) => url !== "/do-not-send")).toEqual([]);
+  },
+});
+module.exports = { test, expect, schema };

package/src/templates/testing/playwright.config.cjs

@@ -0,0 +1,25 @@
+const { defineConfig } = require("@playwright/test");
+const path = require("path");
+module.exports = defineConfig({
+  testDir: path.resolve(__dirname, ".."),
+  testMatch: "**/*.spec.cjs",
+  workers: 1,
+  timeout: 30000,
+  outputDir: path.resolve(__dirname, "../../test-results"),
+  reporter: [["list"], ["html", { open: "never" }]],
+  use: {
+    baseURL: "http://127.0.0.1:4297",
+    serviceWorkers: "block",
+    screenshot: "only-on-failure",
+    trace: "off",
+    video: "off",
+    channel: process.env.CRUDFORGE_BROWSER_CHANNEL || undefined,
+  },
+  webServer: {
+    cwd: path.resolve(__dirname, "../.."),
+    command: "node tests/generated/serve.cjs",
+    url: "http://127.0.0.1:4297",
+    reuseExistingServer: false,
+    timeout: 180000,
+  },
+});

package/src/templates/testing/serve.cjs

@@ -0,0 +1,22 @@
+const { spawn } = require("child_process");
+const child = spawn(
+  process.execPath,
+  [
+    "node_modules/@angular/cli/bin/ng.js",
+    "serve",
+    "--configuration",
+    "crudforge-test",
+    "--host",
+    "127.0.0.1",
+  ],
+  {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      NG_BUILD_MAX_WORKERS: process.env.NG_BUILD_MAX_WORKERS || "2",
+    },
+  },
+);
+for (const signal of ["SIGTERM", "SIGINT"])
+  process.on(signal, () => child.kill(signal));
+child.on("exit", (code) => (process.exitCode = code || 0));

package/src/templates/testing/smoke.spec.cjs

@@ -0,0 +1,180 @@
+const { test, expect, schema } = require("./mock.cjs");
+test("application starts", async ({ page, backend }) => {
+  await backend.login(page);
+  await expect(page.locator("body")).toBeVisible();
+});
+if (schema.auth)
+  test("authenticated identity survives refresh", async ({ page, backend }) => {
+    await backend.login(page);
+    await expect(page.locator("user").first()).toContainText("Smoke User");
+    await page.reload();
+    await expect(page.locator("user").first()).toContainText("Smoke User");
+  });
+async function fill(form, entity, page) {
+  for (const field of entity.fields) {
+    const control = form.locator(`[formControlName="${field.fieldName}"]`);
+    if (!(await control.count())) continue;
+    if (field.fieldTypeIsEnum) {
+      await control.click();
+      await page
+        .getByRole("option", { name: String(field.value), exact: true })
+        .click();
+    } else if (field.fieldType === "Boolean") {
+      const input = control.locator("input");
+      await input.setChecked(!!field.value);
+    } else if (
+      ["LocalDate", "Instant", "ZonedDateTime"].includes(field.fieldType)
+    ) {
+      const date = new Date(field.value);
+      await control.fill(
+        `${date.getUTCMonth() + 1}/${date.getUTCDate()}/${date.getUTCFullYear()}`,
+      );
+      await control.press("Tab");
+    } else await control.fill(String(field.value));
+  }
+  for (const rel of entity.relationships) {
+    const select = form.locator(`[formControlName="${rel.field}"]`);
+    await select.click();
+    const option = page.getByRole("option").first();
+    await expect(option).toBeVisible();
+    if (!rel.many || (await option.getAttribute("aria-selected")) !== "true")
+      await option.click();
+    if (rel.many) await page.keyboard.press("Escape");
+  }
+}
+async function openEntity(page, entity) {
+  await page.goto("/admin/" + entity.slug);
+  await expect(
+    page.getByRole("heading", {
+      name: entity.name + " Management",
+      exact: true,
+    }),
+  ).toBeVisible();
+  const toggle = page.getByRole("button", { name: "Switch to Table View" });
+  if (await toggle.isVisible()) await toggle.click();
+}
+for (const entity of schema.entities) {
+  test(`${entity.name}: navigation and pagination`, async ({
+    page,
+    backend,
+  }) => {
+    await backend.login(page);
+    await openEntity(page, entity);
+    await expect(
+      page.getByRole("heading", {
+        name: entity.name + " Management",
+        exact: true,
+      }),
+    ).toBeVisible();
+    await expect(page.locator("td.mat-column-id").first()).toHaveText("1");
+    await page.getByRole("button", { name: "Next page" }).click();
+    await expect(page.locator("td.mat-column-id").first()).toHaveText("11");
+  });
+  test(`${entity.name}: create, required validation and edit`, async ({
+    page,
+    backend,
+  }) => {
+    await backend.login(page);
+    await openEntity(page, entity);
+    await page.getByRole("button", { name: "New", exact: true }).click();
+    let form = page
+      .locator("form")
+      .filter({ has: page.getByRole("button", { name: "Save", exact: true }) });
+    await expect(form).toBeVisible();
+    const required = entity.fields.find(
+      (f) =>
+        f.fieldValidateRules.includes("required") &&
+        ["String", "TextBlob", "Integer", "Long"].includes(f.fieldType),
+    );
+    if (required) {
+      await form.locator(`[formControlName="${required.fieldName}"]`).fill("");
+      await expect(
+        form.getByRole("button", { name: "Save", exact: true }),
+      ).toBeDisabled();
+    }
+    await fill(form, entity, page);
+    await expect(
+      form.getByRole("button", { name: "Save", exact: true }),
+    ).toBeEnabled();
+    backend.setFailure(true);
+    await form.getByRole("button", { name: "Save", exact: true }).click();
+    await expect(
+      form.getByText("Unable to save record. Please try again."),
+    ).toBeVisible();
+    backend.setFailure(false);
+    await form.getByRole("button", { name: "Save", exact: true }).click();
+    await expect
+      .poll(() => backend.writes.filter((w) => w.method === "POST").length)
+      .toBe(1);
+    await openEntity(page, entity);
+    await page
+      .locator(`button[matTooltip="Edit ${entity.name}"]`)
+      .first()
+      .click();
+    const confirm = page.getByRole("button", { name: "Confirm", exact: true });
+    if (await confirm.isVisible()) await confirm.click();
+    await expect(form).toBeVisible();
+    await fill(form, entity, page);
+    const textField = entity.fields.find(
+      (f) =>
+        String(f.value).length > 0 &&
+        ["String", "TextBlob"].includes(f.fieldType) &&
+        !f.fieldValidateRules.some((r) => r.startsWith("pattern(")),
+    );
+    if (textField) {
+      const changed = String(textField.value).replace(/./, "Z");
+      await form
+        .locator(`[formControlName="${textField.fieldName}"]`)
+        .fill(changed);
+    }
+    await form.getByRole("button", { name: "Save", exact: true }).click();
+    await expect
+      .poll(() => backend.writes.filter((w) => w.method === "PUT").length)
+      .toBe(1);
+    if (textField)
+      expect(
+        backend.writes.find((w) => w.method === "PUT").data[
+          textField.fieldName
+        ],
+      ).not.toBe(
+        backend.writes.find((w) => w.method === "POST").data[
+          textField.fieldName
+        ],
+      );
+  });
+  test(`${entity.name}: loading and failed request recovery`, async ({
+    page,
+    backend,
+  }) => {
+    await backend.login(page);
+    await openEntity(page, entity);
+    backend.setDelay(500);
+    await page.reload();
+    await expect(page.locator(".animate-pulse").first()).toBeVisible();
+    await expect(page.locator("td.mat-column-id").first()).toHaveText("1");
+    backend.setDelay(0);
+    backend.setFailure(true);
+    await page.reload();
+    await expect(page.locator("td.mat-column-id")).toHaveCount(0);
+    backend.setFailure(false);
+    await page.reload();
+    await expect(page.locator("td.mat-column-id").first()).toHaveText("1");
+  });
+}
+
+test("unmapped requests cannot reach a backend", async ({ page, backend }) => {
+  await backend.login(page);
+  const result = await page.evaluate(async () => {
+    try {
+      await fetch("https://unmapped-backend.invalid/do-not-send", {
+        method: "POST",
+        body: "synthetic",
+      });
+      return "unexpected";
+    } catch {
+      return "blocked";
+    }
+  });
+  expect(result).toBe("blocked");
+  expect(backend.blocked).toContain("/do-not-send");
+});

package/src/utils/branding.js

@@ -0,0 +1,39 @@
+const colors = require('./colors');
+const packageJson = require('../../package.json');
+
+const BANNER = `
+  ____ ____  _   _ ____  _____                     _      ___ 
+ / ___|  _ \\| | | |  _ \\|  ___|__  _ __ __ _  ___  | |    |_ _|
+| |   | |_) | | | | | | | |_ / _ \\| '__/ _\` |/ _ \\ | |     | | 
+| |___|  _ <| |_| | |_| |  _| (_) | | | (_| |  __/ | |___  | | 
+ \\____|_| \\_\\\\___/|____/|_|  \\___/|_|  \\__, |\\___| |_____|___|
+                                      |___/                  
+`;
+
+const DEVELOPER_INFO = "Developed by TeamCodeMe";
+const TEAMCODEME_URL = "https://www.teamcodeme.com/";
+
+function printBanner(config = {}) {
+  const brandingOpts = config.branding || {};
+  if (brandingOpts.banner === false) return;
+
+  const colorName = brandingOpts.bannerColor || 'green';
+  const bannerColorFn = colors[colorName] || colors.green;
+
+  console.log(bannerColorFn(BANNER));
+  console.log(colors.cyan(`                  ${DEVELOPER_INFO}`));
+  console.log(colors.dim(`                  ${TEAMCODEME_URL}\n`));
+}
+
+function printSuccessFooter() {
+  console.log(colors.cyan(`  ${DEVELOPER_INFO}  ·  ${TEAMCODEME_URL}\n`));
+}
+
+module.exports = {
+  BANNER,
+  DEVELOPER_INFO,
+  TEAMCODEME_URL,
+  printBanner,
+  printSuccessFooter,
+  version: packageJson.version
+};

package/src/utils/colors.js

@@ -0,0 +1,18 @@
+const NO_COLOR = process.env.NO_COLOR !== undefined;
+const IS_CI = process.env.CI !== undefined && process.env.CI !== 'false';
+const HAS_NO_TTY = !process.stdout.isTTY;
+
+// Enable color if not overridden by NO_COLOR, non-TTY, or CI (unless forced)
+const colorsEnabled = !NO_COLOR && !HAS_NO_TTY && (!IS_CI || process.env.FORCE_COLOR);
+
+const colors = {
+  green: (text) => colorsEnabled ? `\x1b[32m${text}\x1b[0m` : text,
+  cyan: (text) => colorsEnabled ? `\x1b[36m${text}\x1b[0m` : text,
+  yellow: (text) => colorsEnabled ? `\x1b[33m${text}\x1b[0m` : text,
+  bold: (text) => colorsEnabled ? `\x1b[1m${text}\x1b[0m` : text,
+  dim: (text) => colorsEnabled ? `\x1b[2m${text}\x1b[0m` : text,
+  red: (text) => colorsEnabled ? `\x1b[31m${text}\x1b[0m` : text,
+  colorsEnabled // Expose for testing
+};
+
+module.exports = colors;

package/src/utils/diff.js

@@ -0,0 +1,109 @@
+const colors = require('./colors');
+
+/**
+ * Computes line-level differences using Longest Common Subsequence (LCS).
+ * @param {string[]} oldLines 
+ * @param {string[]} newLines 
+ * @returns {object[]}
+ */
+function diffLines(oldLines, newLines) {
+  const n = oldLines.length;
+  const m = newLines.length;
+  
+  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (oldLines[i - 1] === newLines[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+  
+  const result = [];
+  let i = n, j = m;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      result.unshift({ type: 'common', value: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: 'added', value: newLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: 'removed', value: oldLines[i - 1] });
+      i--;
+    }
+  }
+  return result;
+}
+
+/**
+ * Formats a list of changes into a unified diff showing modifications and context.
+ * @param {string} oldText 
+ * @param {string} newText 
+ * @returns {object[]} - Formatted line objects.
+ */
+function formatDiff(oldText, newText) {
+  const oldLines = oldText.split(/\r?\n/);
+  const newLines = newText.split(/\r?\n/);
+  const diff = diffLines(oldLines, newLines);
+  
+  const lines = [];
+  const contextSize = 2; // Context lines to show around changes
+  
+  for (let idx = 0; idx < diff.length; idx++) {
+    const item = diff[idx];
+    if (item.type === 'added') {
+      lines.push({ type: 'added', text: `+ ${item.value}` });
+    } else if (item.type === 'removed') {
+      lines.push({ type: 'removed', text: `- ${item.value}` });
+    } else {
+      // Check if a change resides within the context window
+      const start = Math.max(0, idx - contextSize);
+      const end = Math.min(diff.length - 1, idx + contextSize);
+      let hasChangeNearby = false;
+      for (let k = start; k <= end; k++) {
+        if (diff[k].type !== 'common') {
+          hasChangeNearby = true;
+          break;
+        }
+      }
+      
+      if (hasChangeNearby) {
+        lines.push({ type: 'common', text: `  ${item.value}` });
+      } else {
+        if (lines.length > 0 && lines[lines.length - 1].type !== 'ellipsis') {
+          lines.push({ type: 'ellipsis', text: '  ...' });
+        }
+      }
+    }
+  }
+  return lines;
+}
+
+/**
+ * Colorizes a list of formatted diff lines.
+ * @param {object[]} diffLines 
+ * @returns {string}
+ */
+function colorizeDiff(diffLines) {
+  return diffLines.map(line => {
+    if (line.type === 'added') {
+      return colors.green(line.text);
+    } else if (line.type === 'removed') {
+      return colors.red(line.text);
+    } else if (line.type === 'ellipsis') {
+      return colors.dim(line.text);
+    } else {
+      return line.text;
+    }
+  }).join('\n');
+}
+
+module.exports = {
+  diffLines,
+  formatDiff,
+  colorizeDiff
+};