@sundaysf/cli-v3 0.0.1

package/dist/cli.js

@@ -0,0 +1,1327 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import pc4 from "picocolors";
+
+// src/core/paths.ts
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs-extra";
+var here = path.dirname(fileURLToPath(import.meta.url));
+var packageRoot = () => {
+  let dir = here;
+  for (let i = 0; i < 4; i++) {
+    if (fs.existsSync(path.join(dir, "package.json")) && fs.existsSync(path.join(dir, "templates"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error("Could not locate @sundaysf/cli-v3 package root (templates/ not found)");
+};
+var templatesDir = () => path.join(packageRoot(), "templates");
+var templatePath = (name) => path.join(templatesDir(), name);
+var cliVersion = () => {
+  const pkg = fs.readJsonSync(path.join(packageRoot(), "package.json"));
+  return pkg.version;
+};
+
+// src/commands/new.ts
+import path4 from "path";
+import { randomBytes } from "crypto";
+import * as p2 from "@clack/prompts";
+import fs5 from "fs-extra";
+import pc2 from "picocolors";
+
+// src/core/template-engine.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+var TOKEN_RE = /__SF_[A-Z0-9_]+__/g;
+var RENAME_MAP = {
+  _gitignore: ".gitignore",
+  "_package.json": "package.json",
+  _dockerignore: ".dockerignore"
+};
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".json",
+  ".md",
+  ".yaml",
+  ".yml",
+  ".example",
+  ".html",
+  ".txt"
+]);
+var TEXT_BASENAMES = /* @__PURE__ */ new Set([
+  ".sundaysrc",
+  ".env.example",
+  ".prettierrc",
+  ".prettierignore",
+  "_gitignore",
+  ".gitignore",
+  "_dockerignore",
+  ".dockerignore",
+  "Dockerfile"
+]);
+var isTextFile = (file) => {
+  const base = path2.basename(file);
+  return TEXT_BASENAMES.has(base) || TEXT_EXTENSIONS.has(path2.extname(base));
+};
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git"]);
+var copyTemplate = async (src, dest) => {
+  await fs2.copy(src, dest, {
+    overwrite: false,
+    errorOnExist: false,
+    filter: (s) => !SKIP_DIRS.has(path2.basename(s))
+  });
+};
+var listFiles = async (dir) => {
+  const out = [];
+  const walk = async (d) => {
+    const entries = await fs2.readdir(d, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path2.join(d, e.name);
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name)) await walk(full);
+      } else {
+        out.push(full);
+      }
+    }
+  };
+  await walk(dir);
+  return out;
+};
+var renderString = (content, tokens, file = "<string>") => {
+  return content.replace(TOKEN_RE, (match) => {
+    if (!(match in tokens)) {
+      throw new Error(`Unknown template token ${match} in ${file}`);
+    }
+    return tokens[match];
+  });
+};
+var renderTokens = async (dir, tokens) => {
+  const touched = [];
+  for (const file of await listFiles(dir)) {
+    if (!isTextFile(file)) continue;
+    const content = await fs2.readFile(file, "utf8");
+    if (!TOKEN_RE.test(content)) {
+      TOKEN_RE.lastIndex = 0;
+      continue;
+    }
+    TOKEN_RE.lastIndex = 0;
+    const rendered = renderString(content, tokens, path2.relative(dir, file));
+    await fs2.writeFile(file, rendered, "utf8");
+    touched.push(file);
+  }
+  return touched;
+};
+var applyRenames = async (dir) => {
+  const renamed = [];
+  for (const file of await listFiles(dir)) {
+    const target = RENAME_MAP[path2.basename(file)];
+    if (!target) continue;
+    const dest = path2.join(path2.dirname(file), target);
+    await fs2.move(file, dest, { overwrite: true });
+    renamed.push(dest);
+  }
+  return renamed;
+};
+var assertNoLeftoverTokens = async (dir) => {
+  const leftovers = [];
+  for (const file of await listFiles(dir)) {
+    if (!isTextFile(file)) continue;
+    const content = await fs2.readFile(file, "utf8");
+    const found = content.match(TOKEN_RE);
+    if (found) leftovers.push(`${path2.relative(dir, file)}: ${[...new Set(found)].join(", ")}`);
+  }
+  if (leftovers.length) {
+    throw new Error(`Unrendered template tokens:
+  ${leftovers.join("\n  ")}`);
+  }
+};
+var assertNoForbiddenFiles = async (dir, forbidden = [".npmrc"]) => {
+  for (const file of await listFiles(dir)) {
+    if (forbidden.includes(path2.basename(file))) {
+      throw new Error(`Forbidden file in generated project: ${path2.relative(dir, file)}`);
+    }
+  }
+};
+
+// src/core/overlay.ts
+import path3 from "path";
+import fs4 from "fs-extra";
+
+// src/core/inject.ts
+import fs3 from "fs-extra";
+var insertBeforeMarker = async (file, marker, lines) => {
+  if (!await fs3.pathExists(file)) {
+    throw new Error(`Cannot inject into "${file}": file does not exist`);
+  }
+  const original = await fs3.readFile(file, "utf8");
+  const eol = original.includes("\r\n") ? "\r\n" : "\n";
+  const fileLines = original.split(eol);
+  const markerIndex = fileLines.findIndex((l) => l.includes(marker));
+  if (markerIndex === -1) {
+    throw new Error(
+      `Marker "${marker}" not found in ${file}. This file must keep the marker so sundaysf can extend it; restore the line and retry.`
+    );
+  }
+  const existing = new Set(fileLines.map((l) => l.trim()));
+  const inserted = [];
+  const skipped = [];
+  for (const line of lines) {
+    if (line.trim() !== "" && existing.has(line.trim())) {
+      skipped.push(line);
+    } else {
+      inserted.push(line);
+    }
+  }
+  if (inserted.length > 0) {
+    fileLines.splice(markerIndex, 0, ...inserted);
+    await fs3.writeFile(file, fileLines.join(eol), "utf8");
+  }
+  return { file, inserted, skipped };
+};
+
+// src/core/overlay.ts
+var OVERLAY_MANIFEST = "overlay.json";
+var sortKeys = (obj) => Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+var mergePackageJson = async (file, patch) => {
+  const pkg = await fs4.readJson(file);
+  for (const key of ["dependencies", "devDependencies", "scripts"]) {
+    if (!patch[key]) continue;
+    const current = pkg[key] ?? {};
+    pkg[key] = sortKeys({ ...current, ...patch[key] });
+  }
+  await fs4.writeJson(file, pkg, { spaces: 2 });
+};
+var applyOverlay = async (overlayDir, projectDir) => {
+  const manifestPath = path3.join(overlayDir, OVERLAY_MANIFEST);
+  const manifest = await fs4.pathExists(manifestPath) ? await fs4.readJson(manifestPath) : {};
+  await fs4.copy(overlayDir, projectDir, {
+    overwrite: false,
+    errorOnExist: false,
+    filter: (src) => path3.basename(src) !== OVERLAY_MANIFEST
+  });
+  if (manifest.packageJson) {
+    const candidates = ["package.json", "_package.json"].map((f) => path3.join(projectDir, f));
+    const target = candidates.find((f) => fs4.existsSync(f));
+    if (!target) throw new Error("Overlay wants to merge package.json but none exists in project");
+    await mergePackageJson(target, manifest.packageJson);
+  }
+  for (const inj of manifest.inject ?? []) {
+    await insertBeforeMarker(path3.join(projectDir, inj.file), inj.marker, inj.lines);
+  }
+};
+
+// src/core/exec.ts
+import { spinner, log } from "@clack/prompts";
+import { execa } from "execa";
+import pc from "picocolors";
+var StepError = class extends Error {
+  constructor(message, output) {
+    super(message);
+    this.output = output;
+    this.name = "StepError";
+  }
+  output;
+};
+var run = async (cmd, args, options) => {
+  try {
+    const result = await execa(cmd, args, { ...options, all: true, reject: true });
+    return String(result.all ?? result.stdout ?? "");
+  } catch (err) {
+    const e = err;
+    throw new StepError(e.shortMessage ?? e.message, e.all);
+  }
+};
+var step = async (label, fn) => {
+  const s = spinner();
+  s.start(label);
+  try {
+    await fn();
+    s.stop(pc.green("\u2714 ") + label);
+    return true;
+  } catch (err) {
+    const e = err;
+    s.stop(pc.red("\u2716 ") + label);
+    log.error(e.message);
+    if (e.output) {
+      log.message(pc.dim(e.output.trim().split("\n").slice(-30).join("\n")));
+    }
+    return false;
+  }
+};
+
+// src/core/prompts.ts
+import * as p from "@clack/prompts";
+var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var bail = (value) => {
+  if (p.isCancel(value)) {
+    p.cancel("Operation cancelled.");
+    process.exit(130);
+  }
+  throw new Error("Unexpected prompt result");
+};
+var confirm2 = async (message, initialValue) => {
+  const v = await p.confirm({ message, initialValue });
+  if (p.isCancel(v)) bail(v);
+  return v;
+};
+var text2 = async (message, opts) => {
+  const v = await p.text({
+    message,
+    placeholder: opts.placeholder,
+    initialValue: opts.initialValue,
+    validate: opts.validate ? (value) => opts.validate(value ?? "") : void 0
+  });
+  if (p.isCancel(v)) bail(v);
+  return String(v ?? "");
+};
+var select2 = async (message, options, initialValue) => {
+  const v = await p.select({
+    message,
+    options,
+    initialValue
+  });
+  if (p.isCancel(v)) bail(v);
+  return v;
+};
+
+// src/commands/new.ts
+var PROJECT_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var DEFAULT_PORT = 3005;
+var detectPackageManager = () => {
+  const ua = process.env.npm_config_user_agent ?? "";
+  return ua.startsWith("pnpm") ? "pnpm" : "npm";
+};
+var validateProjectName = (name) => {
+  if (!PROJECT_NAME_RE.test(name)) {
+    return "Use lowercase letters, numbers and dashes, starting with a letter or number (max 64 chars)";
+  }
+  return void 0;
+};
+var validatePort = (raw) => {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > 65535)
+    return "Port must be an integer between 1 and 65535";
+  return void 0;
+};
+var buildTokens = (name, port, withAuth) => ({
+  __SF_PROJECT_NAME__: name,
+  __SF_PROJECT_SLUG__: name,
+  __SF_DB_NAME__: name.replace(/-/g, "_"),
+  __SF_PORT__: String(port),
+  __SF_CLI_VERSION__: cliVersion(),
+  __SF_YEAR__: String((/* @__PURE__ */ new Date()).getFullYear()),
+  // .env.example never carries a real secret; `.env` gets a fresh one (see writeDotEnv).
+  __SF_JWT_SECRET__: withAuth ? "change-me-to-a-random-string-of-at-least-32-chars" : ""
+});
+var generateJwtSecret = () => randomBytes(48).toString("base64url");
+var writeDotEnv = async (projectDir, withAuth) => {
+  const example = await fs5.readFile(path4.join(projectDir, ".env.example"), "utf8");
+  let env = example;
+  if (withAuth) {
+    env = env.replace(/^JWT_SECRET=.*$/m, `JWT_SECRET=${generateJwtSecret()}`);
+  }
+  await fs5.writeFile(path4.join(projectDir, ".env"), env, "utf8");
+};
+var scaffoldProject = async (dir, name, port, withAuth) => {
+  await fs5.ensureDir(dir);
+  await copyTemplate(templatePath("api"), dir);
+  if (withAuth) await applyOverlay(templatePath("api-auth"), dir);
+  await renderTokens(dir, buildTokens(name, port, withAuth));
+  await applyRenames(dir);
+  await assertNoLeftoverTokens(dir);
+  await assertNoForbiddenFiles(dir);
+  await writeDotEnv(dir, withAuth);
+  return { dir, name, port, withAuth };
+};
+var isEmptyDir = async (dir) => {
+  if (!await fs5.pathExists(dir)) return true;
+  const entries = await fs5.readdir(dir);
+  return entries.length === 0;
+};
+var runNew = async (rawName, opts) => {
+  const interactive = isInteractive() && !opts.yes;
+  p2.intro(pc2.bgCyan(pc2.black(` sundaysf v${cliVersion()} `)) + " " + pc2.dim("new API project"));
+  let name = rawName?.trim();
+  if (!name) {
+    if (!interactive) throw new Error("Project name is required: sundaysf new <name>");
+    name = await text2("Project name", { placeholder: "my-api", validate: validateProjectName });
+  }
+  const nameError = validateProjectName(name);
+  if (nameError) throw new Error(`Invalid project name "${name}": ${nameError}`);
+  const dir = path4.resolve(process.cwd(), name);
+  if (!await isEmptyDir(dir)) {
+    throw new Error(`Directory "${name}" already exists and is not empty.`);
+  }
+  let withAuth = opts.withAuth;
+  if (withAuth === void 0) {
+    withAuth = interactive ? await confirm2("Include auth (user/auth tables, register/login/me, JWT)?", false) : false;
+  }
+  let portRaw = opts.port;
+  if (portRaw === void 0) {
+    portRaw = interactive ? await text2("HTTP port", { initialValue: String(DEFAULT_PORT), validate: validatePort }) : String(DEFAULT_PORT);
+  }
+  const portError = validatePort(portRaw);
+  if (portError) throw new Error(`Invalid port "${portRaw}": ${portError}`);
+  const port = Number(portRaw);
+  const pm = opts.pm ?? detectPackageManager();
+  const doInstall = opts.install ?? (interactive ? await confirm2(`Run ${pm} install?`, true) : true);
+  const doGit = opts.git ?? (interactive ? await confirm2("Initialize a git repository?", true) : true);
+  await step("Scaffolding project files", async () => {
+    await scaffoldProject(dir, name, port, withAuth);
+  });
+  let gitOk = false;
+  if (doGit) {
+    gitOk = await step("git init", async () => {
+      await run("git", ["init", "-b", "main"], { cwd: dir });
+    });
+  }
+  let installOk = false;
+  if (doInstall) {
+    installOk = await step(`${pm} install`, async () => {
+      await run(pm, ["install"], { cwd: dir, env: { ...process.env, CI: "1" } });
+    });
+    if (installOk) {
+      await step("Formatting with prettier", async () => {
+        await run(pm, ["run", "format"], { cwd: dir });
+      });
+    }
+  }
+  if (gitOk) {
+    await step("Initial commit", async () => {
+      await run("git", ["add", "-A"], { cwd: dir });
+      await run(
+        "git",
+        ["commit", "-q", "-m", `chore: scaffold ${name} with @sundaysf/cli-v3 ${cliVersion()}`],
+        { cwd: dir }
+      );
+    });
+  }
+  const next = [
+    `cd ${name}`,
+    ...doInstall && installOk ? [] : [`${pm} install`],
+    "docker compose up -d          # local Postgres",
+    `${pm} run db:migrate`,
+    `${pm} run start:dev             # http://localhost:${port}/api/health`,
+    "sundaysf generate entity product name:string:unique price:decimal"
+  ];
+  p2.note(next.join("\n"), "Next steps");
+  p2.outro(pc2.green(`Project "${name}" is ready.`) + (withAuth ? pc2.dim(" (with auth)") : ""));
+};
+var registerNewCommand = (program2) => {
+  program2.command("new").description("Create a new API project (Express 5 + Knex + Postgres) ready to work on").argument("[name]", "project name (lowercase, dashes allowed)").option("--with-auth", "include auth: user/auth tables, register/login/me, JWT").option("--no-auth", "explicitly skip auth (no prompt)").option("--port <port>", "HTTP port for the API", void 0).option("--no-install", "skip dependency installation").option("--no-git", "skip git init and initial commit").option("--pm <pm>", "package manager: npm | pnpm").option("-y, --yes", "accept all defaults, no prompts").action(async (name, raw) => {
+    const opts = {
+      withAuth: raw.withAuth === true ? true : raw.auth === false ? false : void 0,
+      port: raw.port,
+      install: raw.install,
+      git: raw.git,
+      pm: raw.pm,
+      yes: raw.yes
+    };
+    if (opts.pm && !["npm", "pnpm"].includes(opts.pm)) {
+      throw new Error(`Unsupported package manager "${opts.pm}" (use npm or pnpm)`);
+    }
+    await runNew(name, opts);
+  });
+};
+
+// src/commands/generate-entity.ts
+import path7 from "path";
+import * as p3 from "@clack/prompts";
+import fs8 from "fs-extra";
+import pc3 from "picocolors";
+import { execa as execa2 } from "execa";
+
+// src/core/naming.ts
+var splitWords = (input) => {
+  const trimmed = input.trim();
+  if (!trimmed) return [];
+  return trimmed.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean).map((w) => w.toLowerCase());
+};
+var capitalize = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+var toKebab = (input) => splitWords(input).join("-");
+var toSnake = (input) => splitWords(input).join("_");
+var toPascal = (input) => splitWords(input).map(capitalize).join("");
+var toCamel = (input) => {
+  const words = splitWords(input);
+  return words.map((w, i) => i === 0 ? w : capitalize(w)).join("");
+};
+var ENTITY_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+var isValidEntityName = (input) => ENTITY_NAME_RE.test(input.trim());
+var entityNames = (input) => {
+  if (!isValidEntityName(input)) {
+    throw new Error(
+      `Invalid entity name "${input}": must start with a letter and contain only letters, numbers, "-" or "_"`
+    );
+  }
+  return {
+    kebab: toKebab(input),
+    pascal: toPascal(input),
+    camel: toCamel(input),
+    snake: toSnake(input)
+  };
+};
+
+// src/core/fields.ts
+var FIELD_TYPES = [
+  "string",
+  "text",
+  "integer",
+  "decimal",
+  "boolean",
+  "date",
+  "datetime",
+  "json",
+  "uuid"
+];
+var RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set(["id", "uuid", "createdAt", "updatedAt"]);
+var FIELD_NAME_RE = /^[a-z][a-zA-Z0-9]*$/;
+var FIELD_SYNTAX = "name:type[?][:unique][=default]   e.g. price:decimal  title:string:unique  categoryId:category.id  notes:text?";
+var parseDefault = (raw) => {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+  return raw.replace(/^['"](.*)['"]$/, "$1");
+};
+var parseFieldSpec = (token) => {
+  const fail = (why) => {
+    throw new Error(`Invalid field "${token}": ${why}
+Syntax: ${FIELD_SYNTAX}`);
+  };
+  const colon = token.indexOf(":");
+  if (colon <= 0) fail("expected name:type");
+  const name = token.slice(0, colon);
+  if (!FIELD_NAME_RE.test(name))
+    fail("field name must be camelCase (letters and numbers, starting lowercase)");
+  if (RESERVED_FIELD_NAMES.has(name)) fail(`"${name}" is generated automatically`);
+  let rest = token.slice(colon + 1);
+  let def;
+  const eq = rest.indexOf("=");
+  if (eq !== -1) {
+    const rawDefault = rest.slice(eq + 1);
+    if (!rawDefault) fail("empty default value");
+    def = parseDefault(rawDefault);
+    rest = rest.slice(0, eq);
+  }
+  const parts = rest.split(":").filter(Boolean);
+  if (parts.length === 0) fail("missing type");
+  let nullable = false;
+  const [rawType, ...modifiers] = parts.map((p4) => {
+    if (p4.endsWith("?")) {
+      nullable = true;
+      return p4.slice(0, -1);
+    }
+    return p4;
+  });
+  let unique = false;
+  for (const m of modifiers) {
+    if (m === "unique") unique = true;
+    else fail(`unknown modifier "${m}" (supported: unique)`);
+  }
+  const spec = { name, type: "string", nullable, unique };
+  if (rawType.endsWith(".id")) {
+    const entity = rawType.slice(0, -".id".length);
+    if (!entity) fail("reference must be <entity>.id");
+    spec.type = "ref";
+    spec.ref = entityNames(entity);
+  } else if (FIELD_TYPES.includes(rawType)) {
+    spec.type = rawType;
+  } else {
+    fail(`unknown type "${rawType}" (supported: ${FIELD_TYPES.join(", ")}, <entity>.id)`);
+  }
+  if (def !== void 0) {
+    if (spec.type === "boolean" && typeof def !== "boolean")
+      fail("boolean default must be true or false");
+    if ((spec.type === "integer" || spec.type === "decimal" || spec.type === "ref") && typeof def !== "number") {
+      fail("numeric default expected");
+    }
+    spec.default = def;
+  }
+  return spec;
+};
+var parseFields = (tokens) => {
+  const specs = tokens.map(parseFieldSpec);
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of specs) {
+    if (seen.has(s.name)) throw new Error(`Duplicate field "${s.name}"`);
+    seen.add(s.name);
+  }
+  return specs;
+};
+var jsLiteral = (v) => typeof v === "string" ? `'${v.replace(/'/g, "\\'")}'` : String(v);
+var toKnexColumn = (f) => {
+  let col;
+  switch (f.type) {
+    case "string":
+      col = `table.string('${f.name}', 255)`;
+      break;
+    case "text":
+      col = `table.text('${f.name}')`;
+      break;
+    case "integer":
+      col = `table.integer('${f.name}')`;
+      break;
+    case "decimal":
+      col = `table.decimal('${f.name}', 15, 2)`;
+      break;
+    case "boolean":
+      col = `table.boolean('${f.name}')`;
+      break;
+    case "date":
+      col = `table.date('${f.name}')`;
+      break;
+    case "datetime":
+      col = `table.timestamp('${f.name}')`;
+      break;
+    case "json":
+      col = `table.jsonb('${f.name}')`;
+      break;
+    case "uuid":
+      col = `table.uuid('${f.name}')`;
+      break;
+    case "ref":
+      col = `table.integer('${f.name}').references('id').inTable('${f.ref.snake}').onDelete('CASCADE').index()`;
+      break;
+  }
+  if (!f.nullable) col += ".notNullable()";
+  if (f.unique) col += ".unique()";
+  if (f.default !== void 0) {
+    col += f.type === "json" ? `.defaultTo(JSON.stringify(${jsLiteral(f.default)}))` : `.defaultTo(${jsLiteral(f.default)})`;
+  }
+  return `${col};`;
+};
+var toTsType = (f) => {
+  const base = {
+    string: "string",
+    text: "string",
+    integer: "number",
+    decimal: "number",
+    boolean: "boolean",
+    date: "string",
+    datetime: "Date | string",
+    json: "Record<string, unknown>",
+    uuid: "string",
+    ref: "number"
+  };
+  return f.nullable ? `${base[f.type]} | null` : base[f.type];
+};
+var toTsProp = (f) => {
+  const optional = f.nullable || f.default !== void 0 ? "?" : "";
+  return `${f.name}${optional}: ${toTsType(f)};`;
+};
+var zodBase = (f) => {
+  switch (f.type) {
+    case "string":
+      return "z.string().trim().min(1).max(255)";
+    case "text":
+      return "z.string()";
+    case "integer":
+      return "z.number().int()";
+    case "decimal":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "date":
+      return "z.iso.date()";
+    case "datetime":
+      return "z.coerce.date()";
+    case "json":
+      return "z.record(z.string(), z.unknown())";
+    case "uuid":
+      return "z.uuid()";
+    case "ref":
+      return "z.number().int().positive()";
+  }
+};
+var toZodCreate = (f) => {
+  let z = zodBase(f);
+  if (f.nullable) z += ".nullable()";
+  if (f.default !== void 0) z += `.default(${jsLiteral(f.default)})`;
+  else if (f.nullable) z += ".optional()";
+  return `${f.name}: ${z},`;
+};
+var toZodUpdate = (f) => {
+  let z = zodBase(f);
+  if (f.nullable) z += ".nullable()";
+  return `${f.name}: ${z}.optional(),`;
+};
+var sampleValue = (f, variant = "create") => {
+  const alt = variant === "update";
+  switch (f.type) {
+    case "string":
+      return f.unique ? `\`${f.name}-${alt ? "updated-" : ""}\${suffix}\`` : `'${alt ? "Updated" : "Sample"} ${f.name}'`;
+    case "text":
+      return alt ? "'Updated text'" : "'Sample text'";
+    case "integer":
+      return alt ? "7" : "42";
+    case "decimal":
+      return alt ? "99.5" : "19.99";
+    case "boolean":
+      return alt ? "false" : "true";
+    case "date":
+      return alt ? "'2025-02-01'" : "'2025-01-15'";
+    case "datetime":
+      return alt ? "'2025-02-01T10:00:00.000Z'" : "'2025-01-15T10:00:00.000Z'";
+    case "json":
+      return alt ? "{ key: 'updated' }" : "{ key: 'value' }";
+    case "uuid":
+      return alt ? "'11111111-1111-4111-8111-111111111111'" : "'00000000-0000-4000-8000-000000000000'";
+    case "ref":
+      return "1";
+  }
+};
+var hasReferences = (fields) => fields.some((f) => f.type === "ref");
+
+// src/core/project.ts
+import path5 from "path";
+import fs6 from "fs-extra";
+var SUNDAYSRC = ".sundaysrc";
+var findProjectRoot = async (cwd = process.cwd()) => {
+  let dir = path5.resolve(cwd);
+  for (; ; ) {
+    if (await fs6.pathExists(path5.join(dir, SUNDAYSRC))) return dir;
+    const parent = path5.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+};
+var readSundaysrc = async (root) => {
+  return await fs6.readJson(path5.join(root, SUNDAYSRC));
+};
+var requireV3Project = async (cwd = process.cwd()) => {
+  const root = await findProjectRoot(cwd);
+  if (!root) {
+    throw new Error(
+      "Not inside a Sundays project (no .sundaysrc found in this directory or any parent). Run this command inside a project created with `sundaysf new`."
+    );
+  }
+  const rc = await readSundaysrc(root);
+  if (!rc.cli) {
+    throw new Error(
+      `${path5.join(root, SUNDAYSRC)} has no "cli" field: this looks like a v2 project. sundaysf v3 generators require a project created with \`sundaysf new\` (v3).`
+    );
+  }
+  const barrel = path5.join(root, "src", "db", "index.ts");
+  if (!await fs6.pathExists(barrel)) {
+    throw new Error(`Missing ${barrel}: cannot register generated DAOs.`);
+  }
+  const content = await fs6.readFile(barrel, "utf8");
+  for (const marker of ["// @sundays:interfaces", "// @sundays:daos"]) {
+    if (!content.includes(marker)) {
+      throw new Error(
+        `Marker "${marker}" not found in src/db/index.ts. Restore it so generators can extend the barrel.`
+      );
+    }
+  }
+  return root;
+};
+
+// src/generators/entity/context.ts
+var migrationTimestamp = (date = /* @__PURE__ */ new Date()) => date.toISOString().replace(/[-:T]/g, "").slice(0, 14);
+
+// src/generators/entity/index.ts
+import path6 from "path";
+import fs7 from "fs-extra";
+
+// src/generators/entity/render/controller.ts
+var renderController = ({ names }) => {
+  const { pascal: P, camel: c, kebab: k } = names;
+  return `import type { NextFunction, Request, Response } from 'express';
+import { badRequest, notFound } from '../../common/errors/http.error';
+import { getPagination } from '../../common/utils/pagination';
+import { ${P}DAO } from '../../db';
+import { validate${P}Create } from '../../dto/input/${k}/${k}.create.dto';
+import { validate${P}Update } from '../../dto/input/${k}/${k}.update.dto';
+
+export class ${P}Controller {
+  private _${c}DAO = new ${P}DAO();
+
+  /** GET /api/${k}?page=&limit= */
+  public async getAll(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const { page, limit } = getPagination(req.query);
+      const result = await this._${c}DAO.getAll(page, limit);
+      res.status(200).json(result);
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  /** GET /api/${k}/:uuid */
+  public async getByUuid(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const row = await this._${c}DAO.getByUuid(req.params.uuid as string);
+      if (!row) throw notFound('${P} not found');
+      res.status(200).json({ success: true, data: row });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  /** POST /api/${k} */
+  public async create(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const input = validate${P}Create(req.body);
+      const created = await this._${c}DAO.create(input);
+      res.status(201).json({ success: true, data: created });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  /** PUT /api/${k}/:uuid */
+  public async update(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const existing = await this._${c}DAO.getByUuid(req.params.uuid as string);
+      if (!existing?.id) throw notFound('${P} not found');
+      const input = validate${P}Update(req.body);
+      if (Object.keys(input).length === 0) throw badRequest('No fields to update');
+      const updated = await this._${c}DAO.update(existing.id, input);
+      res.status(200).json({ success: true, data: updated });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  /** DELETE /api/${k}/:uuid */
+  public async delete(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const existing = await this._${c}DAO.getByUuid(req.params.uuid as string);
+      if (!existing?.id) throw notFound('${P} not found');
+      await this._${c}DAO.delete(existing.id);
+      res.status(200).json({ success: true, message: '${P} deleted' });
+    } catch (err) {
+      next(err);
+    }
+  }
+}
+`;
+};
+
+// src/generators/entity/render/controller-test.ts
+var objectLiteral = (entries) => entries.length ? `{ ${entries.join(", ")} }` : "{}";
+var renderControllerTest = ({ names, fields }) => {
+  const { pascal: P, kebab: k } = names;
+  const rowFields = fields.map(
+    (f) => `${f.name}: ${sampleValue(f).replace(/`([^`]*)\$\{suffix\}`/, "'$1x'")}`
+  );
+  const createFields = fields.map(
+    (f) => `${f.name}: ${sampleValue(f).replace(/`([^`]*)\$\{suffix\}`/, "'$1x'")}`
+  );
+  const stableFields = fields.filter((f) => f.type !== "datetime").map((f) => `${f.name}: ${sampleValue(f).replace(/`([^`]*)\$\{suffix\}`/, "'$1x'")}`);
+  const updatable = fields.find((f) => f.type !== "ref") ?? fields[0];
+  const updateBody = updatable ? objectLiteral([
+    `${updatable.name}: ${sampleValue(updatable, "update").replace(/`([^`]*)\$\{suffix\}`/, "'$1y'")}`
+  ]) : "{}";
+  return `import type { NextFunction, Request, Response } from 'express';
+import { HttpError } from '../../../common/errors/http.error';
+
+const mockDao = {
+  getAll: jest.fn(),
+  getByUuid: jest.fn(),
+  create: jest.fn(),
+  update: jest.fn(),
+  delete: jest.fn(),
+};
+jest.mock('../../../db', () => ({ ${P}DAO: jest.fn(() => mockDao) }));
+
+import { ${P}Controller } from '../${k}.controller';
+
+const mockRes = (): Response => {
+  const res: Partial<Response> = {};
+  res.status = jest.fn().mockReturnValue(res);
+  res.json = jest.fn().mockReturnValue(res);
+  return res as Response;
+};
+
+const row = ${objectLiteral(["id: 1", "uuid: 'uuid-1'", ...rowFields])};
+const createBody = ${objectLiteral(createFields)};
+const expectedCreate = ${objectLiteral(stableFields)};
+const updateBody = ${updateBody};
+
+describe('${P}Controller', () => {
+  const controller = new ${P}Controller();
+  let next: jest.MockedFunction<NextFunction>;
+  const errorOf = (): HttpError => next.mock.calls[0][0] as unknown as HttpError;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    next = jest.fn();
+  });
+
+  it('getAll returns the paginated envelope', async () => {
+    const page = { success: true, data: [row], page: 2, limit: 5, count: 1, totalCount: 1, totalPages: 1 };
+    mockDao.getAll.mockResolvedValue(page);
+    const res = mockRes();
+    await controller.getAll({ query: { page: '2', limit: '5' } } as unknown as Request, res, next);
+    expect(mockDao.getAll).toHaveBeenCalledWith(2, 5);
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith(page);
+  });
+
+  it('getByUuid returns the row', async () => {
+    mockDao.getByUuid.mockResolvedValue(row);
+    const res = mockRes();
+    await controller.getByUuid({ params: { uuid: 'uuid-1' } } as unknown as Request, res, next);
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({ success: true, data: row });
+  });
+
+  it('getByUuid answers 404 when missing', async () => {
+    mockDao.getByUuid.mockResolvedValue(null);
+    await controller.getByUuid({ params: { uuid: 'nope' } } as unknown as Request, mockRes(), next);
+    expect(errorOf().statusCode).toBe(404);
+  });
+
+  it('create validates and returns 201', async () => {
+    mockDao.create.mockResolvedValue(row);
+    const res = mockRes();
+    await controller.create({ body: createBody } as Request, res, next);
+    expect(mockDao.create).toHaveBeenCalledWith(expect.objectContaining(expectedCreate));
+    expect(res.status).toHaveBeenCalledWith(201);
+    expect(res.json).toHaveBeenCalledWith({ success: true, data: row });
+  });
+
+  it('create rejects unknown fields with 400', async () => {
+    await controller.create({ body: { ...createBody, __unknown__: true } } as Request, mockRes(), next);
+    expect(errorOf().statusCode).toBe(400);
+    expect(mockDao.create).not.toHaveBeenCalled();
+  });
+
+  it('update resolves the id and returns 200', async () => {
+    mockDao.getByUuid.mockResolvedValue(row);
+    mockDao.update.mockResolvedValue({ ...row, ...updateBody });
+    const res = mockRes();
+    await controller.update({ params: { uuid: 'uuid-1' }, body: updateBody } as unknown as Request, res, next);
+    expect(mockDao.update).toHaveBeenCalledWith(1, expect.objectContaining(updateBody));
+    expect(res.status).toHaveBeenCalledWith(200);
+  });
+
+  it('update answers 404 when missing and 400 on an empty body', async () => {
+    mockDao.getByUuid.mockResolvedValue(null);
+    await controller.update({ params: { uuid: 'nope' }, body: updateBody } as unknown as Request, mockRes(), next);
+    expect(errorOf().statusCode).toBe(404);
+
+    next = jest.fn();
+    mockDao.getByUuid.mockResolvedValue(row);
+    await controller.update({ params: { uuid: 'uuid-1' }, body: {} } as unknown as Request, mockRes(), next);
+    expect(errorOf().statusCode).toBe(400);
+  });
+
+  it('delete removes the row', async () => {
+    mockDao.getByUuid.mockResolvedValue(row);
+    mockDao.delete.mockResolvedValue(true);
+    const res = mockRes();
+    await controller.delete({ params: { uuid: 'uuid-1' } } as unknown as Request, res, next);
+    expect(mockDao.delete).toHaveBeenCalledWith(1);
+    expect(res.json).toHaveBeenCalledWith({ success: true, message: '${P} deleted' });
+  });
+
+  it('delete answers 404 when missing', async () => {
+    mockDao.getByUuid.mockResolvedValue(null);
+    await controller.delete({ params: { uuid: 'nope' } } as unknown as Request, mockRes(), next);
+    expect(errorOf().statusCode).toBe(404);
+  });
+});
+`;
+};
+
+// src/generators/entity/render/dao.ts
+var renderDao = ({ names, fields }) => {
+  const uniques = fields.filter((f) => f.unique);
+  const knexImport = uniques.length ? `import type { Knex } from 'knex';
+` : "";
+  const finders = uniques.map(
+    (f) => `
+  async getBy${toPascal(f.name)}(${f.name}: ${toTsType(f)}, trx?: Knex.Transaction): Promise<I${names.pascal} | null> {
+    const row = await this.q(trx).where({ ${f.name} }).first();
+    return (row as I${names.pascal} | undefined) ?? null;
+  }`
+  ).join("\n");
+  return `${knexImport}import { BaseDAO } from '../../BaseDAO';
+import type { I${names.pascal} } from '../../interfaces/${names.kebab}/${names.kebab}.interfaces';
+
+export class ${names.pascal}DAO extends BaseDAO<I${names.pascal}> {
+  protected readonly table = '${names.snake}';
+${finders ? finders + "\n" : ""}}
+`;
+};
+
+// src/generators/entity/render/dto.ts
+var header = `import { z } from 'zod';
+import { parseDto } from '../../../common/validation/parse-dto';
+`;
+var renderCreateDto = ({ names, fields }) => {
+  const body = fields.map((f) => `    ${toZodCreate(f)}`).join("\n");
+  return `${header}
+export const ${names.pascal}CreateSchema = z
+  .object({
+${body ? body + "\n" : ""}  })
+  .strict();
+
+export type ${names.pascal}CreateInput = z.infer<typeof ${names.pascal}CreateSchema>;
+
+export const validate${names.pascal}Create = (input: unknown): ${names.pascal}CreateInput =>
+  parseDto(${names.pascal}CreateSchema, input);
+`;
+};
+var renderUpdateDto = ({ names, fields }) => {
+  const body = fields.map((f) => `    ${toZodUpdate(f)}`).join("\n");
+  return `${header}
+/** Partial update: every field optional, no defaults applied. */
+export const ${names.pascal}UpdateSchema = z
+  .object({
+${body ? body + "\n" : ""}  })
+  .strict();
+
+export type ${names.pascal}UpdateInput = z.infer<typeof ${names.pascal}UpdateSchema>;
+
+export const validate${names.pascal}Update = (input: unknown): ${names.pascal}UpdateInput =>
+  parseDto(${names.pascal}UpdateSchema, input);
+`;
+};
+
+// src/generators/entity/render/interface.ts
+var renderInterface = ({ names, fields }) => {
+  const props = fields.map((f) => `  ${toTsProp(f)}`).join("\n");
+  return `import type { IEntity } from '../../d.types';
+
+export interface I${names.pascal} extends IEntity {
+${props ? props + "\n" : ""}}
+`;
+};
+
+// src/generators/entity/render/migration.ts
+var renderMigration = ({ names, fields }) => {
+  const columns = fields.map((f) => `    ${toKnexColumn(f)}`).join("\n");
+  return `import type { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('${names.snake}', (table) => {
+    table.increments('id').primary();
+    table.uuid('uuid').notNullable().unique();
+${columns ? columns + "\n" : ""}    table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now());
+    table.timestamp('updatedAt').notNullable().defaultTo(knex.fn.now());
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists('${names.snake}');
+}
+`;
+};
+
+// src/generators/entity/render/route-test.ts
+var renderRouteTest = ({ names, fields }) => {
+  const { pascal: P, kebab: k, snake } = names;
+  const refs = fields.filter((f) => f.type === "ref");
+  const skip = hasReferences(fields);
+  const createFields = fields.map((f) => `  ${f.name}: ${sampleValue(f)},`).join("\n");
+  const updatable = fields.find((f) => f.type !== "ref");
+  const updateBody = updatable ? `{ ${updatable.name}: ${sampleValue(updatable, "update")} }` : "{}";
+  const describeFn = skip ? "describe.skip" : "describe";
+  const skipNote = skip ? `// SKIPPED until you provide the parent rows: this entity references ${refs.map((r) => `${r.ref.snake} (${r.name})`).join(", ")}.
+// Create them in beforeAll (e.g. with new ${refs[0].ref.pascal}DAO().create({...})), set the ids in
+// createBody, delete them in afterAll, and change describe.skip to describe.
+` : "";
+  return `import { randomUUID } from 'crypto';
+import request from 'supertest';
+import app from '../../../app';
+import { KnexManager } from '../../../db';
+
+${skipNote}// Integration test: real Postgres (docker compose up -d) with migrations applied.
+const suffix = randomUUID().slice(0, 8);
+const createBody = {
+${createFields ? createFields + "\n" : ""}};
+const updateBody = ${updateBody};
+
+${describeFn}('/api/${k}', () => {
+  const created: string[] = [];
+
+  beforeAll(async () => {
+    await KnexManager.connect();
+  });
+
+  afterAll(async () => {
+    if (created.length) await KnexManager.getConnection()('${snake}').whereIn('uuid', created).delete();
+    await KnexManager.disconnect();
+  });
+
+  it('creates a ${k}', async () => {
+    const res = await request(app).post('/api/${k}').send(createBody);
+    expect(res.status).toBe(201);
+    expect(res.body.success).toBe(true);
+    expect(res.body.data.uuid).toEqual(expect.any(String));
+    expect(res.body.data.id).toEqual(expect.any(Number));
+    created.push(res.body.data.uuid);
+  });
+
+  it('rejects unknown fields', async () => {
+    const res = await request(app).post('/api/${k}').send({ ...createBody, __unknown__: true });
+    expect(res.status).toBe(400);
+    expect(res.body).toMatchObject({ success: false, message: 'Validation failed' });
+  });
+
+  it('lists with pagination', async () => {
+    const res = await request(app).get('/api/${k}?page=1&limit=5');
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ success: true, page: 1, limit: 5 });
+    expect(Array.isArray(res.body.data)).toBe(true);
+    expect(res.body.data.some((row: { uuid: string }) => row.uuid === created[0])).toBe(true);
+  });
+
+  it('reads by uuid', async () => {
+    const res = await request(app).get(\`/api/${k}/\${created[0]}\`);
+    expect(res.status).toBe(200);
+    expect(res.body.data.uuid).toBe(created[0]);
+  });
+
+  it('answers 404 for an unknown uuid', async () => {
+    const res = await request(app).get(\`/api/${k}/\${randomUUID()}\`);
+    expect(res.status).toBe(404);
+    expect(res.body).toEqual({ success: false, message: '${P} not found' });
+  });
+${updatable ? `
+  it('updates', async () => {
+    const res = await request(app).put(\`/api/${k}/\${created[0]}\`).send(updateBody);
+    expect(res.status).toBe(200);
+    expect(res.body.data).toMatchObject(updateBody);
+  });
+` : ""}
+  it('rejects an empty update', async () => {
+    const res = await request(app).put(\`/api/${k}/\${created[0]}\`).send({});
+    expect(res.status).toBe(400);
+  });
+
+  it('deletes', async () => {
+    const res = await request(app).delete(\`/api/${k}/\${created[0]}\`);
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ success: true, message: '${P} deleted' });
+    const gone = await request(app).get(\`/api/${k}/\${created[0]}\`);
+    expect(gone.status).toBe(404);
+    created.length = 0;
+  });
+});
+`;
+};
+
+// src/generators/entity/render/router.ts
+var renderRouter = ({ names }) => {
+  const { pascal: P, camel: c, kebab: k } = names;
+  return `import { Router } from 'express';
+import { ${P}Controller } from '../../controllers/${k}/${k}.controller';
+
+/** Mounted automatically at /api/${k} by src/routes/index.ts. */
+export class ${P}Router {
+  public router: Router = Router();
+  private readonly _${c}Controller = new ${P}Controller();
+
+  constructor() {
+    this.initRoutes();
+  }
+
+  private initRoutes(): void {
+    const ctrl = this._${c}Controller;
+    this.router.get('/', ctrl.getAll.bind(ctrl));
+    this.router.get('/:uuid', ctrl.getByUuid.bind(ctrl));
+    this.router.post('/', ctrl.create.bind(ctrl));
+    this.router.put('/:uuid', ctrl.update.bind(ctrl));
+    this.router.delete('/:uuid', ctrl.delete.bind(ctrl));
+  }
+}
+`;
+};
+
+// src/generators/entity/index.ts
+var renderEntityFiles = (ctx, opts = {}) => {
+  const { kebab, snake } = ctx.names;
+  const files = [];
+  if (opts.migration !== false) {
+    files.push({
+      path: `src/migrations/${ctx.timestamp}_create_${snake}.ts`,
+      content: renderMigration(ctx)
+    });
+  }
+  files.push(
+    { path: `src/db/interfaces/${kebab}/${kebab}.interfaces.ts`, content: renderInterface(ctx) },
+    { path: `src/db/dao/${kebab}/${kebab}.dao.ts`, content: renderDao(ctx) },
+    { path: `src/dto/input/${kebab}/${kebab}.create.dto.ts`, content: renderCreateDto(ctx) },
+    { path: `src/dto/input/${kebab}/${kebab}.update.dto.ts`, content: renderUpdateDto(ctx) },
+    { path: `src/controllers/${kebab}/${kebab}.controller.ts`, content: renderController(ctx) },
+    { path: `src/routes/${kebab}/${kebab}.router.ts`, content: renderRouter(ctx) }
+  );
+  if (opts.tests !== false) {
+    files.push(
+      {
+        path: `src/controllers/${kebab}/__tests__/${kebab}.controller.test.ts`,
+        content: renderControllerTest(ctx)
+      },
+      {
+        path: `src/routes/${kebab}/__tests__/${kebab}.routes.test.ts`,
+        content: renderRouteTest(ctx)
+      }
+    );
+  }
+  return files;
+};
+var barrelLinesFor = (ctx) => {
+  const { kebab, pascal } = ctx.names;
+  return {
+    interfaces: [`export type { I${pascal} } from './interfaces/${kebab}/${kebab}.interfaces';`],
+    daos: [`export { ${pascal}DAO } from './dao/${kebab}/${kebab}.dao';`]
+  };
+};
+var findExistingMigration = async (root, snake) => {
+  const dir = path6.join(root, "src", "migrations");
+  if (!await fs7.pathExists(dir)) return null;
+  const match = (await fs7.readdir(dir)).find((f) => f.endsWith(`_create_${snake}.ts`));
+  return match ?? null;
+};
+var generateEntity = async (ctx, root, opts = {}) => {
+  const warnings = [];
+  let files = renderEntityFiles(ctx, opts);
+  const existingMigration = await findExistingMigration(root, ctx.names.snake);
+  if (existingMigration) {
+    warnings.push(`Migration ${existingMigration} already exists, not creating another one.`);
+    files = files.filter((f) => !f.path.startsWith("src/migrations/"));
+  }
+  for (const f of ctx.fields) {
+    if (f.type === "ref" && !await fs7.pathExists(path6.join(root, "src", "db", "dao", f.ref.kebab))) {
+      warnings.push(
+        `Field "${f.name}" references entity "${f.ref.kebab}" but src/db/dao/${f.ref.kebab}/ does not exist yet. Generate it first or the migration will fail.`
+      );
+    }
+  }
+  const clashes = [];
+  for (const f of files) {
+    if (await fs7.pathExists(path6.join(root, f.path))) clashes.push(f.path);
+  }
+  if (clashes.length && !opts.force) {
+    throw new Error(
+      `These files already exist (use --force to overwrite code files):
+  ${clashes.join("\n  ")}`
+    );
+  }
+  const barrelLines = barrelLinesFor(ctx);
+  if (opts.dryRun) return { files, barrelLines, warnings };
+  for (const f of files) {
+    await fs7.outputFile(path6.join(root, f.path), f.content, "utf8");
+  }
+  const barrel = path6.join(root, "src", "db", "index.ts");
+  await insertBeforeMarker(barrel, "// @sundays:interfaces", barrelLines.interfaces);
+  await insertBeforeMarker(barrel, "// @sundays:daos", barrelLines.daos);
+  return { files, barrelLines, warnings };
+};
+
+// src/commands/generate-entity.ts
+var promptFields = async () => {
+  const tokens = [];
+  p3.log.info(`Define the fields (syntax: ${FIELD_SYNTAX})`);
+  for (; ; ) {
+    const name = await text2("Field name (camelCase)", { placeholder: "name" });
+    const type = await select2(
+      "Type",
+      [
+        ...FIELD_TYPES.map((t) => ({ value: t, label: t })),
+        { value: "ref", label: "<entity>.id (foreign key)" }
+      ],
+      "string"
+    );
+    let typeToken = type;
+    if (type === "ref") {
+      const entity = await text2("Referenced entity", { placeholder: "category" });
+      typeToken = `${entity}.id`;
+    }
+    const nullable = await confirm2("Nullable?", false);
+    const unique = await confirm2("Unique?", false);
+    const def = await text2("Default value (leave empty for none)", { placeholder: "" });
+    let token = `${name}:${typeToken}${nullable ? "?" : ""}${unique ? ":unique" : ""}`;
+    if (def.trim()) token += `=${def.trim()}`;
+    tokens.push(token);
+    if (!await confirm2("Add another field?", true)) break;
+  }
+  return tokens;
+};
+var formatFiles = async (root, files) => {
+  const prettier = path7.join(root, "node_modules", ".bin", "prettier");
+  if (!await fs8.pathExists(prettier)) return;
+  await execa2(prettier, ["--write", "--log-level", "silent", ...files], { cwd: root });
+};
+var runGenerateEntity = async (rawName, rawFields, opts) => {
+  p3.intro(pc3.bgCyan(pc3.black(" sundaysf ")) + " " + pc3.dim("generate entity"));
+  const root = await requireV3Project();
+  const names = entityNames(rawName);
+  let tokens = [...rawFields, ...opts.fields ? opts.fields.split(/\s+/).filter(Boolean) : []];
+  if (tokens.length === 0) {
+    if (!isInteractive()) throw new Error(`No fields given.
+Syntax: ${FIELD_SYNTAX}`);
+    tokens = await promptFields();
+  }
+  const fields = parseFields(tokens);
+  const ctx = { names, fields, timestamp: migrationTimestamp() };
+  const result = await generateEntity(ctx, root, {
+    tests: opts.tests,
+    migration: opts.migration,
+    force: opts.force,
+    dryRun: opts.dryRun
+  });
+  for (const w of result.warnings) p3.log.warn(w);
+  if (opts.dryRun) {
+    for (const f of result.files) {
+      p3.log.step(pc3.bold(f.path));
+      process.stdout.write(f.content + "\n");
+    }
+    p3.log.step(pc3.bold("src/db/index.ts") + " would receive:");
+    process.stdout.write(
+      [...result.barrelLines.interfaces, ...result.barrelLines.daos].join("\n") + "\n"
+    );
+    p3.outro("Dry run: nothing written.");
+    return;
+  }
+  await formatFiles(root, [...result.files.map((f) => f.path), "src/db/index.ts"]);
+  p3.note(
+    [...result.files.map((f) => pc3.green("+ ") + f.path), pc3.yellow("~ ") + "src/db/index.ts"].join(
+      "\n"
+    ),
+    `Entity ${names.pascal}`
+  );
+  p3.note(
+    [
+      "npm run db:migrate",
+      "npm run typecheck && npm test",
+      `curl -X POST localhost:$PORT/api/${names.kebab} -H 'content-type: application/json' -d '{...}'`
+    ].join("\n"),
+    "Next steps"
+  );
+  p3.outro(pc3.green(`${names.pascal} generated.`) + pc3.dim(` Mounted at /api/${names.kebab}`));
+};
+var registerGenerateCommand = (program2) => {
+  const generate = program2.command("generate").alias("g").description("Generate code inside an existing project");
+  generate.command("entity").description(
+    "Generate migration, interface, DAO, DTOs, controller, router and tests for an entity"
+  ).argument("<name>", "entity name (product, productCategory, product-category...)").argument("[fields...]", `fields: ${FIELD_SYNTAX}`).option(
+    "--fields <spec>",
+    "fields as a single space separated string (alternative to positional)"
+  ).option("--no-tests", "do not generate test files").option("--no-migration", "do not generate the migration").option("--dry-run", "print what would be generated without writing").option("--force", "overwrite existing code files (never migrations)").action(async (name, fields, opts) => {
+    await runGenerateEntity(name, fields, opts);
+  });
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("sundaysf").description(
+  "Sundays Framework v3 \u2014 scaffold an Express 5 + Knex + Postgres API and generate entities"
+).version(cliVersion(), "-v, --version").showHelpAfterError();
+registerNewCommand(program);
+registerGenerateCommand(program);
+program.parseAsync(process.argv).catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(pc4.red("\u2716 ") + message);
+  process.exit(1);
+});