@rebasepro/server-postgres 0.10.1-canary.6f89f77 → 0.10.1-canary.7801eed

package/dist/PostgresBootstrapper.d.ts

@@ -26,9 +26,13 @@ export interface PostgresDriverConfig {
      */
     introspectionSchema?: string;
     /**
-     * Realtime options. Currently only channel retention, which is opt-in:
-     * without rules here no channel keeps any history and broadcast stays
-     * fire-and-forget. See {@link ChannelRetentionRule}.
+     * Realtime options, both opt-in:
+     *
+     *  - `channels` — retention. Without rules no channel keeps any history and
+     *    broadcast stays fire-and-forget. See {@link ChannelRetentionRule}.
+     *  - `bus` — the cross-instance transport for channel broadcast and
+     *    presence. Defaults to in-process only, which is correct for a single
+     *    instance and wrong for two. See {@link ChannelBusConfig}.
      */
     realtime?: RealtimeChannelsConfig;
 }

package/dist/auth/schema-version.d.ts

@@ -0,0 +1,106 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { CollectionConfig } from "@rebasepro/types";
+/**
+ * The auth schema version this runtime expects to find in the database.
+ *
+ * Bump this whenever a migration in `ensureAuthTablesExist` makes the schema
+ * unreadable by the runtime that came before it — that is, whenever a *previous*
+ * version's auth queries would break against the migrated shape. Additive
+ * changes (a new nullable column nobody older references) do not need a bump.
+ *
+ * History. Note that 1 is a label for an era, not a value any database holds:
+ * stamping did not exist then, so an era-1 database reads as unstamped
+ * (`null`), and 2 is the first version ever actually written. The numbering
+ * starts at 2 only because two schema eras already existed when it was
+ * introduced; it could just as well have started at 1. It is not worth
+ * renumbering now — deployed databases already carry 2, and lowering the
+ * constant would make them look newer than the runtime and refuse the boot.
+ *
+ *   1 — Device-session refresh tokens. A row *was* a session, identified by
+ *       `unique_device_session UNIQUE (uid, user_agent, ip_address)`, and
+ *       `createToken` upserted with `ON CONFLICT (uid, user_agent, ip_address)`.
+ *   2 — Session-scoped, rotation-safe refresh tokens: `session_id`, `revoked`,
+ *       `rotated_at`, `session_started_at`, and `unique_device_session`
+ *       dropped because two live tokens of one session share all three columns.
+ *
+ * The 1 → 2 migration is why this file exists. Dropping the constraint is
+ * one-way: a version-1 runtime deployed afterwards boots perfectly, logs
+ * `✅ Auth tables ready` (its `CREATE TABLE IF NOT EXISTS` never revisits the
+ * existing table, so it cannot re-add the constraint), answers `/health` with
+ * 200 — and then fails every single login and refresh with SQLSTATE 42P10,
+ * because its `ON CONFLICT` names a constraint that no longer exists. A silent
+ * total auth outage behind a green health check. The stamp below turns that
+ * into a boot refusal.
+ */
+export declare const AUTH_SCHEMA_VERSION = 2;
+/**
+ * Thrown when the database was migrated by a runtime newer than this one.
+ *
+ * Distinct class rather than a bare `Error` because `ensureAuthTablesExist`
+ * wraps its migrations in a catch that deliberately swallows failures and
+ * continues — every other problem there is better survived than crashed on.
+ * This one is not, so the catch rethrows on this type specifically.
+ */
+export declare class AuthSchemaVersionError extends Error {
+    readonly databaseVersion: number;
+    readonly runtimeVersion: number;
+    constructor(databaseVersion: number, runtimeVersion: number);
+}
+/**
+ * The schema the auth tables live in, derived exactly as `ensureAuthTablesExist`
+ * derives it. Shared so the two cannot drift: a stamp written to one schema and
+ * read from another would read as "never stamped" forever.
+ */
+export declare function resolveAuthSchema(collection?: CollectionConfig): string;
+/**
+ * Read the stamped version, or `null` when the database has never been stamped.
+ *
+ * `null` is not an error and must not be treated as one: every database
+ * provisioned before this file existed is unstamped, and so is every fresh one.
+ * Uses `to_regclass` rather than selecting straight from the table so a missing
+ * schema or table is a `null` rather than a thrown 42P01.
+ */
+export declare function readAuthSchemaVersion(db: NodePgDatabase, authSchema: string): Promise<number | null>;
+/**
+ * Refuse to run against a database a newer runtime has already migrated.
+ *
+ * Deliberately one-directional. A database *older* than this runtime is the
+ * normal upgrade path — the migrations in `ensureAuthTablesExist` are about to
+ * bring it forward, so it is not an error. Only the reverse is unrecoverable.
+ */
+export declare function assertAuthSchemaCompatible(db: NodePgDatabase, authSchema: string): Promise<void>;
+/**
+ * Record that this runtime's migrations have been applied.
+ *
+ * Called at the end of `ensureAuthTablesExist`, so a boot that failed partway
+ * through leaves the older stamp in place and the next boot migrates again.
+ */
+export declare function stampAuthSchemaVersion(db: NodePgDatabase, authSchema: string): Promise<void>;
+/** What {@link probeAuthSchema} found. */
+export interface AuthSchemaProbeResult {
+    /** False when this runtime cannot be trusted to serve auth against this database. */
+    healthy: boolean;
+    /** The stamped version, or `null` on a database that predates stamping. */
+    databaseVersion: number | null;
+    /** {@link AUTH_SCHEMA_VERSION}. */
+    runtimeVersion: number;
+    /** Human-readable descriptions of each mismatch found. Empty when healthy. */
+    problems: string[];
+}
+/**
+ * Check that the auth schema is one this runtime can actually write to.
+ *
+ * Two independent checks, because either alone has a blind spot:
+ *
+ *  - The **stamp** catches a runtime older than the database. It is the precise
+ *    signal, but it is blind on every database provisioned before stamping
+ *    existed — which today is all of them.
+ *  - The **structure** catches a database older than the runtime, and works on
+ *    unstamped databases. It is what makes this useful immediately rather than
+ *    one upgrade cycle from now.
+ *
+ * Never throws: a probe that fails to run reports unhealthy with the reason, so
+ * a broken check surfaces as a degraded health response rather than a 500 from
+ * the health endpoint itself.
+ */
+export declare function probeAuthSchema(db: NodePgDatabase, authSchema: string): Promise<AuthSchemaProbeResult>;

