@rebasepro/server-postgres 0.23.0 → 0.24.1-canary.g56af4a4

package/dist/{doctor-Cb2thZ8s.js → doctor-C4WiftHm.js}

@@ -1,54 +1,20 @@
 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 { n as outError, t as out } from "./cli-output-CNdMql-L.js";
-import { t as chalk } from "./source-Br7L7GOI.js";
+import { i as diagnoseDbError, n as deepestErrorMessage, s as parseHostInfo } from "./cli-errors-CaI4ntyD.js";
+import { i as outError, r as out, t as chalk } from "./source-DBDbBTL4.js";
+import { n as planSchema, t as columnPgType } from "./plan-schema-B1YF_tYq.js";
+import { t as generateSchema } from "./generate-drizzle-schema-logic-B74WN37S.js";
+import { r as renderPgType } from "./render-ddl-CtC3y9Ol.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 { effectiveAccess, fieldKeyForColumn, findRelation, getTableName, isRelationRequired, relationalCollections, resolveCollectionRelations, resolveJunctionSpecs, sortCollectionsBySlug, toCollectionAccessor, toSafeIdentifier } from "@rebasepro/common";
+import { toPostgresIdentifier, toSnakeCase } from "@rebasepro/utils";
 import * as fs$1 from "fs";
 import { promises } from "fs";
 //#region ../codegen/dist/index.es.js
 /**
-* Utility functions for the SDK generator
-*/
-/**
-* Convert a slug/snake_case string to PascalCase
-* e.g. "private_notes" → "PrivateNotes"
-*
-* Capitals already inside a word are meaningful and are kept: lowercasing the
-* tail of every chunk turned "TestEntities" into "Testentities", which is what
-* ended up in the generated type names. SHOUTING_CASE is the one shape where
-* the tail is not meaningful, so it is folded down.
-*/
-function toPascalCase(str) {
-	return str.split(/[_\-\s]+/).filter(Boolean).map((word) => {
-		const rest = /^[A-Z0-9]+$/.test(word) ? word.slice(1).toLowerCase() : word.slice(1);
-		return word.charAt(0).toUpperCase() + rest;
-	}).join("");
-}
-/**
-* Convert a slug/snake_case string to camelCase
-* e.g. "private_notes" → "privateNotes"
-*/
-function toCamelCase(str) {
-	if (!/[_\-\s]/.test(str)) return str.charAt(0).toLowerCase() + str.slice(1);
-	const pascal = toPascalCase(str);
-	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-/**
-* Convert a slug to a safe JS identifier
-* e.g. "private-notes" → "privateNotes"
-*/
-function toSafeIdentifier(str) {
-	return toCamelCase(str.replace(/[^a-zA-Z0-9_]/g, "_"));
-}
-/**
 * A schema that cannot be expressed as a valid TypeScript file.
 *
 * Thrown rather than emitted. The generator used to concatenate whatever it was
@@ -201,7 +167,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`.
@@ -221,13 +189,29 @@ function buildAccessors(collections) {
 		if (typeof slug !== "string" || slug.length === 0) throw new CodegenError("A collection has no slug, so it has no name to generate a type for. Every collection needs a unique `slug`.");
 		const safe = toSafeIdentifier(slug);
 		if (safe.length === 0) throw new CodegenError(`The slug ${emitString(slug)} has no characters that can form a property name, so it cannot be reached as \`client.data.<name>\`. Use a slug containing letters, digits, underscores or dashes.`);
-		const existing = bySafeName.get(safe);
-		if (existing !== void 0) throw new CodegenError(`The collections ${emitString(existing)} and ${emitString(slug)} both generate the accessor "${safe}", so only one of them could be reached from the generated client and the other's reads would silently go to the wrong table. Rename one of the slugs.`);
-		bySafeName.set(safe, slug);
-		accessors.set(slug, safe);
+		const accessor = toCollectionAccessor(slug);
+		if (accessor !== safe) console.warn(`[codegen] The collection ${emitString(slug)} would be \`client.data.${safe}\`, a name the client reserves, so its typed accessor is \`client.data.${accessor}\`. \`client.data.collection(${emitString(slug)})\` reaches it too.`);
+		const existing = bySafeName.get(accessor);
+		if (existing !== void 0) throw new CodegenError(`The collections ${emitString(existing)} and ${emitString(slug)} both generate the accessor "${accessor}", so only one of them could be reached from the generated client and the other's reads would silently go to the wrong table. Rename one of the slugs.`);
+		bySafeName.set(accessor, slug);
+		accessors.set(slug, accessor);
 	}
 	return accessors;
 }
+/**
+* A column's type on a write: its own type (a date also as a `Date`), 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) {
+	const written = prop.type === "date" ? `${tsType} | Date` : tsType;
+	return prop.validation?.required || isPrimaryKey(prop) ? written : `${written} | null`;
+}
 /** One emitted `key: type;` line, already indented. */
 function line(key, type, optional) {
 	return `      ${emitKey(key)}${optional ? "?" : ""}: ${type};`;
@@ -239,9 +223,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 +249,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 +335,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));
+			const isOptional = !prop.validation?.required || isAutoAssignedId(prop) || Boolean(prop.databaseDefault);
+			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 +493,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 +504,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 +546,15 @@ var doctor_exports = /* @__PURE__ */ __exportAll({
 	checkCollectionsVsSchema: () => checkCollectionsVsSchema,
 	checkCollectionsVsSdk: () => checkCollectionsVsSdk,
 	getExpectedColumnType: () => getExpectedColumnType,
+	junctionKeyIssues: () => junctionKeyIssues,
 	loadCollections: () => loadCollections,
 	missingExtensionIssues: () => missingExtensionIssues,
+	orphanedJunctionIssues: () => orphanedJunctionIssues,
+	primaryKeyIssues: () => primaryKeyIssues,
 	renderReport: () => renderReport,
 	runDoctor: () => runDoctor,
-	schemaStampIssues: () => schemaStampIssues
+	schemaStampIssues: () => schemaStampIssues,
+	typeMismatchFix: () => typeMismatchFix
 });
 /**
 * Resolve the SQL column name for a property.
@@ -736,6 +775,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 +891,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 +936,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 +960,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 +996,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 +1028,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 {
@@ -929,7 +1072,7 @@ async function checkCollectionsVsDatabase(collections, databaseUrl) {
 									expected: expectedValues.join(", "),
 									actual: dbEnumValues.join(", "),
 									message: `Enum values for "${colName}" in table "${fullTableName}" are out of sync (${parts.join("; ")}).`,
-									fix: "Run `rebase db push` to update the enum"
+									fix: extra.length > 0 && missing.length === 0 ? `PostgreSQL cannot drop an enum label, so \`rebase db push\` leaves ${extra.join(", ")} in place. Harmless unless something still writes it; to retire it, UPDATE its rows to another value, then rewrite the type in a migration (\`rebase db generate\`: CREATE TYPE …, ALTER TABLE … TYPE … USING, DROP TYPE) and \`rebase db migrate\`` : "Run `rebase db push` to add the missing labels" + (extra.length > 0 ? `; it cannot remove ${extra.join(", ")} (PostgreSQL has no ALTER TYPE … DROP VALUE) — retire those with a migration that rewrites the type` : "")
 								});
 							}
 						}
@@ -948,16 +1091,63 @@ 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));
+				}
 			}
 		}
+		if (plan) issues.push(...orphanedJunctionIssues(plan, columnsByTable, pksByTable, fksByTable));
 	} finally {
 		await pool.end();
 	}
 	return {
-		passed: issues.length === 0,
+		passed: !issues.some((issue) => issue.severity !== "info"),
 		issues
 	};
 }
+/**
+* A `public` table in the junction shape that no collection declares.
+*
+* The shape is the planner's: exactly two columns, together the primary key,
+* each a single-column foreign key to a collection's table. Renaming or
+* removing a many-to-many leaves such a table behind — push and boot only
+* create — with every link row still in it and nothing reading it.
+*
+* Info, never more: the table may be data somebody still wants. The remedy is
+* shown, never run.
+*/
+function orphanedJunctionIssues(plan, columnsByTable, pksByTable, fksByTable) {
+	const declared = new Set(plan.tables.map((table) => table.qualified));
+	const collectionTables = new Set(plan.tables.filter((table) => table.kind === "collection").map((table) => table.qualified));
+	const issues = [];
+	for (const [table, columns] of columnsByTable) {
+		if (table.includes(".") || declared.has(`public.${table}`)) continue;
+		if (columns.length !== 2 || (pksByTable.get(table) ?? []).length !== 2) continue;
+		const byConstraint = /* @__PURE__ */ new Map();
+		for (const fk of fksByTable.get(table) ?? []) {
+			const target = `${fk.foreign_table_schema}.${fk.foreign_table_name}`;
+			byConstraint.set(fk.constraint_name, [...byConstraint.get(fk.constraint_name) ?? [], {
+				column: fk.column_name,
+				target
+			}]);
+		}
+		const links = [...byConstraint.values()];
+		if (links.length !== 2 || links.some((link) => link.length !== 1)) continue;
+		if (new Set(links.map(([link]) => link.column)).size !== 2) continue;
+		if (!links.every(([link]) => collectionTables.has(link.target))) continue;
+		const targets = links.map(([link]) => link.target.replace(/^public\./, ""));
+		issues.push({
+			severity: "info",
+			category: "orphaned_junction",
+			table,
+			message: `Table "${table}" links "${targets[0]}" and "${targets[1]}" like a many-to-many junction, but no collection declares it — left behind by a renamed or removed relation?`,
+			fix: `DROP TABLE "public"."${table}";`
+		});
+	}
+	return issues;
+}
 function renderReport(report) {
 	out();
 	out(chalk.bold("  🩺 Rebase Schema Doctor"));
@@ -1032,10 +1222,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 +1297,4 @@ async function runDoctor(options) {
 //#endregion
 export { loadCollections as n, runDoctor as r, doctor_exports as t };
 
-//# sourceMappingURL=doctor-Cb2thZ8s.js.map
+//# sourceMappingURL=doctor-C4WiftHm.js.map