@rebasepro/server-postgres 0.9.1-canary.f2f61da → 0.9.1-canary.fd3754b

package/src/services/collection-helpers.ts

@@ -2,15 +2,6 @@ import { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
 import { CollectionConfig, Property } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { getTableName } from "@rebasepro/common";
-import { logger } from "@rebasepro/server";
-
-// Row identity is derived on both sides of the wire — the driver parses an
-// incoming address into key columns, the admin derives one from a served row —
-// so the implementation lives in `common` and both agree by construction.
-export { buildCompositeId, parseIdValues, COMPOSITE_ID_SEPARATOR } from "@rebasepro/common";
-export type { PrimaryKeyInfo } from "@rebasepro/common";
-import { buildCompositeId, COMPOSITE_ID_SEPARATOR, getDeclaredPrimaryKeys } from "@rebasepro/common";
-import type { PrimaryKeyInfo } from "@rebasepro/common";
 
 /**
  * Shared helper functions for row operations.
@@ -58,27 +49,10 @@ export function getTableForCollection(collection: CollectionConfig, registry: Po
     return table;
 }
 
-/**
- * The key columns a collection's rows are addressed by.
- *
- * Three tiers, in order: properties marked `isId`, the primary keys of the
- * drizzle schema, and finally a column literally named `id`. Only the first is
- * visible to the browser, which is why a key known only to drizzle is reported
- * at boot — see {@link warnOnKeysTheAdminCannotResolve}.
- *
- * Returns `[]` when nothing resolves, rather than throwing. It used to open by
- * resolving the table, which throws when there is none — so the `isId` tier,
- * which needs no table at all, was unreachable for exactly the collections
- * most likely to have no table registered. Every caller that wanted "no keys"
- * to mean "no keys" had to spell that out in a try/catch.
- *
- * Callers that cannot proceed without a key must say so themselves, naming the
- * collection: an empty array here means "this collection has no address", which
- * is a different answer in a notification (broadcast a wildcard) than in a save
- * (fail).
- */
-export function getPrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[] {
-    // Explicitly declared `isId` properties win, and need no table.
+export function getPrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): { fieldName: string; type: "string" | "number"; isUUID?: boolean }[] {
+    const table = getTableForCollection(collection, registry);
+
+    // Fallback to explicitly defined isId properties
     if (collection.properties) {
         const idProps = Object.entries(collection.properties)
             .filter(([_, prop]) => "isId" in (prop as object) && Boolean((prop as { isId?: unknown }).isId))
@@ -93,14 +67,8 @@ export function getPrimaryKeys(collection: CollectionConfig, registry: PostgresC
         }
     }
 
-    // The remaining tiers read the drizzle schema, so they need the table. A
-    // collection without one — another engine's, or simply unregistered — has
-    // nothing more to offer.
-    const table = registry.getTable(getTableName(collection));
-    if (!table) return [];
-
     // Otherwise infer from Drizzle schema
-    const keys: PrimaryKeyInfo[] = [];
+    const keys: { fieldName: string; type: "string" | "number"; isUUID?: boolean }[] = [];
     for (const [key, colRaw] of Object.entries(table)) {
         const col = colRaw as AnyPgColumn;
         if (col && typeof col === "object" && "primary" in col && col.primary) {
@@ -128,141 +96,56 @@ isUUID });
     return keys;
 }
 
-/**
- * The key columns, for callers that cannot do their job without one.
- *
- * {@link getPrimaryKeys} answers "what keys, if any" and returns `[]` for a
- * collection with no address. Most of this driver, though, is building a WHERE
- * clause and has no meaning without a key — for those, an empty array is not an
- * answer, and indexing `[0]` into it produces `Cannot read properties of
- * undefined` three frames from where the real problem is. This says what is
- * wrong and which collection it is wrong about.
- */
-export function requirePrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[] {
-    const keys = getPrimaryKeys(collection, registry);
-    if (keys.length === 0) {
-        throw new Error(
-            `Collection '${collection.slug}' has no primary key, so its rows cannot be addressed. ` +
-            `Mark the key property with \`isId\` in its config, or register a table whose schema declares one.`
-        );
-    }
-    return keys;
-}
-
-/**
- * Collections whose key the *browser* cannot resolve, and what it will do
- * instead.
- *
- * The two sides resolve keys from different evidence. This driver reads, in
- * order: properties marked `isId`, the primary keys of the Drizzle schema, then
- * a column literally named `id`. The admin shares the `CollectionConfig` — it
- * compiles the same collection files into its bundle — but never the Drizzle
- * schema, so the middle tier is invisible to it.
- *
- * Nothing can normalize this at runtime: the server does not serve the admin
- * its collections, so a key resolved here cannot be handed over there. The
- * config files are the only thing both sides read, so the fix is an edit to
- * them, and the most this can do is say exactly which edit.
- *
- * Two shapes, and the second is the dangerous one:
- *
- * - No `isId`, no `id` property → the admin resolves no address, warns in the
- *   console, and rows cannot be opened or linked.
- * - No `isId`, but an `id` property that is *not* the key → the admin addresses
- *   rows by `id` while this driver reads the address as the real key. Nothing
- *   errors: the addresses look right and route wrong.
- */
-export function findUnresolvableKeyCollections(
-    collections: CollectionConfig[],
-    registry: PostgresCollectionRegistry
-): { collection: CollectionConfig; keys: PrimaryKeyInfo[]; shadowedByIdProperty: boolean }[] {
-    const findings: { collection: CollectionConfig; keys: PrimaryKeyInfo[]; shadowedByIdProperty: boolean }[] = [];
-
-    for (const collection of collections) {
-        // Declared `isId` is the tier both sides share: if it is there, they agree.
-        if (getDeclaredPrimaryKeys(collection).length > 0) continue;
-
-        // No registered table resolves to no keys, and a collection this cannot
-        // resolve a key for is one it has nothing to say about.
-        const keys = getPrimaryKeys(collection, registry);
-        if (keys.length === 0) continue;
+export function parseIdValues(idValue: string | number, primaryKeys: { fieldName: string; type: "string" | "number"; isUUID?: boolean }[]): Record<string, string | number> {
+    const result: Record<string, string | number> = {};
 
-        // A single key named `id` is the last tier on both sides: they agree
-        // without anything being declared.
-        if (keys.length === 1 && keys[0].fieldName === "id") continue;
-
-        findings.push({
-            collection,
-            keys,
-            shadowedByIdProperty: Boolean(collection.properties?.id)
-        });
+    if (primaryKeys.length === 0) {
+        return result;
     }
 
-    return findings;
-}
-
-/**
- * Report the collections from {@link findUnresolvableKeyCollections} at boot,
- * with the edit that fixes each one.
- *
- * Grouped by failure, not by collection: the shadowed case is a routing bug and
- * the silent case is a missing feature, and they deserve different urgency.
- */
-export function warnOnKeysTheAdminCannotResolve(
-    collections: CollectionConfig[],
-    registry: PostgresCollectionRegistry
-): void {
-    const findings = findUnresolvableKeyCollections(collections, registry);
-    if (findings.length === 0) return;
-
-    const edit = (f: { collection: CollectionConfig; keys: PrimaryKeyInfo[] }) =>
-        `${f.collection.slug}: mark ${f.keys.map(k => `\`${k.fieldName}\``).join(" and ")} with ` +
-        `\`isId: ${f.keys[0].isUUID ? "\"uuid\"" : f.keys[0].type === "number" ? "\"increment\"" : "true"}\``;
-
-    const shadowed = findings.filter(f => f.shadowedByIdProperty);
-    const silent = findings.filter(f => !f.shadowedByIdProperty);
+    if (primaryKeys.length === 1) {
+        const pk = primaryKeys[0];
+        if (pk.type === "number" && !pk.isUUID) {
+            const parsed = typeof idValue === "number" ? idValue : parseInt(String(idValue), 10);
+            if (isNaN(parsed)) {
+                throw new Error(`Invalid numeric ID: ${idValue}`);
+            }
+            result[pk.fieldName] = parsed;
+        } else {
+            result[pk.fieldName] = String(idValue);
+        }
+        return result;
+    }
 
-    if (shadowed.length > 0) {
-        logger.warn(
-            `⚠️ These collections declare no \`isId\`, and their key is only in the drizzle schema — but they ` +
-            `do have a property called \`id\`. The admin has no way to know \`id\` is not the key, so it will ` +
-            `address rows by it while this server reads the address as the real key: the links look right and ` +
-            `route wrong. Nothing will error.\n\n` +
-            shadowed.map(f => `  • ${edit(f)}`).join("\n") + "\n"
-        );
+    // Composite key - split by :::
+    const parts = String(idValue).split(":::");
+    if (parts.length !== primaryKeys.length) {
+        throw new Error(`Composite ID parts mismatch. Expected ${primaryKeys.length}, got ${parts.length} for ID: ${idValue}`);
     }
 
-    if (silent.length > 0) {
-        logger.warn(
-            `⚠️ These collections declare no \`isId\`, and their key is only in the drizzle schema, which the ` +
-            `admin never sees. It will resolve no address for their rows, so detail links, caching and ` +
-            `relations will not work for them:\n\n` +
-            silent.map(f => `  • ${edit(f)}`).join("\n") + "\n"
-        );
+    for (let i = 0; i < primaryKeys.length; i++) {
+        const pk = primaryKeys[i];
+        const val = parts[i];
+        if (pk.type === "number" && !pk.isUUID) {
+            const parsed = parseInt(val, 10);
+            if (isNaN(parsed)) {
+                throw new Error(`Invalid numeric ID component: ${val}`);
+            }
+            result[pk.fieldName] = parsed;
+        } else {
+            result[pk.fieldName] = val;
+        }
     }
+
+    return result;
 }
 
-/**
- * The address of a row: derived from the collection's primary keys, because a
- * row does not carry one — it is exactly its columns.
- *
- * Falls back to a literal `id` column, for a row that reached us from somewhere
- * other than this driver. Returns `""` when there is no key and no `id` —
- * callers decide what that means, since "unaddressable" is a different answer
- * in a notification (broadcast a wildcard) than in a save (fail).
- */
-export function deriveRowAddress(
-    row: Record<string, unknown>,
-    collection: CollectionConfig,
-    registry: PostgresCollectionRegistry
-): string {
-    const composite = buildCompositeId(row, getPrimaryKeys(collection, registry));
-    // An all-empty composite is indistinguishable from a missing key, and
-    // `buildCompositeId` returns "" for no keys at all.
-    if (composite && composite.split(COMPOSITE_ID_SEPARATOR).some(part => part !== "")) {
-        return composite;
+export function buildCompositeId(values: Record<string, unknown>, primaryKeys: { fieldName: string; type: "string" | "number"; isUUID?: boolean }[]): string {
+    if (primaryKeys.length === 0) {
+        return "";
     }
-    if (row.id !== undefined && row.id !== null) return String(row.id);
-    return "";
+    if (primaryKeys.length === 1) {
+        return String(values[primaryKeys[0].fieldName] ?? "");
+    }
+    return primaryKeys.map(pk => String(values[pk.fieldName] ?? "")).join(":::");
 }
-

package/src/services/dataService.ts

@@ -154,10 +154,9 @@ export class DataService implements DataRepository {
         collectionPath: string,
         values: Partial<M>,
         id?: string | number,
-        databaseId?: string,
-        options?: { upsert?: boolean }
+        databaseId?: string
     ): Promise<Record<string, unknown>> {
-        return this.persistService.save<M>(collectionPath, values, id, databaseId, options);
+        return this.persistService.save<M>(collectionPath, values, id, databaseId);
     }
 
     /**

package/src/services/index.ts

@@ -8,7 +8,6 @@ export {
     getCollectionByPath,
     getTableForCollection,
     getPrimaryKeys,
-    deriveRowAddress,
     parseIdValues,
     buildCompositeId
 } from "./collection-helpers";

package/src/services/realtimeService.ts

@@ -14,7 +14,7 @@ import { applyAuthContext } from "../security/rls-enforcement";
 import { logger } from "@rebasepro/server";
 import { sanitizeErrorForClient } from "../utils/pg-error-utils";
 import { CdcListener, type CdcChangeEvent } from "./cdc/CdcListener";
-import { deriveRowAddress, getPrimaryKeys, type PrimaryKeyInfo } from "./collection-helpers";
+import { getPrimaryKeys, buildCompositeId } from "./collection-helpers";
 
 /** Channel name used for Postgres LISTEN/NOTIFY cross-instance realtime. */
 const PG_NOTIFY_CHANNEL = "rebase_entity_changes";
@@ -390,7 +390,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 authContext
             );
 
-            this.sendCollectionUpdate(clientId, subscriptionId, rows, request.path);
+            this.sendCollectionUpdate(clientId, subscriptionId, rows);
 
         } catch (error) {
             const sanitized = sanitizeErrorForClient(error, request.path);
@@ -554,7 +554,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                     // Phase 1: Send instant row-level patch (no DB query)
                     // This gives immediate cross-tab feedback
                     if (!row || !(row as Record<string, unknown>)?._rebase_invalidated) {
-                        this.sendCollectionPatch(subscription.clientId, subscriptionId, id, row, notifyPath);
+                        this.sendCollectionPatch(subscription.clientId, subscriptionId, id, row);
                     }
 
                     // Phase 2: Schedule a deferred full refetch for correctness
@@ -609,7 +609,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             if (!this._subscriptions.has(subscriptionId)) return;
             try {
                 const rows = await this.fetchCollectionWithAuth(notifyPath, subscription.collectionRequest!, subscription.authContext);
-                this.sendCollectionUpdate(subscription.clientId, subscriptionId, rows, notifyPath);
+                this.sendCollectionUpdate(subscription.clientId, subscriptionId, rows);
             } catch (error) {
                 const sanitized = sanitizeErrorForClient(error, notifyPath);
                 this.sendError(subscription.clientId, sanitized.message, subscriptionId, sanitized.code);
@@ -910,12 +910,11 @@ roles: activeAuth.roles },
         return await this.dataService.fetchOne(notifyPath, id);
     }
 
-    private sendCollectionUpdate(clientId: string, subscriptionId: string, rows: Record<string, unknown>[], path: string) {
+    private sendCollectionUpdate(clientId: string, subscriptionId: string, rows: Record<string, unknown>[]) {
         const message: CollectionUpdateMessage = {
             type: "collection_update",
             subscriptionId,
-            rows: rows,
-            pks: this.primaryKeysForPath(path)
+            rows: rows
         };
         this.sendMessage(clientId, message);
     }
@@ -932,45 +931,17 @@ roles: activeAuth.roles },
     /**
      * Send a lightweight row-level patch to a collection subscriber.
      * The client can merge this into its cached data for instant feedback.
-     *
-     * The key columns ride along: the patch names a row by address, and the
-     * client has to find that row among the ones it cached — which carry
-     * columns and no address. The SDK holds no collection config to derive one
-     * from, so this is the only place the mapping can come from.
      */
-    private sendCollectionPatch(
-        clientId: string,
-        subscriptionId: string,
-        id: string,
-        row: Record<string, unknown> | null,
-        notifyPath: string
-    ) {
+    private sendCollectionPatch(clientId: string, subscriptionId: string, id: string, row: Record<string, unknown> | null) {
         const message: CollectionPatchMessage = {
             type: "collection_patch",
             subscriptionId,
             id,
-            row: row,
-            pks: this.primaryKeysForPath(notifyPath)
+            row: row
         };
         this.sendMessage(clientId, message);
     }
 
-    /** The key columns of the collection at `path`, if they can be resolved. */
-    private primaryKeysForPath(path: string): PrimaryKeyInfo[] | undefined {
-        try {
-            const collection = this.registry.getCollectionByPath(path);
-            if (!collection) return undefined;
-            const keys = getPrimaryKeys(collection, this.registry);
-            return keys.length > 0 ? keys : undefined;
-        } catch {
-            // `getCollectionByPath` throws on a path it cannot walk — and this
-            // is called for parent paths too, which include entity paths like
-            // `posts/1` that name no collection. Telling the subscriber nothing
-            // is right here; letting it throw would drop the notification.
-            return undefined;
-        }
-    }
-
     private sendError(clientId: string, error: string, subscriptionId?: string, code?: string) {
         const message = {
             type: "error" as const,
@@ -1323,9 +1294,17 @@ lastSeen: Date.now() });
 
     /** Compute the canonical (possibly composite) id string from a captured row. */
     private extractIdFromCdcRow(collection: CollectionConfig, row: Record<string, unknown>): string {
-        // Unaddressable falls back to a collection-level invalidation: single-row
-        // subs won't match, but collection subs still refetch.
-        return deriveRowAddress(row, collection, this.registry) || "*";
+        try {
+            const primaryKeys = getPrimaryKeys(collection, this.registry);
+            const composite = buildCompositeId(row, primaryKeys);
+            if (composite && composite !== ":::") return composite;
+        } catch {
+            /* fall through to id-field / wildcard */
+        }
+        // Fallbacks: a plain `id` column (common), else a collection-level
+        // invalidation ("*") — single-row subs won't match but collection subs refetch.
+        if (row.id !== undefined && row.id !== null) return String(row.id);
+        return "*";
     }
 
     // ── App/CDC de-duplication ──

package/src/utils/drizzle-conditions.ts

@@ -1126,19 +1126,6 @@ export class DrizzleConditionBuilder {
             throw new Error(`Vector column '${vectorSearch.property}' not found in table`);
         }
 
-        // The vector is interpolated as a raw SQL literal below (pgvector has no
-        // bind form for the `::vector` cast), so every element must be a finite
-        // number. The REST query parser already enforces this, but this builder
-        // is a shared entry point — validate here too so no future caller can
-        // turn an unchecked value into SQL injection.
-        if (
-            !Array.isArray(vectorSearch.vector) ||
-            vectorSearch.vector.length === 0 ||
-            !vectorSearch.vector.every((n) => typeof n === "number" && Number.isFinite(n))
-        ) {
-            throw new Error("Vector search requires a non-empty array of finite numbers");
-        }
-
         const vectorLiteral = `'[${vectorSearch.vector.join(",")}]'::vector`;
         const distanceFn = vectorSearch.distance || "cosine";
 

package/src/websocket.ts

@@ -620,12 +620,9 @@ roles: ["anon"] };
                 if (error instanceof Error) {
                     logger.error("Stack trace", { detail: error.stack });
                 }
-                // Unwrap the cause chain: a Drizzle failure reports itself as
-                // "Failed query: <sql> params:", which tells the user nothing and
-                // echoes the statement back at them. The reason is in the cause.
                 const errorMessage = process.env.NODE_ENV === "production"
                     ? "An unexpected error occurred"
-                    : extractErrorMessage(error);
+                    : (error instanceof Error ? error.message : "An unexpected error occurred");
                 const errorResponse = {
                     type: "ERROR",
                     requestId,

package/dist/collections/buildRegistry.d.ts

@@ -1,27 +0,0 @@
-import { Relations } from "drizzle-orm";
-import { PgEnum } from "drizzle-orm/pg-core";
-import { CollectionConfig } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "./PostgresCollectionRegistry";
-/**
- * Everything a registry is built from: the collections, and the drizzle schema
- * they are backed by. In BaaS mode all of it is introspected from the live
- * database; in CMS mode it comes from the config and the generated schema.
- */
-export interface RegistrySchema {
-    collections?: CollectionConfig[];
-    tables?: Record<string, unknown>;
-    enums?: Record<string, PgEnum<[string, ...string[]]>>;
-    relations?: Record<string, Relations>;
-}
-/**
- * Build the collection registry for a driver.
- *
- * The order matters and is the reason this is one function rather than a run of
- * statements in the bootstrapper. Keys are resolved from the drizzle schema, so
- * anything that inspects them has to run *after* the tables are registered —
- * and `warnOnKeysTheAdminCannotResolve` fails open if it does not, because a
- * collection whose table it cannot look up is one it has nothing to say about.
- * Warned too early, it would skip every collection and report nothing, which
- * reads exactly like having nothing to report.
- */
-export declare function buildCollectionRegistry(schema: RegistrySchema): PostgresCollectionRegistry;

package/dist/services/row-pipeline.d.ts

@@ -1,63 +0,0 @@
-import { CollectionConfig, Relation } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-/**
- * Turning a drizzle result into a row we serve.
- *
- * There are two shapes, and they are the same walk. Both take a row whose
- * relation fields hold nested objects, both unwrap junction rows to reach the
- * target behind them, and both leave every other column alone. They differ only
- * in what they put where the relation was:
- *
- * - `"ref"` — a `{ id, path, __type: "relation" }` reference carrying the
- *   target's values. This is what the admin renders.
- * - `"inline"` — the target's own columns, flat. This is what REST serves.
- *
- * They used to be two functions that happened to agree, and the agreement was
- * not enforced by anything: the row-identity bug had to be fixed five times
- * across differently-shaped copies of this walk, and one of the copies was
- * dead code nobody had noticed. Whatever the next cross-cutting change is, it
- * is one edit here.
- */
-export type RelationStyle = "ref" | "inline";
-/**
- * Whether a many-relation reaches its target through a junction table.
- *
- * Also used to build the drizzle `with` config, which is why it is exported:
- * the query has to nest one level deeper for a junction, and the row walk has
- * to unwrap that same level back out.
- */
-export declare function isJunctionRelation(relation: Relation): boolean;
-/**
- * The address a relation ref points at.
- *
- * The whole key, not its first column: a composite-keyed target addressed by
- * `tenant_id` alone points at every row that shares it. A target whose key
- * cannot be resolved at all used to throw here — reading `[0]` of an empty
- * array — taking down the parent's fetch over a relation it may not even have
- * asked for. The first column is a guess, but a ref that resolves to nothing
- * beats no rows at all.
- */
-export declare function relationTargetAddress(targetRow: Record<string, unknown>, targetCollection: CollectionConfig, registry: PostgresCollectionRegistry): string;
-/**
- * The row the admin renders: every column, with relations as references.
- *
- * Values are normalized (dates, numbers, NaN) because the admin's view-model
- * expects real types. The row's own address is *not* among the columns — it is
- * derived by the consumer from the collection's primary keys.
- */
-export declare function toCmsRow(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): Record<string, unknown>;
-/**
- * The row REST serves: every column under its own name, with the value Postgres
- * returned, and relations inlined as the target's columns.
- *
- * Values are the ones the database returned, except where that contradicts the
- * declared type: a `number` property is served as a number (see
- * {@link coerceDeclaredNumber}). Dates stay as the database returned them —
- * JSON has its own opinions about dates that the admin's view-model does not
- * share.
- *
- * Keyed by the row rather than by the relation list — a REST fetch only loads
- * the relations `include` asked for, so the row is the authority on which are
- * actually there.
- */
-export declare function toRestRow(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): Record<string, unknown>;

package/src/collections/buildRegistry.ts

@@ -1,59 +0,0 @@
-import { isTable, getTableName, Relations } from "drizzle-orm";
-import { PgEnum, PgTable } from "drizzle-orm/pg-core";
-import { CollectionConfig } from "@rebasepro/types";
-import { logger } from "@rebasepro/server";
-import { PostgresCollectionRegistry } from "./PostgresCollectionRegistry";
-import { warnOnKeysTheAdminCannotResolve } from "../services/collection-helpers";
-
-/**
- * Everything a registry is built from: the collections, and the drizzle schema
- * they are backed by. In BaaS mode all of it is introspected from the live
- * database; in CMS mode it comes from the config and the generated schema.
- */
-export interface RegistrySchema {
-    collections?: CollectionConfig[];
-    tables?: Record<string, unknown>;
-    enums?: Record<string, PgEnum<[string, ...string[]]>>;
-    relations?: Record<string, Relations>;
-}
-
-/**
- * Build the collection registry for a driver.
- *
- * The order matters and is the reason this is one function rather than a run of
- * statements in the bootstrapper. Keys are resolved from the drizzle schema, so
- * anything that inspects them has to run *after* the tables are registered —
- * and `warnOnKeysTheAdminCannotResolve` fails open if it does not, because a
- * collection whose table it cannot look up is one it has nothing to say about.
- * Warned too early, it would skip every collection and report nothing, which
- * reads exactly like having nothing to report.
- */
-export function buildCollectionRegistry(schema: RegistrySchema): PostgresCollectionRegistry {
-    const registry = new PostgresCollectionRegistry();
-
-    if (schema.collections) {
-        registry.registerMultiple(schema.collections);
-        logger.info(
-            `📋 [PostgresRegistry] Registered ${registry.getCollections().length} collections: ` +
-            `[${registry.getCollections().map(c => c.slug).join(", ")}]`
-        );
-    }
-
-    if (schema.tables) {
-        Object.values(schema.tables).forEach((table) => {
-            if (isTable(table)) {
-                registry.registerTable(table as PgTable, getTableName(table));
-            }
-        });
-    }
-
-    if (schema.enums) registry.registerEnums(schema.enums);
-    if (schema.relations) registry.registerRelations(schema.relations);
-
-    // Now that the keys resolve: say which of them the admin cannot see. It
-    // compiles the same collection files into its bundle but never the drizzle
-    // schema, and nothing serves it one, so only an edit to the config fixes it.
-    warnOnKeysTheAdminCannotResolve(registry.getCollections(), registry);
-
-    return registry;
-}