stackloom-cli 1.0.0

package/src/engine/pipeline.js

@@ -0,0 +1,138 @@
+/**
+ * Pipeline — composable generation as an ordered list of small steps.
+ *
+ * Generation is not a god-class with a dozen methods; it is a sequence of
+ * independently testable steps that pass one accumulating context object
+ * along. New capabilities are new steps, not new branches. The standard
+ * transactional pipeline is:
+ *
+ *   plan → render → validate → commit
+ *
+ * render-to-temp, validate-everything, then atomic-commit — so a syntactically
+ * broken file is caught before anything touches the project.
+ */
+import { FileTransaction, realFs } from "./transaction.js";
+import { Validator } from "./validator.js";
+import { Injector } from "./injector.js";
+
+export class Pipeline {
+  constructor(steps = []) {
+    this.steps = [...steps];
+  }
+
+  /** Append a step. */
+  use(step) {
+    this.steps.push(step);
+    return this;
+  }
+
+  /** Run every step in order, threading `context` through. Returns the context. */
+  async run(context = {}) {
+    for (const step of this.steps) {
+      if (!step || typeof step.run !== "function") {
+        throw new Error(`Pipeline step "${step?.name ?? "?"}" has no run() method`);
+      }
+      await step.run(context);
+    }
+    return context;
+  }
+}
+
+/** Build a named step. */
+export function defineStep(name, run) {
+  return { name, run };
+}
+
+/** Resolve the recipe manifest into a concrete plan for this invocation. */
+export const planStep = defineStep("plan", (context) => {
+  const { recipe, blueprint, projectRoot, recipeContext = {}, vars = {} } = context;
+  if (!recipe) throw new Error("Generation pipeline: context.recipe is required");
+  context.plan = recipe.plan({ context: recipeContext, blueprint, projectRoot, vars });
+});
+
+/** Render each planned file and stage it in a transaction — nothing written yet. */
+export function createRenderStep({ renderer, fs = realFs }) {
+  if (typeof renderer !== "function") {
+    throw new Error("createRenderStep requires a renderer(templatePath, context) function");
+  }
+  return defineStep("render", async (context) => {
+    const { projectRoot, plan, templateContext = {} } = context;
+    const transaction = new FileTransaction({ projectRoot, fs });
+    for (const file of plan.files) {
+      const content = await renderer(file.template, templateContext);
+      transaction.stage(file.out, content);
+    }
+    context.transaction = transaction;
+  });
+}
+
+/**
+ * Render each recipe `inject` snippet and splice it into the project's anchor
+ * files, staging the modified files into the same transaction. Idempotent.
+ */
+export function createInjectStep({ renderer, injector }) {
+  if (typeof renderer !== "function") {
+    throw new Error("createInjectStep requires a renderer(templatePath, context) function");
+  }
+  const inj = injector ?? new Injector();
+  return defineStep("inject", async (context) => {
+    const { plan, blueprint, projectRoot, transaction, templateContext = {} } = context;
+    context.injections = [];
+    for (const entry of plan.inject || []) {
+      const snippet = await renderer(entry.template, templateContext);
+      context.injections.push(
+        inj.inject({ anchorName: entry.anchor, snippet, blueprint, projectRoot, transaction }),
+      );
+    }
+  });
+}
+
+/** Validate every staged file; abort the whole generation on any failure. */
+export function createValidateStep({ validator = new Validator() } = {}) {
+  return defineStep("validate", (context) => {
+    const result = validator.validateAll(context.transaction.staged());
+    context.validation = result;
+    if (!result.ok) {
+      const detail = result.failures.map((f) => `  • ${f.relPath}: ${f.message}`).join("\n");
+      throw new Error(
+        `Generation aborted — ${result.failures.length} file(s) failed validation:\n${detail}`,
+      );
+    }
+  });
+}
+
+/** Commit the transaction — or, in dry-run, just record the plan. */
+export const commitStep = defineStep("commit", (context) => {
+  const { transaction, dryRun } = context;
+  context.result = dryRun
+    ? { dryRun: true, files: transaction.plan() }
+    : { dryRun: false, files: transaction.commit() };
+});
+
+/**
+ * Compose the standard transactional generation pipeline:
+ *   plan → render → inject → validate → commit
+ * Rendering is injected so the engine never depends on a specific template
+ * library. Pass `withInject: false` to skip anchor injection (e.g. recipes that
+ * only emit standalone files, or tests exercising render/commit in isolation).
+ * @param {object} args
+ * @param {(templatePath:string, context:object) => Promise<string>|string} args.renderer
+ * @param {Validator} [args.validator]
+ * @param {Injector} [args.injector]
+ * @param {typeof realFs} [args.fs]
+ * @param {boolean} [args.withInject=true]
+ */
+export function createGenerationPipeline({
+  renderer,
+  validator,
+  injector,
+  fs = realFs,
+  withInject = true,
+} = {}) {
+  const steps = [planStep, createRenderStep({ renderer, fs })];
+  if (withInject) {
+    steps.push(createInjectStep({ renderer, injector: injector ?? new Injector({ fs }) }));
+  }
+  steps.push(createValidateStep({ validator }), commitStep);
+  return new Pipeline(steps);
+}

