@starci/hfs 4.0.8 → 4.0.10

package/scaffold/add-inbox-lite.mjs

@@ -0,0 +1,314 @@
+import fs from "node:fs";
+import path from "node:path";
+import { render, TEMPLATES_DIR } from "../sync/index.mjs";
+import { ScaffoldError, pascalOf } from "./service.mjs";
+import { filesBelow } from "./lite-exports.mjs";
+
+const MIGRATION = /^(\d{14})_[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.sql$/;
+const PLACEHOLDER = /@@([A-Za-z][A-Za-z0-9]*)@@/g;
+
+const timestampOf = (now) =>
+  new Date(now()).toISOString().replace(/\D/g, "").slice(0, 14);
+const upperOf = (name) => name.replaceAll("-", "_").toUpperCase();
+const snakeOf = (name) => name.replaceAll("-", "_");
+
+const template = (relative, values) => {
+  const file = path.join(TEMPLATES_DIR, "be", "inbox", relative);
+  const text = fs.readFileSync(file, "utf8").replace(/\r\n/g, "\n");
+  return text.replace(PLACEHOLDER, (whole, name) => {
+    if (values[name] === undefined)
+      throw new ScaffoldError(
+        "HFS_ADD_PLACEHOLDER_UNKNOWN",
+        `template be/inbox/${relative} uses ${whole}, which the lite webhook does not provide`,
+      );
+    return values[name];
+  });
+};
+
+/** Lite replaces only the webhook door; the full-edition pattern remains byte-identical. */
+export const selectLiteWebhookEntries = (entries) =>
+  entries.map((entry) =>
+    entry.template === "webhooks/webhook.door.ts.tpl"
+      ? { ...entry, template: "../inbox/webhook-door.ts.tpl" }
+      : entry,
+  );
+
+const matchingBrace = (text, open) => {
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    if (text[index] === "{") depth += 1;
+    else if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+};
+
+const addEntityManagerImport = (text) => {
+  if (/import type \{[^}]*\bEntityManager\b[^}]*\} from "typeorm"/.test(text))
+    return text;
+  return `import type { EntityManager } from "typeorm"\n${text}`;
+};
+
+/** Gives the selected domain intake the transaction manager while preserving its existing processing body. */
+function adaptedDomainService({ root, service, serviceModule, provider, Provider }) {
+  const prefix = "@modules/domain/";
+  if (!serviceModule.startsWith(prefix))
+    throw new ScaffoldError(
+      "HFS_ADD_INBOX_SERVICE",
+      `lite add webhook needs a domain service module below ${prefix}`,
+    );
+  const owner = path.join(
+    root,
+    "be",
+    "src",
+    "modules",
+    "domain",
+    ...serviceModule.slice(prefix.length).split("/"),
+  );
+  const candidates = filesBelow(owner).filter(
+    (file) =>
+      file.endsWith(".service.ts") &&
+      new RegExp(`\\bexport\\s+class\\s+${service}\\b`).test(
+        fs.readFileSync(file, "utf8"),
+      ),
+  );
+  if (candidates.length !== 1)
+    throw new ScaffoldError(
+      "HFS_ADD_INBOX_SERVICE",
+      `${serviceModule} must export exactly one ${service} class from a .service.ts file before adding the ${provider} webhook`,
+    );
+  const file = candidates[0];
+  let text = fs.readFileSync(file, "utf8").replace(/\r\n/g, "\n");
+  const method = `accept${Provider}Delivery`;
+  const methodAt = text.search(new RegExp(`\\b${method}\\s*\\(`));
+  if (methodAt < 0)
+    throw new ScaffoldError(
+      "HFS_ADD_INBOX_INTAKE",
+      `${service} must declare ${method}(delivery) before adding the ${provider} webhook`,
+    );
+  const paramsOpen = text.indexOf("(", methodAt);
+  const paramsClose = text.indexOf(")", paramsOpen);
+  const bodyOpen = text.indexOf("{", paramsClose);
+  const bodyClose = matchingBrace(text, bodyOpen);
+  if (paramsClose < 0 || bodyOpen < 0 || bodyClose < 0)
+    throw new ScaffoldError(
+      "HFS_ADD_INBOX_INTAKE",
+      `${service}.${method} is not a readable method declaration`,
+    );
+  const parameters = text.slice(paramsOpen + 1, paramsClose).trim();
+  if (/(?:^|,)\s*(?:manager|entityManager)\s*:/.test(parameters)) return { file, text };
+  const manager =
+    /private\s+readonly\s+([A-Za-z][A-Za-z0-9]*)\s*:\s*EntityManager/.exec(
+      text,
+    )?.[1];
+  if (!manager)
+    throw new ScaffoldError(
+      "HFS_ADD_INBOX_INTAKE",
+      `${service}.${method} needs an injected EntityManager so the inbox can keep its processing in one transaction`,
+    );
+  const body = text
+    .slice(bodyOpen + 1, bodyClose)
+    .replaceAll(`this.${manager}`, "entityManager");
+  text = `${text.slice(0, paramsOpen + 1)}${parameters}, entityManager: EntityManager = this.${manager}${text.slice(paramsClose, bodyOpen + 1)}${body}${text.slice(bodyClose)}`;
+  return { file, text: addEntityManagerImport(text) };
+}
+
+const databasePatches = (root) => {
+  const folder = path.join(root, "be", "src", "modules", "platform", "database");
+  const indexFile = path.join(folder, "index.ts");
+  const errorFile = path.join(folder, "errors", "database.error.ts");
+  if (!fs.existsSync(indexFile) || !fs.existsSync(errorFile))
+    throw new ScaffoldError(
+      "HFS_ADD_INBOX_DATABASE",
+      "lite add webhook needs the scaffolded platform/database capability",
+    );
+  let index = fs.readFileSync(indexFile, "utf8").replace(/\r\n/g, "\n");
+  if (!index.includes('export { acceptWebhookDelivery } from "./webhook-inbox.client"'))
+    index = `${index.replace(/\n+$/, "")}\nexport { acceptWebhookDelivery } from "./webhook-inbox.client"\n`;
+  let error = fs.readFileSync(errorFile, "utf8").replace(/\r\n/g, "\n");
+  const enumLine =
+    '    WebhookDeliveryIdRequired = "DATABASE_WEBHOOK_DELIVERY_ID_REQUIRED",';
+  if (!error.includes(enumLine)) {
+    const after =
+      '    IdentifierRejected = "DATABASE_IDENTIFIER_REJECTED",';
+    const mapping =
+      '    [DatabaseErrorCode.IdentifierRejected]: "internal",';
+    if (!error.includes(after) || !error.includes(mapping))
+      throw new ScaffoldError(
+        "HFS_ADD_INBOX_DATABASE",
+        "platform/database has an unknown error-family shape",
+      );
+    error = error
+      .replace(after, `${after}\n    /** A signed delivery omitted the provider's non-empty idempotency key. */\n${enumLine}`)
+      .replace(
+        mapping,
+        `${mapping}\n    [DatabaseErrorCode.WebhookDeliveryIdRequired]: "invalid",`,
+      );
+  }
+  return [
+    { file: indexFile, text: index },
+    { file: errorFile, text: error },
+  ];
+};
+
+const wiredAppModule = ({ root, repo, provider, Provider }) => {
+  const app = repo.sides.be.apps.find((entry) => entry.kind === "api");
+  if (!app)
+    throw new ScaffoldError(
+      "HFS_ADD_NO_API_OWNER",
+      "add webhook needs a declared lite api app",
+    );
+  const file = path.join(root, "be", "apps", app.name, "src", "app.module.ts");
+  const relative = `be/apps/${app.name}/src/app.module.ts`;
+  if (!fs.existsSync(file))
+    throw new ScaffoldError(
+      "HFS_ADD_WIRE_MISSING",
+      `add webhook registers its inbox in ${relative}, which does not exist`,
+    );
+  const symbol = `${Provider}InboxModule`;
+  const importLine = `import { ${symbol} } from "@modules/domain/${provider}-inbox"`;
+  const lines = fs.readFileSync(file, "utf8").replace(/\r\n/g, "\n").split("\n");
+  const lastImport = lines.reduce(
+    (last, line, index) => (line.startsWith("import ") ? index : last),
+    -1,
+  );
+  const imports = lines.findIndex((line) => /^\s*imports: \[$/.test(line));
+  if (lastImport < 0 || imports < 0)
+    throw new ScaffoldError(
+      "HFS_ADD_WIRE_INVALID",
+      `add webhook could not find the imports array in ${relative}`,
+    );
+  if (!lines.includes(importLine)) {
+    lines.splice(lastImport + 1, 0, importLine);
+    const shiftedImports = imports > lastImport ? imports + 1 : imports;
+    const indent = /^(\s*)/.exec(lines[shiftedImports])?.[1] ?? "";
+    lines.splice(
+      shiftedImports + 1,
+      0,
+      `${indent}    ${symbol}.register({ isGlobal: true }),`,
+    );
+  }
+  return { file, text: `${lines.join("\n").replace(/\n+$/, "")}\n` };
+};
+
+/** Writes the lite provider inbox and adapts the selected domain intake to share its transaction. */
+export function addLiteWebhookInbox({
+  root,
+  repo,
+  noun,
+  provider,
+  values,
+  now = Date.now,
+}) {
+  if (repo.edition !== "lite" || noun !== "webhook") return [];
+  const Provider = pascalOf(provider);
+  const table = `${snakeOf(provider)}_inbox`;
+  const migrationsDir = path.join(root, "supabase", "migrations");
+  const migrations = fs.existsSync(migrationsDir)
+    ? fs.readdirSync(migrationsDir).filter((file) => MIGRATION.test(file)).sort()
+    : [];
+  const suffix = `${provider}-inbox.sql`;
+  if (migrations.some((file) => file.endsWith(`_${suffix}`)))
+    throw new ScaffoldError(
+      "HFS_ADD_EXISTS",
+      `webhook ${provider} already has an inbox migration`,
+    );
+  const stamp = timestampOf(now);
+  const latest = migrations.at(-1)?.slice(0, 14);
+  if (latest && stamp <= latest)
+    throw new ScaffoldError(
+      "HFS_ADD_MIGRATION_ORDER",
+      `the current UTC timestamp ${stamp} is not later than the latest migration ${latest}; fix the clock or wait for the next second`,
+    );
+  const renderValues = {
+    ...values,
+    provider,
+    Provider,
+    providerUpper: upperOf(provider),
+    table,
+  };
+  const base = `be/src/modules/domain/${provider}-inbox`;
+  const planned = [
+    {
+      relative: `supabase/migrations/${stamp}_${suffix}`,
+      text: template("migration.sql.tpl", renderValues),
+    },
+    { relative: `${base}/index.ts`, text: template("index.ts.tpl", renderValues) },
+    {
+      relative: `${base}/${provider}-inbox.module-definition.ts`,
+      text: template("module-definition.ts.tpl", renderValues),
+    },
+    {
+      relative: `${base}/${provider}-inbox.options.ts`,
+      text: template("options.ts.tpl", renderValues),
+    },
+    {
+      relative: `${base}/${provider}-inbox.module.ts`,
+      text: template("module.ts.tpl", renderValues),
+    },
+    {
+      relative: `${base}/${provider}-inbox.service.ts`,
+      text: template("service.ts.tpl", renderValues),
+    },
+    {
+      relative: `${base}/persistence/${provider}-inbox.sql.ts`,
+      text: template("sql.ts.tpl", renderValues),
+    },
+  ];
+  const databaseSql = "be/src/modules/platform/database/database.sql.ts";
+  if (!fs.existsSync(path.join(root, ...databaseSql.split("/")))) {
+    planned.push({
+      relative: databaseSql,
+      text: render(
+        fs.readFileSync(
+          path.join(TEMPLATES_DIR, "be", "skeleton-lite", "src", "modules", "platform", "database", "database.sql.ts"),
+          "utf8",
+        ),
+        {},
+      ),
+    });
+  }
+  const databaseClient = path.join(
+    root,
+    "be",
+    "src",
+    "modules",
+    "platform",
+    "database",
+    "webhook-inbox.client.ts",
+  );
+  if (!fs.existsSync(databaseClient))
+    planned.push({
+      relative: "be/src/modules/platform/database/webhook-inbox.client.ts",
+      text: template("database-client.ts.tpl", renderValues),
+    });
+  const clashes = planned
+    .filter((entry) => fs.existsSync(path.join(root, ...entry.relative.split("/"))))
+    .map((entry) => entry.relative);
+  if (clashes.length)
+    throw new ScaffoldError(
+      "HFS_ADD_EXISTS",
+      `webhook ${provider} inbox already exists: ${clashes.join(", ")}`,
+    );
+  const servicePatch = adaptedDomainService({
+    root,
+    service: values.service,
+    serviceModule: values.serviceModule,
+    provider,
+    Provider,
+  });
+  const patches = [
+    servicePatch,
+    ...databasePatches(root),
+    wiredAppModule({ root, repo, provider, Provider }),
+  ];
+  for (const entry of planned) {
+    const target = path.join(root, ...entry.relative.split("/"));
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, entry.text);
+  }
+  for (const patch of patches) fs.writeFileSync(patch.file, patch.text);
+  return planned.map((entry) => entry.relative);
+}

