@rebasepro/server-postgres 0.18.0 → 0.19.0

package/dist/doctor-D7HWmGzs.js

@@ -0,0 +1,974 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { r as __exportAll } from "./__vite-browser-external-BnuHet1e.js";
+import { i as diagnoseDbError, n as deepestErrorMessage, o as parseHostInfo } from "./cli-errors-DxN4yzdH.js";
+import { t as generateSchema } from "./generate-drizzle-schema-logic-so2Z_lyC.js";
+import { n as outError, t as out } from "./cli-output-CNdMql-L.js";
+import { t as chalk } from "./source-Br7L7GOI.js";
+import { loadCollectionsFromDirectory } from "@rebasepro/server";
+import { computeSchemaVersion, isManyToMany, isPostgresCollectionConfig } from "@rebasepro/types";
+import { fieldKeyForColumn, findRelation, getTableName, isRelationRequired, relationalCollections, resolveCollectionRelations, sortCollectionsBySlug } from "@rebasepro/common";
+import { 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
+* given, so a slug that collided with another one, or that was not an
+* identifier, produced a file that either failed to compile or — worse —
+* compiled while quietly routing one collection to another's slug.
+*/
+var CodegenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodegenError";
+	}
+};
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* A property name for the emitted TypeScript: verbatim when it is a valid
+* identifier, quoted otherwise.
+*
+* Every key that reaches the output goes through here. Column names are not
+* required to be identifiers — `"order"`, `"user id"`, a quoted Postgres
+* identifier — and the previous behaviour of camel-casing them into shape
+* renamed the column in the type while the wire kept the original, so the
+* generated `Row` described fields that did not exist.
+*/
+function emitKey(key) {
+	return IDENTIFIER.test(key) ? key : JSON.stringify(key);
+}
+/**
+* A string literal, escaped.
+*
+* `"${value}"` was the previous form. A value containing a quote closed the
+* literal early, which at best broke the file and at worst let a slug from a
+* remote contract inject top-level statements into a file the developer
+* compiles and bundles.
+*/
+function emitString(value) {
+	return JSON.stringify(value);
+}
+/** The `id`s of an enum declared as an array, an array of `{ id }`, or an object map. */
+function enumIds(raw) {
+	if (Array.isArray(raw)) return raw.map((entry) => entry && typeof entry === "object" ? entry.id : entry);
+	if (raw && typeof raw === "object") return Object.keys(raw);
+	return [];
+}
+function propertyToTypeScriptType(prop) {
+	switch (prop.type) {
+		case "string": {
+			const sp = prop;
+			if (sp.enum) {
+				const ids = enumIds(sp.enum);
+				if (ids.length === 0) return "string";
+				return ids.map((v) => emitString(String(v))).join(" | ");
+			}
+			return "string";
+		}
+		case "number": {
+			const np = prop;
+			if (np.enum) {
+				const ids = enumIds(np.enum);
+				const numbers = ids.map(Number);
+				if (ids.length === 0 || numbers.some((n) => !Number.isFinite(n))) return "number";
+				return numbers.map((n) => String(n)).join(" | ");
+			}
+			return "number";
+		}
+		case "boolean": return "boolean";
+		case "date": return "string";
+		case "geopoint": return "{ latitude: number; longitude: number; }";
+		case "reference": return "string | number";
+		case "relation": return "string | number";
+		case "map": {
+			const mapProp = prop;
+			if (mapProp.properties) return `{ ${Object.entries(mapProp.properties).map(([k, v]) => {
+				const child = v;
+				const optional = !child.validation?.required;
+				const type = propertyToTypeScriptType(child);
+				return `${emitKey(k)}${optional ? "?" : ""}: ${optional ? `${type} | null` : type};`;
+			}).join(" ")} }`;
+			return "Record<string, unknown>";
+		}
+		case "array": {
+			const arrProp = prop;
+			if (arrProp.of) return `Array<${propertyToTypeScriptType(arrProp.of)}>`;
+			return "Array<unknown>";
+		}
+		case "vector": return "number[]";
+		case "binary": return "string";
+		default: return "unknown";
+	}
+}
+/**
+* Unwrap a relation target that arrived as a module namespace rather than the
+* collection itself — `target: () => import("./authors")` is a common slip.
+*/
+function resolveTargetCollection(relation) {
+	try {
+		let target = relation.target();
+		if (target && (target.default || target.__esModule)) target = target.default ?? target;
+		return target;
+	} catch {
+		return;
+	}
+}
+/** The TypeScript type of a foreign key: whatever the target's primary key is. */
+function foreignKeyType(relation) {
+	const target = resolveTargetCollection(relation);
+	if (!target?.properties) return "string | number";
+	const idProp = Object.entries(target.properties).find(([_, p]) => p.isId);
+	if (!idProp) return "string | number";
+	return idProp[1].type === "number" ? "number" : "string";
+}
+/** Whether a property is the collection's primary key. */
+function isPrimaryKey(prop) {
+	return Boolean(prop.isId);
+}
+/**
+* Whether the server assigns this primary key, so a write does not have to.
+* `true` and `"manual"` both mean the caller supplies it.
+*/
+function isAutoAssignedId(prop) {
+	const isId = prop.isId;
+	return Boolean(isId) && isId !== "manual" && isId !== true;
+}
+/**
+* The type an *included* relation arrives as: the target's own row, inlined.
+*
+* This is what the read pipeline actually serves — `toRestRow` puts the
+* target's flat columns where the relation was, and the SDK and the HTTP API
+* both go through it. It is deliberately *not* a `{ __type: "relation" }`
+* envelope: that shape is the admin's view-model and never reaches a
+* developer's `find()`.
+*
+* Falls back to an open record when the target is not part of this generation
+* run, since there is no `Row` to point at.
+*/
+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;
+}
+/**
+* Map every slug to the property name it is reachable under on `client.data`.
+*
+* The accessor is a safe identifier because `client.data.myNotes` is the point
+* of generating this at all, and `collectionsDictionary` maps it back to the
+* slug the wire uses. Two slugs that safe down to the same identifier cannot
+* both have it: the interface would not compile, and the dictionary — an object
+* literal — would silently keep only the last, routing one collection's reads
+* to the other's table. There is no defensible way to pick, so this refuses.
+*/
+function buildAccessors(collections) {
+	const accessors = /* @__PURE__ */ new Map();
+	const bySafeName = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const slug = collection.slug;
+		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);
+	}
+	return accessors;
+}
+/** One emitted `key: type;` line, already indented. */
+function line(key, type, optional) {
+	return `      ${emitKey(key)}${optional ? "?" : ""}: ${type};`;
+}
+/**
+* The keys `excludeFromApi` takes off the API surface — in *both* directions.
+*
+* `excludeFromApi` means one thing: the API surface does not mention this
+* 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.
+*
+* Keyed by the property name *and* by its column name, the same pair the
+* server's `stripExcluded` deletes, so a foreign key or a relation addressed
+* under the column name cannot put the property back.
+*/
+function excludedApiKeys(properties) {
+	const excluded = /* @__PURE__ */ new Set();
+	for (const [key, rawProp] of Object.entries(properties)) {
+		const prop = rawProp;
+		if (!prop?.excludeFromApi) continue;
+		excluded.add(key);
+		if (prop.columnName) excluded.add(prop.columnName);
+	}
+	return excluded;
+}
+function generateTypedefs(input) {
+	const collections = sortCollectionsBySlug(input);
+	const accessors = buildAccessors(collections);
+	const lines = [
+		"/**",
+		" * This file was auto-generated by Rebase.",
+		" * Do not make direct changes to the file.",
+		" */",
+		"",
+		"export interface Database {"
+	];
+	for (const collection of collections) {
+		const properties = collection.properties ?? {};
+		let resolvedRelations = {};
+		try {
+			resolvedRelations = resolveCollectionRelations(collection);
+		} catch (e) {
+			console.warn(`[rebase] Could not resolve the relations of "${collection.slug}", so its generated type has no relation fields and none of their foreign-key columns. This is usually a circular import in the collection files — make sure the target is \`() => otherCollection\` and not evaluated at module load.\n  ${e instanceof Error ? e.message : String(e)}`);
+		}
+		const subcollections = collection.subcollections;
+		if (Array.isArray(subcollections) && subcollections.length > 0) console.warn(`[rebase] "${collection.slug}" declares ${subcollections.length} subcollection(s), which are not part of the generated Database: they are reached over a nested path (\`data/${collection.slug}/<id>/<relation>\`), not as a top-level accessor. Register a subcollection as a collection of its own if you want a typed accessor for it.`);
+		lines.push(`  ${emitKey(accessors.get(collection.slug))}: {`);
+		lines.push("    Row: {");
+		const emittedKeys = /* @__PURE__ */ new Set();
+		const excluded = excludedApiKeys(properties);
+		for (const key of excluded) emittedKeys.add(key);
+		for (const [key, rawProp] of Object.entries(properties)) {
+			const prop = rawProp;
+			if (prop.type === "relation") continue;
+			if (excluded.has(key)) continue;
+			const tsType = propertyToTypeScriptType(prop);
+			const isRequired = Boolean(prop.validation?.required) || isPrimaryKey(prop);
+			lines.push(line(key, isRequired ? tsType : `${tsType} | null`, !isRequired));
+			emittedKeys.add(key);
+		}
+		for (const [relKey, relation] of Object.entries(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) {
+			const fkKey = fieldKeyForColumn(collection, relation.localKey);
+			if (emittedKeys.has(fkKey)) continue;
+			const fkType = foreignKeyType(relation);
+			const shadowedByInclude = relKey === fkKey;
+			const tsType = shadowedByInclude ? `${fkType} | ${includedRelationType(relation, accessors)}` : fkType;
+			const isRequired = isRelationRequired(collection, relation) && !shadowedByInclude;
+			lines.push(line(fkKey, isRequired ? tsType : `${tsType} | null`, !isRequired));
+			emittedKeys.add(fkKey);
+		}
+		for (const [key, relation] of Object.entries(resolvedRelations)) {
+			if (emittedKeys.has(key)) continue;
+			lines.push(line(key, includedRelationType(relation, accessors), true));
+			emittedKeys.add(key);
+		}
+		for (const [key, rawProp] of Object.entries(properties)) {
+			if (rawProp.type !== "relation") continue;
+			if (emittedKeys.has(key)) continue;
+			lines.push(line(key, "Record<string, unknown>", true));
+			emittedKeys.add(key);
+		}
+		lines.push("    };");
+		lines.push("    Insert: {");
+		emittedKeys.clear();
+		for (const key of excluded) emittedKeys.add(key);
+		for (const [key, rawProp] of Object.entries(properties)) {
+			const prop = rawProp;
+			if (prop.type === "relation") continue;
+			if (excluded.has(key)) continue;
+			const tsType = propertyToTypeScriptType(prop);
+			const isOptional = !prop.validation?.required || isAutoAssignedId(prop);
+			lines.push(line(key, 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, 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));
+			emittedKeys.add(key);
+		}
+		emitWritableRelations(lines, collection, properties, resolvedRelations, emittedKeys, true);
+		lines.push("    };");
+		lines.push("  };");
+	}
+	lines.push("}");
+	lines.push("");
+	lines.push("export type CollectionName = keyof Database;");
+	lines.push("");
+	lines.push("export const collectionsDictionary = {");
+	for (const collection of collections) lines.push(`  ${emitKey(accessors.get(collection.slug))}: ${emitString(collection.slug)},`);
+	lines.push("} as const;");
+	lines.push("");
+	lines.push("export type CollectionsDictionary = typeof collectionsDictionary;");
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* The two ways a write can name a `belongsTo` target, both of which the server
+* accepts: the foreign key under its own wire name (`{ authorId: 5 }`, which
+* passes through to the `author_id` column untouched) and the relation
+* *property* (`{ author: 5 }`, which the write transformer maps onto that
+* column).
+*
+* Only the first was generated, so the documented and idiomatic write shape was
+* a type error.
+*
+* The second form is emitted under the **property key**, not the resolved
+* relation name, because that is what the transformer keys off: it looks the
+* payload key up in `properties` and only treats it as a relation if what it
+* finds there is one. A relation whose `relationName` differs from its property
+* key is reachable as the property and not as the name, so emitting the name
+* would have offered a key that writes to a column that does not exist.
+*/
+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));
+		emittedKeys.add(key);
+	};
+	for (const relation of Object.values(resolvedRelations)) if (relation.kind === "belongsTo" && relation.localKey) emit(fieldKeyForColumn(collection, relation.localKey), relation);
+	for (const [key, rawProp] of Object.entries(properties)) {
+		if (rawProp.type !== "relation") continue;
+		const relation = findRelation(resolvedRelations, key);
+		if (relation?.kind === "belongsTo" && relation.localKey) emit(key, relation);
+	}
+}
+//#endregion
+//#region src/schema/doctor.ts
+/**
+* Rebase Schema Doctor — Three-way schema drift detection.
+*
+* Compares:
+*  1. Collection definitions → Generated Drizzle schema (staleness check)
+*  2. Collection definitions → Live PostgreSQL database (structural drift)
+*
+* Run via:  rebase doctor
+*/
+var doctor_exports = /* @__PURE__ */ __exportAll({
+	checkCollectionsVsDatabase: () => checkCollectionsVsDatabase,
+	checkCollectionsVsSchema: () => checkCollectionsVsSchema,
+	checkCollectionsVsSdk: () => checkCollectionsVsSdk,
+	getExpectedColumnType: () => getExpectedColumnType,
+	loadCollections: () => loadCollections,
+	missingExtensionIssues: () => missingExtensionIssues,
+	renderReport: () => renderReport,
+	runDoctor: () => runDoctor,
+	schemaStampIssues: () => schemaStampIssues
+});
+/**
+* Resolve the SQL column name for a property.
+* Uses the explicit `columnName` when set (e.g. from introspection),
+* falling back to `toSnakeCase(propName)` for manually-authored collections.
+*/
+var resolveColumnName = (propName, prop) => {
+	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
+	return toSnakeCase(propName);
+};
+function getExpectedColumnType(prop) {
+	switch (prop.type) {
+		case "string": {
+			const sp = prop;
+			if (sp.enum) return "USER-DEFINED";
+			if ("isId" in sp && sp.isId === "uuid") return "uuid";
+			if (sp.columnType === "uuid") return "uuid";
+			if (sp.columnType === "char") return "character";
+			if (sp.columnType === "varchar") return "character varying";
+			return "text";
+		}
+		case "number": {
+			const np = prop;
+			if (np.columnType) return {
+				serial: "integer",
+				bigserial: "bigint",
+				smallserial: "smallint"
+			}[np.columnType] ?? np.columnType;
+			if (np.validation?.integer || "isId" in np && np.isId) return "integer";
+			return "numeric";
+		}
+		case "boolean": return "boolean";
+		case "date": {
+			const dp = prop;
+			if (dp.columnType === "date") return "date";
+			if (dp.columnType === "time") return "time without time zone";
+			return "timestamp with time zone";
+		}
+		case "array": {
+			const ap = prop;
+			let colType = ap.columnType;
+			if (!colType && ap.of && !Array.isArray(ap.of)) {
+				const ofProp = ap.of;
+				if (ofProp.type === "string") colType = "text[]";
+				else if (ofProp.type === "number") colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+				else if (ofProp.type === "boolean") colType = "boolean[]";
+			}
+			if (colType === "json") return "json";
+			if (colType === "jsonb") return "jsonb";
+			if (colType && colType.endsWith("[]")) return "ARRAY";
+			return "jsonb";
+		}
+		case "map":
+			if (prop.columnType === "json") return "json";
+			return "jsonb";
+		case "relation": return null;
+		case "reference": return "text";
+		case "vector": return "USER-DEFINED";
+		case "binary": return "bytea";
+		default: return null;
+	}
+}
+/**
+* Re-exported so callers keep importing it from here, but the implementation is
+* now shared with the runtime and the generators — a doctor that disagreed with
+* the policy generator about which files are collections would compare the
+* wrong thing.
+*/
+async function loadCollections(collectionsPath) {
+	return loadCollectionsFromDirectory(collectionsPath);
+}
+async function checkCollectionsVsSchema(collections, schemaFilePath) {
+	const issues = [];
+	if (!fs$1.existsSync(schemaFilePath)) {
+		issues.push({
+			severity: "error",
+			category: "schema_stale",
+			message: "Generated schema file does not exist.",
+			fix: "Run `rebase schema generate`"
+		});
+		return {
+			passed: false,
+			issues
+		};
+	}
+	const postgresCollections = relationalCollections(collections);
+	if (postgresCollections.length === 0) return {
+		passed: true,
+		issues
+	};
+	try {
+		const expectedSchema = await generateSchema(postgresCollections);
+		const actualSchema = await promises.readFile(schemaFilePath, "utf-8");
+		const normalize = (s) => s.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+		if (normalize(expectedSchema) !== normalize(actualSchema)) issues.push({
+			severity: "warning",
+			category: "schema_stale",
+			message: "Generated schema is out of date — collection definitions have changed since last generation.",
+			fix: "Run `rebase schema generate`"
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		issues.push({
+			severity: "warning",
+			category: "schema_stale",
+			message: `Could not regenerate schema for comparison: ${message}`,
+			fix: "Run `rebase schema generate` to verify"
+		});
+	}
+	return {
+		passed: issues.length === 0,
+		issues
+	};
+}
+async function checkCollectionsVsSdk(collections, sdkFilePath) {
+	const issues = [];
+	if (!fs$1.existsSync(sdkFilePath)) {
+		issues.push({
+			severity: "info",
+			category: "sdk_not_generated",
+			message: "Typed SDK not generated (optional).",
+			fix: "Run `rebase generate-sdk` if you want typed collection access"
+		});
+		return {
+			passed: true,
+			issues,
+			notApplicable: "not generated (optional)"
+		};
+	}
+	try {
+		const expectedSdk = generateTypedefs(collections);
+		const actualSdk = await promises.readFile(sdkFilePath, "utf-8");
+		const normalize = (s) => s.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+		if (normalize(expectedSdk) !== normalize(actualSdk)) issues.push({
+			severity: "warning",
+			category: "sdk_stale",
+			message: "Generated SDK types are out of date — collection definitions have changed since last SDK generation.",
+			fix: "Run `rebase generate-sdk`"
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (err instanceof Error && err.name === "CodegenError") issues.push({
+			severity: "error",
+			category: "sdk_ungeneratable",
+			message: `The typed SDK cannot be generated from these collections: ${message}`,
+			fix: "Fix the collection definitions named above, then run `rebase generate-sdk`"
+		});
+		else issues.push({
+			severity: "warning",
+			category: "sdk_stale",
+			message: `Could not regenerate SDK types for comparison: ${message}`,
+			fix: "Run `rebase generate-sdk` to verify"
+		});
+	}
+	return {
+		passed: issues.length === 0,
+		issues
+	};
+}
+/**
+* Extensions the collections need, that the database does not have installed.
+*
+* Only `vector` today, and only because a `{ type: "vector" }` property plans a
+* column of a type that will not exist. Rebase installs it only where a project
+* has said it may (`database({ extensions: ["vector"] })`), so the absence is
+* often correct configuration and a wrong deployment — which is exactly why the
+* report has to name it rather than the first failing INSERT.
+*
+* Exported for its test.
+*/
+function missingExtensionIssues(collections, installed) {
+	if (!collections.some((collection) => Object.values(collection.properties ?? {}).some((property) => property?.type === "vector")) || installed.has("vector")) return [];
+	return [{
+		severity: "error",
+		category: "missing_table",
+		message: "A collection declares a `{ type: \"vector\" }` property and the pgvector extension is not installed on this database.",
+		fix: "Declare it — `database({ extensions: [\"vector\"] })` in config/resources.ts — and use an image that ships the library (the scaffold's pgvector/pgvector:pg18; a stock postgres:18 does not). Or install it once by hand: CREATE EXTENSION vector;"
+	}];
+}
+/**
+* The stamp the runtime wrote, against the collections on disk.
+*
+* A stamp that disagrees means this database was provisioned from a different
+* set of collections than the ones in this checkout — a colleague's branch, an
+* older deploy, a tenant somebody else migrated. Everything else in this report
+* is then describing a schema somebody else created, which is worth knowing
+* before acting on any of it.
+*
+* A warning, not an error, and never a direction: the stamp is a hash, so it
+* can say the two disagree and never which is ahead. `null` — never stamped —
+* is not a finding: every database provisioned before the stamp existed reads
+* that way, and so does every fresh one.
+*/
+async function schemaStampIssues(pool, collections) {
+	let stamped = null;
+	try {
+		if (!(await pool.query(`SELECT to_regclass('"rebase"."schema_meta"') IS NOT NULL AS present`)).rows[0]?.present) return [];
+		stamped = (await pool.query(`SELECT value FROM "rebase"."schema_meta" WHERE key = 'collections_schema_version' LIMIT 1`)).rows[0]?.value ?? null;
+	} catch {
+		return [];
+	}
+	if (!stamped) return [];
+	const expected = computeSchemaVersion(collections);
+	if (stamped === expected) return [];
+	return [{
+		severity: "warning",
+		category: "schema_stale",
+		message: `This database was provisioned from a different set of collections (stamp ${stamped.slice(0, 12)}…, this checkout computes ${expected.slice(0, 12)}…).`,
+		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."
+	}];
+}
+async function checkCollectionsVsDatabase(collections, databaseUrl) {
+	const issues = [];
+	const pgModule = await import("pg");
+	const { Pool } = pgModule.default ?? pgModule;
+	const pool = new Pool({ connectionString: databaseUrl });
+	const schemas = Array.from(/* @__PURE__ */ new Set([
+		"public",
+		"rebase",
+		...relationalCollections(collections).filter(isPostgresCollectionConfig).map((c) => c.schema).filter((s) => !!s)
+	]));
+	try {
+		const tablesResult = await pool.query(`SELECT table_schema, table_name 
+             FROM information_schema.tables 
+             WHERE table_schema = ANY($1) AND table_type = 'BASE TABLE'`, [schemas]);
+		const existingTables = new Set(tablesResult.rows.map((r) => r.table_schema === "public" ? r.table_name : `${r.table_schema}.${r.table_name}`));
+		const extensionsResult = await pool.query("SELECT extname FROM pg_extension");
+		const installedExtensions = new Set(extensionsResult.rows.map((r) => r.extname));
+		issues.push(...missingExtensionIssues(collections, installedExtensions));
+		issues.push(...await schemaStampIssues(pool, collections));
+		const columnsResult = await pool.query(`SELECT table_schema, table_name, column_name, data_type, is_nullable, udt_name
+             FROM information_schema.columns
+             WHERE table_schema = ANY($1)
+             ORDER BY table_schema, table_name, ordinal_position`, [schemas]);
+		const columnsByTable = /* @__PURE__ */ new Map();
+		for (const row of columnsResult.rows) {
+			const tableSchema = row.table_schema;
+			const tableName = row.table_name;
+			const key = tableSchema === "public" ? tableName : `${tableSchema}.${tableName}`;
+			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
+             FROM pg_type t
+             JOIN pg_enum e ON t.oid = e.enumtypid
+             ORDER BY 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 fksResult = await pool.query(`SELECT
+                tc.constraint_name,
+                tc.table_schema,
+                tc.table_name,
+                kcu.column_name,
+                ccu.table_schema AS foreign_table_schema,
+                ccu.table_name AS foreign_table_name,
+                ccu.column_name AS foreign_column_name
+             FROM information_schema.table_constraints AS tc
+             JOIN information_schema.key_column_usage AS kcu
+                 ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+             JOIN information_schema.constraint_column_usage AS ccu
+                 ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+             WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = ANY($1)`, [schemas]);
+		const fksByTable = /* @__PURE__ */ new Map();
+		for (const row of fksResult.rows) {
+			const tableSchema = row.table_schema;
+			const tableName = row.table_name;
+			const key = tableSchema === "public" ? tableName : `${tableSchema}.${tableName}`;
+			if (!fksByTable.has(key)) fksByTable.set(key, []);
+			fksByTable.get(key).push(row);
+		}
+		const postgresCollections = relationalCollections(collections);
+		for (const collection of postgresCollections) {
+			const tableName = getTableName(collection);
+			const schemaName = collection.schema || "public";
+			const fullTableName = schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
+			if (!existingTables.has(fullTableName)) {
+				issues.push({
+					severity: "error",
+					category: "missing_table",
+					table: fullTableName,
+					message: `Table "${fullTableName}" does not exist in the database.`,
+					fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
+				});
+				continue;
+			}
+			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"
+			]);
+			for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
+				if (prop.type === "relation") {
+					const relation = findRelation(resolveCollectionRelations(collection), prop.relation?.relationName ?? propName);
+					if (relation?.kind === "belongsTo") {
+						const fkColName = relation.localKey;
+						if (!dbColumnMap.has(fkColName)) issues.push({
+							severity: "error",
+							category: "missing_column",
+							table: fullTableName,
+							column: fkColName,
+							message: `Foreign key column "${fkColName}" for relation "${propName}" is missing from table "${fullTableName}".`,
+							fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
+						});
+						const tableFks = fksByTable.get(fullTableName) ?? [];
+						let targetTableName = "unknown";
+						let targetSchemaName = "public";
+						try {
+							const targetColl = relation.target();
+							targetTableName = getTableName(targetColl);
+							targetSchemaName = targetColl.schema || "public";
+						} catch {}
+						const hasFk = tableFks.some((fk) => fk.column_name === fkColName && fk.foreign_table_name === targetTableName && fk.foreign_table_schema === targetSchemaName);
+						if (dbColumnMap.has(fkColName) && !hasFk) issues.push({
+							severity: "warning",
+							category: "missing_foreign_key",
+							table: fullTableName,
+							column: fkColName,
+							message: `Column "${fkColName}" exists but has no FOREIGN KEY constraint referencing "${targetSchemaName === "public" ? targetTableName : `${targetSchemaName}.${targetTableName}`}".`,
+							fix: "Run `rebase db push` or add the constraint manually"
+						});
+					}
+					continue;
+				}
+				const colName = resolveColumnName(propName, prop);
+				if (systemColumns.has(colName)) continue;
+				const dbCol = dbColumnMap.get(colName);
+				if (!dbCol) {
+					issues.push({
+						severity: "error",
+						category: "missing_column",
+						table: fullTableName,
+						column: colName,
+						message: `Column "${colName}" is defined in collection "${collection.slug}" but missing from table "${fullTableName}".`,
+						fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
+					});
+					continue;
+				}
+				const expectedType = getExpectedColumnType(prop);
+				if (expectedType) {
+					const actualType = dbCol.data_type;
+					let isMismatch = actualType !== expectedType;
+					if (prop.type === "vector" && dbCol.udt_name !== "vector") isMismatch = true;
+					if (prop.type === "array") {
+						const ap = prop;
+						let expectedColType = ap.columnType;
+						if (!expectedColType && ap.of && !Array.isArray(ap.of)) {
+							const ofProp = ap.of;
+							if (ofProp.type === "string") expectedColType = "text[]";
+							else if (ofProp.type === "number") expectedColType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+							else if (ofProp.type === "boolean") expectedColType = "boolean[]";
+						}
+						if (expectedColType && expectedColType.endsWith("[]")) if (actualType !== "ARRAY") isMismatch = true;
+						else {
+							const expectedUdt = expectedColType === "text[]" ? "_text" : expectedColType === "integer[]" ? "_int4" : expectedColType === "boolean[]" ? "_bool" : expectedColType === "numeric[]" ? "_numeric" : "";
+							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 (prop.type === "string" && prop.enum) {
+					const enumValues = prop.enum;
+					if (enumValues) {
+						const enumName = `${tableName}_${colName}`;
+						const dbEnumValues = enumsByName.get(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.`,
+							fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
+						});
+						else {
+							const expectedValues = Array.isArray(enumValues) ? enumValues.map((v) => typeof v === "string" ? v : String(v.id)) : Object.keys(enumValues);
+							const missing = expectedValues.filter((v) => !dbEnumValues.includes(v));
+							const extra = dbEnumValues.filter((v) => !expectedValues.includes(v));
+							if (missing.length > 0 || extra.length > 0) {
+								const parts = [];
+								if (missing.length > 0) parts.push(`missing: ${missing.join(", ")}`);
+								if (extra.length > 0) parts.push(`extra in DB: ${extra.join(", ")}`);
+								issues.push({
+									severity: "warning",
+									category: "enum_value_mismatch",
+									table: fullTableName,
+									column: colName,
+									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"
+								});
+							}
+						}
+					}
+				}
+			}
+			const resolvedRelations = resolveCollectionRelations(collection);
+			for (const relation of Object.values(resolvedRelations)) if (isManyToMany(relation)) {
+				const junctionTable = relation.through.table;
+				const junctionSchema = collection.schema || "public";
+				const fullJunctionTable = junctionSchema === "public" ? junctionTable : `${junctionSchema}.${junctionTable}`;
+				if (!existingTables.has(fullJunctionTable)) issues.push({
+					severity: "error",
+					category: "missing_table",
+					table: fullJunctionTable,
+					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`"
+				});
+			}
+		}
+	} finally {
+		await pool.end();
+	}
+	return {
+		passed: issues.length === 0,
+		issues
+	};
+}
+function renderReport(report) {
+	out();
+	out(chalk.bold("  🩺 Rebase Schema Doctor"));
+	out(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+	out();
+	renderPhase("Collections → Generated Schema", report.collectionsToSchema);
+	renderPhase("Collections → Database", report.schemaToDatabase);
+	renderPhase("Collections → SDK Types", report.collectionsToSdk);
+	out(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+	const { passed, skipped, notApplicable, warnings, errors } = report.summary;
+	const parts = [];
+	parts.push(chalk.green(`${passed} passed`));
+	if (skipped > 0) parts.push(chalk.yellow(`${skipped} skipped`));
+	if (notApplicable > 0) parts.push(chalk.gray(`${notApplicable} not applicable`));
+	if (warnings > 0) parts.push(chalk.yellow(`${warnings} warnings`));
+	if (errors > 0) parts.push(chalk.red(`${errors} errors`));
+	out(`  Summary: ${parts.join(", ")}`);
+	out();
+	if (errors > 0) out(chalk.red.bold("  ✗ Schema drift detected. Run the suggested fixes above."));
+	else if (warnings > 0) out(chalk.yellow.bold("  ⚠ Minor issues detected. Consider running the suggested fixes."));
+	else if (skipped > 0) out(chalk.yellow.bold(`  ⚠ Nothing wrong in the checks that ran, but ${skipped} did not run — this is not a clean bill of health.`));
+	else out(chalk.green.bold("  ✓ All schemas are in sync!"));
+	out();
+}
+function renderPhase(label, phase) {
+	if (phase.skipped) {
+		out(`  ${chalk.yellow("⏭")}  ${label}: ${chalk.yellow(`skipped (${phase.skipped})`)}`);
+		out();
+		return;
+	}
+	if (phase.notApplicable) {
+		out(`  ${chalk.gray("➖")} ${label}: ${chalk.gray(phase.notApplicable)}`);
+		for (const issue of phase.issues.filter((i) => i.severity === "info")) out(`     ${chalk.gray(issue.fix)}`);
+		out();
+		return;
+	}
+	const issues = phase.issues;
+	const errorCount = issues.filter((i) => i.severity === "error").length;
+	const warnCount = issues.filter((i) => i.severity === "warning").length;
+	const infoIssues = issues.filter((i) => i.severity === "info");
+	if (errorCount === 0 && warnCount === 0) out(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
+	else {
+		const parts = [];
+		if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+		if (warnCount > 0) parts.push(`${warnCount} warning${warnCount > 1 ? "s" : ""}`);
+		out(`  ${chalk.yellow("⚠️")}  ${label}: ${chalk.yellow(parts.join(", "))}`);
+	}
+	out();
+	for (const issue of infoIssues) {
+		const fixPart = issue.fix ? chalk.gray(` — ${issue.fix}`) : "";
+		out(`  ${chalk.gray("ℹ")} ${chalk.gray(issue.message)}${fixPart}`);
+		out();
+	}
+	for (const issue of issues.filter((i) => i.severity !== "info")) {
+		const severityIcon = issue.severity === "error" ? chalk.red("✗") : chalk.yellow("⚠");
+		const categoryLabel = formatCategory(issue.category);
+		out(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
+		if (issue.table) {
+			const colPart = issue.column ? ` │ Column: ${chalk.cyan(issue.column)}` : "";
+			out(`  ${chalk.gray("│")} Table: ${chalk.cyan(issue.table)}${colPart}`);
+		}
+		if (issue.expected && issue.actual) out(`  ${chalk.gray("│")} Expected: ${chalk.green(issue.expected)} │ Actual: ${chalk.red(issue.actual)}`);
+		out(`  ${chalk.gray("│")} ${issue.message}`);
+		out(`  ${chalk.gray("│")} Fix: ${chalk.blue(issue.fix)}`);
+		out(`  ${chalk.gray("└" + "─".repeat(48))}`);
+		out();
+	}
+}
+function formatCategory(cat) {
+	return {
+		missing_table: "Missing Table",
+		missing_column: "Missing Column",
+		type_mismatch: "Type Mismatch",
+		missing_constraint: "Missing Constraint",
+		schema_stale: "Stale Schema",
+		missing_enum: "Missing Enum",
+		enum_value_mismatch: "Enum Value Mismatch",
+		missing_foreign_key: "Missing Foreign Key",
+		sdk_stale: "Stale SDK Types",
+		sdk_not_generated: "SDK Types Not Generated",
+		sdk_ungeneratable: "SDK Cannot Be Generated"
+	}[cat];
+}
+async function runDoctor(options) {
+	out();
+	out(chalk.bold("  🩺 Loading collections..."));
+	const collections = await loadCollections(options.collectionsPath);
+	if (collections.length === 0) {
+		outError(chalk.red("  ✗ No collections found."));
+		process.exit(1);
+	}
+	out(chalk.gray(`  Found ${collections.length} collection(s)`));
+	out();
+	out(chalk.gray("  Checking Collections → Generated Schema..."));
+	const collectionsToSchema = await checkCollectionsVsSchema(collections, options.schemaPath);
+	let schemaToDatabase;
+	if (options.databaseUrl) {
+		out(chalk.gray("  Checking Collections → Database..."));
+		try {
+			schemaToDatabase = await checkCollectionsVsDatabase(collections, options.databaseUrl);
+		} catch (err) {
+			const banner = diagnoseDbError(err, options.databaseUrl);
+			if (banner) outError(banner);
+			const reason = deepestErrorMessage(err) ?? (err instanceof Error ? err.message : String(err));
+			schemaToDatabase = {
+				passed: false,
+				issues: [],
+				skipped: `could not reach ${parseHostInfo(options.databaseUrl)} — ${reason}`,
+				blocked: true
+			};
+		}
+	} else {
+		schemaToDatabase = {
+			passed: false,
+			issues: [],
+			skipped: "DATABASE_URL not set"
+		};
+		out(chalk.yellow("  ⚠ DATABASE_URL not set — skipping database comparison."));
+		out(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
+	}
+	out(chalk.gray("  Checking Collections → SDK Types..."));
+	const collectionsToSdk = await checkCollectionsVsSdk(collections, options.sdkPath);
+	const phases = [
+		collectionsToSchema,
+		schemaToDatabase,
+		collectionsToSdk
+	];
+	const allIssues = phases.flatMap((p) => p.issues);
+	const summary = {
+		passed: phases.filter((p) => p.passed && !p.skipped && !p.notApplicable).length,
+		skipped: phases.filter((p) => p.skipped).length,
+		notApplicable: phases.filter((p) => p.notApplicable && !p.skipped).length,
+		warnings: allIssues.filter((i) => i.severity === "warning").length,
+		errors: allIssues.filter((i) => i.severity === "error").length
+	};
+	const report = {
+		collectionsToSchema,
+		collectionsToSdk,
+		schemaToDatabase,
+		summary
+	};
+	renderReport(report);
+	return report;
+}
+//#endregion
+export { loadCollections as n, runDoctor as r, doctor_exports as t };
+
+//# sourceMappingURL=doctor-D7HWmGzs.js.map