package/src/engine/transaction.js

@@ -0,0 +1,105 @@
+/**
+ * FileTransaction — atomic, all-or-nothing file writes.
+ *
+ * Generation stages every file here first; nothing touches the project until
+ * `commit()`. If any write fails mid-commit, every file already written in this
+ * commit is rolled back (prior contents restored, freshly-created files
+ * removed). A half-generated project is never left behind.
+ *
+ * The `fs` adapter is injected, so tests can drive failure paths deterministically.
+ */
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+} from "node:fs";
+import path from "node:path";
+
+/** Default adapter — the real filesystem. */
+export const realFs = { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync };
+
+export class FileTransaction {
+  /**
+   * @param {object} args
+   * @param {string} args.projectRoot - absolute root all staged paths are relative to
+   * @param {typeof realFs} [args.fs] - filesystem adapter (injectable for tests)
+   */
+  constructor({ projectRoot, fs = realFs }) {
+    if (!projectRoot) throw new Error("FileTransaction requires a projectRoot");
+    this.projectRoot = projectRoot;
+    this.fs = fs;
+    this._staged = [];
+    this._committed = false;
+  }
+
+  /**
+   * Stage a file's final content (relative to projectRoot). Upsert semantics —
+   * re-staging the same path replaces it, so successive injections into one
+   * file compose correctly.
+   */
+  stage(relPath, content) {
+    if (this._committed) throw new Error("Cannot stage on an already-committed transaction");
+    const existing = this._staged.find((file) => file.relPath === relPath);
+    if (existing) existing.content = content;
+    else this._staged.push({ relPath, content });
+    return this;
+  }
+
+  /** Latest staged content for a path, or undefined if it has not been staged. */
+  get(relPath) {
+    const entry = this._staged.find((file) => file.relPath === relPath);
+    return entry ? entry.content : undefined;
+  }
+
+  /** Staged files annotated with the action they would perform. */
+  staged() {
+    return this._staged.map((file) => ({
+      relPath: file.relPath,
+      content: file.content,
+      action: this.fs.existsSync(path.join(this.projectRoot, file.relPath))
+        ? "update"
+        : "create",
+    }));
+  }
+
+  /** Dry-run preview — paths + actions, no content, nothing written. */
+  plan() {
+    return this.staged().map(({ relPath, action }) => ({ relPath, action }));
+  }
+
+  /**
+   * Write every staged file. On any failure, roll back all writes from this
+   * commit and rethrow. Returns the journal of applied changes on success.
+   */
+  commit() {
+    if (this._committed) throw new Error("Transaction already committed");
+    const journal = [];
+    try {
+      for (const file of this._staged) {
+        const abs = path.join(this.projectRoot, file.relPath);
+        const existed = this.fs.existsSync(abs);
+        const backup = existed ? this.fs.readFileSync(abs) : null;
+        this.fs.mkdirSync(path.dirname(abs), { recursive: true });
+        this.fs.writeFileSync(abs, file.content);
+        journal.push({ abs, existed, backup });
+      }
+    } catch (err) {
+      for (const entry of journal.reverse()) {
+        try {
+          if (entry.existed) this.fs.writeFileSync(entry.abs, entry.backup);
+          else this.fs.rmSync(entry.abs, { force: true });
+        } catch {
+          // best-effort rollback — surface the original failure regardless
+        }
+      }
+      throw err;
+    }
+    this._committed = true;
+    return journal.map((entry) => ({
+      relPath: path.relative(this.projectRoot, entry.abs),
+      action: entry.existed ? "update" : "create",
+    }));
+  }
+}