package/dist/chunk-DSJWtz9O.js

@@ -0,0 +1,40 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+const require = __createRequire(import.meta.url);
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/dist/collections/validate-relations.d.ts

@@ -0,0 +1,53 @@
+import { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "./PostgresCollectionRegistry";
+/**
+ * Check every relation against the schema it actually runs on, at boot.
+ *
+ * The tagged union made the *shape* of a relation impossible to get wrong: a
+ * `manyToMany` cannot carry a `foreignKeyOnTarget`, a to-many cannot carry a
+ * `localKey`. What it cannot know is whether any of the names are real —
+ * whether `posts_tags` is a table, whether `author_id` is a column, whether a
+ * `joinPath` connects the tables it claims to. Those are facts about the
+ * database, and the type system never sees them.
+ *
+ * Until now nothing checked them until a query ran, and the failures were the
+ * quiet kind. A missing junction table logged a warning and returned no rows,
+ * so `posts/1/tags` answered `[]` — indistinguishable from a post with no tags.
+ * The relation looked configured, the admin drew the tab, the tab was empty,
+ * and nothing anywhere said why.
+ *
+ * The junction default is the sharp edge this exists for. `through.table`
+ * defaults to the two table names sorted and joined, so renaming a table
+ * silently re-points the relation at a name that was never created. It is the
+ * one default whose output changes when you edit something that looks
+ * unrelated.
+ */
+export interface RelationDefect {
+    /** Slug of the collection declaring the relation. */
+    collection: string;
+    relationName: string;
+    kind: ResolvedRelation["kind"];
+    /** What is wrong, in terms of the schema. */
+    problem: string;
+    /** The edit that fixes it. */
+    fix: string;
+}
+/**
+ * Relations whose names do not resolve against the registered schema.
+ *
+ * Fails open wherever it cannot see enough to be sure — an unregistered source
+ * table, a target belonging to another backend — because a false alarm here
+ * costs more than a missed one: it would block boot on a working app.
+ */
+export declare function findRelationDefects(collections: CollectionConfig[], registry: PostgresCollectionRegistry): RelationDefect[];
+/**
+ * Fail boot on any relation that cannot resolve, listing all of them at once.
+ *
+ * Deliberately fatal rather than a warning. Every one of these produces an
+ * empty result at query time and nothing else — an empty tab, an empty
+ * `include`, a subcollection that looks like it has no rows. A server that
+ * refuses to start is recoverable in a minute; a relation that quietly answers
+ * "nothing" is the kind of bug found in production, weeks later, by a user
+ * asking where their data went.
+ */
+export declare function assertRelationsResolve(collections: CollectionConfig[], registry: PostgresCollectionRegistry): void;

package/dist/data-transformer.d.ts

@@ -1,5 +1,5 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { CollectionConfig, Properties, Property, Relation } from "@rebasepro/types";
+import { CollectionConfig, Properties, Property, ResolvedRelation, type ResolvedVia } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 /**
  * Data transformation utilities for converting between frontend and database formats.
@@ -23,13 +23,13 @@ export interface SerializedEntityData {
      */
     inverseRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedRelation;
         newValue: unknown;
     }>;
     /** JoinPath relation updates that require multi-hop writes. */
     joinPathRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedVia;
         newTargetId: string | number | null;
     }>;
 }