package/scaffold/add-table.mjs

@@ -0,0 +1,344 @@
+import fs from "node:fs";
+import path from "node:path";
+import { emitDbTypes, dbTypesPath } from "../emit/db-types.mjs";
+import {
+  loadSlotManifest,
+  readRepoDeclaration,
+} from "../runtime/scripts/hfs/slots.mjs";
+import { render, TEMPLATES_DIR } from "../sync/index.mjs";
+import { ScaffoldError, pascalOf } from "./service.mjs";
+import { registerLiteExports } from "./lite-exports.mjs";
+
+const NAME = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/;
+const MIGRATION = /^(\d{14})_[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.sql$/;
+const POSTGRES_RESERVED = new Set([
+  "all",
+  "analyse",
+  "analyze",
+  "and",
+  "any",
+  "array",
+  "as",
+  "asc",
+  "asymmetric",
+  "authorization",
+  "binary",
+  "both",
+  "case",
+  "cast",
+  "check",
+  "collate",
+  "collation",
+  "column",
+  "concurrently",
+  "constraint",
+  "create",
+  "cross",
+  "current_catalog",
+  "current_date",
+  "current_role",
+  "current_schema",
+  "current_time",
+  "current_timestamp",
+  "current_user",
+  "default",
+  "deferrable",
+  "desc",
+  "distinct",
+  "do",
+  "else",
+  "end",
+  "except",
+  "false",
+  "fetch",
+  "for",
+  "foreign",
+  "freeze",
+  "from",
+  "full",
+  "grant",
+  "group",
+  "having",
+  "ilike",
+  "in",
+  "initially",
+  "inner",
+  "intersect",
+  "into",
+  "is",
+  "isnull",
+  "join",
+  "lateral",
+  "leading",
+  "left",
+  "like",
+  "limit",
+  "localtime",
+  "localtimestamp",
+  "natural",
+  "not",
+  "notnull",
+  "null",
+  "nulls",
+  "offset",
+  "on",
+  "only",
+  "or",
+  "order",
+  "outer",
+  "overlaps",
+  "placing",
+  "primary",
+  "references",
+  "returning",
+  "right",
+  "select",
+  "session_user",
+  "similar",
+  "some",
+  "symmetric",
+  "system_user",
+  "table",
+  "tablesample",
+  "then",
+  "to",
+  "trailing",
+  "true",
+  "union",
+  "unique",
+  "user",
+  "using",
+  "variadic",
+  "verbose",
+  "when",
+  "where",
+  "window",
+  "with",
+]);
+
+const timestampOf = (now) =>
+  new Date(now()).toISOString().replace(/\D/g, "").slice(0, 14);
+const snakeOf = (name) => name.replaceAll("-", "_");
+const featureOf = (name) => name.replaceAll("_", "-");
+const sqlIdentifierOf = (name) =>
+  POSTGRES_RESERVED.has(name) ? `"${name}"` : name;
+const singularOf = (name) => (name.endsWith("s") ? name.slice(0, -1) : name);
+const camelOf = (name) => {
+  const pascal = pascalOf(name);
+  return pascal[0].toLowerCase() + pascal.slice(1);
+};
+
+function template(relative, values) {
+  const file = path.join(TEMPLATES_DIR, ...relative.split("/"));
+  if (!fs.existsSync(file))
+    throw new ScaffoldError(
+      "HFS_ADD_TEMPLATE_MISSING",
+      `table template ${relative} is not carried by this package`,
+    );
+  return fs
+    .readFileSync(file, "utf8")
+    .replace(/\{\{([A-Za-z][A-Za-z0-9]*)\}\}/g, (whole, key) => {
+      if (values[key] === undefined)
+        throw new ScaffoldError(
+          "HFS_ADD_PLACEHOLDER_UNKNOWN",
+          `table template ${relative} uses ${whole}, which add table does not provide`,
+        );
+      return values[key];
+    });
+}
+
+function removeEmptyParents(file, stop) {
+  for (
+    let at = path.dirname(file);
+    at.startsWith(stop) && at !== stop;
+    at = path.dirname(at)
+  ) {
+    if (!fs.existsSync(at) || fs.readdirSync(at).length !== 0) break;
+    fs.rmdirSync(at);
+  }
+}
+
+function wireApiModule(root, app, name) {
+  const relative = `be/apps/${app}/src/app.module.ts`;
+  const file = path.join(root, ...relative.split("/"));
+  if (!fs.existsSync(file))
+    throw new ScaffoldError("HFS_ADD_WIRE_MISSING", `add table registers ${name} in ${relative}, which does not exist`);
+  const symbol = `${pascalOf(name)}Module`;
+  const errorKinds = `${snakeOf(name).toUpperCase()}_ERROR_KINDS`;
+  const importLine = `import { ${errorKinds}, ${symbol} } from "@modules/domain/${name}"`;
+  const lines = fs.readFileSync(file, "utf8").replace(/\r\n/g, "\n").split("\n");
+  const lastImport = lines.reduce((last, line, index) => (line.startsWith("import ") ? index : last), -1);
+  const imports = lines.findIndex((line) => /^\s*imports: \[$/.test(line));
+  const kinds = lines.findIndex((line) => /^\s*kinds: \[$/.test(line));
+  if (lastImport < 0 || imports < 0 || kinds < 0)
+    throw new ScaffoldError("HFS_ADD_WIRE_INVALID", `add table could not find the imports and error kinds arrays in ${relative}`);
+  if (!lines.includes(importLine)) {
+    lines.splice(lastImport + 1, 0, importLine);
+    const shiftedImports = lines.findIndex((line) => /^\s*imports: \[$/.test(line));
+    const indent = /^(\s*)/.exec(lines[shiftedImports])?.[1] ?? "";
+    lines.splice(shiftedImports + 1, 0, `${indent}    ${symbol}.register({ isGlobal: true }),`);
+    const shiftedKinds = lines.findIndex((line) => /^\s*kinds: \[$/.test(line));
+    const kindsIndent = /^(\s*)/.exec(lines[shiftedKinds])?.[1] ?? "";
+    lines.splice(shiftedKinds + 1, 0, `${kindsIndent}    ${errorKinds},`);
+  }
+  fs.writeFileSync(file, `${lines.join("\n").replace(/\n+$/, "")}\n`);
+}
+
+/**
+ * Adds one Supabase table migration and, with `fe`, one typed reader/writer pair to every declared Next app.
+ * `emitTypes` returns the generated database.types.ts text; false is the explicit `--no-types` seam.
+ */
+export function addTable({
+  root,
+  name,
+  fe = false,
+  emitTypes = emitDbTypes,
+  now = Date.now,
+}) {
+  const requestedName = String(name);
+  if (!NAME.test(requestedName))
+    throw new ScaffoldError(
+      "HFS_ADD_NAME_INVALID",
+      `table name ${name} must use lowercase letters, digits and single dash or underscore separators`,
+    );
+  const feature = featureOf(requestedName);
+  const table = snakeOf(requestedName);
+  const manifest = loadSlotManifest();
+  const repo = readRepoDeclaration(manifest, root);
+  const connection = repo.sides?.be?.connections?.find((candidate) => candidate.provider === "supabase");
+  if (!connection) {
+    throw new ScaffoldError(
+      "HFS_ADD_TABLE_PROVIDER",
+      "add table needs a back-end connection whose provider is supabase",
+    );
+  }
+
+  const migrationsDir = path.join(root, "supabase", "migrations");
+  const migrations = fs.existsSync(migrationsDir)
+    ? fs
+        .readdirSync(migrationsDir)
+        .filter((file) => MIGRATION.test(file))
+        .sort()
+    : [];
+  if (migrations.some((file) => file.endsWith(`_${feature}.sql`)))
+    throw new ScaffoldError(
+      "HFS_ADD_EXISTS",
+      `table ${requestedName} already has a migration`,
+    );
+  const stamp = timestampOf(now);
+  const latest = migrations.at(-1)?.slice(0, 14);
+  if (latest && stamp <= latest)
+    throw new ScaffoldError(
+      "HFS_ADD_MIGRATION_ORDER",
+      `the current UTC timestamp ${stamp} is not later than the latest migration ${latest}; fix the clock or wait for the next second`,
+    );
+
+  const values = {
+    name: feature,
+    table,
+    tableSql: sqlIdentifierOf(table),
+    Name: pascalOf(feature),
+    nameCamel: camelOf(feature),
+    upper: table.toUpperCase(),
+    singular: singularOf(feature),
+    Singular: pascalOf(singularOf(feature)),
+  };
+  const planned = [
+    {
+      relative: `supabase/migrations/${stamp}_${feature}.sql`,
+      body: template("be/table/migration.sql.tpl", values),
+    },
+    { relative: `be/src/modules/domain/${feature}/index.ts`, body: template("be/table/index.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/errors/${feature}.error.ts`, body: template("be/table/error.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/${feature}.module.ts`, body: template("be/table/module.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/${feature}.module-definition.ts`, body: template("be/table/module-definition.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/${feature}.options.ts`, body: template("be/table/options.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/${feature}.service.ts`, body: template("be/table/service.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/persistence/${feature}.rows.ts`, body: template("be/table/rows.ts.tpl", values) },
+    { relative: `be/src/modules/domain/${feature}/persistence/${feature}.sql.ts`, body: template("be/table/sql.ts.tpl", values) },
+  ];
+  const databaseSql = "be/src/modules/platform/database/database.sql.ts";
+  if (repo.edition === "lite" && !fs.existsSync(path.join(root, ...databaseSql.split("/")))) {
+    planned.splice(1, 0, {
+      relative: databaseSql,
+      body: render(fs.readFileSync(path.join(TEMPLATES_DIR, "be", "skeleton-lite", "src", "modules", "platform", "database", "database.sql.ts"), "utf8"), {}),
+    });
+  }
+  if (fe) {
+    const apps =
+      repo.sides?.fe?.apps?.filter((app) => app.kind === "next") ?? [];
+    if (!apps.length)
+      throw new ScaffoldError(
+        "HFS_ADD_NO_FRONT_END",
+        "add table --fe needs at least one declared Next app",
+      );
+    for (const app of apps) {
+      const base = `fe/apps/${app.name}/src/modules/db/${feature}`;
+      planned.push(
+        {
+          relative: `${base}/read-${feature}.ts`,
+          body: template("fe/table/read.ts.tpl", values),
+        },
+        {
+          relative: `${base}/write-${feature}.ts`,
+          body: template("fe/table/write.ts.tpl", values),
+        },
+      );
+    }
+  }
+
+  const clash = planned
+    .filter((file) =>
+      fs.existsSync(path.join(root, ...file.relative.split("/"))),
+    )
+    .map((file) => file.relative);
+  if (clash.length)
+    throw new ScaffoldError(
+      "HFS_ADD_EXISTS",
+      `table ${requestedName} already exists: ${clash.join(", ")}`,
+    );
+  const owner = repo.sides.be.apps.find((app) => app.name === connection.owner && app.kind === "api");
+  if (!owner)
+    throw new ScaffoldError("HFS_ADD_NO_API_OWNER", `add table needs the Supabase connection owner ${connection.owner} to be a declared api app`);
+  const ownerFile = path.join(root, "be", "apps", owner.name, "src", "app.module.ts");
+  if (!fs.existsSync(ownerFile))
+    throw new ScaffoldError("HFS_ADD_WIRE_MISSING", `add table registers ${name} in be/apps/${owner.name}/src/app.module.ts, which does not exist`);
+  const ownerBefore = fs.readFileSync(ownerFile, "utf8");
+  const databaseIndex = path.join(root, "be", "src", "modules", "platform", "database", "index.ts");
+  const databaseIndexBefore = repo.edition === "lite" && fs.existsSync(databaseIndex) ? fs.readFileSync(databaseIndex) : null;
+  const typesFile = path.join(root, ...dbTypesPath.split("/"));
+  const typesBefore = fs.existsSync(typesFile) ? fs.readFileSync(typesFile) : null;
+  const created = [];
+  try {
+    for (const file of planned) {
+      const target = path.join(root, ...file.relative.split("/"));
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, file.body);
+      created.push(target);
+    }
+    if (emitTypes !== false) {
+      const generated = emitTypes({ root });
+      if (typeof generated === "string") {
+        const target = path.join(root, ...dbTypesPath.split("/"));
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, generated);
+      }
+    }
+    wireApiModule(root, owner.name, feature);
+    if (repo.edition === "lite") registerLiteExports({ root, generator: "table" });
+  } catch (error) {
+    fs.writeFileSync(ownerFile, ownerBefore);
+    if (databaseIndexBefore !== null) fs.writeFileSync(databaseIndex, databaseIndexBefore);
+    if (typesBefore === null) fs.rmSync(typesFile, { force: true });
+    else fs.writeFileSync(typesFile, typesBefore);
+    for (const file of [...created].reverse()) {
+      if (fs.existsSync(file)) fs.rmSync(file);
+      removeEmptyParents(file, root);
+    }
+    throw error;
+  }
+  return {
+    created: planned.map((file) => file.relative),
+    types: emitTypes === false ? "skipped" : dbTypesPath,
+  };
+}