package/src/engine/validator.js

@@ -0,0 +1,190 @@
+/**
+ * Validator — the pre-commit gate that makes "error-free code" a guarantee.
+ *
+ * Every staged file is checked before the transaction is allowed to commit; a
+ * single failure aborts the whole generation, so a syntactically broken file
+ * never reaches the project.
+ *
+ * Strategies are pluggable per file extension. The shipped default for code is
+ * `scanDelimiters` — a dependency-free balanced-delimiter scanner that catches
+ * the real bug class (stray code, unbalanced braces/parens, unterminated
+ * strings). It is a heuristic, not a full parser: a `@babel/parser` / `tsc`
+ * strategy can be registered when those deps are available, without touching
+ * any caller.
+ */
+import path from "node:path";
+
+/**
+ * Punctuation after which a `/` begins a regex literal rather than division.
+ * `<` and `>` are deliberately excluded: in JSX `</Tag>` and `/>` are far more
+ * common than a regex following a comparison operator.
+ */
+const REGEX_PRECEDERS = new Set("([{,;:=!&|?+-*%~^".split(""));
+
+/**
+ * Scan source for balanced (), [], {} — aware of strings, template literals,
+ * comments and regex literals. Returns `{ balanced, error? }`.
+ *
+ * Known heuristic limits: template-literal `${}` interiors are treated as
+ * opaque, and JSX angle brackets are not tracked.
+ */
+export function scanDelimiters(src) {
+  const closeToOpen = { ")": "(", "]": "[", "}": "{" };
+  const openers = new Set(["(", "[", "{"]);
+  const stack = [];
+  let prev = "";
+  let i = 0;
+  const n = src.length;
+
+  while (i < n) {
+    const c = src[i];
+    const next = src[i + 1];
+
+    if (c === "/" && next === "/") {
+      i += 2;
+      while (i < n && src[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      if (i >= n) return { balanced: false, error: "Unterminated block comment" };
+      i += 2;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      i++;
+      while (i < n && src[i] !== c) {
+        if (src[i] === "\\") i++;
+        i++;
+      }
+      if (i >= n) return { balanced: false, error: "Unterminated string literal" };
+      i++;
+      prev = c;
+      continue;
+    }
+    if (c === "`") {
+      i++;
+      while (i < n && src[i] !== "`") {
+        if (src[i] === "\\") i++;
+        i++;
+      }
+      if (i >= n) return { balanced: false, error: "Unterminated template literal" };
+      i++;
+      prev = "`";
+      continue;
+    }
+    if (c === "/" && (prev === "" || REGEX_PRECEDERS.has(prev))) {
+      i++;
+      let inClass = false;
+      while (i < n) {
+        const r = src[i];
+        if (r === "\\") {
+          i += 2;
+          continue;
+        }
+        if (r === "[") inClass = true;
+        else if (r === "]") inClass = false;
+        else if (r === "/" && !inClass) break;
+        else if (r === "\n") return { balanced: false, error: "Unterminated regex literal" };
+        i++;
+      }
+      if (i >= n) return { balanced: false, error: "Unterminated regex literal" };
+      i++;
+      prev = "/";
+      continue;
+    }
+    if (c === " " || c === "\t" || c === "\r" || c === "\n") {
+      i++;
+      continue;
+    }
+    if (openers.has(c)) {
+      stack.push({ c, i });
+      prev = c;
+      i++;
+      continue;
+    }
+    if (closeToOpen[c]) {
+      const top = stack.pop();
+      if (!top || top.c !== closeToOpen[c]) {
+        return { balanced: false, error: `Unexpected "${c}" at index ${i}` };
+      }
+      prev = c;
+      i++;
+      continue;
+    }
+    prev = c;
+    i++;
+  }
+
+  if (stack.length) {
+    const top = stack[stack.length - 1];
+    return { balanced: false, error: `Unclosed "${top.c}" at index ${top.i}` };
+  }
+  return { balanced: true };
+}
+
+/** Code strategy: non-empty + balanced delimiters. */
+function codeStrategy(file) {
+  if (!file.content || !file.content.trim()) {
+    return { ok: false, relPath: file.relPath, message: "Generated file is empty" };
+  }
+  const scan = scanDelimiters(file.content);
+  if (!scan.balanced) {
+    return { ok: false, relPath: file.relPath, message: scan.error };
+  }
+  return { ok: true, relPath: file.relPath };
+}
+
+/** JSON strategy: must parse. */
+function jsonStrategy(file) {
+  try {
+    JSON.parse(file.content);
+    return { ok: true, relPath: file.relPath };
+  } catch (err) {
+    return { ok: false, relPath: file.relPath, message: `Invalid JSON: ${err.message}` };
+  }
+}
+
+/** Unknown extensions pass — only registered types are gated. */
+function passStrategy(file) {
+  return { ok: true, relPath: file.relPath };
+}
+
+const DEFAULT_STRATEGIES = {
+  js: codeStrategy,
+  cjs: codeStrategy,
+  mjs: codeStrategy,
+  jsx: codeStrategy,
+  ts: codeStrategy,
+  tsx: codeStrategy,
+  json: jsonStrategy,
+};
+
+export class Validator {
+  /**
+   * @param {object} [options]
+   * @param {Record<string, (file:{relPath:string,content:string}) => {ok:boolean}>} [options.strategies]
+   *   Extra/override strategies keyed by extension (no dot).
+   */
+  constructor({ strategies = {} } = {}) {
+    this.strategies = { ...DEFAULT_STRATEGIES, ...strategies };
+  }
+
+  /** Validate one staged file. */
+  validateFile(file) {
+    const ext = path.extname(file.relPath).slice(1).toLowerCase();
+    const strategy = this.strategies[ext] || passStrategy;
+    return strategy(file);
+  }
+
+  /** Validate every staged file. Returns `{ ok, failures }`. */
+  validateAll(files) {
+    const failures = [];
+    for (const file of files) {
+      const result = this.validateFile(file);
+      if (!result.ok) failures.push(result);
+    }
+    return { ok: failures.length === 0, failures };
+  }
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export { default as init } from "./commands/init.js";
+export { default as generate } from "./commands/generate/index.js";
+export { default as preset } from "./commands/preset.js";
+export { default as finalize } from "./commands/finalize.js";

package/src/recipes/__tests__/recipe.test.js

@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest";
+import os from "node:os";
+import { evaluateCondition, recipeLoader, RecipeLoadError } from "../index.js";
+import { blueprintLoader } from "../../blueprint/index.js";
+
+describe("evaluateCondition", () => {
+  it("resolves identifiers (missing = falsy)", () => {
+    expect(evaluateCondition("withFrontend", { withFrontend: true })).toBe(true);
+    expect(evaluateCondition("withFrontend", {})).toBe(false);
+  });
+
+  it("treats empty/missing expressions as always-true", () => {
+    expect(evaluateCondition("", {})).toBe(true);
+    expect(evaluateCondition(undefined, {})).toBe(true);
+  });
+
+  it("supports !, &&, ||, ==, != and parentheses", () => {
+    expect(evaluateCondition("!withFrontend", { withFrontend: false })).toBe(true);
+    expect(evaluateCondition("a && b", { a: true, b: false })).toBe(false);
+    expect(evaluateCondition("a || b", { a: false, b: true })).toBe(true);
+    expect(evaluateCondition('architecture == "advanced"', { architecture: "advanced" })).toBe(true);
+    expect(evaluateCondition('architecture != "advanced"', { architecture: "moderate" })).toBe(true);
+    expect(evaluateCondition("(a || b) && c", { a: true, b: false, c: false })).toBe(false);
+  });
+
+  it("allows : in identifiers (hasField:slug)", () => {
+    expect(evaluateCondition("hasField:slug", { "hasField:slug": true })).toBe(true);
+  });
+
+  it("rejects malformed expressions", () => {
+    expect(() => evaluateCondition("a &&", {})).toThrow();
+    expect(() => evaluateCondition("(a || b", {})).toThrow();
+    expect(() => evaluateCondition("a == == b", {})).toThrow();
+  });
+});
+
+describe("RecipeLoader", () => {
+  it("loads the built-in resource recipe", async () => {
+    const recipe = await recipeLoader.load("resource");
+    expect(recipe.name).toBe("resource");
+    expect(recipe.data.files.length).toBe(14);
+    expect(recipe.data.inject.length).toBe(4);
+    expect(recipe.data.requires.length).toBe(1);
+  });
+
+  it("loads the module and page recipes", async () => {
+    expect((await recipeLoader.load("module")).name).toBe("module");
+    expect((await recipeLoader.load("page")).name).toBe("page");
+  });
+
+  it("rejects an unknown recipe", async () => {
+    await expect(recipeLoader.load("nope-not-real")).rejects.toThrow(RecipeLoadError);
+  });
+});
+
+describe("Recipe.plan", () => {
+  it("applies declared param defaults", async () => {
+    const recipe = await recipeLoader.load("resource");
+    const plan = recipe.plan({ context: {} });
+    expect(plan.context.withFrontend).toBe(true);
+    expect(plan.context.withTests).toBe(false);
+    expect(plan.context.architecture).toBe("moderate");
+    expect(plan.context.formMode).toBe("page");
+  });
+
+  it("filters files/inject/requires by `when` and renders out paths", async () => {
+    const recipe = await recipeLoader.load("resource");
+    const blueprint = await blueprintLoader.load(os.tmpdir());
+    const vars = { kebab: "order", Name: "Order" };
+
+    const backendOnly = recipe.plan({
+      context: { withFrontend: false },
+      blueprint,
+      projectRoot: os.tmpdir(),
+      vars,
+    });
+    expect(backendOnly.files.length).toBe(5);
+    expect(backendOnly.inject.length).toBe(1);
+    expect(backendOnly.requires.length).toBe(0);
+    expect(backendOnly.files[0].out).toBe("backend/src/modules/order/models/Order.js");
+
+    const full = recipe.plan({
+      context: { withFrontend: true, withTests: true, "hasField:slug": true },
+      blueprint,
+      projectRoot: os.tmpdir(),
+      vars,
+    });
+    expect(full.files.length).toBe(13);
+    expect(full.inject.length).toBe(4);
+    expect(full.requires).toEqual([
+      { scope: "backend", package: "slugify", version: "^1.6.6" },
+    ]);
+  });
+
+  it("emits the types file only for TypeScript projects", async () => {
+    const recipe = await recipeLoader.load("resource");
+    const blueprint = await blueprintLoader.load(os.tmpdir());
+    const plan = recipe.plan({
+      context: { withFrontend: true, usesTypeScript: true },
+      blueprint,
+      projectRoot: os.tmpdir(),
+      vars: { kebab: "order", Name: "Order" },
+    });
+    expect(plan.files.some((f) => f.out.endsWith("types/order.types.ts"))).toBe(true);
+  });
+
+  it("lets formMode select the page-shell template", async () => {
+    const recipe = await recipeLoader.load("resource");
+    const blueprint = await blueprintLoader.load(os.tmpdir());
+    const planFor = (formMode) =>
+      recipe.plan({
+        context: { withFrontend: true, formMode },
+        blueprint,
+        projectRoot: os.tmpdir(),
+        vars: { kebab: "order", Name: "Order" },
+      });
+
+    for (const mode of ["page", "modal", "sidepanel", "inline"]) {
+      const plan = planFor(mode);
+      const shell = plan.files.find((f) => f.out.endsWith("ListPage.jsx"));
+      expect(shell.template).toBe(`resource/page-${mode}.jsx.ejs`);
+    }
+
+    // The dedicated routed form page exists only for "page" mode.
+    expect(planFor("page").files.some((f) => f.out.endsWith("FormPage.jsx"))).toBe(true);
+    expect(planFor("modal").files.some((f) => f.out.endsWith("FormPage.jsx"))).toBe(false);
+  });
+});

package/src/recipes/builtin/module.json

@@ -0,0 +1,22 @@
+{
+  "name": "module",
+  "description": "Backend-only module: Mongoose model, service, controller, routes, validator. No frontend.",
+  "params": {
+    "withTests": { "type": "boolean", "default": false, "description": "Generate backend test files." },
+    "architecture": { "type": "string", "default": "moderate", "description": "lightweight | moderate | advanced." }
+  },
+  "files": [
+    { "template": "resource/model.js.ejs", "out": "{@backend.modules}/{kebab}/models/{Name}.js" },
+    { "template": "resource/service.js.ejs", "out": "{@backend.modules}/{kebab}/services/{Name}.service.js", "when": "architecture != \"lightweight\"" },
+    { "template": "resource/controller.js.ejs", "out": "{@backend.modules}/{kebab}/controllers/{Name}.controller.js" },
+    { "template": "resource/routes.js.ejs", "out": "{@backend.modules}/{kebab}/routes/{Name}.routes.js" },
+    { "template": "resource/validator.js.ejs", "out": "{@backend.validators}/{Name}.validator.js" },
+    { "template": "resource/test.ejs", "out": "{@backend.modules}/{kebab}/tests/{Name}.test.js", "when": "architecture != \"lightweight\" && (withTests || architecture == \"advanced\")" }
+  ],
+  "inject": [
+    { "anchor": "backend.routes", "template": "snippets/route-mount.ejs" }
+  ],
+  "requires": [
+    { "scope": "backend", "package": "slugify", "version": "^1.6.6", "when": "hasField:slug || hasField:code || hasField:sku" }
+  ]
+}

package/src/recipes/builtin/page.json

@@ -0,0 +1,21 @@
+{
+  "name": "page",
+  "description": "Frontend admin page wired to an existing backend resource: list page plus optional table/form components and API client.",
+  "params": {
+    "withForm": { "type": "boolean", "default": true, "description": "Generate a form component for create/edit." },
+    "withApi": { "type": "boolean", "default": true, "description": "Generate the API client module." },
+    "formMode": { "type": "string", "default": "page", "description": "page | modal | sidepanel | inline — how the form is mounted." }
+  },
+  "files": [
+    { "template": "resource/page-{formMode}.jsx.ejs", "out": "{@frontend.adminPages}/{kebab}/ListPage.jsx" },
+    { "template": "resource/components/table.jsx.ejs", "out": "{@frontend.components}/tables/{Name}Table.jsx" },
+    { "template": "resource/components/form.jsx.ejs", "out": "{@frontend.components}/forms/{Name}Form.jsx", "when": "withForm" },
+    { "template": "resource/api.js.ejs", "out": "{@frontend.api}/{kebab}.api.js", "when": "withApi" }
+  ],
+  "inject": [
+    { "anchor": "frontend.lazyImports", "template": "snippets/lazy-import.ejs" },
+    { "anchor": "frontend.routes", "template": "snippets/route-entry.ejs" },
+    { "anchor": "frontend.nav", "template": "snippets/nav-entry.ejs" }
+  ],
+  "requires": []
+}

package/src/recipes/builtin/resource.json

@@ -0,0 +1,35 @@
+{
+  "name": "resource",
+  "description": "Full-stack CRUD resource: Mongoose model, service, controller, routes, validator, plus optional admin pages, table/form components, API client and hooks.",
+  "params": {
+    "withFrontend": { "type": "boolean", "default": true, "description": "Generate frontend pages, components, API client and hooks." },
+    "withTests": { "type": "boolean", "default": false, "description": "Generate backend test files." },
+    "architecture": { "type": "string", "default": "moderate", "description": "lightweight | moderate | advanced." },
+    "formMode": { "type": "string", "default": "page", "description": "page | modal | sidepanel | inline — how the create/edit form is mounted." }
+  },
+  "files": [
+    { "template": "resource/model.js.ejs", "out": "{@backend.modules}/{kebab}/models/{Name}.js" },
+    { "template": "resource/service.js.ejs", "out": "{@backend.modules}/{kebab}/services/{Name}.service.js", "when": "architecture != \"lightweight\"" },
+    { "template": "resource/controller.js.ejs", "out": "{@backend.modules}/{kebab}/controllers/{Name}.controller.js" },
+    { "template": "resource/routes.js.ejs", "out": "{@backend.modules}/{kebab}/routes/{Name}.routes.js" },
+    { "template": "resource/validator.js.ejs", "out": "{@backend.validators}/{Name}.validator.js" },
+    { "template": "resource/test.ejs", "out": "{@backend.modules}/{kebab}/tests/{Name}.test.js", "when": "architecture != \"lightweight\" && (withTests || architecture == \"advanced\")" },
+    { "template": "resource/page-{formMode}.jsx.ejs", "out": "{@frontend.adminPages}/{kebab}/ListPage.jsx", "when": "withFrontend" },
+    { "template": "resource/page-detail.jsx.ejs", "out": "{@frontend.adminPages}/{kebab}/DetailPage.jsx", "when": "withFrontend" },
+    { "template": "resource/page-form.jsx.ejs", "out": "{@frontend.adminPages}/{kebab}/FormPage.jsx", "when": "withFrontend && formMode == \"page\"" },
+    { "template": "resource/components/table.jsx.ejs", "out": "{@frontend.components}/tables/{Name}Table.jsx", "when": "withFrontend" },
+    { "template": "resource/components/form.jsx.ejs", "out": "{@frontend.components}/forms/{Name}Form.jsx", "when": "withFrontend" },
+    { "template": "resource/api.js.ejs", "out": "{@frontend.api}/{kebab}.api.js", "when": "withFrontend" },
+    { "template": "resource/hooks.js.ejs", "out": "{@frontend.hooks}/use{Name}.js", "when": "withFrontend" },
+    { "template": "resource/types.ts.ejs", "out": "{frontend}/src/types/{kebab}.types.ts", "when": "withFrontend && usesTypeScript" }
+  ],
+  "inject": [
+    { "anchor": "backend.routes", "template": "snippets/route-mount.ejs" },
+    { "anchor": "frontend.lazyImports", "template": "snippets/lazy-import.ejs", "when": "withFrontend" },
+    { "anchor": "frontend.routes", "template": "snippets/route-entry.ejs", "when": "withFrontend" },
+    { "anchor": "frontend.nav", "template": "snippets/nav-entry.ejs", "when": "withFrontend" }
+  ],
+  "requires": [
+    { "scope": "backend", "package": "slugify", "version": "^1.6.6", "when": "hasField:slug || hasField:code || hasField:sku" }
+  ]
+}