better-supabase 0.14.0 → 0.15.0

package/dist/json-schema-Ca6gYbEP.js

@@ -0,0 +1,888 @@
+import { t as isList } from "./guards-6F2bCtQR.js";
+import { i as tableJsonSchema, r as fieldJsonSchema, t as forTarget } from "./table-schema-CD8cJz_M.js";
+import { i as entityNames } from "./entity-naming-Dtyq5sKE.js";
+//#region src/generators/shared.ts
+const INTEGER$1 = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8"
+]);
+const NUMBER$1 = /* @__PURE__ */ new Set([
+	"float4",
+	"float8",
+	"numeric",
+	"oid",
+	"money"
+]);
+const DATETIME = /* @__PURE__ */ new Set(["timestamptz"]);
+function scalarKind(column) {
+	if (column.enum) return {
+		kind: "enum",
+		values: column.enum
+	};
+	if (column.json) return { kind: "json" };
+	if (column.codec === "instant") return { kind: "instant" };
+	if (column.codec === "plainDateTime") return { kind: "plainDateTime" };
+	if (column.codec === "bigint") return { kind: "bigint" };
+	if (column.codec === "string") return { kind: "string" };
+	if (column.type === "uuid") return { kind: "uuid" };
+	if (INTEGER$1.has(column.type)) return { kind: "integer" };
+	if (NUMBER$1.has(column.type)) return { kind: "number" };
+	if (column.type === "bool") return { kind: "boolean" };
+	if (DATETIME.has(column.type)) return { kind: "datetime" };
+	if (column.type === "date") return { kind: "date" };
+	if (column.type === "record" || column.type === "void") return { kind: "unknown" };
+	return { kind: "string" };
+}
+/** App names of the columns that plugins fill from the table's flags. */
+function managedColumns(table) {
+	const { timestamps, actor, softDelete } = table.flags;
+	return new Set([
+		timestamps?.createdAt,
+		timestamps?.updatedAt,
+		actor?.createdBy,
+		actor?.updatedBy,
+		actor?.impersonatedBy,
+		softDelete
+	].filter((name) => name !== void 0));
+}
+/**
+* The generated row type of a field (its element type for arrays). Storage path
+* columns validate as strings and are cast to their `StoragePath` brand.
+*/
+function rowType(table, plan) {
+	const type = `NonNullable<RowOf<'${table}'>['${plan.name}']>`;
+	return plan.column.array ? `${type}[number]` : type;
+}
+/** The fields a variant accepts; read-only columns are left out of writes. */
+function fieldsFor(table, variant, input) {
+	const fields = [];
+	const managed = managedColumns(table);
+	for (const [name, column] of Object.entries(table.columns)) {
+		if (variant === "Insert" && (column.generated || column.insertable === false)) continue;
+		if (variant === "Update" && (column.generated || column.updatable === false)) continue;
+		fields.push({
+			name,
+			column,
+			scalar: scalarKind(column),
+			nullable: column.nullable,
+			optional: variant === "Update" || variant === "Insert" && (column.nullable || column.hasDefault),
+			customJson: Boolean(column.json && (input.config.json[`${table.schema}.${table.name}.${column.db}`] ?? input.config.json[`${table.name}.${column.db}`])),
+			managed: managed.has(name)
+		});
+	}
+	return fields;
+}
+const TEMPORAL_GUARDS = {
+	instant: "isInstant",
+	plainDate: "isPlainDate",
+	plainDateTime: "isPlainDateTime"
+};
+/**
+* The `better-supabase` guards the generated validators call. They check
+* `Symbol.toStringTag`, so the module never reads `Temporal` when it loads.
+*/
+function temporalGuardImport(input, extraKinds = []) {
+	const names = /* @__PURE__ */ new Set();
+	for (const kind of extraKinds) {
+		const guard = TEMPORAL_GUARDS[kind];
+		if (guard) names.add(guard);
+	}
+	for (const [, table] of tableEntries(input)) for (const plan of fieldsFor(table, "Row", input)) {
+		if (plan.customJson || plan.column.storage !== void 0) continue;
+		const guard = TEMPORAL_GUARDS[plan.scalar.kind];
+		if (guard) names.add(guard);
+	}
+	return names.size === 0 ? void 0 : `import { ${[...names].toSorted().join(", ")} } from ${JSON.stringify(input.runtimeImport ?? "better-supabase")};`;
+}
+const EXAMPLE = /^\s*@example\s+(.+?)\s*$/gm;
+const DEPRECATED = /^\s*@deprecated\b.*$/gm;
+const IS_DEPRECATED = /^\s*@deprecated\b/m;
+/**
+* Splits a comment into its description and `@example` lines. An example is
+* JSON (`@example 42`, `@example "KVK-1"`) or, when it doesn't parse, text. A
+* `@deprecated` line (with or without text) sets `deprecated` and is left out
+* of the description.
+*/
+function parseComment(comment) {
+	if (!comment) return { examples: [] };
+	const deprecated = IS_DEPRECATED.test(comment);
+	const examples = [...comment.matchAll(EXAMPLE)].map((match) => {
+		const raw = match[1] ?? "";
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return raw;
+		}
+	});
+	const description = comment.replaceAll(EXAMPLE, "").replaceAll(DEPRECATED, "").trim();
+	return {
+		...description ? { description } : {},
+		examples,
+		...deprecated ? { deprecated: true } : {}
+	};
+}
+const COMPARISON = /^(?:(char_length|length)\(\(?"?(\w+)"?\)?(?:::[\w ]+)?\)|\(?"?(\w+)"?\)?(?:::[\w ]+)?)\s*(>=|>|<=|<)\s*\(?'?(-?\d+(?:\.\d+)?)'?\)?(?:::[\w ]+)?$/;
+const REVERSED = /^\(?'?(-?\d+(?:\.\d+)?)'?\)?(?:::[\w ]+)?\s*(>=|>|<=|<)\s*(?:(char_length|length)\(\(?"?(\w+)"?\)?(?:::[\w ]+)?\)|\(?"?(\w+)"?\)?(?:::[\w ]+)?)$/;
+const FLIP = {
+	">=": "<=",
+	">": "<",
+	"<=": ">=",
+	"<": ">"
+};
+/** Drops parentheses that wrap the whole expression. */
+function unwrap(expression) {
+	let text = expression.trim().replace(/^CHECK\s*/, "");
+	while (text.startsWith("(") && text.endsWith(")")) {
+		let depth = 0;
+		let wraps = true;
+		for (let i = 0; i < text.length - 1; i += 1) {
+			if (text[i] === "(") depth += 1;
+			else if (text[i] === ")") depth -= 1;
+			if (depth === 0) {
+				wraps = false;
+				break;
+			}
+		}
+		if (!wraps) break;
+		text = text.slice(1, -1).trim();
+	}
+	return text;
+}
+/** Terms of a top-level `AND` chain. */
+function conjuncts(expression) {
+	const terms = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < expression.length; i += 1) {
+		const char = expression[i];
+		if (char === "(") depth += 1;
+		else if (char === ")") depth -= 1;
+		else if (depth === 0 && expression.startsWith(" AND ", i)) {
+			terms.push(expression.slice(start, i));
+			start = i + 5;
+		}
+	}
+	terms.push(expression.slice(start));
+	return terms.map(unwrap);
+}
+function comparison(term) {
+	const forward = COMPARISON.exec(term);
+	if (forward) return {
+		column: forward[2] ?? forward[3] ?? "",
+		length: forward[1] !== void 0,
+		operator: forward[4],
+		value: Number(forward[5])
+	};
+	const reversed = REVERSED.exec(term);
+	if (!reversed) return;
+	return {
+		column: reversed[4] ?? reversed[5] ?? "",
+		length: reversed[3] !== void 0,
+		operator: FLIP[reversed[2]],
+		value: Number(reversed[1])
+	};
+}
+/**
+* Bounds from simple CHECK constraints, by column: `price >= 0`, `rating
+* between 1 and 5`, `char_length(name) <= 200`. Terms joined by `OR`, functions
+* other than `length` and `char_length`, and comparisons between columns are
+* left out.
+*/
+function parseCheckBounds(definition) {
+	const bounds = /* @__PURE__ */ new Map();
+	for (const term of conjuncts(unwrap(definition))) {
+		if (/\sOR\s/i.test(term)) continue;
+		const parsed = comparison(term);
+		if (!parsed?.column || Number.isNaN(parsed.value)) continue;
+		const current = bounds.get(parsed.column) ?? {};
+		bounds.set(parsed.column, {
+			...current,
+			...boundOf(parsed)
+		});
+	}
+	return bounds;
+}
+function boundOf({ length, operator, value }) {
+	if (length) switch (operator) {
+		case ">=": return { minLength: value };
+		case ">": return { minLength: value + 1 };
+		case "<=": return { maxLength: value };
+		case "<": return { maxLength: value - 1 };
+		default: return operator;
+	}
+	switch (operator) {
+		case ">=": return { minimum: value };
+		case ">": return { exclusiveMinimum: value };
+		case "<=": return { maximum: value };
+		case "<": return { exclusiveMaximum: value };
+		default: return operator;
+	}
+}
+/** `customer_tags` → `Customer tags`. */
+function titleOf(name) {
+	const words = name.replaceAll("_", " ").trim();
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+const docsIndexes = /* @__PURE__ */ new WeakMap();
+const checkIndexes = /* @__PURE__ */ new WeakMap();
+/** CHECK definitions by `schema.name`, built once per extras. */
+function checksIndex(extras) {
+	let index = checkIndexes.get(extras);
+	if (index) return index;
+	const map = /* @__PURE__ */ new Map();
+	for (const table of extras.tables) {
+		const key = `${table.schema}.${table.name}`;
+		map.set(key, [...map.get(key) ?? [], ...table.checks.map((check) => check.definition)]);
+	}
+	index = map;
+	checkIndexes.set(extras, index);
+	return index;
+}
+/** The catalog keyed for `tableDocs`, built once per catalog. */
+function docsIndex(catalog) {
+	let index = docsIndexes.get(catalog);
+	if (index) return index;
+	const entries = /* @__PURE__ */ new Map();
+	for (const item of [
+		...catalog.tables,
+		...catalog.views,
+		...catalog.materializedViews ?? []
+	]) {
+		const key = `${item.schema}.${item.name}`;
+		if (!entries.has(key)) entries.set(key, item);
+	}
+	const columns = /* @__PURE__ */ new Map();
+	for (const column of catalog.columns) {
+		const list = columns.get(column.table_id);
+		if (list) list.push(column);
+		else columns.set(column.table_id, [column]);
+	}
+	index = {
+		entries,
+		columns
+	};
+	docsIndexes.set(catalog, index);
+	return index;
+}
+/** Title, description and per-column docs, or `undefined` without a catalog. */
+function tableDocs(input, table) {
+	const catalog = input.introspection;
+	if (!catalog) return;
+	const index = docsIndex(catalog);
+	const entry = index.entries.get(`${table.schema}.${table.name}`);
+	const checks = /* @__PURE__ */ new Map();
+	const addChecks = (definition) => {
+		for (const [column, bounds] of parseCheckBounds(definition)) checks.set(column, {
+			...checks.get(column),
+			...bounds
+		});
+	};
+	const extras = input.extras;
+	for (const definition of extras ? checksIndex(extras).get(`${table.schema}.${table.name}`) ?? [] : []) addChecks(definition);
+	const fields = /* @__PURE__ */ new Map();
+	for (const column of entry ? index.columns.get(entry.id) ?? [] : []) {
+		if (column.check) addChecks(column.check);
+		const { description, examples } = parseComment(column.comment);
+		fields.set(column.name, {
+			...description === void 0 ? {} : { description },
+			...examples.length > 0 ? { examples } : {}
+		});
+	}
+	for (const [column, bounds] of checks) fields.set(column, {
+		...fields.get(column),
+		...bounds
+	});
+	const { description } = parseComment(entry?.comment ?? null);
+	return {
+		title: titleOf(table.name),
+		...description === void 0 ? {} : { description },
+		fields
+	};
+}
+/** A variant's title: `Customers`, `Customers insert`, `Customers update`. */
+function variantTitle(docs, variant) {
+	return variant === "Row" ? docs.title : `${docs.title} ${variant.toLowerCase()}`;
+}
+function exampleFits(scalar, value) {
+	switch (scalar.kind) {
+		case "uuid":
+		case "string":
+		case "datetime":
+		case "date": return typeof value === "string";
+		case "enum": return typeof value === "string" && scalar.values.includes(value);
+		case "integer": return Number.isInteger(value);
+		case "number": return typeof value === "number";
+		case "boolean": return typeof value === "boolean";
+		case "json":
+		case "unknown": return true;
+		case "instant":
+		case "plainDate":
+		case "plainDateTime":
+		case "bigint": return false;
+		default: return scalar;
+	}
+}
+/**
+* The docs a field's validator can carry: value bounds on numbers, length
+* bounds on text, and only examples its type accepts.
+*/
+function fieldDocs(docs, plan) {
+	const found = docs?.fields.get(plan.column.db);
+	if (!found || plan.customJson || plan.column.storage !== void 0) return {};
+	const numeric = !plan.column.array && (plan.scalar.kind === "integer" || plan.scalar.kind === "number");
+	const text = !plan.column.array && plan.scalar.kind === "string";
+	const fits = (value) => value === null && plan.nullable || (plan.column.array ? Array.isArray(value) && value.every((item) => exampleFits(plan.scalar, item)) : exampleFits(plan.scalar, value));
+	const examples = found.examples?.filter(fits) ?? [];
+	return {
+		...found.description === void 0 ? {} : { description: found.description },
+		...examples.length > 0 ? { examples } : {},
+		...numeric ? pick(found, [
+			"minimum",
+			"exclusiveMinimum",
+			"maximum",
+			"exclusiveMaximum"
+		]) : {},
+		...text ? pick(found, ["minLength", "maxLength"]) : {}
+	};
+}
+/**
+* A field as `tableSchema()` and `tableJsonSchema()` read it. A jsonb column
+* with a configured TypeScript type becomes `custom`; set `schema` on the
+* result for one with a validator.
+*/
+function fieldSpec(plan, docs) {
+	return {
+		...plan.customJson ? { kind: "custom" } : plan.scalar,
+		...plan.nullable ? { nullable: true } : {},
+		...plan.optional ? { optional: true } : {},
+		...plan.column.array ? { array: true } : {},
+		...plan.managed ? { readOnly: true } : {},
+		...docs
+	};
+}
+function pick(bounds, keys) {
+	const out = {};
+	for (const key of keys) {
+		const value = bounds[key];
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function optionalLine(line) {
+	return line === void 0 ? [] : [line];
+}
+function variantsFor(table) {
+	if (table.kind !== "view") return [
+		"Row",
+		"Insert",
+		"Update"
+	];
+	const columns = Object.values(table.columns).filter((column) => !column.generated);
+	return [
+		"Row",
+		...columns.some((column) => column.insertable !== false) ? ["Insert"] : [],
+		...columns.some((column) => column.updatable !== false) ? ["Update"] : []
+	];
+}
+function tableEntries(input) {
+	return Object.entries(input.meta.tables).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+}
+function propertyKey(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+/** `customerTags` + `Insert` → `customerTagsInsert`. */
+function schemaName(table, variant) {
+	return `${table.replace(/^[A-Z]/, (c) => c.toLowerCase())}${variant}`;
+}
+/** Output path next to the main module: `generated.ts` → `generated.zod.ts`. */
+function siblingPath(output, suffix) {
+	return output.replace(/(\.[cm]?ts)?$/, `.${suffix}`);
+}
+const HEADER = "// Generated by better-supabase. Do not edit; run `better-supabase gen`.\n";
+/**
+* `./metadata.ts#metadataSchema` → `{ from: './metadata.ts', name:
+* 'metadataSchema' }`.
+*/
+function parseImport(spec) {
+	const [from, name] = spec.split("#");
+	if (!from || !name) throw new Error(`Expected "path#export", got "${spec}"`);
+	return {
+		from,
+		name
+	};
+}
+//#endregion
+//#region src/generators/extras.ts
+const INTEGER = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8"
+]);
+const NUMBER = /* @__PURE__ */ new Set([
+	"float4",
+	"float8",
+	"numeric",
+	"oid",
+	"money"
+]);
+const KIND_SUFFIX = {
+	input: "Input",
+	change: "Change",
+	listFilter: "ListFilter"
+};
+const ENTITY_SCHEMA_KINDS = [
+	"input",
+	"change",
+	"listFilter"
+];
+const ROW_RESULT = /^Models\["([^"]+)"\]\['Row'\](\[\]| \| null)$/;
+function lowerFirst(name) {
+	return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function camel(name) {
+	return lowerFirst(name.replaceAll(/[_-]([a-zA-Z0-9])/g, (_, c) => c.toUpperCase()));
+}
+/** `workItemId` and `work_item_id` → `Work item id`. */
+function labelOf(name) {
+	return titleOf(name.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase());
+}
+/** `(string | null)[]` → `string`. */
+function elementType(tsType) {
+	return tsType.replace(/\[\]$/, "").replace(/^\((.*)\)$/, "$1").replace(/ \| null$/, "");
+}
+/**
+* The scalar kind of a function argument or result, from its Postgres type and
+* the TypeScript type `gen` wrote (which reflects the configured codecs).
+*/
+function typeScalar(pgType, tsType, values) {
+	if (values && values.length > 0) return {
+		kind: "enum",
+		values
+	};
+	switch (tsType) {
+		case "Temporal.Instant": return { kind: "instant" };
+		case "Temporal.PlainDateTime": return { kind: "plainDateTime" };
+		case "bigint": return { kind: "bigint" };
+		case "Json": return { kind: "json" };
+	}
+	const pg = pgType?.replace(/^_/, "");
+	if (pg === "uuid") return { kind: "uuid" };
+	if (pg !== void 0 && INTEGER.has(pg) && tsType === "number") return { kind: "integer" };
+	if (pg === "timestamptz" && tsType === "string") return { kind: "datetime" };
+	if (pg === "date" && tsType === "string") return { kind: "date" };
+	if (pg !== void 0 && NUMBER.has(pg) && tsType === "number") return { kind: "number" };
+	switch (tsType) {
+		case "number": return { kind: "number" };
+		case "boolean": return { kind: "boolean" };
+		case "string": return { kind: "string" };
+		default: return { kind: "unknown" };
+	}
+}
+function argsSchema(fn, input) {
+	if (fn.args.length === 0 || fn.args.some((arg) => arg.name === "")) return;
+	const meta = input.meta.functions[fn.key];
+	const fields = {};
+	for (const arg of fn.args) {
+		const pgType = meta?.args.find((each) => each.name === arg.name)?.type;
+		const spec = { ...typeScalar(pgType, elementType(arg.tsType), arg.values) };
+		fields[arg.name] = {
+			...spec,
+			...arg.tsType.endsWith("[]") ? { array: true } : {},
+			...arg.optional ? { optional: true } : {}
+		};
+	}
+	return {
+		name: `${camel(fn.key)}Args`,
+		title: `${fn.key} arguments`,
+		fields
+	};
+}
+function resultSchema(fn, input) {
+	const name = `${camel(fn.key)}Result`;
+	const title = `${fn.key} result`;
+	const row = ROW_RESULT.exec(fn.returns);
+	if (row?.[1] !== void 0) {
+		const set = row[2] === "[]";
+		return {
+			name,
+			title,
+			set,
+			nullable: !set,
+			of: {
+				kind: "row",
+				table: row[1]
+			}
+		};
+	}
+	if (fn.returns.startsWith("{")) return;
+	const element = fn.returnsSet ? fn.returns.replace(/\[\]$/, "").replace(/^\((.*)\)$/, "$1") : fn.returns;
+	const scalar = typeScalar(input.meta.functions[fn.key]?.returns, elementType(element), void 0);
+	if (scalar.kind === "unknown") return;
+	return {
+		name,
+		title,
+		set: fn.returnsSet,
+		nullable: element.endsWith(" | null"),
+		of: {
+			kind: "scalar",
+			scalar
+		}
+	};
+}
+function renamedInput(schema, rename, name) {
+	return {
+		name,
+		title: rename(schema.title),
+		fields: Object.fromEntries(Object.entries(schema.fields).map(([field, spec]) => [rename(field), spec]))
+	};
+}
+function blockInputs(block) {
+	const names = entityNames(block.entities.filter((entity) => entity.from.singular !== entity.to.singular).map((entity) => ({
+		from: entity.from,
+		to: entity.to
+	})));
+	return block.entities.flatMap((entity) => ENTITY_SCHEMA_KINDS.flatMap((kind) => {
+		const schema = entity.schemas[kind];
+		return schema === void 0 ? [] : [renamedInput(schema, (identifier) => names.rename(identifier), `${camel(entity.to.singular)}${KIND_SUFFIX[kind]}`)];
+	}));
+}
+/**
+* The schemas beside the table ones: each function's arguments and result, and
+* each installed block's inputs under the names the config gives its entities.
+* Overloaded functions are left out: one schema can't pick a signature.
+*/
+function extraSchemas(input) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const fn of input.model.functions) counts.set(fn.key, (counts.get(fn.key) ?? 0) + 1);
+	const functions = input.model.functions.filter((fn) => counts.get(fn.key) === 1).toSorted((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	return {
+		inputs: [...functions.flatMap((fn) => {
+			const schema = argsSchema(fn, input);
+			return schema ? [schema] : [];
+		}), ...input.model.blocks.flatMap((block) => blockInputs(block))],
+		results: functions.flatMap((fn) => {
+			const schema = resultSchema(fn, input);
+			return schema ? [schema] : [];
+		})
+	};
+}
+/** Every scalar kind the extra schemas use, for the Temporal guard import. */
+function extraKinds(extras) {
+	return [...extras.inputs.flatMap((schema) => Object.values(schema.fields).map((field) => field.kind)), ...extras.results.flatMap((result) => result.of.kind === "scalar" ? [result.of.scalar.kind] : [])].filter((kind) => kind !== "custom");
+}
+/** The TypeScript type a field validates to. */
+function fieldType(spec) {
+	let type = scalarType(spec);
+	if (spec.array) type = `${type.includes(" | ") ? `(${type})` : type}[]`;
+	return spec.nullable ? `${type} | null` : type;
+}
+function scalarType(spec) {
+	switch (spec.kind) {
+		case "uuid":
+		case "string":
+		case "datetime":
+		case "date": return "string";
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "instant": return "Temporal.Instant";
+		case "plainDate": return "Temporal.PlainDate";
+		case "plainDateTime": return "Temporal.PlainDateTime";
+		case "bigint": return "bigint";
+		case "json": return "Json";
+		case "enum": return spec.values.map((value) => JSON.stringify(value)).join(" | ");
+		case "unknown":
+		case "custom": return "unknown";
+		default: return spec;
+	}
+}
+/** `{ title: string; estimate?: number | null }`. */
+function objectType(schema) {
+	const entries = Object.entries(schema.fields).map(([name, spec]) => `${propertyKey(name)}${spec.optional ? "?" : ""}: ${fieldType(spec)}`);
+	return entries.length === 0 ? "Record<never, never>" : `{ ${entries.join("; ")} }`;
+}
+/** The TypeScript type a result schema validates to. */
+function resultType(result) {
+	const item = result.of.kind === "row" ? `RowOf<'${result.of.table}'>` : fieldType({
+		...result.of.scalar,
+		nullable: result.set && result.nullable
+	});
+	if (result.set) return `${item.includes(" | ") ? `(${item})` : item}[]`;
+	return result.nullable ? `${item} | null` : item;
+}
+function metaOf(name, spec, label) {
+	return {
+		label: label ?? labelOf(name),
+		required: spec.optional !== true && spec.nullable !== true,
+		...spec.kind === "enum" ? { options: spec.values } : {},
+		...spec.minimum === void 0 ? {} : { minimum: spec.minimum },
+		...spec.exclusiveMinimum === void 0 ? {} : { exclusiveMinimum: spec.exclusiveMinimum },
+		...spec.maximum === void 0 ? {} : { maximum: spec.maximum },
+		...spec.exclusiveMaximum === void 0 ? {} : { exclusiveMaximum: spec.exclusiveMaximum },
+		...spec.minLength === void 0 ? {} : { minLength: spec.minLength },
+		...spec.maxLength === void 0 ? {} : { maxLength: spec.maxLength }
+	};
+}
+/** A short one-line comment labels its column; anything longer is a description. */
+function commentLabel(description) {
+	return description !== void 0 && description.length <= 60 && !description.includes("\n") ? description.replace(/\.$/, "") : void 0;
+}
+/**
+* Form metadata by schema: every writable table's Insert fields, keyed by
+* table, and every extra input schema, keyed by its export name.
+*/
+function fieldMeta(input, extras) {
+	const out = {};
+	for (const [key, table] of tableEntries(input)) {
+		if (!variantsFor(table).includes("Insert")) continue;
+		const docs = tableDocs(input, table);
+		const fields = {};
+		for (const plan of fieldsFor(table, "Insert", input)) {
+			const found = fieldDocs(docs, plan);
+			const spec = plan.customJson ? { kind: "custom" } : { ...plan.scalar };
+			fields[plan.name] = metaOf(plan.column.db, {
+				...spec,
+				...found,
+				...plan.optional ? { optional: true } : {},
+				...plan.nullable ? { nullable: true } : {}
+			}, commentLabel(found.description));
+		}
+		out[key] = fields;
+	}
+	for (const schema of extras.inputs) out[schema.name] = Object.fromEntries(Object.entries(schema.fields).map(([name, spec]) => [name, metaOf(name, spec)]));
+	return out;
+}
+/** `export const fieldMeta = { ... } as const;` for the TypeScript generators. */
+function fieldMetaLines(input, extras) {
+	const meta = fieldMeta(input, extras);
+	const lines = [
+		"",
+		"/** Labels, required flags, options and bounds for each writable field, for forms. */",
+		"export const fieldMeta = {"
+	];
+	for (const [schema, fields] of Object.entries(meta)) {
+		lines.push(`  ${propertyKey(schema)}: {`);
+		for (const [name, field] of Object.entries(fields)) lines.push(`    ${propertyKey(name)}: ${JSON.stringify(field)},`);
+		lines.push("  },");
+	}
+	lines.push("} as const;");
+	return lines;
+}
+//#endregion
+//#region src/generators/json-schema-target.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null && !isList(value);
+}
+/** Keywords whose value is one subschema. */
+const SINGLE = /* @__PURE__ */ new Set([
+	"additionalProperties",
+	"additionalItems",
+	"contains",
+	"propertyNames",
+	"not",
+	"if",
+	"then",
+	"else"
+]);
+/** Keywords whose value is a list of subschemas. */
+const LISTS = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf"
+]);
+/** Keywords whose value maps names to subschemas. */
+const MAPS = /* @__PURE__ */ new Set([
+	"properties",
+	"patternProperties",
+	"definitions"
+]);
+/** 2020-12 keywords draft-07 has no equivalent for; draft-07 would ignore them. */
+const DROPPED = /* @__PURE__ */ new Set([
+	"$dynamicAnchor",
+	"$anchor",
+	"unevaluatedProperties",
+	"unevaluatedItems"
+]);
+function mapValues(value, convert) {
+	if (!isObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, isObject(child) ? convert(child) : child]));
+}
+/**
+* Rewrites a 2020-12 schema into draft-07: `$defs` becomes `definitions` (and
+* `$ref`s into it follow), `prefixItems` becomes the array form of `items`,
+* `dependentRequired` and `dependentSchemas` become `dependencies`, and
+* keywords without a draft-07 form are left out. A draft-07 schema passes
+* through unchanged.
+*/
+function toDraft07(schema) {
+	const out = {};
+	const dependencies = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (DROPPED.has(key)) continue;
+		if (key === "$schema") continue;
+		if (key === "$defs") out["definitions"] = mapValues(value, toDraft07);
+		else if (key === "$ref" || key === "$dynamicRef") out["$ref"] = typeof value === "string" ? value.replace(/^#\/\$defs\//, "#/definitions/") : value;
+		else if (key === "prefixItems" && isList(value)) out["items"] = value.map((item) => isObject(item) ? toDraft07(item) : item);
+		else if (key === "items") {
+			const converted = isObject(value) ? toDraft07(value) : value;
+			if (schema["prefixItems"] === void 0) out["items"] = converted;
+			else out["additionalItems"] = converted;
+		} else if (key === "dependentRequired" || key === "dependentSchemas") Object.assign(dependencies, mapValues(value, toDraft07));
+		else if (SINGLE.has(key) && isObject(value)) out[key] = toDraft07(value);
+		else if (LISTS.has(key) && isList(value)) out[key] = value.map((item) => isObject(item) ? toDraft07(item) : item);
+		else if (MAPS.has(key)) out[key] = mapValues(value, toDraft07);
+		else out[key] = value;
+	}
+	if (Object.keys(dependencies).length > 0) out["dependencies"] = {
+		...isObject(out["dependencies"]) ? out["dependencies"] : {},
+		...dependencies
+	};
+	return out;
+}
+//#endregion
+//#region src/generators/json-schema.ts
+const NO_EXTRAS = {
+	inputs: [],
+	results: []
+};
+/** Marks the deprecated table and columns, which only `meta` knows about. */
+function withDeprecated(schema, deprecated, columns) {
+	if (!deprecated && columns.length === 0) return schema;
+	const properties = schema["properties"];
+	return {
+		...schema,
+		...deprecated ? { deprecated: true } : {},
+		...columns.length > 0 && typeof properties === "object" && properties ? { properties: Object.fromEntries(Object.entries(properties).map(([name, value]) => [name, columns.includes(name) && typeof value === "object" && value ? {
+			...value,
+			deprecated: true
+		} : value])) } : {}
+	};
+}
+function resultJsonSchema(result, defs, prefix) {
+	if (result.of.kind === "row") {
+		const row = `${result.of.table}Row`;
+		if (defs[row] === void 0) return;
+		const ref = { $ref: `${prefix}${row}` };
+		return {
+			title: result.title,
+			...result.set ? {
+				type: "array",
+				items: ref
+			} : { anyOf: [ref, { type: "null" }] }
+		};
+	}
+	return {
+		title: result.title,
+		...fieldJsonSchema({
+			...result.of.scalar,
+			array: result.set,
+			nullable: result.nullable && !result.set
+		}),
+		...result.set && result.nullable ? { items: fieldJsonSchema({
+			...result.of.scalar,
+			nullable: true
+		}) } : {}
+	};
+}
+/** Each field's `fieldMeta` label as its `title`. */
+function withLabels(schema, labels) {
+	const properties = schema["properties"];
+	if (!labels || typeof properties !== "object" || !properties) return schema;
+	return {
+		...schema,
+		properties: Object.fromEntries(Object.entries(properties).map(([name, value]) => {
+			const label = labels[name]?.label;
+			return [name, label !== void 0 && typeof value === "object" && value ? {
+				title: label,
+				...value
+			} : value];
+		}))
+	};
+}
+/**
+* JSON Schema `$defs` for every table: `customersRow`, `customersInsert`, ...
+* `target` lowers the document to draft-07 or the OpenAPI 3.0 dialect, which
+* keep the schemas under `definitions`.
+*/
+function buildJsonSchema(input, id, target = "draft-2020-12", extras = NO_EXTRAS) {
+	const defs = {};
+	for (const [key, table] of tableEntries(input)) {
+		const docs = tableDocs(input, table);
+		const description = docs ? docs.description : table.description;
+		for (const variant of variantsFor(table)) {
+			const plans = fieldsFor(table, variant, input);
+			const schema = tableJsonSchema({
+				...docs ? { title: variantTitle(docs, variant) } : {},
+				...description === void 0 ? {} : { description },
+				fields: Object.fromEntries(plans.map((plan) => {
+					const spec = fieldSpec(plan, fieldDocs(docs, plan));
+					return [plan.name, docs || plan.column.description === void 0 ? spec : {
+						description: plan.column.description,
+						...spec
+					}];
+				}))
+			});
+			defs[`${key}${variant}`] = withDeprecated(schema, table.deprecated === true, plans.filter((plan) => plan.column.deprecated).map((plan) => plan.name));
+		}
+	}
+	for (const schema of extras.inputs) defs[schema.name] = tableJsonSchema({
+		title: schema.title,
+		fields: schema.fields
+	});
+	const prefix = target === "draft-2020-12" ? "#/$defs/" : "#/definitions/";
+	for (const result of extras.results) {
+		const schema = resultJsonSchema(result, defs, prefix);
+		if (schema) defs[result.name] = schema;
+	}
+	switch (target) {
+		case "draft-2020-12": return {
+			$schema: "https://json-schema.org/draft/2020-12/schema",
+			...id ? { $id: id } : {},
+			$defs: defs
+		};
+		case "draft-07": return forTarget({
+			...id ? { $id: id } : {},
+			definitions: Object.fromEntries(Object.entries(defs).map(([name, def]) => [name, toDraft07(def)]))
+		}, "draft-07");
+		case "openapi-3.0": return {
+			...id ? { $id: id } : {},
+			definitions: Object.fromEntries(Object.entries(defs).map(([name, def]) => [name, forTarget(def, "openapi-3.0")]))
+		};
+		default: return target;
+	}
+}
+/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
+function jsonSchema(options = {}) {
+	return {
+		apiVersion: 1,
+		name: "json-schema",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "schema.json");
+			const extras = extraSchemas(input);
+			const document = buildJsonSchema(input, options.id, options.target, extras);
+			return [{
+				path,
+				contents: `${JSON.stringify(options.fieldMeta ? labelled(document, fieldMeta(input, extras)) : document, null, 2)}\n`
+			}];
+		}
+	};
+}
+/** The document with `fieldMeta` labels on each table's Insert and each input. */
+function labelled(document, meta) {
+	const key = "$defs" in document ? "$defs" : "definitions";
+	const defs = document[key];
+	if (typeof defs !== "object" || !defs) return document;
+	return {
+		...document,
+		[key]: Object.fromEntries(Object.entries(defs).map(([name, def]) => {
+			const labels = meta[name] ?? (name.endsWith("Insert") ? meta[name.slice(0, -6)] : void 0);
+			return [name, isJsonObject(def) ? withLabels(def, labels) : def];
+		}))
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { variantsFor as C, variantTitle as S, schemaName as _, extraSchemas as a, tableEntries as b, resultType as c, fieldSpec as d, fieldsFor as f, rowType as g, propertyKey as h, extraKinds as i, HEADER as l, parseImport as m, jsonSchema as n, fieldMetaLines as o, optionalLine as p, toDraft07 as r, objectType as s, buildJsonSchema as t, fieldDocs as u, siblingPath as v, temporalGuardImport as x, tableDocs as y };