package/dist/ensure-collection-tables-DGMYK0fr.js

@@ -0,0 +1,304 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { d as isPostgresCollectionConfig } from "./src-D5xBTl32.js";
+import { g as getTableName, k as toSnakeCase, p as findRelation, v as resolveCollectionRelations } from "./src-3VmUJ8Xn.js";
+//#region src/schema/generate-postgres-ddl-logic.ts
+var resolveColumnName = (propName, prop) => {
+	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
+	return toSnakeCase(propName);
+};
+var getPrimaryKeyProp = (collection) => {
+	if (collection.properties) {
+		const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in prop && Boolean(prop.isId));
+		if (idPropEntry) {
+			const prop = idPropEntry[1];
+			const isUuid = prop.type === "string" && "isId" in prop && prop.isId === "uuid";
+			return {
+				name: idPropEntry[0],
+				type: prop.type === "number" ? "number" : "string",
+				isUuid
+			};
+		}
+	}
+	const idProp = collection.properties?.["id"];
+	if (idProp?.type === "number") return {
+		name: "id",
+		type: "number",
+		isUuid: false
+	};
+	return {
+		name: "id",
+		type: "string",
+		isUuid: idProp?.type === "string" && "isId" in idProp && idProp.isId === "uuid"
+	};
+};
+var isIdProperty = (propName, prop, collection) => {
+	if ("isId" in prop && Boolean(prop.isId)) return true;
+	return !Object.values(collection.properties ?? {}).some((p) => "isId" in p && Boolean(p.isId)) && propName === "id";
+};
+var getSqlColumnType = (propName, prop, collection, collections) => {
+	switch (prop.type) {
+		case "string": {
+			const stringProp = prop;
+			if (stringProp.enum) {
+				const tableName = getTableName(collection);
+				const colName = resolveColumnName(propName, prop);
+				return `"${isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public"}"."${tableName}_${colName}"`;
+			}
+			if (stringProp.isId === "uuid" || stringProp.columnType === "uuid") return "UUID";
+			if (stringProp.columnType === "char") return "CHAR(255)";
+			if (stringProp.columnType === "varchar") return "VARCHAR(255)";
+			return "TEXT";
+		}
+		case "number": {
+			const numProp = prop;
+			const isId = isIdProperty(propName, prop, collection);
+			if ("isId" in numProp && numProp.isId === "increment") return "INTEGER GENERATED BY DEFAULT AS IDENTITY";
+			if (numProp.columnType) {
+				if (numProp.columnType === "double precision") return "DOUBLE PRECISION";
+				return numProp.columnType.toUpperCase();
+			}
+			return numProp.validation?.integer || isId ? "INTEGER" : "NUMERIC";
+		}
+		case "boolean": return "BOOLEAN";
+		case "date": {
+			const dateProp = prop;
+			if (dateProp.columnType === "date") return "DATE";
+			if (dateProp.columnType === "time") return "TIME";
+			return "TIMESTAMP WITH TIME ZONE";
+		}
+		case "map": return prop.columnType === "json" ? "JSON" : "JSONB";
+		case "array": {
+			const arrayProp = prop;
+			let colType = arrayProp.columnType;
+			if (!colType && arrayProp.of && !Array.isArray(arrayProp.of)) {
+				const ofProp = arrayProp.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 === "text[]") return "TEXT[]";
+			if (colType === "integer[]") return "INTEGER[]";
+			if (colType === "boolean[]") return "BOOLEAN[]";
+			if (colType === "numeric[]") return "NUMERIC[]";
+			return "JSONB";
+		}
+		case "vector": return `VECTOR(${prop.dimensions})`;
+		case "binary": return "BYTEA";
+		case "relation": {
+			const refProp = prop;
+			const relation = findRelation(resolveCollectionRelations(collection), refProp.relation?.relationName ?? propName);
+			if (relation?.kind !== "belongsTo") throw new Error(`Relation ${propName} does not put a column on this table (only \`belongsTo\` does)`);
+			let targetCollection;
+			try {
+				targetCollection = relation.target();
+			} catch {
+				return "TEXT";
+			}
+			const pkProp = getPrimaryKeyProp(targetCollection);
+			return pkProp.type === "number" ? "INTEGER" : pkProp.isUuid ? "UUID" : "TEXT";
+		}
+		case "reference": {
+			const refProp = prop;
+			const targetCollection = collections.find((c) => c.slug === refProp.path || getTableName(c) === refProp.path);
+			if (!targetCollection) return "TEXT";
+			const pkProp = getPrimaryKeyProp(targetCollection);
+			return pkProp.type === "number" ? "INTEGER" : pkProp.isUuid ? "UUID" : "TEXT";
+		}
+		default: return "TEXT";
+	}
+};
+//#endregion
+//#region src/schema/ensure-collection-tables.ts
+/**
+* Bringing a database up to date with a bundle's collections, additively.
+*
+* ## Why this exists
+*
+* A managed runtime boots someone else's compiled project against a database it
+* has never seen. Auth tables are ensured at boot already, but collection tables
+* were not created by anything: the platform ran the app and every `/api/data/*`
+* request answered 500 on a missing relation. `rebase db push` cannot help — it
+* is an Atlas-driven CLI command, and the runtime image ships no CLI.
+*
+* ## Why additive-only, forever
+*
+* This runs unattended, against a database with customers' data in it, with no
+* human reading a diff. So it may only ever do things that cannot lose data:
+* create a missing table, add a missing column, create a missing enum type.
+*
+* It will **never** drop a table or a column, narrow a type, or alter a
+* constraint. A removed field leaves its column behind; a renamed field looks
+* like an addition and the old column stays. That is the correct trade for an
+* automated path — the alternative is an unattended process that can silently
+* destroy a column, which is precisely the failure `db push` was hardened
+* against. Destructive changes stay a deliberate, human-reviewed migration.
+*
+* Because of that, this is safe to run on every boot, and re-running it is a
+* no-op.
+*/
+/** Postgres identifiers this module is willing to interpolate. */
+var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+function assertSafeIdentifier(value, what) {
+	if (!SAFE_IDENTIFIER.test(value)) throw new Error(`Refusing to build SQL with an unsafe ${what}: ${JSON.stringify(value)}`);
+	return value;
+}
+function schemaOf(collection) {
+	return isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
+}
+function qualified(collection) {
+	return `${schemaOf(collection)}.${getTableName(collection)}`;
+}
+/**
+* Enum types a collection's properties require, as `schema.typename`.
+*
+* Named exactly as the DDL generator names them (`<table>_<column>`), because
+* a column added here has to reference the same type the generator would have
+* created — a second, differently-named type for the same field would be a
+* silent schema fork.
+*/
+function requiredEnums(collection) {
+	const table = getTableName(collection);
+	const schema = schemaOf(collection);
+	const out = [];
+	for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
+		const p = prop;
+		if (!("enum" in p) || !p.enum) continue;
+		if (p.type !== "string" && p.type !== "number") continue;
+		const values = p.enum.map((entry) => entry && typeof entry === "object" && "id" in entry ? String(entry.id) : String(entry)).filter((v) => v.length > 0);
+		if (values.length === 0) continue;
+		out.push({
+			name: `${schema}.${table}_${resolveColumnName(propName, p)}`,
+			values
+		});
+	}
+	return out;
+}
+/** Single-quote escaping for an enum label. */
+function quoteLiteral(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+* Decide what to add. Pure — the caller supplies what exists and runs the result.
+*
+* Ordering matters and is deliberate: enum types before the tables and columns
+* that reference them, tables before the columns added to other tables (a new
+* table may be the target of a relation), and nothing is emitted twice.
+*/
+function planCollectionSchemaEnsure(collections, existing) {
+	const actions = [];
+	const plannedEnums = /* @__PURE__ */ new Set();
+	for (const collection of collections) for (const { name, values } of requiredEnums(collection)) {
+		if (existing.enums.has(name) || plannedEnums.has(name)) continue;
+		plannedEnums.add(name);
+		const [schema, typeName] = name.split(".");
+		actions.push({
+			kind: "create-enum",
+			target: name,
+			sql: `CREATE TYPE "${schema}"."${typeName}" AS ENUM (${values.map(quoteLiteral).join(", ")});`
+		});
+	}
+	const created = /* @__PURE__ */ new Set();
+	for (const collection of collections) {
+		const key = qualified(collection);
+		if (existing.tables.has(key) || created.has(key)) continue;
+		created.add(key);
+		const schema = schemaOf(collection);
+		const table = getTableName(collection);
+		const idEntry = Object.entries(collection.properties ?? {}).find(([n, p]) => isIdProperty(n, p, collection));
+		const idName = idEntry ? resolveColumnName(idEntry[0], idEntry[1]) : "id";
+		const idProp = idEntry?.[1];
+		let idDef;
+		if (idProp?.type === "number") idDef = `"${idName}" BIGSERIAL PRIMARY KEY`;
+		else if (idProp && idProp.type === "string" && idProp.isId === "uuid") idDef = `"${idName}" UUID PRIMARY KEY DEFAULT gen_random_uuid()`;
+		else idDef = `"${idName}" TEXT PRIMARY KEY`;
+		actions.push({
+			kind: "create-table",
+			target: key,
+			sql: `CREATE TABLE IF NOT EXISTS "${schema}"."${table}" (${idDef});`
+		});
+	}
+	for (const collection of collections) {
+		const key = qualified(collection);
+		const schema = schemaOf(collection);
+		const table = getTableName(collection);
+		const present = existing.tables.get(key) ?? /* @__PURE__ */ new Set();
+		for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
+			const p = prop;
+			if (isIdProperty(propName, p, collection)) continue;
+			if (p.type === "reference" || p.type === "relation") continue;
+			const column = resolveColumnName(propName, p);
+			if (present.has(column)) continue;
+			const type = getSqlColumnType(propName, p, collection, collections);
+			actions.push({
+				kind: "add-column",
+				target: `${key}.${column}`,
+				sql: `ALTER TABLE "${schema}"."${table}" ADD COLUMN IF NOT EXISTS "${column}" ${type};`
+			});
+		}
+	}
+	return {
+		actions,
+		statements: actions.map((a) => a.sql)
+	};
+}
+/** Read what the database has, for the schemas the collections live in. */
+async function readExistingSchema(client, schemas) {
+	const tables = /* @__PURE__ */ new Map();
+	const enums = /* @__PURE__ */ new Set();
+	if (schemas.length === 0) return {
+		tables,
+		enums
+	};
+	const inList = schemas.map((schema) => `'${assertSafeIdentifier(schema, "schema name")}'`).join(", ");
+	const { rows: columns } = await client.query(`SELECT table_schema, table_name, column_name
+         FROM information_schema.columns
+         WHERE table_schema IN (${inList})`);
+	for (const row of columns) {
+		const key = `${row.table_schema}.${row.table_name}`;
+		if (!tables.has(key)) tables.set(key, /* @__PURE__ */ new Set());
+		tables.get(key).add(row.column_name);
+	}
+	const { rows: enumRows } = await client.query(`SELECT n.nspname AS schema, t.typname AS name
+         FROM pg_type t
+         JOIN pg_namespace n ON t.typnamespace = n.oid
+         WHERE t.typtype = 'e' AND n.nspname IN (${inList})`);
+	for (const row of enumRows) enums.add(`${row.schema}.${row.name}`);
+	return {
+		tables,
+		enums
+	};
+}
+/**
+* Bring the database up to date. Returns what it did.
+*
+* Each statement runs on its own rather than in one transaction: they are all
+* independently safe and idempotent, and a single failure (an enum label that
+* cannot be added, say) should not roll back the tables that were created fine.
+* The error is surfaced with the statement that caused it.
+*/
+async function ensureCollectionTables(client, collections, log) {
+	const schemas = Array.from(new Set(collections.map(schemaOf)));
+	for (const schema of schemas) {
+		assertSafeIdentifier(schema, "schema name");
+		if (schema !== "public") await client.query(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
+	}
+	const plan = planCollectionSchemaEnsure(collections, await readExistingSchema(client, schemas));
+	if (plan.actions.length === 0) {
+		log?.("Schema is up to date; nothing to create.");
+		return plan;
+	}
+	for (const action of plan.actions) try {
+		await client.query(action.sql);
+		log?.(`${action.kind}: ${action.target}`);
+	} catch (err) {
+		throw new Error(`Failed to ${action.kind} ${action.target}: ${err instanceof Error ? err.message : String(err)}\n  ${action.sql}`);
+	}
+	return plan;
+}
+//#endregion
+export { ensureCollectionTables };
+
+//# sourceMappingURL=ensure-collection-tables-DGMYK0fr.js.map