better-supabase 0.12.0 → 0.14.0

package/dist/cli/scaffold-CPH8sEhw.js

@@ -0,0 +1,901 @@
+import { a as list, p as commandMeta, r as defineCliCommand } from "./command-33pu13LT.js";
+import { n as CliError } from "./errors-BTe6A15O.js";
+import { t as display } from "./io-DH1kcmmP.js";
+import { t as isRecord } from "./guards-CUlDNYZs.js";
+import { t as detectProject } from "./detect-RApSAA8v.js";
+import { d as applyCasing, i as metaPaths } from "./emit-DbQeLlHt.js";
+import { t as importFresh } from "./fresh-import-DzgsGHkX.js";
+import { a as hasConflicts, n as applyPlan, r as changeLines, s as planResult, t as PLAN_ARGS } from "./files-C5JfVnj5.js";
+import { existsSync } from "node:fs";
+import { posix, resolve } from "node:path";
+import { FIELD_FORMATS, tenantNameOf } from "better-supabase/config";
+//#region src/cli/scaffold/api.ts
+const SCAFFOLD_FRAMEWORKS = ["hono", "next"];
+const GENERATED_HEADER = "// @generated by better-supabase scaffold. Do not edit; run `better-supabase scaffold api` again instead.";
+const join$2 = (...parts) => posix.normalize(posix.join(...parts));
+function importFrom$1(context, from, to) {
+	let path = posix.relative(posix.dirname(from), to);
+	if (!path.startsWith(".")) path = `./${path}`;
+	if (context.tsExtensions) return path;
+	return path.replace(/\.tsx?$/, "").replace(/^(\.\.?\/.+)\/index$/, "$1");
+}
+const quote$2 = (value) => JSON.stringify(value);
+function generatedModule(context) {
+	const names = context.tables.map(quote$2).join(", ");
+	const resources = context.tables.map((table) => `  ${/^[A-Za-z_$][\w$]*$/.test(table) ? table : quote$2(table)}: true,`).join("\n");
+	return `${GENERATED_HEADER}
+
+/** The tables served as REST resources and documented in the API model. */
+export const tableNames = [${names}] as const;
+
+export const resources = {
+${resources}
+} as const;
+
+export const basePath = ${quote$2(context.basePath)};
+`;
+}
+function apiModule(context, path, generated) {
+	return `import { defineApi } from 'better-supabase/spec';
+
+import { betterSupabase } from '${importFrom$1(context, path, join$2(context.srcDir, "lib", "supabase", "index.ts"))}';
+import { basePath, resources, tableNames } from '${importFrom$1(context, path, generated)}';
+
+export { basePath, resources, tableNames };
+
+/**
+ * The API model. Every OpenAPI version, and the other spec formats, render
+ * from it, and \`better-supabase spec emit\` reads it. Describe resources,
+ * add list queries and custom routes here: this file is yours, and
+ * \`better-supabase scaffold api\` never rewrites it.
+ */
+export const api = defineApi(betterSupabase, {
+  info: { title: 'API', version: '1.0.0' },
+  basePath,
+  resources,
+});
+`;
+}
+function nextFiles(context, api) {
+	const routeDir = join$2(context.srcDir, "app", context.basePath);
+	const resources = join$2(routeDir, "[...path]", "route.ts");
+	const spec = join$2(routeDir, "openapi.json", "route.ts");
+	const server = join$2(context.srcDir, "lib", "supabase", "server.ts");
+	return [{
+		path: resources,
+		generated: false,
+		contents: `import { basePath, resources } from '${importFrom$1(context, resources, api)}';
+import { bs } from '${importFrom$1(context, resources, server)}';
+
+export const { GET, POST, PATCH, PUT, DELETE } = bs.resources(resources, { basePath });
+`
+	}, {
+		path: spec,
+		generated: false,
+		contents: `import { specResponse } from 'better-supabase/spec';
+
+import { api } from '${importFrom$1(context, spec, api)}';
+
+const { document } = api.openapi();
+
+export const GET = (request: Request) => specResponse(document, request);
+`
+	}];
+}
+function honoFiles(context, api) {
+	const path = join$2(context.srcDir, `${context.name}-routes.ts`);
+	const server = join$2(context.srcDir, "server.ts");
+	return [{
+		path,
+		generated: false,
+		contents: `import { specResponse } from 'better-supabase/spec';
+
+import { api, basePath, tableNames } from '${importFrom$1(context, path, api)}';
+import type { bs as server } from '${importFrom$1(context, path, server)}';
+
+const { document } = api.openapi();
+
+/**
+ * The OpenAPI document and a REST resource per table. Mount it in
+ * server.ts with \`.route('/', apiRoutes(bs))\`.
+ */
+export function apiRoutes(bs: typeof server) {
+  const routes = bs
+    .app()
+    .get(\`\${basePath}/openapi.json\`, (c) => specResponse(document, c.req.raw))
+    .use(\`\${basePath}/*\`, bs.middleware());
+  for (const table of tableNames) routes.route(\`\${basePath}/\${table}\`, bs.resource(table));
+  return routes;
+}
+`
+	}];
+}
+/** The files `scaffold api` writes for a framework. */
+function scaffoldApiFiles(context) {
+	const lib = join$2(context.srcDir, "lib");
+	const generated = join$2(lib, `${context.name}.generated.ts`);
+	const api = join$2(lib, `${context.name}.ts`);
+	const shared = [{
+		path: generated,
+		generated: true,
+		contents: generatedModule(context)
+	}, {
+		path: api,
+		generated: false,
+		contents: apiModule(context, api, generated)
+	}];
+	switch (context.framework) {
+		case "next": return [...shared, ...nextFiles(context, api)];
+		case "hono": return [...shared, ...honoFiles(context, api)];
+		default: {
+			const unknown = context.framework;
+			throw new Error(`Unknown framework: ${String(unknown)}`);
+		}
+	}
+}
+/** What to do after the files are written. */
+function scaffoldNextSteps(context, specsEntry) {
+	const api = join$2(context.srcDir, "lib", `${context.name}.ts`);
+	const steps = [];
+	if (context.framework === "hono") steps.push(`Mount the routes in ${join$2(context.srcDir, "server.ts")}: \`.route('/', apiRoutes(bs))\`.`);
+	if (specsEntry !== api) steps.push(`Set \`specs: { entry: '${api}' }\` in better-supabase.config.ts, so \`better-supabase spec emit\` reads the API model.`);
+	steps.push(`Describe the resources in ${api}; \`scaffold api\` only rewrites ${context.name}.generated.ts.`);
+	return steps;
+}
+//#endregion
+//#region src/cli/scaffold/screens.ts
+/** Thrown for a table the screens can't serve; the message is for the user. */
+var ScreensError = class extends Error {};
+const NEXT_NAVIGATION = "next/navigation";
+const FUNCTION_DEFAULTS = /* @__PURE__ */ new Set([
+	"now()",
+	"gen_random_uuid()",
+	"auth.uid()"
+]);
+const quote$1 = (value) => `'${value.replaceAll("'", "\\'")}'`;
+const join$1 = (...parts) => posix.normalize(posix.join(...parts));
+const pascal = (name) => name.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+function labelOf(column) {
+	const text = column.replace(/_id$/, "").split("_").join(" ");
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function importFrom(context, from, to) {
+	let path = posix.relative(posix.dirname(from), to);
+	if (!path.startsWith(".")) path = `./${path}`;
+	return context.tsExtensions ? path : path.replace(/\.tsx?$/, "");
+}
+/** The literal a form starts from, or undefined for none or a function default. */
+function literalDefault(value) {
+	if (value === void 0 || FUNCTION_DEFAULTS.has(value)) return;
+	return value.replace(/^'(.*)'$/, "$1");
+}
+/** The first text column, which names a row on the list and in pickers. */
+function titleColumn(table) {
+	const columns = Object.entries(table.columns ?? {});
+	return table.subject?.title ?? columns.find(([, column]) => column.type === "text")?.[0] ?? "id";
+}
+function inputOf(column, config) {
+	if (column.identity === true || FUNCTION_DEFAULTS.has(column.default ?? "")) return;
+	if (column.references !== void 0) return "reference";
+	switch (column.type) {
+		case "text":
+			if (column.options !== void 0) return "select";
+			return column.format === void 0 ? "text" : FIELD_FORMATS[column.format].input;
+		case "uuid": return "text";
+		case "integer":
+		case "bigint":
+		case "numeric": return "number";
+		case "boolean": return "checkbox";
+		case "date": return "date";
+		case "timestamptz": return config.codecs.timestamptz === "instant" ? void 0 : "datetime";
+		case "jsonb":
+		case "text[]": return;
+		default: {
+			const unknown = column.type;
+			throw new Error(`Unknown column type: ${String(unknown)}`);
+		}
+	}
+}
+function fieldsOf(context, table) {
+	const { config } = context;
+	return Object.entries(table.columns ?? {}).map(([column, settings]) => {
+		const input = inputOf(settings, config);
+		const reference = settings.references;
+		const targetTable = reference !== void 0 && !("block" in reference) ? config.appTables[reference.table] : void 0;
+		if (input === void 0 && settings.nullable === false && settings.default === void 0 && settings.identity !== true) throw new ScreensError(`${context.table}.${column} is required, but the form has no input for a ${settings.type} column. Give it a default or make it nullable.`);
+		return {
+			column,
+			prop: applyCasing(column, config.casing),
+			label: labelOf(column),
+			config: settings,
+			input: input === "reference" && !targetTable ? "text" : input,
+			initial: literalDefault(settings.default),
+			target: targetTable && reference ? {
+				key: applyCasing(reference.table, config.casing),
+				title: applyCasing(titleColumn(targetTable), config.casing)
+			} : void 0
+		};
+	});
+}
+/** How a form value becomes the column's type, given the generated codecs. */
+function parseExpression(field, config) {
+	const name = quote$1(field.column);
+	if (field.input === "checkbox") return `form.get(${name}) === 'on'`;
+	const required = field.config.nullable === false;
+	const read = required ? `required(form, ${name})` : `optional(form, ${name})`;
+	const wrap = (parse) => required ? `${parse}(${read})` : `map(${read}, ${parse})`;
+	if (field.config.options !== void 0 && field.config.type === "text") {
+		const options = `[${field.config.options.map(quote$1).join(", ")}] as const`;
+		return required ? `oneOf(${read}, ${options})` : `map(${read}, (value) => oneOf(value, ${options}))`;
+	}
+	const { type } = field.config;
+	if (type === "integer") return wrap("Number");
+	if (type === "bigint") return INT8_PARSERS[config.codecs.int8](read, wrap);
+	if (type === "numeric") return config.codecs.numeric === "string" ? read : wrap("Number");
+	return type === "timestamptz" ? wrap("toTimestamp") : read;
+}
+const INT8_PARSERS = {
+	bigint: (_read, wrap) => wrap("BigInt"),
+	string: (read) => read,
+	number: (_read, wrap) => wrap("Number")
+};
+function namesOf(context, table) {
+	const { config } = context;
+	const scope = table.scope === void 0 || table.scope === "inherit" ? config.sql.scope ?? "tenant" : table.scope;
+	const bigintId = table.id === "bigint";
+	const idValue = bigintId ? config.codecs.int8 === "bigint" ? "BigInt(id)" : config.codecs.int8 === "string" ? "id" : "Number(id)" : "id";
+	return {
+		key: applyCasing(context.table, config.casing),
+		component: pascal(context.table),
+		href: context.basePath.split("/").filter((segment) => !/^\(.*\)$/.test(segment)).join("/"),
+		tenant: scope === "tenant" ? applyCasing(`${tenantNameOf(config.blocks) ?? "organization"}_id`, config.casing) : void 0,
+		deletedAt: table.subject?.softDelete === true ? applyCasing("deleted_at", config.casing) : void 0,
+		title: applyCasing(titleColumn(table), config.casing),
+		idPattern: bigintId ? String.raw`/^\d+$/` : String.raw`/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i`,
+		idValue
+	};
+}
+function whereOf(names, extra = []) {
+	const parts = [
+		...extra,
+		...names.tenant ? [`${names.tenant}: tenant`] : [],
+		...names.deletedAt ? [`${names.deletedAt}: { isNull: true }`] : []
+	];
+	return parts.length === 0 ? "" : `, where: { ${parts.join(", ")} }`;
+}
+function requireCall(names) {
+	return names.tenant ? "const { db, tenant } = await bs.require({ requireTenant: true });" : "const { db } = await bs.require();";
+}
+const SHOW = `/** A column value as text for the list and detail pages. */
+export function show(value: unknown): string {
+  if (value === null || value === undefined) {
+    return '';
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(show).join(', ');
+  }
+
+  if (typeof value === 'object' && value.toString === Object.prototype.toString) {
+    return JSON.stringify(value);
+  }
+
+  return String(value);
+}
+`;
+function listPage(context, names, fields, paths) {
+	const shown = fields.filter((field) => field.config.type !== "jsonb").slice(0, 5);
+	const props = [.../* @__PURE__ */ new Set([
+		"id",
+		names.title,
+		...shown.map((field) => field.prop)
+	])];
+	const order = context.config.appTables[context.table]?.timestamps !== false ? `, orderBy: { ${applyCasing("created_at", context.config.casing)}: 'desc' }` : "";
+	const cells = props.filter((prop) => prop !== "id").map((prop) => prop === names.title ? `            <td><Link href={\`${names.href}/\${row.id}\`}>{show(row.${prop}) || row.id}</Link></td>` : `            <td>{show(row.${prop})}</td>`);
+	const headers = props.filter((prop) => prop !== "id").map((prop) => `          <th>${fields.find((field) => field.prop === prop)?.label ?? labelOf(prop)}</th>`);
+	return `import Link from 'next/link';
+import { Suspense } from 'react';
+
+import { bs } from '${importFrom(context, paths.list, paths.server)}';
+import { show } from '${importFrom(context, paths.list, paths.show)}';
+
+export const metadata = { title: '${labelOf(context.table)}' };
+
+/**
+ * The ${context.table} list, written once by \`better-supabase scaffold screens\`.
+ * The record-grid recipe adds search, filters, saved views and bulk actions.
+ */
+export default function ${names.component}Page() {
+  return (
+    <main>
+      <h1>${labelOf(context.table)}</h1>
+      <p><Link href="${names.href}/new">New</Link></p>
+      <Suspense fallback={<p>Loading</p>}>
+        <${names.component}List />
+      </Suspense>
+    </main>
+  );
+}
+
+async function ${names.component}List() {
+  ${requireCall(names)}
+
+  const rows = await db.${names.key}
+    .findMany({ select: [${props.map(quote$1).join(", ")}]${whereOf(names)}${order}, limit: 100 })
+    .orThrow();
+
+  if (rows.length === 0) {
+    return <p>Nothing here yet. <Link href="${names.href}/new">Add the first one</Link>.</p>;
+  }
+
+  return (
+    <table>
+      <thead>
+        <tr>
+${headers.join("\n")}
+        </tr>
+      </thead>
+      <tbody>
+        {rows.map((row) => (
+          <tr key={row.id}>
+${cells.join("\n")}
+          </tr>
+        ))}
+      </tbody>
+    </table>
+  );
+}
+`;
+}
+function detailPage(context, names, fields, paths) {
+	const props = ["id", ...fields.map((field) => field.prop)];
+	const rows = fields.map((field) => `        <dt>${field.label}</dt>\n        <dd>{show(row.${field.prop})}</dd>`);
+	return `import Link from 'next/link';
+import { notFound } from '${NEXT_NAVIGATION}';
+import { Suspense } from 'react';
+
+import { bs } from '${importFrom(context, paths.detail, paths.server)}';
+import { show } from '${importFrom(context, paths.detail, paths.show)}';
+
+export const metadata = { title: '${labelOf(context.table)}' };
+
+/**
+ * One row of ${context.table}, written once by \`better-supabase scaffold screens\`.
+ * The record-page recipe adds the rows that reference it, comments and tags.
+ */
+export default function ${names.component}RecordPage({
+  params,
+}: {
+  params: Promise<{ id: string }>;
+}) {
+  return (
+    <main>
+      <p><Link href="${names.href}">All ${labelOf(context.table).toLowerCase()}</Link></p>
+      <Suspense fallback={<p>Loading</p>}>
+        <${names.component}Record params={params} />
+      </Suspense>
+    </main>
+  );
+}
+
+async function ${names.component}Record({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  if (!${names.idPattern}.test(id)) {
+    notFound();
+  }
+
+  ${requireCall(names)}
+
+  const row = await db.${names.key}
+    .findFirst({ select: [${props.map(quote$1).join(", ")}]${whereOf(names, [names.idValue === "id" ? "id" : `id: ${names.idValue}`])} })
+    .orThrow();
+
+  if (!row) {
+    notFound();
+  }
+
+  return (
+    <article>
+      <h1>{show(row.${names.title}) || row.id}</h1>
+      <dl>
+${rows.join("\n")}
+      </dl>
+    </article>
+  );
+}
+`;
+}
+function newPage(context, names, fields, paths) {
+	const targets = fields.flatMap((field) => field.input === "reference" && field.target ? [{
+		field,
+		...field.target
+	}] : []);
+	const loads = targets.map((target) => `db.${target.key}.findMany({ select: ['id', ${quote$1(target.title)}], limit: 200 }).orThrow()`);
+	const options = targets.map((target, index) => `      ${target.field.column}: ${targets.length === 1 ? "lists" : `lists[${index}]`}.map((row) => ({ value: String(row.id), label: String(row.${target.title} ?? row.id) })),`);
+	const header = `export const metadata = { title: 'New ${labelOf(context.table).toLowerCase()}' };
+
+/** The create form for ${context.table}, written once by \`better-supabase scaffold screens\`. */`;
+	if (targets.length === 0) return `import { ${names.component}Form } from '${importFrom(context, paths.newPage, paths.form)}';
+
+${header}
+export default function New${names.component}Page() {
+  return (
+    <main>
+      <h1>New ${labelOf(context.table).toLowerCase()}</h1>
+      <${names.component}Form />
+    </main>
+  );
+}
+`;
+	return `import { Suspense } from 'react';
+
+import { bs } from '${importFrom(context, paths.newPage, paths.server)}';
+import { ${names.component}Form } from '${importFrom(context, paths.newPage, paths.form)}';
+
+${header}
+export default function New${names.component}Page() {
+  return (
+    <main>
+      <h1>New ${labelOf(context.table).toLowerCase()}</h1>
+      <Suspense fallback={<p>Loading</p>}>
+        <${names.component}FormLoader />
+      </Suspense>
+    </main>
+  );
+}
+
+/** Loads the rows each reference picker lists. */
+async function ${names.component}FormLoader() {
+  const { db } = await bs.require(${names.tenant ? "{ requireTenant: true }" : ""});
+
+  const lists = ${targets.length === 1 ? `await ${loads[0]}` : `await Promise.all([\n    ${loads.join(",\n    ")},\n  ])`};
+
+  return (
+    <${names.component}Form
+      options={{
+${options.join("\n")}
+      }}
+    />
+  );
+}
+`;
+}
+function inputMarkup(field) {
+	const name = quote$1(field.column).replaceAll("'", "\"");
+	const required = field.config.nullable === false ? " required" : "";
+	const initial = field.initial === void 0 ? "" : ` defaultValue=${JSON.stringify(field.initial)}`;
+	const id = `id=${name}`;
+	const label = `        <label htmlFor=${name}>${field.label}</label>`;
+	switch (field.input) {
+		case "checkbox": return `        <label>
+          <input type="checkbox" name=${name}${field.initial === "true" ? " defaultChecked" : ""} /> ${field.label}
+        </label>`;
+		case "select": {
+			const choices = (field.config.options ?? []).map((option) => `          <option value=${JSON.stringify(option)}>${option}</option>`).join("\n");
+			return `${label}
+        <select ${id} name=${name}${required}${initial}>
+${field.config.nullable === false ? "" : "          <option value=\"\">None</option>\n"}${choices}
+        </select>`;
+		}
+		case "reference": return `${label}
+        <select ${id} name=${name}${required}>
+          <option value="">${field.config.nullable === false ? "Pick one" : "None"}</option>
+          {options[${name}]?.map((option) => (
+            <option key={option.value} value={option.value}>{option.label}</option>
+          ))}
+        </select>`;
+		case "textarea": return `${label}
+        <textarea ${id} name=${name}${required}${field.config.max === void 0 ? "" : ` maxLength={${field.config.max}}`}${initial} />`;
+		case "number": return `${label}
+        <input ${id} name=${name} type="number"${field.config.min === void 0 ? "" : ` min={${field.config.min}}`}${field.config.max === void 0 ? "" : ` max={${field.config.max}}`}${field.config.type === "numeric" ? " step=\"any\"" : ""}${required}${initial} />`;
+		case "datetime": return `${label}
+        <input ${id} name=${name} type="datetime-local"${required} />`;
+		case void 0: return "";
+		case "text":
+		case "email":
+		case "url":
+		case "tel":
+		case "color":
+		case "date": return `${label}
+        <input ${id} name=${name}${field.input === "text" ? "" : ` type="${field.input}"`}${field.config.type === "text" && field.config.max !== void 0 ? ` maxLength={${field.config.max}}` : ""}${required}${initial} />`;
+		default: {
+			const unknown = field.input;
+			throw new Error(`Unknown input: ${String(unknown)}`);
+		}
+	}
+}
+function formModule(context, names, fields, paths) {
+	const inputs = fields.filter((field) => field.input !== void 0).map((field) => `      <p>\n${inputMarkup(field)}\n      </p>`);
+	const pickers = fields.some((field) => field.input === "reference");
+	const props = pickers ? `{
+  options,
+}: {
+  options: Readonly<Record<string, readonly Option[]>>;
+}` : "";
+	const option = pickers ? `
+interface Option {
+  readonly value: string;
+  readonly label: string;
+}
+` : "";
+	return `'use client';
+
+import { useActionState } from 'react';
+
+import { create${names.component} } from '${importFrom(context, paths.form, paths.actions)}';
+${option}
+/**
+ * The create form. Each column gets the input its type, format and options
+ * call for; the record-form recipe swaps the selects for searchable pickers.
+ */
+export function ${names.component}Form(${props}) {
+  const [state, action, pending] = useActionState(create${names.component}, { error: null });
+
+  return (
+    <form action={action}>
+${inputs.join("\n")}
+      {state.error ? <p role="alert">{state.error}</p> : null}
+      <button type="submit" disabled={pending}>Create</button>
+    </form>
+  );
+}
+`;
+}
+function actionsModule(context, names, fields, paths) {
+	const values = fields.filter((field) => field.input !== void 0).map((field) => `    ${field.prop}: ${parseExpression(field, context.config)},`);
+	const tenant = names.tenant ? `, ${names.tenant}: tenant` : "";
+	const code = values.join("\n");
+	const helpers = HELPERS.filter(([name]) => code.includes(`${name}(`)).map(([, source]) => `${source}\n`).join("");
+	return `'use server';
+
+import { redirect } from '${NEXT_NAVIGATION}';
+
+import { bs } from '${importFrom(context, paths.actions, paths.server)}';
+
+export interface CreateState {
+  readonly error: string | null;
+}
+
+/** A form value the action refuses; the message is shown on the form. */
+class FieldError extends Error {}
+
+${helpers}function valuesOf(form: FormData) {
+  return {
+${values.join("\n")}
+  };
+}
+
+/** Creates a row from the form, then opens it. The table's policies check the caller. */
+export async function create${names.component}(
+  _state: CreateState,
+  form: FormData,
+): Promise<CreateState> {
+  ${requireCall(names)}
+
+  let values: ReturnType<typeof valuesOf>;
+
+  try {
+    values = valuesOf(form);
+  } catch (error) {
+    if (error instanceof FieldError) {
+      return { error: error.message };
+    }
+
+    throw error;
+  }
+
+  const created = await db.${names.key}.create({ ...values${tenant} }, { select: ['id'] });
+
+  if (!created.ok) {
+    return { error: created.error.message };
+  }
+
+  redirect(\`${names.href}/\${created.data.id}\`);
+}
+`;
+}
+const HELPERS = [
+	["optional", `function optional(form: FormData, name: string): string | null {
+  const value = form.get(name);
+
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : null;
+}
+`],
+	["required", `function required(form: FormData, name: string): string {
+  const value = form.get(name);
+
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new FieldError(\`Fill in \${name}.\`);
+  }
+
+  return value.trim();
+}
+`],
+	["map", `function map<T>(value: string | null, parse: (value: string) => T): T | null {
+  return value === null ? null : parse(value);
+}
+`],
+	["oneOf", `function oneOf<const T extends string>(value: string, options: readonly T[]): T {
+  const found = options.find((option) => option === value);
+
+  if (found === undefined) {
+    throw new FieldError(\`\${value} is not one of the options.\`);
+  }
+
+  return found;
+}
+`],
+	["toTimestamp", `function toTimestamp(value: string): string {
+  return new Date(value).toISOString();
+}
+`]
+];
+/** The pages `scaffold screens <table>` writes for Next.js, each written once. */
+function scaffoldScreensFiles(context) {
+	const table = context.config.appTables[context.table];
+	if (!table) {
+		const known = Object.keys(context.config.appTables);
+		throw new ScreensError(known.length === 0 ? `"${context.table}" is not an app table, and the config has none. Add it under appTables first.` : `"${context.table}" is not an app table. App tables: ${known.join(", ")}.`);
+	}
+	if (table.scope === "none") throw new ScreensError(`${context.table} has scope "none", so only the service role writes it. Screens need a table the caller writes.`);
+	if (/[[\]]/.test(context.basePath)) throw new ScreensError(`--base-path takes a static route, got "${context.basePath}". Move the pages under a dynamic segment yourself.`);
+	const fields = fieldsOf(context, table);
+	const names = namesOf(context, table);
+	const dir = join$1(context.srcDir, "app", context.basePath);
+	const ext = (name, tsx) => join$1(dir, `${name}.${tsx ? "tsx" : "ts"}`);
+	const paths = {
+		server: join$1(context.srcDir, "lib", "supabase", "server.ts"),
+		show: ext("show", false),
+		list: ext("page", true),
+		newPage: join$1(dir, "new", "page.tsx"),
+		detail: join$1(dir, "[id]", "page.tsx"),
+		form: ext("form", true),
+		actions: ext("actions", false)
+	};
+	return [
+		{
+			path: paths.list,
+			generated: false,
+			contents: listPage(context, names, fields, paths)
+		},
+		{
+			path: paths.newPage,
+			generated: false,
+			contents: newPage(context, names, fields, paths)
+		},
+		{
+			path: paths.detail,
+			generated: false,
+			contents: detailPage(context, names, fields, paths)
+		},
+		{
+			path: paths.form,
+			generated: false,
+			contents: formModule(context, names, fields, paths)
+		},
+		{
+			path: paths.actions,
+			generated: false,
+			contents: actionsModule(context, names, fields, paths)
+		},
+		{
+			path: paths.show,
+			generated: false,
+			contents: SHOW
+		}
+	];
+}
+//#endregion
+//#region src/cli/commands/scaffold.ts
+const ARGS = {
+	framework: {
+		type: "string",
+		description: "hono or next. Defaults to the one in package.json",
+		valueHint: "name"
+	},
+	tables: {
+		type: "string",
+		description: "Tables to serve. Defaults to every table and view in the public schema",
+		valueHint: "list"
+	},
+	name: {
+		type: "string",
+		description: "The API module's name: lib/<name>.ts and lib/<name>.generated.ts. Defaults to api",
+		valueHint: "name"
+	},
+	"base-path": {
+		type: "string",
+		description: "Where the resources are served. Defaults to /api",
+		valueHint: "path"
+	}
+};
+const SCREENS_ARGS = {
+	table: {
+		type: "positional",
+		required: false,
+		description: "The app table to write pages for"
+	},
+	framework: {
+		type: "string",
+		description: "next. Defaults to next when package.json lists it",
+		valueHint: "name"
+	},
+	"base-path": {
+		type: "string",
+		description: "The route the pages live under. Defaults to /<table>",
+		valueHint: "path"
+	}
+};
+const isFramework = (value) => SCAFFOLD_FRAMEWORKS.some((framework) => framework === value);
+/**
+* The public tables and views in the metadata module `gen` writes, or undefined
+* without one.
+*/
+async function generatedTables(config) {
+	const path = resolve(config.root, metaPaths(config.output).js);
+	if (!existsSync(path)) return;
+	const meta = (await importFresh(path))["default"];
+	const tables = isRecord(meta) ? meta["tables"] : void 0;
+	if (!isRecord(tables)) return;
+	return Object.entries(tables).filter(([, table]) => isRecord(table) && table["schema"] === "public" && (table["kind"] === "table" || table["kind"] === "view")).map(([key]) => key);
+}
+async function runScaffoldApi(config, args, options = {}) {
+	const configured = config.scaffold.api ?? {};
+	const project = await detectProject(config.root);
+	const detected = project.frameworks.filter(isFramework);
+	const chosen = args.framework ?? configured.framework;
+	const framework = chosen ?? (detected.length === 1 ? detected[0] : void 0);
+	if (!isFramework(framework)) throw new CliError("usage", chosen === void 0 ? "Pass --framework hono or --framework next, or set scaffold.api.framework." : `--framework takes hono or next, got "${chosen}".`);
+	const name = args.name ?? configured.name ?? "api";
+	if (!/^[a-z][\w-]*$/i.test(name)) throw new CliError("usage", `--name must be a file name without a folder, got "${name}".`);
+	const basePath = `/${(args["base-path"] ?? configured.basePath ?? "/api").replaceAll(/^\/+|\/+$/g, "")}`;
+	const known = await generatedTables(config);
+	const requested = args.tables === void 0 ? [...configured.tables ?? []] : list(args.tables);
+	if (requested.length === 0 && !known) return {
+		code: 1,
+		errorCode: "not_found",
+		error: `No ${display(config.root, metaPaths(config.output).js)}. Run \`better-supabase gen\` first, or pass --tables.`
+	};
+	const unknown = known ? requested.filter((table) => !known.includes(table)) : [];
+	if (unknown.length > 0) return {
+		code: 1,
+		error: `Unknown tables: ${unknown.join(", ")}. Known tables: ${known?.join(", ")}.`
+	};
+	const tables = requested.length > 0 ? requested : known ?? [];
+	if (tables.length === 0) return {
+		code: 1,
+		error: "There are no public tables to serve. Pass --tables."
+	};
+	const context = {
+		framework,
+		srcDir: project.srcDir,
+		tsExtensions: project.tsExtensions,
+		name,
+		basePath,
+		tables
+	};
+	const plan = {
+		root: config.root,
+		regenerate: "better-supabase scaffold api",
+		files: scaffoldApiFiles(context).filter((file) => options.generatedOnly !== true || file.generated).map((file) => ({
+			path: file.path,
+			contents: file.contents,
+			policy: file.generated ? "owned" : "create"
+		}))
+	};
+	const applied = await applyPlan(plan, {
+		...args,
+		...options.check === true ? { check: true } : {}
+	});
+	const files = applied.changes;
+	const lines = changeLines(applied);
+	if (applied.mode !== "write" || options.generatedOnly === true || hasConflicts(applied)) return planResult(plan, applied, { data: {
+		framework,
+		tables
+	} });
+	const steps = scaffoldNextSteps(context, config.specs.entry);
+	const save = config.scaffold.api === void 0 ? [
+		"",
+		"Add this to your config so `better-supabase gen` keeps the generated file current:",
+		`  scaffold: { api: ${scaffoldSnippet({
+			framework,
+			...name === "api" ? {} : { name },
+			...basePath === "/api" ? {} : { basePath },
+			...requested.length > 0 ? { tables: requested } : {}
+		})} }`
+	] : [];
+	return {
+		code: 0,
+		output: [
+			...lines,
+			"",
+			"Next:",
+			...steps.map((step) => `- ${step}`),
+			...save
+		].join("\n"),
+		data: {
+			framework,
+			tables,
+			files,
+			steps
+		}
+	};
+}
+/** Writes list, create and detail pages for one app table, each once. */
+async function runScaffoldScreens(config, args) {
+	const { table } = args;
+	if (table === void 0) throw new CliError("usage", "Name the app table: `better-supabase scaffold screens <table>`.");
+	const project = await detectProject(config.root);
+	const framework = args.framework ?? (project.frameworks.includes("next") ? "next" : void 0);
+	if (framework !== "next") throw new CliError("usage", framework === void 0 ? "Screens are Next.js pages, and package.json has no next. Pass --framework next." : `Screens are Next.js pages; --framework ${framework} has none.`);
+	const basePath = `/${(args["base-path"] ?? table).replaceAll(/^\/+|\/+$/g, "")}`;
+	let files;
+	try {
+		files = scaffoldScreensFiles({
+			config,
+			table,
+			srcDir: project.srcDir,
+			tsExtensions: project.tsExtensions,
+			basePath
+		});
+	} catch (error) {
+		if (error instanceof ScreensError) return {
+			code: 1,
+			errorCode: "invalid_input",
+			error: error.message
+		};
+		throw error;
+	}
+	const plan = {
+		root: config.root,
+		regenerate: "better-supabase scaffold screens",
+		files: files.map((file) => ({
+			path: file.path,
+			contents: file.contents,
+			policy: "create"
+		}))
+	};
+	const applied = await applyPlan(plan, args);
+	if (applied.mode !== "write" || hasConflicts(applied)) return planResult(plan, applied, { data: {
+		table,
+		basePath
+	} });
+	const steps = [`Open ${basePath} in \`next dev\`. The pages call \`bs\` from lib/supabase/server; \`better-supabase add next\` writes it if you don't have one.`, "The files are yours. For search, saved views, a board or a calendar, start from the record-* recipes: https://bettersupabase.com/docs/registry/ui-recipes"];
+	return {
+		code: 0,
+		output: [
+			...changeLines(applied),
+			"",
+			"Next:",
+			...steps.map((step) => `- ${step}`)
+		].join("\n"),
+		data: {
+			table,
+			basePath,
+			files: applied.changes,
+			steps
+		}
+	};
+}
+const quote = (value) => `'${value}'`;
+const scaffoldSnippet = (api) => `{ ${Object.entries(api).map(([key, value]) => `${key}: ${typeof value === "string" ? quote(value) : `[${value.map(quote).join(", ")}]`}`).join(", ")} }`;
+const scaffoldApiCommand = defineCliCommand({
+	meta: commandMeta("scaffold api"),
+	args: {
+		...ARGS,
+		...PLAN_ARGS
+	},
+	lists: ["tables"],
+	run: (args, { config }) => runScaffoldApi(config, args)
+});
+const scaffoldScreensCommand = defineCliCommand({
+	meta: commandMeta("scaffold screens"),
+	args: {
+		...SCREENS_ARGS,
+		...PLAN_ARGS
+	},
+	run: (args, { config }) => runScaffoldScreens(config, args)
+});
+//#endregion
+export { scaffoldScreensCommand as i, runScaffoldScreens as n, scaffoldApiCommand as r, runScaffoldApi as t };