@rebasepro/server-postgres 0.25.0 → 0.25.1

package/dist/generated-schema-diff-eZCklRZQ.js

@@ -0,0 +1,1025 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { l as searchColumnNames } from "./search-column-BM-GV6vH.js";
+import { i as isAuthCollection, t as AUTH_USERS_COLUMNS } from "./auth-users-columns-C72EMoDJ.js";
+import { o as sharedRelationName } from "./plan-schema-Czf3q4-Q.js";
+import { _ as humanize, g as mapPgType, i as buildTablesMap, l as getIconForTable, p as singularize, r as buildEnumMap, u as identifyJoinTables } from "./introspect-db-logic-DgQVzccW.js";
+import { logger } from "@rebasepro/server";
+import { getTableColumns, getTableName, isTable, relations, sql } from "drizzle-orm";
+import { bigint, boolean, char, cidr, customType, date, doublePrecision, geometry, inet, integer, interval, json, jsonb, line, macaddr, macaddr8, numeric, pgSchema, pgTable, point, primaryKey, real, smallint, text, time, timestamp, uuid, varchar, vector } from "drizzle-orm/pg-core";
+import { fieldKeyForColumn, getJunctionCollectionConfig, getTableName as getTableName$1, resolveCollectionRelations, resolveJunctionSpecs } from "@rebasepro/common";
+import { firstFreeKey, toWireKey } from "@rebasepro/utils";
+//#region src/schema/introspect-runtime.ts
+/**
+* Read the RLS posture of each table in a schema.
+*
+* This is what decides whether baas mode may serve a table. A table with RLS
+* disabled has no authorization model: since every authenticated request runs
+* as `rebase_user`, and that role is granted DML on the schema, serving such a
+* table hands every row to every logged-in user.
+*/
+async function readRlsStatus(client, pgSchema) {
+	const { rows } = await client.query(`SELECT c.relname AS table,
+                c.relrowsecurity AS rls_enabled,
+                (SELECT count(*) FROM pg_policy p WHERE p.polrelid = c.oid) AS policy_count
+         FROM pg_class c
+         JOIN pg_namespace n ON n.oid = c.relnamespace
+         WHERE n.nspname = $1 AND c.relkind = 'r'`, [pgSchema]);
+	return new Map(rows.map((r) => [r.table, {
+		table: r.table,
+		rlsEnabled: r.rls_enabled === true,
+		policyCount: Number(r.policy_count ?? 0)
+	}]));
+}
+/**
+* Read tables, columns, enums, primary keys and foreign keys for a schema.
+* Mirrors the queries in introspect-db.ts.
+*/
+async function introspectSchema(client, pgSchema) {
+	const { rows: tables } = await client.query(`SELECT table_name
+         FROM information_schema.tables
+         WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+           AND table_name NOT LIKE 'drizzle_%'
+           AND table_name NOT LIKE 'rebase_%'
+         ORDER BY table_name`, [pgSchema]);
+	const { rows: columns } = await client.query(`SELECT
+            c.table_name,
+            c.column_name,
+            c.data_type,
+            c.udt_name,
+            c.is_nullable,
+            c.column_default,
+            -- A stored generated column must be declared as one, or drizzle
+            -- writes DEFAULT into it on every INSERT. Postgres tolerates that
+            -- today; the generated module has always declared them properly,
+            -- and the runtime tables are built to match it.
+            c.is_generated,
+            c.generation_expression,
+            (SELECT a.atttypmod FROM pg_attribute a
+             JOIN pg_class pc ON a.attrelid = pc.oid
+             WHERE pc.relname = c.table_name
+               AND a.attname = c.column_name
+               AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod
+         FROM information_schema.columns c
+         WHERE c.table_schema = $1`, [pgSchema]);
+	const { rows: enumValues } = await client.query(`SELECT t.typname AS enum_name,
+                e.enumlabel AS enum_value,
+                e.enumsortorder AS sort_order
+         FROM pg_type t
+         JOIN pg_enum e ON t.oid = e.enumtypid
+         JOIN pg_namespace n ON t.typnamespace = n.oid
+         WHERE n.nspname = $1
+         ORDER BY t.typname, e.enumsortorder`, [pgSchema]);
+	const { rows: pks } = await client.query(`SELECT t.relname as table_name, a.attname as column_name
+         FROM   pg_index i
+         JOIN   pg_attribute a ON a.attrelid = i.indrelid
+                             AND a.attnum = ANY(i.indkey)
+         JOIN   pg_class t ON t.oid = i.indrelid
+         JOIN   pg_namespace n ON n.oid = t.relnamespace
+         WHERE  i.indisprimary AND n.nspname = $1`, [pgSchema]);
+	const { rows: fks } = await client.query(`SELECT
+            tc.table_name,
+            kcu.column_name,
+            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 = $1`, [pgSchema]);
+	const tablesMap = buildTablesMap(tables, columns, pks, fks);
+	return {
+		tablesMap,
+		enumMap: buildEnumMap(enumValues),
+		joinTables: identifyJoinTables(tablesMap)
+	};
+}
+/** Derive the `isId` flavour for a primary-key column. */
+function idKindFor(col, propType) {
+	if (col.data_type.toLowerCase() === "uuid") return "uuid";
+	if (propType === "number") return "increment";
+	return true;
+}
+function buildProperties(meta, enumMap) {
+	const properties = {};
+	const takenKeys = /* @__PURE__ */ new Set();
+	for (const col of meta.columns) {
+		const isPk = meta.pks.includes(col.column_name);
+		if (meta.fks.some((fk) => fk.column_name === col.column_name) && !isPk) continue;
+		const enumValues = enumMap.get(col.udt_name);
+		const isEnum = col.data_type === "USER-DEFINED" && enumValues !== void 0;
+		const isVector = col.udt_name === "vector";
+		const propType = isEnum ? "string" : isVector ? "vector" : mapPgType(col.data_type);
+		const property = {
+			name: humanize(col.column_name),
+			columnName: col.column_name,
+			type: propType
+		};
+		const key = firstFreeKey([toWireKey(col.column_name), col.column_name], takenKeys);
+		takenKeys.add(key);
+		if (isPk) property.isId = idKindFor(col, propType);
+		else if (col.is_nullable === "NO" && col.column_default === null) property.validation = { required: true };
+		if (isEnum && enumValues) property.enum = enumValues.map((value) => ({
+			id: value,
+			label: humanize(value)
+		}));
+		properties[key] = property;
+	}
+	return properties;
+}
+/**
+* Owning relations, derived from this table's foreign keys — the same shape
+* `generateCollectionFile` writes into a collection file: a `relation` property
+* whose nested descriptor carries `kind`, a `target` thunk and the `localKey`.
+*
+* The shape is load-bearing, not cosmetic. `resolveCollectionRelations` reads
+* relations from `property.relation` and `resolveRelation` requires `target` to
+* be a thunk; this used to emit `target`/`cardinality`/`localKey` flat on the
+* property with the slug as a bare string, which satisfies neither. Nothing
+* threw — the resolver simply skipped every such property and reported that the
+* collection had no relations. So an introspected BaaS collection had its FK
+* columns removed from `properties` (they "surface as relations") and then no
+* resolvable relation to surface as, which is why writing the FK column
+* directly came back as `has no field 'product_id'`: `assertKnownWriteFields`
+* learns that column from the resolved relation's `localKey`.
+*
+* The thunk closes over the collections being built in this same pass rather
+* than importing a module, which is what a runtime introspection has instead of
+* generated files. It is called lazily, after the map is fully populated, so a
+* table may reference one introspected later.
+*/
+function buildRelations(meta, slugByTable, collectionBySlug) {
+	const relations = {};
+	for (const fk of meta.fks) {
+		const targetSlug = slugByTable.get(fk.foreign_table_name);
+		if (!targetSlug) continue;
+		let key = toWireKey(fk.column_name.replace(/_id$/, ""));
+		if (meta.pks.includes(fk.column_name) && key === fk.column_name) key = fk.foreign_table_name;
+		relations[key] = {
+			name: humanize(key),
+			type: "relation",
+			relation: {
+				kind: "belongsTo",
+				target: () => collectionBySlug.get(targetSlug),
+				localKey: fk.column_name
+			}
+		};
+	}
+	return relations;
+}
+/**
+* Turn an introspected schema into collections.
+*
+* Join tables are skipped: they carry no identity of their own and exist to
+* express a many-to-many edge between two other tables.
+*/
+function buildCollectionsFromSchema({ tablesMap, enumMap, joinTables }, pgSchema) {
+	const slugByTable = /* @__PURE__ */ new Map();
+	for (const tableName of tablesMap.keys()) if (!joinTables.has(tableName)) slugByTable.set(tableName, tableName);
+	const collections = [];
+	const collectionBySlug = /* @__PURE__ */ new Map();
+	for (const [tableName, meta] of tablesMap) {
+		if (joinTables.has(tableName)) continue;
+		const collectionName = humanize(tableName);
+		const collection = {
+			name: collectionName,
+			singularName: singularize(collectionName),
+			slug: tableName,
+			table: tableName,
+			schema: pgSchema,
+			icon: getIconForTable(tableName),
+			properties: {
+				...buildProperties(meta, enumMap),
+				...buildRelations(meta, slugByTable, collectionBySlug)
+			}
+		};
+		collections.push(collection);
+		collectionBySlug.set(tableName, collection);
+	}
+	return collections;
+}
+//#endregion
+//#region src/schema/dynamic-tables.ts
+/**
+* Build drizzle tables at runtime from an introspected schema.
+*
+* **Every** data source's tables are built here, from `information_schema`,
+* after boot-ensure has run — a project with declared collections included. The
+* committed `schema.generated.ts` is a build artefact for Atlas, `db push`,
+* `eject` and user code; the runtime does not read it for its tables, because a
+* file that is one commit behind the database used to change what the server
+* served (a renamed foreign-key column 500'd every request, a lost relation
+* silently emptied a list). See `catalogue-schema.ts` for the caller.
+*
+* These are handed to drizzle as its schema, which keeps the relational query
+* path (`db.query.*`) working; without them FetchService would fall back to
+* plain selects and lose relation loading.
+*
+* Two things a caller has to supply for the tables to match what the generated
+* module used to produce, both about *names*: the Drizzle object is keyed by the
+* wire name of a column and not by the column (`authorId`, not `author_id`), and
+* a relation is keyed by the collection's own relation key rather than by a
+* guess made from the foreign key. Both come from the collections — see
+* `columnKeysFromCollections` and `buildDrizzleRelationsFromCollections`.
+*/
+var columnNameAsKey = (_table, column) => column;
+/** drizzle ships no bytea builder; binary must round-trip as a Buffer. */
+var bytea = customType({ dataType: () => "bytea" });
+/**
+* A full-text search column, declared with its real SQL type.
+*
+* Not cosmetic: `isSearchIndexColumn` asks the column for its type and drops
+* every `tsvector` from the projection, so a search column that fell through to
+* `text` (the old default for an unrecognised type) would be selected, returned
+* to callers, and rendered in the admin as a wall of lexemes. drizzle ships no
+* builder for these two.
+*/
+var tsvector = customType({ dataType: () => "tsvector" });
+var tsquery = customType({ dataType: () => "tsquery" });
+/**
+* Postgres stores a column's type modifier (varchar length, vector dimensions)
+* in `atttypmod`. For length-carrying string types it is length + VARHDRSZ(4);
+* for pgvector it is the dimension count as-is. -1 means unspecified.
+*/
+function varlenLength(col) {
+	return col.atttypmod && col.atttypmod > 4 ? col.atttypmod - 4 : void 0;
+}
+/**
+* Map a Postgres type to a drizzle column builder, keyed on `udt_name` — the
+* concrete underlying type, which is exact where `data_type` reports umbrella
+* values like "ARRAY" or "USER-DEFINED".
+*
+* Unknown types fall back to `text`: the driver still reads and writes them,
+* with the value passing through as a string, which beats dropping the column.
+*/
+function scalarBuilder(udtName, name, col) {
+	switch (udtName) {
+		case "uuid": return uuid(name);
+		case "bool": return boolean(name);
+		case "int2": return smallint(name);
+		case "int4": return integer(name);
+		case "int8": return bigint(name, { mode: "number" });
+		case "float4": return real(name);
+		case "float8": return doublePrecision(name);
+		case "numeric":
+		case "money": return numeric(name);
+		case "json": return json(name);
+		case "jsonb": return jsonb(name);
+		case "date": return date(name);
+		case "time": return time(name);
+		case "timetz": return time(name, { withTimezone: true });
+		case "timestamp": return timestamp(name, { mode: "string" });
+		case "timestamptz": return timestamp(name, {
+			withTimezone: true,
+			mode: "string"
+		});
+		case "interval": return interval(name);
+		case "bytea": return bytea(name);
+		case "inet": return inet(name);
+		case "cidr": return cidr(name);
+		case "macaddr": return macaddr(name);
+		case "macaddr8": return macaddr8(name);
+		case "point": return point(name);
+		case "line": return line(name);
+		case "geometry": return geometry(name);
+		case "vector": {
+			const dimensions = col.atttypmod && col.atttypmod > 0 ? col.atttypmod : void 0;
+			return dimensions ? vector(name, { dimensions }) : text(name);
+		}
+		case "bpchar": {
+			const length = varlenLength(col);
+			return length ? char(name, { length }) : char(name);
+		}
+		case "varchar": {
+			const length = varlenLength(col);
+			return length ? varchar(name, { length }) : text(name);
+		}
+		case "tsvector": return tsvector(name);
+		case "tsquery": return tsquery(name);
+		default: return text(name);
+	}
+}
+/** See {@link FluentColumnBuilder}. */
+var fluent = (builder) => builder;
+function columnBuilderFor(col) {
+	if (col.udt_name.startsWith("_")) return fluent(scalarBuilder(col.udt_name.slice(1), col.column_name, col)).array();
+	return scalarBuilder(col.udt_name, col.column_name, col);
+}
+/**
+* Build one drizzle table per introspected table, keyed by table name.
+*
+* @param columnKey how a column is named on the wire — see {@link ColumnKeyResolver}.
+*/
+function buildDrizzleTablesFromSchema(tablesMap, pgSchemaName = "public", columnKey = columnNameAsKey) {
+	const schema = pgSchemaName === "public" ? null : pgSchema(pgSchemaName);
+	const createTable = schema ? schema.table.bind(schema) : pgTable;
+	const tables = {};
+	for (const [tableName, meta] of tablesMap) {
+		const columns = {};
+		const keyOf = /* @__PURE__ */ new Map();
+		for (const col of meta.columns) {
+			let builder = columnBuilderFor(col);
+			if (col.is_nullable === "NO") builder = fluent(builder).notNull();
+			if (meta.pks.length === 1 && meta.pks[0] === col.column_name) builder = fluent(builder).primaryKey();
+			if (col.is_generated === "ALWAYS") builder = fluent(builder).generatedAlwaysAs(sql.raw(col.generation_expression ?? ""));
+			const key = columnKey(tableName, col.column_name);
+			keyOf.set(col.column_name, key);
+			columns[key] = builder;
+		}
+		tables[tableName] = createTable(tableName, columns, meta.pks.length > 1 ? (t) => [primaryKey({ columns: meta.pks.map((pk) => t[keyOf.get(pk) ?? pk]) })] : void 0);
+	}
+	return tables;
+}
+/**
+* Build drizzle `relations()` for the foreign keys, so the relational query
+* path can actually load them.
+*
+* FetchService asks drizzle for `with: { <key>: true }`, keyed by the relation
+* property on the collection. Tables alone don't satisfy that — without these,
+* `?include=author` silently returns the raw `author_id` and no author.
+*
+* The keys here must match `buildRelations` in introspect-runtime.ts, which is
+* what names the collection's relation properties.
+*/
+function buildDrizzleRelationsFromSchema(tablesMap, tables, columnKey = columnNameAsKey) {
+	/** Owning side, per table: the `one()` relations from its foreign keys. */
+	const owning = /* @__PURE__ */ new Map();
+	/** Inverse side, per referenced table: the matching `many()` back-references. */
+	const inverse = /* @__PURE__ */ new Map();
+	for (const [tableName, meta] of tablesMap) {
+		if (!tables[tableName]) continue;
+		const columnNames = new Set(meta.columns.map((c) => columnKey(tableName, c.column_name)));
+		for (const fk of meta.fks) {
+			if (!tables[fk.foreign_table_name]) continue;
+			let key = toWireKey(fk.column_name.replace(/_id$/, ""));
+			if (meta.pks.includes(fk.column_name) && key === fk.column_name) key = fk.foreign_table_name;
+			if (columnNames.has(key)) continue;
+			const relationName = `${tableName}_${fk.column_name}`;
+			owning.set(tableName, [...owning.get(tableName) ?? [], {
+				key,
+				targetTable: fk.foreign_table_name,
+				fkColumn: columnKey(tableName, fk.column_name),
+				targetColumn: columnKey(fk.foreign_table_name, fk.foreign_column_name),
+				relationName
+			}]);
+			const backKey = tableName;
+			if (new Set((tablesMap.get(fk.foreign_table_name)?.columns ?? []).map((c) => columnKey(fk.foreign_table_name, c.column_name))).has(backKey)) continue;
+			inverse.set(fk.foreign_table_name, [...inverse.get(fk.foreign_table_name) ?? [], {
+				key: backKey,
+				sourceTable: tableName,
+				relationName
+			}]);
+		}
+	}
+	const built = {};
+	for (const tableName of tablesMap.keys()) {
+		const table = tables[tableName];
+		const ones = owning.get(tableName) ?? [];
+		const manys = inverse.get(tableName) ?? [];
+		if (!table || ones.length === 0 && manys.length === 0) continue;
+		built[`${tableName}Relations`] = relations(table, ({ one, many }) => {
+			const map = {};
+			for (const rel of ones) map[rel.key] = one(tables[rel.targetTable], {
+				fields: [getTableColumns(table)[rel.fkColumn]],
+				references: [getTableColumns(tables[rel.targetTable])[rel.targetColumn]],
+				relationName: rel.relationName
+			});
+			for (const rel of manys) {
+				if (map[rel.key]) continue;
+				map[rel.key] = many(tables[rel.sourceTable], { relationName: rel.relationName });
+			}
+			return map;
+		});
+	}
+	return built;
+}
+//#endregion
+//#region src/schema/config-relations.ts
+/**
+* Build drizzle `relations()` for declared collections, from the collections.
+*
+* The heuristic builder in `dynamic-tables.ts` names a relation after the
+* foreign-key column (`author_id` → `author`), which is the only evidence a
+* database offers and is right for BaaS mode. It is wrong for a project that
+* declares its collections: there the relation's name is whatever the author
+* called it, `include=writer` addresses that name, and a relation whose key was
+* guessed from the column simply does not answer to it — the read returns the
+* bare foreign key and no target, silently, which is how a demo lost every
+* relation in its list view while the detail view (a different code path) kept
+* working.
+*
+* So when there are collections, they are the authority for *which* relations
+* exist and what they are called; the live catalogue is the authority for the
+* columns underneath. This is the same pairing `generate-drizzle-schema-logic`
+* emits into `schema.generated.ts` — kind for kind, key for key, and paired by
+* the same {@link sharedRelationName} — only built against tables read back from
+* `information_schema` rather than against a file.
+*/
+/** A collection's table, with any schema prefix stripped — as the DDL creates it. */
+function bareTableName(name) {
+	return name.includes(".") ? name.split(".").pop() : name;
+}
+/**
+* The field key a collection's rows are addressed by, as the generated module
+* spells it: the property marked `isId`, else `id`.
+*
+* Deliberately the config's answer rather than the catalogue's primary key —
+* `references: [users.id]` in the generated file is keyed the same way, and the
+* two have to name the same Drizzle key for a relation to compile at all.
+*/
+function primaryKeyFieldKey(collection) {
+	for (const [key, prop] of Object.entries(collection.properties ?? {})) if (prop && typeof prop === "object" && "isId" in prop && Boolean(prop.isId)) return key;
+	return "id";
+}
+/**
+* The field key on the source table that a `hasOne`/`hasMany` foreign key
+* holds: its `sourceKey` when the link names one, else the primary key.
+*/
+function sourceKeyFieldKey(relation, collection) {
+	return relation.sourceKey ? fieldKeyForColumn(collection, relation.sourceKey) : primaryKeyFieldKey(collection);
+}
+/**
+* A column of a built table, by its Drizzle key or by its column name.
+*
+* The key is the answer in the ordinary case, and the name is the fallback for
+* the one place a caller holds a column and not a field: a junction table's two
+* foreign keys, which are keyed by column *unless* the project also declares a
+* collection over that table, in which case they are keyed by its property
+* names. Looking both up costs a scan of one table and removes the difference.
+*/
+function columnOf(table, key) {
+	if (!table) return void 0;
+	const direct = getTableColumns(table)[key];
+	if (direct) return direct;
+	for (const column of Object.values(getTableColumns(table))) if (column?.name === key) return column;
+}
+/**
+* Drizzle relations for every declared collection, keyed `<table>Relations`.
+*
+* @param collections every collection backed by a table in `tables`
+* @param tables      catalogue-built tables, keyed by bare table name
+*/
+function buildDrizzleRelationsFromCollections(collections, tables) {
+	const ones = /* @__PURE__ */ new Map();
+	const manys = /* @__PURE__ */ new Map();
+	/** `<relationName>::<kind>` already emitted on a table — the generator dedupes the same way. */
+	const emitted = /* @__PURE__ */ new Map();
+	const claim = (table, name, kind) => {
+		const seen = emitted.get(table) ?? /* @__PURE__ */ new Set();
+		emitted.set(table, seen);
+		const key = `${name}::${kind}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	};
+	const addOne = (table, spec) => ones.set(table, [...ones.get(table) ?? [], spec]);
+	const addMany = (table, spec) => manys.set(table, [...manys.get(table) ?? [], spec]);
+	const byTable = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const table = bareTableName(getTableName$1(collection));
+		if (table && tables[table]) byTable.set(table, collection);
+	}
+	for (const [tableName, collection] of byTable) {
+		const table = tables[tableName];
+		for (const [relationKey, relation] of Object.entries(resolveCollectionRelations(collection))) {
+			let target;
+			try {
+				target = relation.target();
+			} catch (err) {
+				logger.debug(`[schema] Relation ${collection.slug}.${relationKey} has no resolvable target`, { error: err });
+				continue;
+			}
+			const targetTable = tables[bareTableName(getTableName$1(target))];
+			const name = sharedRelationName(relation, collection);
+			switch (relation.kind) {
+				case "belongsTo": {
+					if (!targetTable) continue;
+					if (!claim(tableName, name, relation.kind)) continue;
+					const localKey = fieldKeyForColumn(collection, relation.localKey);
+					const referenced = primaryKeyFieldKey(target);
+					const field = columnOf(table, localKey);
+					const reference = columnOf(targetTable, referenced);
+					if (!field || !reference) continue;
+					addOne(tableName, {
+						key: relationKey,
+						target: targetTable,
+						fields: [field],
+						references: [reference],
+						relationName: name
+					});
+					break;
+				}
+				case "hasOne": {
+					if (!targetTable) continue;
+					if (!claim(tableName, name, relation.kind)) continue;
+					const field = columnOf(table, sourceKeyFieldKey(relation, collection));
+					const reference = columnOf(targetTable, fieldKeyForColumn(target, relation.foreignKeyOnTarget));
+					if (!field || !reference) continue;
+					addOne(tableName, {
+						key: relationKey,
+						target: targetTable,
+						fields: [field],
+						references: [reference],
+						relationName: name
+					});
+					break;
+				}
+				case "hasMany":
+					if (!targetTable) continue;
+					if (!claim(tableName, name, relation.kind)) continue;
+					addMany(tableName, {
+						key: relationKey,
+						target: targetTable,
+						relationName: name
+					});
+					break;
+				case "manyToMany": {
+					const junctionName = bareTableName(relation.through.table);
+					const junction = tables[junctionName];
+					if (!junction) continue;
+					if (!claim(tableName, name, relation.kind)) continue;
+					addMany(tableName, {
+						key: relationKey,
+						target: junction,
+						relationName: name
+					});
+					addJunctionSides(relation, collection, target, junctionName, tables, addOne, claim);
+					break;
+				}
+				case "via": break;
+			}
+		}
+	}
+	for (const [tableName, collection] of byTable) {
+		const table = tables[tableName];
+		for (const [, relation] of Object.entries(resolveCollectionRelations(collection))) {
+			if (relation.kind !== "hasMany" && relation.kind !== "hasOne") continue;
+			let target;
+			try {
+				target = relation.target();
+			} catch {
+				continue;
+			}
+			const targetTableName = bareTableName(getTableName$1(target));
+			const targetTable = tables[targetTableName];
+			if (!targetTable) continue;
+			const name = sharedRelationName(relation, collection);
+			if (!claim(targetTableName, name, "belongsTo")) continue;
+			const fkKey = fieldKeyForColumn(target, relation.foreignKeyOnTarget);
+			const field = columnOf(targetTable, fkKey);
+			const reference = columnOf(table, sourceKeyFieldKey(relation, collection));
+			if (!field || !reference) continue;
+			addOne(targetTableName, {
+				key: `_synth_${targetTableName}_${fkKey}`,
+				target: tables[tableName],
+				fields: [field],
+				references: [reference],
+				relationName: name
+			});
+		}
+	}
+	const built = {};
+	for (const tableName of /* @__PURE__ */ new Set([...ones.keys(), ...manys.keys()])) {
+		const table = tables[tableName];
+		if (!table) continue;
+		const tableOnes = ones.get(tableName) ?? [];
+		const tableManys = manys.get(tableName) ?? [];
+		built[`${tableName}Relations`] = relations(table, ({ one, many }) => {
+			const map = {};
+			for (const spec of tableOnes) map[spec.key] = one(spec.target, {
+				fields: spec.fields,
+				references: spec.references,
+				relationName: spec.relationName
+			});
+			for (const spec of tableManys) {
+				if (map[spec.key]) continue;
+				map[spec.key] = many(spec.target, { relationName: spec.relationName });
+			}
+			return map;
+		});
+	}
+	return built;
+}
+/**
+* The junction table's own two `one()` sides.
+*
+* A many-to-many is a `many(junction)` on each endpoint, so the junction has to
+* carry the matching `one()` back to each — without them drizzle can join a
+* post to its `posts_tags` rows and no further, and the tags come back as
+* junction rows. Keyed by the junction's own columns, which is how the
+* generated file keys them too.
+*/
+function addJunctionSides(relation, sourceCollection, targetCollection, junctionName, tables, addOne, claim) {
+	const junction = tables[junctionName];
+	const sourceTable = tables[bareTableName(getTableName$1(sourceCollection))];
+	const targetTable = tables[bareTableName(getTableName$1(targetCollection))];
+	if (!junction || !sourceTable || !targetTable) return;
+	const sourceName = sharedRelationName(relation, sourceCollection);
+	const inverse = Object.values(resolveCollectionRelations(targetCollection)).find((r) => r.kind === "manyToMany" && bareTableName(r.through.table) === junctionName);
+	const targetName = inverse ? sharedRelationName(inverse, targetCollection) : `${junctionName}_${relation.through.targetColumn}`;
+	const pairs = [[
+		relation.through.sourceColumn,
+		sourceTable,
+		sourceName,
+		sourceCollection,
+		"source"
+	], [
+		relation.through.targetColumn,
+		targetTable,
+		targetName,
+		targetCollection,
+		"target"
+	]];
+	for (const [column, endpointTable, relationName, endpointCollection] of pairs) {
+		if (!claim(junctionName, relationName, "junction")) continue;
+		const field = columnOf(junction, column);
+		const reference = columnOf(endpointTable, primaryKeyFieldKey(endpointCollection));
+		if (!field || !reference) continue;
+		addOne(junctionName, {
+			key: column,
+			target: endpointTable,
+			fields: [field],
+			references: [reference],
+			relationName
+		});
+	}
+}
+//#endregion
+//#region src/schema/catalogue-schema.ts
+/** The Postgres schema a collection's table lives in. */
+function schemaOfCollection(collection, fallback) {
+	const declared = collection.schema;
+	return typeof declared === "string" && declared.length > 0 ? declared : fallback;
+}
+/**
+* How a column of each table is keyed in the Drizzle object.
+*
+* The wire name, which is the property key — `authorId`, never `author_id` —
+* because that is what every read and write path in this driver indexes tables
+* and rows by, and what the generated module has always emitted. Getting this
+* wrong does not throw: drizzle leaves an unknown key out of the statement and
+* the write reports success having stored nothing.
+*
+* Two exceptions, both columns no property declares:
+*
+*  - the generated search columns keep their raw names, because `search_vector`
+*    is how `searchColumnNames` excludes them from responses and how the
+*    condition builder finds the one to match against;
+*  - a table no collection claims (a junction) is keyed by its **key** columns'
+*    names, which is also what the generated file does for them — but a
+*    junction that declares `through.properties` keys those payload columns by
+*    their property key, for the same reason a collection does. `joinedAt` with
+*    `columnName: "joined_at"` has to be one name on both sides or a `_pivot`
+*    write is silently dropped by drizzle and the read serves a key the caller
+*    never declared.
+*/
+function columnKeysFromCollections(collections) {
+	const byTable = /* @__PURE__ */ new Map();
+	const rawColumns = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const table = bareTableName(getTableName$1(collection));
+		if (!table) continue;
+		byTable.set(table, collection);
+		rawColumns.set(table, new Set(searchColumnNames(collection)));
+	}
+	const junctionByTable = /* @__PURE__ */ new Map();
+	for (const spec of resolveJunctionSpecs(collections).values()) {
+		if (Object.keys(spec.properties).length === 0) continue;
+		junctionByTable.set(bareTableName(spec.table), getJunctionCollectionConfig(spec));
+	}
+	return (tableName, columnName) => {
+		const collection = byTable.get(tableName);
+		if (!collection) {
+			const junction = junctionByTable.get(tableName);
+			return junction ? fieldKeyForColumn(junction, columnName) : columnName;
+		}
+		if (rawColumns.get(tableName)?.has(columnName)) return columnName;
+		return fieldKeyForColumn(collection, columnName);
+	};
+}
+/**
+* Read the tables this data source serves out of `information_schema`.
+*
+* Restricted to the collections handed in, because the driver is given every
+* collection the project declares while each database holds only its own: an
+* unfiltered read had a second source (`database("analytics")`) reporting the
+* default's tables as its own. Junction tables come too — they back no
+* collection and a many-to-many is unreadable without them.
+*
+* Every schema the collections name is read, not just `public`. The users
+* collection lives in `rebase`, and a run restricted to `public` would leave the
+* registry with no table for it at all.
+*/
+async function readCatalogueSchema(options) {
+	const { client, collections, defaultSchema } = options;
+	/** schema → the tables wanted from it. */
+	const wanted = /* @__PURE__ */ new Map();
+	const want = (schema, table) => {
+		const set = wanted.get(schema) ?? /* @__PURE__ */ new Set();
+		wanted.set(schema, set);
+		set.add(table);
+	};
+	for (const collection of collections) {
+		const table = bareTableName(getTableName$1(collection));
+		if (table) want(schemaOfCollection(collection, defaultSchema), table);
+	}
+	for (const spec of resolveJunctionSpecs(collections).values()) want(spec.schema, bareTableName(spec.table));
+	const columnKey = columnKeysFromCollections(collections);
+	const tables = {};
+	const meta = /* @__PURE__ */ new Map();
+	const missing = [];
+	for (const [schema, names] of wanted) {
+		const live = await introspectSchema(client, schema);
+		const present = /* @__PURE__ */ new Map();
+		for (const name of names) {
+			const found = live.tablesMap.get(name);
+			if (!found) {
+				missing.push(schema === defaultSchema ? name : `${schema}.${name}`);
+				continue;
+			}
+			if (tables[name]) continue;
+			present.set(name, found);
+			meta.set(name, found);
+		}
+		Object.assign(tables, buildDrizzleTablesFromSchema(present, schema, columnKey));
+	}
+	return {
+		tables,
+		relations: buildDrizzleRelationsFromCollections(collections, tables),
+		meta,
+		missing
+	};
+}
+/**
+* The BaaS variant: no collections are declared, so every table in one schema is
+* served and both the collections and the relations are derived from the
+* foreign keys.
+*
+* Kept apart from {@link readCatalogueSchema} because the two answer different
+* questions. Here the database is the entire specification; there it supplies
+* the columns for a specification the project already wrote down.
+*/
+function buildBaasSchema(tablesMap, pgSchemaName, collections) {
+	const columnKey = columnKeysFromCollections(collections);
+	const tables = buildDrizzleTablesFromSchema(tablesMap, pgSchemaName, columnKey);
+	return {
+		tables,
+		relations: buildDrizzleRelationsFromSchema(tablesMap, tables, columnKey)
+	};
+}
+//#endregion
+//#region src/schema/generated-schema-diff.ts
+/**
+* Compare the committed `schema.generated.ts` against the live catalogue, and
+* say so — once per difference, at boot, as a warning and nothing more.
+*
+* The runtime stopped reading that file for its tables (see
+* `catalogue-schema.ts`), which removes an entire class of production failure
+* and creates a smaller one: a stale file is now *invisible*. It is still real —
+* it is what Atlas plans migrations from, what `db push` diffs, what `eject`
+* writes out and what user code imports — so a project whose file no longer
+* describes its database will hit it later, in a tool, with no clue that boot
+* already knew.
+*
+* Hence this: a guard rather than a doc. It never fails boot and never changes
+* what is served — the previous arrangement, where the file could do both,
+* is exactly what was removed.
+*
+* `generated-schema-staleness.ts` answers a narrower question (does the file
+* name every table the collections do) from the file's *source text*. This one
+* compares the loaded module against the database, column by column.
+*/
+/**
+* The families a boot warning is worth raising over.
+*
+* Deliberately coarse. `varchar(120)` and `text` are the same family because the
+* runtime treats them identically and a warning about the difference would fire
+* on every boot of a correct project — the widths still reach Postgres, which
+* enforces them. What this is looking for is the kind of drift that changes what
+* a value *is*: a number that became text, a timestamp that became a date, a
+* column that stopped existing.
+*/
+function typeFamily(sqlType) {
+	if (!sqlType) return "unknown";
+	let type = sqlType.trim().toLowerCase();
+	const isArray = type.endsWith("[]") || type.startsWith("_");
+	type = type.replace(/\[\]$/, "").replace(/^_/, "");
+	type = type.replace(/\s*\([^)]*\)\s*$/, "").trim();
+	const family = FAMILIES[type] ?? type;
+	return isArray ? `${family}[]` : family;
+}
+var FAMILIES = {
+	text: "text",
+	varchar: "text",
+	"character varying": "text",
+	bpchar: "text",
+	char: "text",
+	character: "text",
+	citext: "text",
+	name: "text",
+	int2: "integer",
+	smallint: "integer",
+	smallserial: "integer",
+	int4: "integer",
+	int: "integer",
+	integer: "integer",
+	serial: "integer",
+	int8: "bigint",
+	bigint: "bigint",
+	bigserial: "bigint",
+	float4: "float",
+	real: "float",
+	float8: "float",
+	"double precision": "float",
+	numeric: "numeric",
+	decimal: "numeric",
+	money: "numeric",
+	bool: "boolean",
+	boolean: "boolean",
+	uuid: "uuid",
+	json: "json",
+	jsonb: "jsonb",
+	date: "date",
+	time: "time",
+	"time without time zone": "time",
+	timetz: "time",
+	"time with time zone": "time",
+	timestamp: "timestamp",
+	"timestamp without time zone": "timestamp",
+	timestamptz: "timestamptz",
+	"timestamp with time zone": "timestamptz",
+	interval: "interval",
+	bytea: "bytea",
+	tsvector: "tsvector",
+	tsquery: "tsquery",
+	vector: "vector"
+};
+function catalogueColumns(meta) {
+	const columns = /* @__PURE__ */ new Map();
+	for (const col of meta.columns) columns.set(col.column_name, {
+		name: col.column_name,
+		family: typeFamily(col.udt_name || col.data_type),
+		notNull: col.is_nullable === "NO"
+	});
+	return columns;
+}
+/**
+* Every way the generated module and the database disagree, for the tables both
+* describe.
+*
+* One-directional in one respect only: a table the module has and the database
+* does not is reported (that is the stale-file case), while a table the database
+* has and the module does not is left alone — a database may hold anything, and
+* the collections-vs-file question is `generated-schema-staleness`'s.
+*/
+function diffGeneratedSchemaAgainstCatalogue(options) {
+	const { generated, catalogue, collections } = options;
+	if (!generated) return [];
+	const collectionByTable = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const table = getTableName$1(collection);
+		if (table) collectionByTable.set(bareTableName(table), collection);
+	}
+	const differences = [];
+	for (const value of Object.values(generated)) {
+		if (!isTable(value)) continue;
+		const table = getTableName(value);
+		const collection = collectionByTable.get(table);
+		const at = {
+			table,
+			collection: collection?.slug
+		};
+		const meta = catalogue.get(table);
+		if (!meta) {
+			if (collection) differences.push({
+				...at,
+				kind: "missing-table"
+			});
+			continue;
+		}
+		const live = catalogueColumns(meta);
+		const seen = /* @__PURE__ */ new Set();
+		const authOwned = isAuthCollection(collection) ? new Set(AUTH_USERS_COLUMNS.map((c) => c.column)) : void 0;
+		for (const [key, column] of Object.entries(getTableColumns(value))) {
+			const name = column.name ?? key;
+			seen.add(name);
+			const property = collection ? fieldKeyForColumn(collection, name) : key;
+			const generatedFamily = typeFamily(column.getSQLType?.());
+			const generatedNotNull = Boolean(column.notNull);
+			const found = live.get(name);
+			if (!found) {
+				differences.push({
+					...at,
+					kind: "missing-column",
+					column: name,
+					property,
+					generated: generatedFamily
+				});
+				continue;
+			}
+			if (found.family !== generatedFamily) differences.push({
+				...at,
+				kind: "type",
+				column: name,
+				property,
+				generated: generatedFamily,
+				live: found.family
+			});
+			if (found.notNull !== generatedNotNull && !authOwned?.has(name)) differences.push({
+				...at,
+				kind: "nullability",
+				column: name,
+				property,
+				generated: generatedNotNull ? "NOT NULL" : "nullable",
+				live: found.notNull ? "NOT NULL" : "nullable"
+			});
+		}
+		for (const [name, column] of live) {
+			if (seen.has(name)) continue;
+			if (authOwned?.has(name)) continue;
+			differences.push({
+				...at,
+				kind: "extra-column",
+				column: name,
+				property: collection ? fieldKeyForColumn(collection, name) : name,
+				live: column.family
+			});
+		}
+	}
+	return differences;
+}
+/**
+* Boot's drift question, asked of a database from outside a boot.
+*
+* The same two calls boot makes before it warns, with the arguments it makes
+* them with: the catalogue read the way the registry reads it
+* ({@link readCatalogueSchema}), then {@link diffGeneratedSchemaAgainstCatalogue}
+* over its metadata. `rebase doctor` asks through here, because the boot
+* warning sends the reader to the doctor for "the full report" — and while the
+* doctor compared on its own terms, it answered "In sync" over a NOT NULL and a
+* left-behind column that boot had just warned about.
+*
+* `collections` are the data source's own, as boot filters them.
+*/
+async function readGeneratedSchemaDrift(options) {
+	const { client, generated, collections, defaultSchema } = options;
+	if (!generated || collections.length === 0) return [];
+	return diffGeneratedSchemaAgainstCatalogue({
+		generated,
+		catalogue: (await readCatalogueSchema({
+			client,
+			collections,
+			defaultSchema
+		})).meta,
+		collections
+	});
+}
+/** One line, in the terms the reader has: collection, property, column. */
+function describeSchemaDifference(difference) {
+	const where = difference.collection ? `${difference.collection} (table "${difference.table}")` : `table "${difference.table}"`;
+	const field = difference.column ? `${difference.property && difference.property !== difference.column ? `${difference.property} → "${difference.column}"` : `"${difference.column}"`}` : void 0;
+	switch (difference.kind) {
+		case "missing-table": return `${where} is in schema.generated.ts but not in the database`;
+		case "missing-column": return `${where}: ${field} is in schema.generated.ts but not in the database`;
+		case "extra-column": return `${where}: ${field} is in the database but not in schema.generated.ts (${difference.live})`;
+		case "type": return `${where}: ${field} is ${difference.generated} in schema.generated.ts and ${difference.live} in the database`;
+		case "nullability": return `${where}: ${field} is ${difference.generated} in schema.generated.ts and ${difference.live} in the database`;
+	}
+}
+/**
+* Report the differences, one warning each, and never throw.
+*
+* Per difference rather than one summary block on purpose: these are read out of
+* a log aggregator as often as a terminal, and a single multi-line message
+* cannot be filtered down to the one collection somebody is looking at.
+*
+* The fix it names is `rebase db push`. `rebase dev` rewrites
+* schema.generated.ts from the collections on every change, and boot applies
+* only additive changes, so what is still different at boot is the database
+* behind the file: a rename, a dropped column, a narrowed type, a NOT NULL.
+* `rebase schema generate` rewrites the file and leaves the database as it is,
+* so it is named only for collections that changed since the file was written.
+*/
+function warnOnGeneratedSchemaDrift(differences) {
+	if (differences.length === 0) return;
+	logger.warn(`📄 [schema] schema.generated.ts and the database disagree (${differences.length} difference${differences.length === 1 ? "" : "s"}). Boot applies only additive changes; these are the ones it left for you. Run \`rebase db push\` to apply them (it shows the plan and asks before anything destructive), or \`rebase db generate\` for a migration. If the collections changed since schema.generated.ts was written, run \`rebase schema generate\` first.`);
+	for (const difference of differences) logger.warn(`   • ${describeSchemaDifference(difference)}`, {
+		schemaDrift: {
+			kind: difference.kind,
+			table: difference.table,
+			collection: difference.collection,
+			column: difference.column,
+			property: difference.property,
+			generated: difference.generated,
+			live: difference.live
+		},
+		fix: "rebase db push"
+	});
+}
+//#endregion
+export { buildBaasSchema as a, introspectSchema as c, warnOnGeneratedSchemaDrift as i, readRlsStatus as l, diffGeneratedSchemaAgainstCatalogue as n, readCatalogueSchema as o, readGeneratedSchemaDrift as r, buildCollectionsFromSchema as s, describeSchemaDifference as t };
+
+//# sourceMappingURL=generated-schema-diff-eZCklRZQ.js.map