@rebasepro/server-postgres 0.23.0 → 0.24.0

package/dist/{column-plan-helpers-DF-8dTVa.js → column-plan-helpers-1-LQD0yI.js}

@@ -4,7 +4,6 @@ import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
 import { toSnakeCase } from "@rebasepro/utils";
 //#region src/schema/column-plan-helpers.ts
 var column_plan_helpers_exports = /* @__PURE__ */ __exportAll({
-	assertSinglePrimaryKey: () => assertSinglePrimaryKey,
 	declaresEnumType: () => declaresEnumType,
 	enumLabelsOf: () => enumLabelsOf,
 	getPrimaryKeyColumn: () => getPrimaryKeyColumn,
@@ -12,6 +11,7 @@ var column_plan_helpers_exports = /* @__PURE__ */ __exportAll({
 	getPrimaryKeyProp: () => getPrimaryKeyProp,
 	idColumnDefault: () => idColumnDefault,
 	isIdProperty: () => isIdProperty,
+	primaryKeyPropertyNames: () => primaryKeyPropertyNames,
 	resolveColumnName: () => resolveColumnName
 });
 /**
@@ -27,27 +27,31 @@ var resolveColumnName = (propName, prop) => {
 /** Every property that carries a truthy `isId`, in declaration order. */
 var idPropertyEntries = (collection) => Object.entries(collection.properties ?? {}).filter(([, prop]) => prop && typeof prop === "object" && "isId" in prop && Boolean(prop.isId));
 /**
-* Refuse a collection that declares two primary keys.
+* The properties marked `isId`, in declaration order.
 *
-* Postgres allows a composite primary key; Rebase does not model one, and the
-* three emitters each invented a different wrong answer for it. The Drizzle
-* generator appended `.primaryKey()` to both columns (two primary keys, which
-* drizzle-kit turns into an error at push time), the DDL generator wrote two
-* inline `PRIMARY KEY` clauses in one `CREATE TABLE` (Postgres: "multiple
-* primary keys for table are not allowed"), and boot-ensure created the table
-* with the *first* id column and silently never added the second — so a managed
-* tenant got a table missing a column its own collection reads.
+* Several of them are one composite primary key: the table carries a single
+* `PRIMARY KEY (a, b)` constraint over their columns, and a row's address lists
+* the parts in this same order (`buildCompositeId`), which is the order the
+* admin reads them in too.
+*/
+var primaryKeyPropertyNames = (collection) => idPropertyEntries(collection).map(([name]) => name);
+/**
+* The one column a link into this collection points at.
 *
-* None of those is recoverable at runtime, and two of them fail long after the
-* config was written. Refused here instead, where the collection has a name.
+* A foreign key column references a single column, and Postgres only accepts
+* that column when it is unique on its own — `REFERENCES t (a)` against a
+* composite key `(a, b)` fails with "there is no unique constraint matching
+* given keys for referenced table". So a link into a collection whose key
+* spans several columns has no column to point at, and it is refused here,
+* naming the link, rather than emitted as a constraint `db push` or boot would
+* then fail to create.
+*
+* @param via the link that needs the column, for the refusal: `relation "posts.author"`.
 */
-var assertSinglePrimaryKey = (collection) => {
+var getPrimaryKeyProp = (collection, via) => {
 	const ids = idPropertyEntries(collection);
-	if (ids.length < 2) return;
-	throw new Error(`Collection "${collection.slug ?? collection.name ?? "(unnamed)"}" marks ${ids.length} properties with \`isId\` (${ids.map(([name]) => `"${name}"`).join(", ")}). Composite primary keys are not supported: give exactly one property \`isId\`, and express the second key with \`indexes: [{ on: [...], unique: true, reason: "…" }]\`.`);
-};
-var getPrimaryKeyProp = (collection) => {
-	const idPropEntry = idPropertyEntries(collection)[0];
+	if (ids.length > 1) throw new Error(`${via} points at collection "${collection.slug ?? collection.name ?? "(unnamed)"}", whose primary key spans ${ids.length} columns (${ids.map(([name]) => `"${name}"`).join(", ")}). A foreign key is one column and cannot reference a composite key. Point the link at a collection with a single-column key, or reach these rows with a \`via\` relation, whose \`joinPath\` compares every key column.`);
+	const idPropEntry = ids[0];
 	if (idPropEntry) {
 		const [name, prop] = idPropEntry;
 		return {
@@ -63,10 +67,16 @@ var getPrimaryKeyProp = (collection) => {
 		prop: idProp
 	};
 };
-/** The primary key's property key. What a Drizzle relation's `references` names. */
-var getPrimaryKeyName = (collection) => getPrimaryKeyProp(collection).name;
-/** The primary key's column. What a foreign key's `REFERENCES` names. */
-var getPrimaryKeyColumn = (collection) => getPrimaryKeyProp(collection).column;
+/**
+* The primary key's property key. What a Drizzle relation's `references`
+* names. Refused on the same terms as {@link getPrimaryKeyProp}.
+*/
+var getPrimaryKeyName = (collection, via) => getPrimaryKeyProp(collection, via).name;
+/**
+* The primary key's column. What a foreign key's `REFERENCES` names. Refused
+* on the same terms as {@link getPrimaryKeyProp}.
+*/
+var getPrimaryKeyColumn = (collection, via) => getPrimaryKeyProp(collection, via).column;
 var isIdProperty = (propName, prop, collection) => {
 	if ("isId" in prop && Boolean(prop.isId)) return true;
 	return idPropertyEntries(collection).length === 0 && propName === "id";
@@ -136,6 +146,6 @@ var idColumnDefault = (propName, prop, collection) => {
 	};
 };
 //#endregion
-export { getPrimaryKeyColumn as a, idColumnDefault as c, enumLabelsOf as i, isIdProperty as l, column_plan_helpers_exports as n, getPrimaryKeyName as o, declaresEnumType as r, getPrimaryKeyProp as s, assertSinglePrimaryKey as t, resolveColumnName as u };
+export { getPrimaryKeyName as a, isIdProperty as c, getPrimaryKeyColumn as i, primaryKeyPropertyNames as l, declaresEnumType as n, getPrimaryKeyProp as o, enumLabelsOf as r, idColumnDefault as s, column_plan_helpers_exports as t, resolveColumnName as u };
 
-//# sourceMappingURL=column-plan-helpers-DF-8dTVa.js.map
+//# sourceMappingURL=column-plan-helpers-1-LQD0yI.js.map

package/dist/column-plan-helpers-1-LQD0yI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-plan-helpers-1-LQD0yI.js","names":[],"sources":["../src/schema/column-plan-helpers.ts"],"sourcesContent":["/**\n * The questions about a property that the schema planner asks first.\n *\n * What is the primary key, what is this column called, what does an id default\n * to, what labels does this enum have. `schema/plan/plan-schema.ts` is the only\n * caller — it is the only reader of a `Property` — and these live beside it\n * rather than inside it because they are also where the *refusals* are, and a\n * refusal wants to be reachable and testable on its own.\n *\n * They were extracted while there were still three emitters, each carrying its\n * own verbatim copy of all four rules until one of them was edited: the audit\n * that produced this module counted twelve open disagreements and found that a\n * third of the commits touching those files were re-synchronisations. The\n * emitters are renderers now and there is nothing left to keep in step, but the\n * questions are still questions about a property rather than about a plan, so\n * this is where they belong.\n *\n * Everything here is pure and synchronous, and it throws rather than guesses:\n * an enum with no values, a `cuid` id on Postgres and a foreign key into a\n * composite key are all configurations that produce a broken database in\n * silence, so they are refused where every path passes.\n */\nimport type {\n    CollectionConfig,\n    NumberProperty,\n    Property,\n    StringProperty\n} from \"@rebasepro/types\";\nimport { toSnakeCase } from \"@rebasepro/utils\";\n\n/**\n * Resolve the SQL column name for a property.\n *\n * Uses the explicit `columnName` when set (e.g. from introspection), falling\n * back to `toSnakeCase(propName)` for manually-authored collections.\n */\nexport const resolveColumnName = (propName: string, prop?: Property | null): string => {\n    if (prop && \"columnName\" in prop && typeof prop.columnName === \"string\") {\n        return prop.columnName;\n    }\n    return toSnakeCase(propName);\n};\n\n/** Every property that carries a truthy `isId`, in declaration order. */\nconst idPropertyEntries = (collection: CollectionConfig): [string, Property][] =>\n    Object.entries(collection.properties ?? {}).filter(\n        ([, prop]) => prop && typeof prop === \"object\" && \"isId\" in prop && Boolean((prop as { isId?: unknown }).isId)\n    ) as [string, Property][];\n\n/**\n * The properties marked `isId`, in declaration order.\n *\n * Several of them are one composite primary key: the table carries a single\n * `PRIMARY KEY (a, b)` constraint over their columns, and a row's address lists\n * the parts in this same order (`buildCompositeId`), which is the order the\n * admin reads them in too.\n */\nexport const primaryKeyPropertyNames = (collection: CollectionConfig): string[] =>\n    idPropertyEntries(collection).map(([name]) => name);\n\n/**\n * A collection's primary key, by both of its names.\n *\n * `name` is the property key — what the generated Drizzle table is keyed by,\n * so it is what a relation's `references` names. `column` is the SQL\n * identifier, so it is what a foreign key's `REFERENCES` names. They differ\n * whenever the key is camelCase or carries a `columnName` (`authorId` is\n * `author_id`, and every table `rebase schema introspect` adopts is spelled\n * that way), and a constraint written with the key named a column that does\n * not exist: `db push` could not build its desired state, and boot failed the\n * constraint on every start.\n */\nexport interface PrimaryKey {\n    /** Property key: the Drizzle object key and the JSON field. */\n    name: string;\n    /** SQL column. */\n    column: string;\n    /** The declaring property; absent for the implicit `id TEXT` of a collection that declares none. */\n    prop?: Property;\n}\n\n/**\n * The one column a link into this collection points at.\n *\n * A foreign key column references a single column, and Postgres only accepts\n * that column when it is unique on its own — `REFERENCES t (a)` against a\n * composite key `(a, b)` fails with \"there is no unique constraint matching\n * given keys for referenced table\". So a link into a collection whose key\n * spans several columns has no column to point at, and it is refused here,\n * naming the link, rather than emitted as a constraint `db push` or boot would\n * then fail to create.\n *\n * @param via the link that needs the column, for the refusal: `relation \"posts.author\"`.\n */\nexport const getPrimaryKeyProp = (collection: CollectionConfig, via: string): PrimaryKey => {\n    const ids = idPropertyEntries(collection);\n    if (ids.length > 1) {\n        throw new Error(\n            `${via} points at collection \"${collection.slug ?? collection.name ?? \"(unnamed)\"}\", whose primary ` +\n            `key spans ${ids.length} columns (${ids.map(([name]) => `\"${name}\"`).join(\", \")}). A foreign key is ` +\n            \"one column and cannot reference a composite key. Point the link at a collection with a \" +\n            \"single-column key, or reach these rows with a `via` relation, whose `joinPath` compares every \" +\n            \"key column.\"\n        );\n    }\n    const idPropEntry = ids[0];\n    if (idPropEntry) {\n        const [name, prop] = idPropEntry;\n        return { name, column: resolveColumnName(name, prop), prop };\n    }\n    // Fallback: a collection that declares no `isId` gets an implicit `id`.\n    const idProp = collection.properties?.[\"id\"] as Property | undefined;\n    return { name: \"id\", column: resolveColumnName(\"id\", idProp), prop: idProp };\n};\n\n/**\n * The primary key's property key. What a Drizzle relation's `references`\n * names. Refused on the same terms as {@link getPrimaryKeyProp}.\n */\nexport const getPrimaryKeyName = (collection: CollectionConfig, via: string): string =>\n    getPrimaryKeyProp(collection, via).name;\n\n/**\n * The primary key's column. What a foreign key's `REFERENCES` names. Refused\n * on the same terms as {@link getPrimaryKeyProp}.\n */\nexport const getPrimaryKeyColumn = (collection: CollectionConfig, via: string): string =>\n    getPrimaryKeyProp(collection, via).column;\n\nexport const isIdProperty = (propName: string, prop: Property, collection: CollectionConfig): boolean => {\n    if (\"isId\" in prop && Boolean(prop.isId)) return true;\n\n    // Only fall back to \"id\" when NO property is explicitly marked.\n    return idPropertyEntries(collection).length === 0 && propName === \"id\";\n};\n\n/**\n * The labels an `enum` declares, in order, whichever form it was written in.\n *\n * `EnumValues` is `EnumValueConfig[] | Record<id, label>` and the docs recommend\n * the record. Boot-ensure read only the array form — `(p.enum as unknown[]).map`\n * — so a record-form enum threw `p.enum.map is not a function` on a managed\n * tenant, at boot, with no developer in the loop. The other two emitters each\n * carried their own copy of the both-forms walk.\n *\n * An empty list throws rather than returning `[]`. `CREATE TYPE … AS ENUM ()`\n * is not valid SQL, so every emitter \"handled\" it by skipping the type and then\n * typing the column with it anyway: Drizzle referenced an enum variable it never\n * declared (the generated file does not compile), the DDL named a type nothing\n * creates, and boot-ensure's `ADD COLUMN` failed — and add-column is not a\n * survivable action, so the boot died. There is no useful column at the end of\n * any of those paths.\n */\nexport const enumLabelsOf = (propName: string, prop: Property, collection: CollectionConfig): string[] => {\n    const values = (prop as { enum?: unknown }).enum;\n    if (values === undefined || values === null) return [];\n\n    const labels = Array.isArray(values)\n        ? values.map((entry: unknown) =>\n            String(entry !== null && typeof entry === \"object\" && \"id\" in (entry as Record<string, unknown>)\n                ? (entry as Record<string, unknown>).id\n                : entry))\n        : Object.keys(values as Record<string, unknown>).map(String);\n\n    const usable = labels.filter(label => label.length > 0);\n    if (usable.length === 0) {\n        throw new Error(\n            `Property \"${propName}\" of collection \"${collection.slug ?? collection.name ?? \"(unnamed)\"}\" ` +\n            \"declares an empty `enum`. A Postgres enum type needs at least one label — \" +\n            \"`CREATE TYPE … AS ENUM ()` is not valid SQL — so the column would reference a type \" +\n            \"nothing creates. List the values, or drop the `enum` for a plain column.\"\n        );\n    }\n    return usable;\n};\n\n/**\n * Does this property compile to a Postgres enum *type*?\n *\n * Strings only. A `number` property with an `enum` used to create a type on all\n * three paths and then declare the column `NUMERIC`/`INTEGER`, so the type was\n * orphaned the moment it was created and the values it listed were enforced by\n * nothing. The dropdown in the panel is driven by the config, not the column, so\n * nothing is lost by not creating it — and a type no column uses is one more\n * object `db push` has to plan a DROP for.\n */\nexport const declaresEnumType = (prop: Property): boolean =>\n    prop.type === \"string\" && Boolean((prop as StringProperty).enum);\n\n/**\n * The `DEFAULT` an id column carries, as the thing itself rather than a\n * rendered string — each emitter spells it differently.\n *\n * The three of them disagreed on all four strategies. The DDL generator wrote\n * `DEFAULT ${prop.isId}` verbatim, so the documented `` isId: \"sql`gen_id()`\" ``\n * reached Postgres with the template wrapper still on it — a syntax error in\n * `schema.sql`. Boot-ensure gave a default to `uuid` and to nothing else, so on\n * a managed tenant every other strategy produced a column with no default at\n * all, and the first insert that trusted the config failed on a NULL primary\n * key. Only the Drizzle generator stripped the wrapper.\n */\nexport type IdColumnDefault =\n    /** `gen_random_uuid()` / `.defaultRandom()`. */\n    | { kind: \"uuid\" }\n    /** `GENERATED BY DEFAULT AS IDENTITY` / `.generatedByDefaultAsIdentity()` — part of the type, not a DEFAULT. */\n    | { kind: \"identity\" }\n    /** A raw SQL expression, wrapper already stripped. */\n    | { kind: \"sql\"; expression: string };\n\n/**\n * Refuses `isId: \"cuid\"`.\n *\n * `DEFAULT cuid()` has been emitted since the option existed and no `cuid()`\n * function has ever been created — not by the generators, not by boot, not by\n * any migration. So the column has never had a working default on Postgres: the\n * first insert that relied on it failed with `function cuid() does not exist`.\n * There is nothing to keep compatible.\n *\n * It is refused rather than implemented. Shipping a real `rebase.cuid()` means a\n * new SQL function in the same carved-out class as the search helpers — excluded\n * from Atlas by pattern, applied by boot, re-applied by push, checked by the\n * doctor, and versioned across the fleet forever — to reproduce a monotonic id\n * that `uuid` already provides and that a project wanting cuid's exact shape can\n * write itself in one line of SQL.\n */\nexport const idColumnDefault = (propName: string, prop: Property, collection: CollectionConfig): IdColumnDefault | undefined => {\n    if (!(\"isId\" in prop)) return undefined;\n    const isId = (prop as { isId?: unknown }).isId;\n    // `true` and `\"manual\"` both mean \"the application supplies it\".\n    if (isId === undefined || isId === null || isId === true || isId === \"manual\" || isId === false) return undefined;\n    if (typeof isId !== \"string\") return undefined;\n\n    if (prop.type === \"string\" && (isId as StringProperty[\"isId\"]) === \"uuid\") return { kind: \"uuid\" };\n    if (prop.type === \"number\" && (isId as NumberProperty[\"isId\"]) === \"increment\") return { kind: \"identity\" };\n\n    if (isId === \"cuid\") {\n        throw new Error(\n            `Property \"${propName}\" of collection \"${collection.slug ?? collection.name ?? \"(unnamed)\"}\" ` +\n            \"uses `isId: \\\"cuid\\\"`, which Postgres cannot honour: the generated default calls a `cuid()` \" +\n            \"function that Rebase has never created, so every insert relying on it fails. \" +\n            \"Use `isId: \\\"uuid\\\"`, or give the strategy as SQL — ``isId: \\\"sql`my_id()`\\\"`` — and create that \" +\n            \"function in a migration.\"\n        );\n    }\n\n    // Any other string is a raw SQL default. Written either bare\n    // (`gen_random_uuid()::text`) or in the documented template form\n    // (``sql`gen_random_uuid()::text` ``); the wrapper is markup, not SQL.\n    const expression = isId.startsWith(\"sql`\") && isId.endsWith(\"`\")\n        ? isId.substring(4, isId.length - 1)\n        : isId;\n    return { kind: \"sql\", expression };\n};\n"],"mappings":"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"}

package/dist/data-transformer.d.ts

@@ -41,14 +41,6 @@ export declare function sanitizeAndConvertDates(obj: unknown): unknown;
  * Transform relations for database storage (relation objects to IDs)
  */
 export declare function serializeDataToServer<M extends Record<string, unknown>>(row: M, properties: Properties, collection?: CollectionConfig, registry?: PostgresCollectionRegistry): SerializedEntityData;
-/**
- * Serialize a single property value for database storage.
- *
- * `propertyKey` is only ever used to phrase errors and warnings. Without it the
- * one trace a bad value left was `Expected array value for array property, got
- * string` — no collection, no property, no value, which in the log of a
- * thousand-row import names nothing at all.
- */
 export declare function serializePropertyToServer(value: unknown, property: Property, propertyKey?: string): unknown;
 /**
  * Transform IDs back to relation objects for frontend

package/dist/{doctor-Cb2thZ8s.js → doctor-C-sYWbmt.js}

@@ -1,16 +1,17 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
 import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
-import { t as columnPgType } from "./plan-schema-C0fxM8dY.js";
-import { i as diagnoseDbError, n as deepestErrorMessage, s as parseHostInfo } from "./cli-errors-B8qHg02P.js";
-import { t as generateSchema } from "./generate-drizzle-schema-logic-BfzK7UQd.js";
+import { i as diagnoseDbError, n as deepestErrorMessage, s as parseHostInfo } from "./cli-errors-DsA-K9uP.js";
+import { n as planSchema, t as columnPgType } from "./plan-schema-DU9exq6C.js";
+import { t as generateSchema } from "./generate-drizzle-schema-logic-sSFDp6LR.js";
+import { r as renderPgType } from "./render-ddl-Ds2t_d9V.js";
 import { n as outError, t as out } from "./cli-output-CNdMql-L.js";
 import { t as chalk } from "./source-Br7L7GOI.js";
 import { n as describeDeclarationDifferences, t as compareGeneratedDeclarations } from "./generated-schema-staleness-Di9c4ZxN.js";
 import { loadCollectionsFromDirectory } from "@rebasepro/server";
 import { computeSchemaVersion, getDeclaredSubcollections, isManyToMany, isPostgresCollectionConfig } from "@rebasepro/types";
 import { effectiveAccess, fieldKeyForColumn, findRelation, getTableName, isRelationRequired, relationalCollections, resolveCollectionRelations, resolveJunctionSpecs, sortCollectionsBySlug } from "@rebasepro/common";
-import { toSnakeCase } from "@rebasepro/utils";
+import { toPostgresIdentifier, toSnakeCase } from "@rebasepro/utils";
 import * as fs$1 from "fs";
 import { promises } from "fs";
 //#region ../codegen/dist/index.es.js
@@ -201,7 +202,9 @@ function includedRelationType(relation, accessors) {
 	const slug = resolveTargetCollection(relation)?.slug ?? relation.targetSlug;
 	const accessor = slug ? accessors.get(slug) : void 0;
 	const rowType = accessor ? `Database[${emitString(accessor)}]["Row"]` : "Record<string, unknown>";
-	return relation.cardinality === "many" ? `Array<${rowType}>` : rowType;
+	const pivot = relation.kind === "manyToMany" ? pivotType(relation.through.properties, "read") : void 0;
+	const elementType = pivot ? `${rowType} & { _pivot?: ${pivot} }` : rowType;
+	return relation.cardinality === "many" ? `Array<${elementType}>` : elementType;
 }
 /**
 * Map every slug to the property name it is reachable under on `client.data`.
@@ -228,6 +231,19 @@ function buildAccessors(collections) {
 	}
 	return accessors;
 }
+/**
+* A column's type on a write: its own type, or `null` too when it is not
+* required.
+*
+* `Row` has typed a non-required column `T | null` for a while; its write twins
+* did not, so the one way to clear a value — `update(id, { publishedAt: null })`,
+* `{ authorId: null }` to unassign, the edit-form round trip of a row that came
+* back with nulls in it — was a compile error the server would have accepted.
+* A primary key is never null, required or not.
+*/
+function writableType(prop, tsType) {
+	return prop.validation?.required || isPrimaryKey(prop) ? tsType : `${tsType} | null`;
+}
 /** One emitted `key: type;` line, already indented. */
 function line(key, type, optional) {
 	return `      ${emitKey(key)}${optional ? "?" : ""}: ${type};`;
@@ -239,9 +255,9 @@ function line(key, type, optional) {
 * property. `Row` already honoured that; `Insert` and `Update` deliberately did
 * not, on the reading that the column is stripped from responses rather than
 * from writes. That left the generated types as the one place a password hash
-* was still named, and it invited a client to send one. The server still
-* *accepts* such a field on a write — this describes the surface, it does not
-* add an enforcement point — but nothing generated advertises it.
+* was still named, and it invited a client to send one. The server refuses
+* such a field on a write (`VALIDATION_EXCLUDED_FIELDS`), so nothing generated
+* advertises it.
 *
 * Read through `effectiveAccess`, so the flag and its longhand
 * `access: { read: [], write: [] }` produce the same file. A *role* rule is
@@ -265,6 +281,28 @@ function excludedApiKeys(properties) {
 	}
 	return excluded;
 }
+/**
+* The keys nobody may write: `access: { write: [] }`, readable or not.
+*
+* Off `Insert` and `Update` for the same reason `excludedApiKeys` takes a
+* hidden property off all three — except that a field everyone can read but
+* nobody can write stays on `Row`. The server refuses one on any write with
+* `VALIDATION_EXCLUDED_FIELDS`, for every caller, `admin` included, so a
+* generated `create({ computed })` compiled and could only ever be a 400.
+*
+* A write rule naming *roles* is not this: some caller can write it, and one
+* generated shape cannot say which.
+*/
+function unwritableKeys(properties) {
+	const unwritable = /* @__PURE__ */ new Set();
+	for (const [key, rawProp] of Object.entries(properties)) {
+		const prop = rawProp;
+		if (effectiveAccess(prop)?.write?.length !== 0) continue;
+		unwritable.add(key);
+		if (prop.columnName) unwritable.add(prop.columnName);
+	}
+	return unwritable;
+}
 function generateTypedefs(input) {
 	const collections = sortCollectionsBySlug(input);
 	const accessors = buildAccessors(collections);
@@ -329,39 +367,42 @@ function generateTypedefs(input) {
 		}
 		lines.push("    };");
 		lines.push("    Insert: {");
+		const notWritable = /* @__PURE__ */ new Set([...excluded, ...unwritableKeys(properties)]);
 		emittedKeys.clear();
-		for (const key of excluded) emittedKeys.add(key);
+		for (const key of notWritable) emittedKeys.add(key);
 		for (const [key, rawProp] of Object.entries(properties)) {
 			const prop = rawProp;
 			if (prop.type === "relation") continue;
-			if (excluded.has(key)) continue;
+			if (notWritable.has(key)) continue;
 			const tsType = propertyToTypeScriptType(prop);
 			const isOptional = !prop.validation?.required || isAutoAssignedId(prop);
-			lines.push(line(key, tsType, isOptional));
+			lines.push(line(key, writableType(prop, tsType), isOptional));
 			emittedKeys.add(key);
 		}
 		emitWritableRelations(lines, collection, properties, resolvedRelations, emittedKeys, false);
 		lines.push("    };");
 		lines.push("    Update: {");
 		emittedKeys.clear();
-		for (const key of excluded) emittedKeys.add(key);
+		for (const key of notWritable) emittedKeys.add(key);
 		for (const [key, rawProp] of Object.entries(properties)) {
 			const prop = rawProp;
 			if (prop.type === "relation") continue;
 			if (isPrimaryKey(prop)) continue;
-			if (excluded.has(key)) continue;
-			lines.push(line(key, propertyToTypeScriptType(prop), true));
+			if (notWritable.has(key)) continue;
+			lines.push(line(key, writableType(prop, propertyToTypeScriptType(prop)), true));
 			emittedKeys.add(key);
 		}
 		emitWritableRelations(lines, collection, properties, resolvedRelations, emittedKeys, true);
 		lines.push("    };");
-		lines.push("    Relations: {");
+		if (Object.keys(resolvedRelations).length === 0) lines.push("    Relations: Record<never, never>;");
+		else lines.push("    Relations: {");
 		for (const [key, relation] of Object.entries(resolvedRelations)) {
 			const slug = resolveTargetCollection(relation)?.slug ?? relation.targetSlug;
 			const accessor = slug ? accessors.get(slug) : void 0;
 			lines.push(`      ${emitKey(key)}: ${accessor ? emitString(accessor) : "never"};`);
 		}
-		lines.push("    };");
+		if (Object.keys(resolvedRelations).length > 0) lines.push("    };");
+		lines.push(`    Slug: ${emitString(collection.slug)};`);
 		lines.push("  };");
 	}
 	lines.push("}");
@@ -484,8 +525,9 @@ function includeHelperLines() {
 function emitWritableRelations(lines, collection, properties, resolvedRelations, emittedKeys, allOptional) {
 	const emit = (key, relation) => {
 		if (emittedKeys.has(key)) return;
-		const optional = allOptional || !isRelationRequired(collection, relation);
-		lines.push(line(key, foreignKeyType(relation), optional));
+		const required = isRelationRequired(collection, relation);
+		const type = required ? foreignKeyType(relation) : `${foreignKeyType(relation)} | null`;
+		lines.push(line(key, type, allOptional || !required));
 		emittedKeys.add(key);
 	};
 	for (const relation of Object.values(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) emit(fieldKeyForColumn(collection, relation.localKey), relation);
@@ -494,6 +536,31 @@ function emitWritableRelations(lines, collection, properties, resolvedRelations,
 		const relation = findRelation(resolvedRelations, key);
 		if (relation?.kind === "belongsTo" && relation.localKey) emit(key, relation);
 	}
+	for (const [key, relation] of Object.entries(resolvedRelations)) {
+		if (relation.cardinality !== "many" || !relation.writable) continue;
+		if (emittedKeys.has(key)) continue;
+		const fk = foreignKeyType(relation);
+		const pivot = relation.kind === "manyToMany" ? pivotType(relation.through.properties, "write") : void 0;
+		const element = `${fk} | { id: ${fk}${pivot ? `; _pivot?: ${pivot}` : ""} }`;
+		lines.push(line(key, `Array<${element}>`, true));
+		emittedKeys.add(key);
+	}
+}
+/**
+* The `_pivot` a many-to-many link carries: the junction's payload columns,
+* typed as a row's columns are on a read and as a write's on a write. `undefined`
+* when the junction declares none, so there is no `_pivot` to name.
+*/
+function pivotType(pivotProperties, direction) {
+	const entries = Object.entries(pivotProperties);
+	if (entries.length === 0) return void 0;
+	return `{ ${entries.map(([key, rawProp]) => {
+		const prop = rawProp;
+		const tsType = propertyToTypeScriptType(prop);
+		const required = Boolean(prop.validation?.required);
+		const type = direction === "write" ? writableType(prop, tsType) : required ? tsType : `${tsType} | null`;
+		return `${emitKey(key)}${required && direction === "read" ? "" : "?"}: ${type};`;
+	}).join(" ")} }`;
 }
 //#endregion
 //#region src/schema/doctor.ts
@@ -511,11 +578,14 @@ var doctor_exports = /* @__PURE__ */ __exportAll({
 	checkCollectionsVsSchema: () => checkCollectionsVsSchema,
 	checkCollectionsVsSdk: () => checkCollectionsVsSdk,
 	getExpectedColumnType: () => getExpectedColumnType,
+	junctionKeyIssues: () => junctionKeyIssues,
 	loadCollections: () => loadCollections,
 	missingExtensionIssues: () => missingExtensionIssues,
+	primaryKeyIssues: () => primaryKeyIssues,
 	renderReport: () => renderReport,
 	runDoctor: () => runDoctor,
-	schemaStampIssues: () => schemaStampIssues
+	schemaStampIssues: () => schemaStampIssues,
+	typeMismatchFix: () => typeMismatchFix
 });
 /**
 * Resolve the SQL column name for a property.
@@ -736,6 +806,91 @@ async function schemaStampIssues(pool, collections) {
 		fix: "A hash says the two disagree, never which is ahead. Check you are pointed at the database you think you are; then `rebase db push` to bring it to these collections."
 	}];
 }
+/** `"public"."posts"` — quoted, for a statement the reader will paste. */
+var quotedTable = (schema, table) => `"${schema}"."${table}"`;
+/**
+* What to do about a column whose type is not the one the collection plans.
+*
+* Both ways out, because the doctor cannot know which side is right: the
+* property moved, or the database did. Putting the property back always clears
+* the finding; converting the column clears it when every value converts.
+*/
+function typeMismatchFix(schema, table, column, actual, planned) {
+	const back = `Either put the property back to the column's type (${actual}), or`;
+	if (!planned) return `${back} run a migration that converts the column.`;
+	const type = renderPgType(planned);
+	return `${back} convert the column when you can watch it (every value must convert): ALTER TABLE ${quotedTable(schema, table)} ALTER COLUMN "${column}" TYPE ${type} USING "${column}"::${type};`;
+}
+/**
+* The table's primary key against the one the collection reads it by.
+*
+* Rebase addresses a row by the key the plan names — the `isId` property, or
+* the implicit `id` — so a table keyed on other columns, or on none, serves
+* reads and writes against a key that does not hold. An error, because that is
+* what it is at runtime.
+*/
+function primaryKeyIssues(tablePlan, dbPk, displayName) {
+	const expected = tablePlan.primaryKey;
+	if (dbPk.length === expected.length && [...dbPk].sort().join("\0") === [...expected].sort().join("\0")) return [];
+	const table = quotedTable(tablePlan.schema, tablePlan.table);
+	const keyList = expected.map((c) => `"${c}"`).join(", ");
+	if (dbPk.length === 0) return [{
+		severity: "error",
+		category: "primary_key_mismatch",
+		table: displayName,
+		expected: expected.join(", "),
+		actual: "(none)",
+		message: `Table "${displayName}" has no primary key; the collection reads its rows by ${keyList}.`,
+		fix: `ALTER TABLE ${table} ADD PRIMARY KEY (${keyList});`
+	}];
+	const only = expected.some((column) => !dbPk.includes(column)) ? "only " : "";
+	const fix = dbPk.length === 1 ? `Mark ${only}the property for column "${dbPk[0]}" with \`isId\` — the table is keyed on it — or re-key the table on ${keyList}.` : `Mark ${only}the properties for columns ${dbPk.map((c) => `"${c}"`).join(", ")} with \`isId\` — together they are the table's composite key — or re-key the table on ${keyList}.`;
+	return [{
+		severity: "error",
+		category: "primary_key_mismatch",
+		table: displayName,
+		expected: expected.join(", "),
+		actual: dbPk.join(", "),
+		message: `Table "${displayName}" is keyed on (${dbPk.join(", ")}), but the collection reads its rows by ${keyList}.`,
+		fix
+	}];
+}
+/**
+* A junction's two key columns: present, typed like the keys they point at,
+* and the table keyed on the pair. Order is not compared — boot and `db push`
+* have built the key in both orders, and either one serves the same rows.
+*/
+function junctionKeyIssues(junctionPlan, dbColumns, dbPk, displayName) {
+	const issues = [];
+	const byName = new Map(dbColumns.map((c) => [c.column_name, c]));
+	for (const column of junctionPlan.columns) {
+		const dbCol = byName.get(column.column);
+		if (!dbCol) {
+			issues.push({
+				severity: "error",
+				category: "missing_column",
+				table: displayName,
+				column: column.column,
+				message: `Junction table "${displayName}" has no "${column.column}" column.`,
+				fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
+			});
+			continue;
+		}
+		const expected = INFORMATION_SCHEMA_NAMES[column.type.kind];
+		if (dbCol.data_type !== expected) issues.push({
+			severity: "warning",
+			category: "type_mismatch",
+			table: displayName,
+			column: column.column,
+			expected,
+			actual: dbCol.data_type,
+			message: `Junction column "${column.column}" in "${displayName}" is ${dbCol.data_type}, but the key it points at is ${expected}.`,
+			fix: typeMismatchFix(junctionPlan.schema, junctionPlan.table, column.column, dbCol.data_type, column.type)
+		});
+	}
+	issues.push(...primaryKeyIssues(junctionPlan, dbPk, displayName));
+	return issues;
+}
 async function checkCollectionsVsDatabase(collections, databaseUrl) {
 	const issues = [];
 	const pgModule = await import("pg");
@@ -767,15 +922,27 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 			if (!columnsByTable.has(key)) columnsByTable.set(key, []);
 			columnsByTable.get(key).push(row);
 		}
-		const enumsResult = await pool.query(`SELECT t.typname as enum_name, e.enumlabel as enum_value
+		const enumsResult = await pool.query(`SELECT n.nspname AS enum_schema, t.typname AS enum_name, e.enumlabel AS enum_value
              FROM pg_type t
+             JOIN pg_namespace n ON n.oid = t.typnamespace
              JOIN pg_enum e ON t.oid = e.enumtypid
-             ORDER BY t.typname, e.enumsortorder`);
+             ORDER BY n.nspname, t.typname, e.enumsortorder`);
 		const enumsByName = /* @__PURE__ */ new Map();
 		for (const row of enumsResult.rows) {
-			if (!enumsByName.has(row.enum_name)) enumsByName.set(row.enum_name, []);
-			enumsByName.get(row.enum_name).push(row.enum_value);
+			const key = `${row.enum_schema}.${row.enum_name}`;
+			if (!enumsByName.has(key)) enumsByName.set(key, []);
+			enumsByName.get(key).push(row.enum_value);
 		}
+		const pksResult = await pool.query(`SELECT n.nspname AS table_schema, c.relname AS table_name,
+                    array_agg(a.attname::text ORDER BY array_position(i.indkey::int2[], a.attnum)) AS columns
+             FROM pg_index i
+             JOIN pg_class c ON c.oid = i.indrelid
+             JOIN pg_namespace n ON n.oid = c.relnamespace
+             JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(i.indkey::int2[])
+             WHERE i.indisprimary AND n.nspname = ANY($1)
+             GROUP BY n.nspname, c.relname`, [schemas]);
+		const pksByTable = /* @__PURE__ */ new Map();
+		for (const row of pksResult.rows) pksByTable.set(row.table_schema === "public" ? row.table_name : `${row.table_schema}.${row.table_name}`, row.columns);
 		const fksResult = await pool.query(`SELECT
                 tc.constraint_name,
                 tc.table_schema,
@@ -800,6 +967,14 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 		}
 		const postgresCollections = relationalCollections(collections);
 		const junctionSpecs = resolveJunctionSpecs(postgresCollections);
+		let plan;
+		try {
+			plan = planSchema(postgresCollections);
+		} catch {
+			plan = void 0;
+		}
+		const tablePlans = new Map((plan?.tables ?? []).map((t) => [t.qualified, t]));
+		const checkedJunctions = /* @__PURE__ */ new Set();
 		for (const collection of postgresCollections) {
 			const tableName = getTableName(collection);
 			const schemaName = collection.schema || "public";
@@ -816,11 +991,8 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 			}
 			const dbColumns = columnsByTable.get(fullTableName) ?? [];
 			const dbColumnMap = new Map(dbColumns.map((c) => [c.column_name, c]));
-			const systemColumns = /* @__PURE__ */ new Set([
-				"id",
-				"created_on",
-				"updated_on"
-			]);
+			const tablePlan = tablePlans.get(`${schemaName}.${tableName}`);
+			if (tablePlan) issues.push(...primaryKeyIssues(tablePlan, pksByTable.get(fullTableName) ?? [], fullTableName));
 			for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
 				if (prop.type === "relation") {
 					const relation = findRelation(resolveCollectionRelations(collection), prop.relation?.relationName ?? propName);
@@ -855,7 +1027,6 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 					continue;
 				}
 				const colName = resolveColumnName(propName, prop);
-				if (systemColumns.has(colName)) continue;
 				const dbCol = dbColumnMap.get(colName);
 				if (!dbCol) {
 					issues.push({
@@ -888,29 +1059,32 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 							if (expectedUdt && dbCol.udt_name !== expectedUdt) isMismatch = true;
 						}
 					}
-					if (isMismatch) issues.push({
-						severity: "warning",
-						category: "type_mismatch",
-						table: fullTableName,
-						column: colName,
-						expected: prop.type === "vector" ? "vector" : expectedType,
-						actual: dbCol.udt_name === "vector" ? "vector" : actualType,
-						message: `Column "${colName}" in table "${fullTableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${dbCol.udt_name === "vector" ? "vector" : actualType}".`,
-						fix: "Review collection property type or run a migration"
-					});
+					if (isMismatch) {
+						const planned = tablePlan?.columns.find((c) => c.column === colName)?.type;
+						issues.push({
+							severity: "warning",
+							category: "type_mismatch",
+							table: fullTableName,
+							column: colName,
+							expected: prop.type === "vector" ? "vector" : expectedType,
+							actual: dbCol.udt_name === "vector" ? "vector" : actualType,
+							message: `Column "${colName}" in table "${fullTableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${dbCol.udt_name === "vector" ? "vector" : actualType}".`,
+							fix: typeMismatchFix(schemaName, tableName, colName, actualType, planned)
+						});
+					}
 				}
 				if (prop.type === "string" && prop.enum) {
 					const enumValues = prop.enum;
 					if (enumValues) {
-						const enumName = `${tableName}_${colName}`;
-						const dbEnumValues = enumsByName.get(enumName);
+						const enumName = toPostgresIdentifier(`${tableName}_${colName}`);
+						const dbEnumValues = enumsByName.get(`${schemaName}.${enumName}`);
 						if (!dbEnumValues) issues.push({
 							severity: "warning",
 							category: "missing_enum",
 							table: fullTableName,
 							column: colName,
 							expected: enumName,
-							message: `Enum type "${enumName}" is defined in collection but not found in the database.`,
+							message: `Enum type "${schemaName}"."${enumName}" is defined in collection but not found in the database.`,
 							fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
 						});
 						else {
@@ -948,6 +1122,11 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 					message: `Junction table "${fullJunctionTable}" for many-to-many relation "${relation.relationName}" is missing.`,
 					fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
 				});
+				else if (!checkedJunctions.has(fullJunctionTable)) {
+					checkedJunctions.add(fullJunctionTable);
+					const junctionPlan = tablePlans.get(`${junctionSchema}.${junctionTable}`);
+					if (junctionPlan) issues.push(...junctionKeyIssues(junctionPlan, columnsByTable.get(fullJunctionTable) ?? [], pksByTable.get(fullJunctionTable) ?? [], fullJunctionTable));
+				}
 			}
 		}
 	} finally {
@@ -1032,10 +1211,12 @@ function formatCategory(cat) {
 		missing_column: "Missing Column",
 		type_mismatch: "Type Mismatch",
 		missing_constraint: "Missing Constraint",
+		primary_key_mismatch: "Primary Key Mismatch",
 		schema_stale: "Stale Schema",
 		missing_enum: "Missing Enum",
 		enum_value_mismatch: "Enum Value Mismatch",
 		missing_foreign_key: "Missing Foreign Key",
+		orphaned_junction: "Orphaned Junction Table",
 		sdk_stale: "Stale SDK Types",
 		sdk_not_generated: "SDK Types Not Generated",
 		sdk_ungeneratable: "SDK Cannot Be Generated"
@@ -1105,4 +1286,4 @@ async function runDoctor(options) {
 //#endregion
 export { loadCollections as n, runDoctor as r, doctor_exports as t };
 
-//# sourceMappingURL=doctor-Cb2thZ8s.js.map
+//# sourceMappingURL=doctor-C-sYWbmt.js.map