@rebasepro/server-postgres 0.9.1-canary.c0d4c07 → 0.9.1-canary.d198c11

package/dist/schema/doctor.d.ts

@@ -2,7 +2,7 @@ import { CollectionConfig, Property } from "@rebasepro/types";
 export type IssueSeverity = "error" | "warning" | "info";
 export interface DoctorIssue {
     severity: IssueSeverity;
-    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale" | "sdk_not_generated";
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale";
     table?: string;
     column?: string;
     expected?: string;

package/dist/security/policy-drift.d.ts

@@ -63,36 +63,6 @@ export declare function parseExpectedPolicies(ddl: string): PolicyRef[];
  * of reads. The same blindness would hide a policy that fails open.
  */
 export declare function checkPolicyDrift(client: Queryable, collections: CollectionConfig[]): Promise<PolicyDrift>;
-/**
- * Does this name look like one the generator produced for this table?
- *
- * Unnamed rules compile to `<table>_<op>_<sha1[0:7]>` (plus `_<idx>` when one
- * rule spans several operations), and the hash covers the rule's semantics — so
- * *editing* a rule renames its policy. The policy under the old name is left
- * behind by `db push`, which only DROPs the names it is about to CREATE, and
- * Postgres ORs PERMISSIVE policies together: a superseded `USING (true)` keeps
- * granting everything no matter how tight its replacement is.
- *
- * Matching the shape is what makes dropping them safe. A hand-written policy
- * would have to collide with a 7-hex digest to be mistaken for generated one;
- * a policy named anything else is left alone and merely reported, because a
- * custom name is indistinguishable from one someone wrote in SQL on purpose.
- */
-export declare function isGeneratedPolicyName(name: string, table: string): boolean;
-export interface OrphanCleanup {
-    /** Superseded generated policies that were dropped. */
-    dropped: PolicyRef[];
-    /** Orphans left in place because their names are not generator-shaped. */
-    kept: PolicyRef[];
-}
-/**
- * Drop the policies an earlier push superseded but never removed.
- *
- * Only touches tables the collections describe — a table with no expected
- * policy is not ours to reconcile, and scanning by schema alone would sweep up
- * policies belonging to something else sharing the database.
- */
-export declare function dropOrphanedPolicies(client: Queryable, drift: PolicyDrift, collections: CollectionConfig[]): Promise<OrphanCleanup>;
 export declare const hasDrift: (d: PolicyDrift) => boolean;
 /** Human-readable report; empty string when the database matches the config. */
 export declare function formatPolicyDrift(drift: PolicyDrift): string;

package/dist/services/FetchService.d.ts

@@ -40,22 +40,52 @@ export declare class FetchService {
      * the target relation so actual row data is returned.
      */
     private buildWithConfig;
+    /**
+     * Detect if a many-to-many relation uses a junction table in the Drizzle schema.
+     */
+    private isJunctionRelation;
     /**
      * Get the Drizzle relation name on the junction table that points to the actual target row.
      * For example, for posts_tags junction, this returns "tag_id" (the relation pointing to tags).
      */
     private getJunctionTargetRelationName;
+    /**
+     * Convert a db.query result row (with nested relation objects) to a flat row.
+     * Handles:
+     * - Type normalization (dates, numbers, NaN) via normalizeDbValues
+     * - Converting nested relation objects to { id, path, __type: "relation" } for CMS
+     * - Flattening junction-table many-to-many results
+     *
+     * The row's own address is not among them: it is derived by the consumer
+     * from the collection's primary keys.
+     */
+    private drizzleResultToRow;
     /**
      * Post-fetch joinPath relations for a single flat row.
      * joinPath relations cannot be expressed via Drizzle's `with` config,
      * so they must be loaded separately after the primary query.
      */
     private resolveJoinPathRelations;
+    /**
+     * Post-fetch joinPath relations for a batch of flat rows.
+     * Uses batch fetching to avoid N+1 queries for list views.
+     */
+    private resolveJoinPathRelationsBatch;
     /**
      * Resolves joinPath relations for raw REST rows and directly injects them.
      * Uses RelationService to query the database and maps results back to the flattened objects.
      */
     private resolveJoinPathRelationsBatchRest;
+    /**
+     * Convert a db.query result row to a flat REST-style row with populated relations.
+     *
+     * Every column is copied through under its own name, with the value Postgres
+     * returned. This used to open with a synthesized `id` and then skip the key
+     * column, which renamed it (a `sku` primary key was served as `id`, and `sku`
+     * did not appear at all) and restringified it (`42` → `"42"`). Consumers that
+     * need an address derive it from the collection's primary keys.
+     */
+    private drizzleResultToRestRow;
     /**
      * Build db.query-compatible options from standard fetch options.
      * Handles filter, search, orderBy, limit, and cursor-based pagination.
@@ -86,10 +116,8 @@ export declare class FetchService {
     }): Promise<Record<string, unknown>[]>;
     /**
      * Fallback path used when db.query is unavailable.
-     *
-     * The primary path runs the results through `toCmsRow`, which maps
-     * relations from what drizzle already nested — no query per row. This one
-     * has no nesting to read, so it resolves relations itself, in batches.
+     * The primary path uses drizzleResultToRow which handles relation
+     * mapping without N+1 queries.
      *
      * Process raw database results into flat rows with relations.
      */

package/dist/services/RelationService.d.ts

@@ -20,40 +20,6 @@ export declare class RelationService {
     private db;
     private registry;
     constructor(db: DrizzleClient, registry: PostgresCollectionRegistry);
-    /**
-     * One target row, as the {@link RelatedRow} everything here returns.
-     *
-     * Eight sites built this by hand, which is how the address came to be the
-     * target's first key column in all eight — one edit, eight places to miss.
-     *
-     * `resolveNested` is the one thing they did not agree on, and the
-     * disagreement was invisible: the single-parent fetches pass `db` and
-     * `registry` to `parseDataFromServer`, so the target's *own* relations get
-     * resolved too, while the batch paths deliberately do not — a query per
-     * target row is the N+1 the batching exists to avoid. Naming the parameter
-     * makes that a decision rather than a difference between two call sites
-     * nobody was comparing.
-     */
-    private toRelatedRow;
-    /**
-     * A WHERE matching any of `parentIds`, by the whole key.
-     *
-     * A single key is an `IN (…)`. A composite one cannot be: matching
-     * `tenant_id IN (1, 1)` collects every row of tenant 1, so two parents that
-     * share their first column each receive the other's relations. It becomes
-     * an OR of ANDs — one exact address per parent — which Postgres indexes the
-     * same way it would a multi-column key lookup.
-     */
-    private parentKeyCondition;
-    /**
-     * Reject a relation that cannot express a composite-keyed parent.
-     *
-     * `localKey` and `foreignKeyOnTarget` are single column names: one column
-     * cannot reference a two-column key, so such a relation has no correct
-     * reading. Left alone it would silently match on the first key column and
-     * hand a tenant's rows to its neighbour — say so instead.
-     */
-    private assertSingleKeyAddressable;
     /**
      * Fetch rows related to a parent row through a specific relation
      */
@@ -106,6 +72,7 @@ export declare class RelationService {
         relationKey: string;
         relation: Relation;
         newValue: unknown;
+        currentId?: string | number;
     }>): Promise<void>;
     /**
      * Handle inverse relations with joinPath

package/dist/services/collection-helpers.d.ts

@@ -24,80 +24,4 @@ export interface DrizzleColumnMeta {
 export declare function getColumnMeta(col: AnyPgColumn): DrizzleColumnMeta;
 export declare function getCollectionByPath(collectionPath: string, registry: PostgresCollectionRegistry): CollectionConfig;
 export declare function getTableForCollection(collection: CollectionConfig, registry: PostgresCollectionRegistry): PgTable<any>;
-/**
- * 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 declare function getPrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[];
-/**
- * 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 declare function requirePrimaryKeys(collection: CollectionConfig, registry: PostgresCollectionRegistry): PrimaryKeyInfo[];
-/**
- * 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 declare function findUnresolvableKeyCollections(collections: CollectionConfig[], registry: PostgresCollectionRegistry): {
-    collection: CollectionConfig;
-    keys: PrimaryKeyInfo[];
-    shadowedByIdProperty: boolean;
-}[];
-/**
- * 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 declare function warnOnKeysTheAdminCannotResolve(collections: CollectionConfig[], registry: PostgresCollectionRegistry): void;
-/**
- * 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 declare function deriveRowAddress(row: Record<string, unknown>, collection: CollectionConfig, registry: PostgresCollectionRegistry): string;

package/dist/services/index.d.ts

@@ -1,4 +1,4 @@
 export { FetchService } from "./FetchService";
 export { PersistService } from "./PersistService";
 export { RelationService } from "./RelationService";
-export { getCollectionByPath, getTableForCollection, getPrimaryKeys, deriveRowAddress, parseIdValues, buildCompositeId } from "./collection-helpers";
+export { getCollectionByPath, getTableForCollection, getPrimaryKeys, parseIdValues, buildCompositeId } from "./collection-helpers";

package/dist/services/realtimeService.d.ts

@@ -177,15 +177,8 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
     /**
      * 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;
-    /** The key columns of the collection at `path`, if they can be resolved. */
-    private primaryKeysForPath;
     private sendError;
     private sendMessage;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgres",
   "type": "module",
-  "version": "0.9.1-canary.c0d4c07",
+  "version": "0.9.1-canary.d198c11",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -71,21 +71,18 @@
     "execa": "^9.6.1",
     "pg": "^8.21.0",
     "ws": "^8.21.0",
-    "@rebasepro/common": "0.9.1-canary.c0d4c07",
-    "@rebasepro/codegen": "0.9.1-canary.c0d4c07",
-    "@rebasepro/utils": "0.9.1-canary.c0d4c07",
-    "@rebasepro/server": "0.9.1-canary.c0d4c07",
-    "@rebasepro/types": "0.9.1-canary.c0d4c07"
+    "@rebasepro/common": "0.9.1-canary.d198c11",
+    "@rebasepro/codegen": "0.9.1-canary.d198c11",
+    "@rebasepro/utils": "0.9.1-canary.d198c11",
+    "@rebasepro/types": "0.9.1-canary.d198c11",
+    "@rebasepro/server": "0.9.1-canary.d198c11"
   },
   "devDependencies": {
-    "@hono/node-server": "^2.0.9",
-    "@jest/globals": "^30.4.1",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.9.3",
     "@types/pg": "^8.20.0",
     "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^6.0.2",
-    "hono": "^4.12.25",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
     "typescript": "^6.0.3",
@@ -106,7 +103,6 @@
     "test:lint": "eslint \"src/**\" --quiet",
     "test": "jest --passWithNoTests",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
-    "smoke:baas": "tsx scripts/smoke-baas.ts"
+    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
   }
 }

package/src/PostgresBackendDriver.ts

@@ -29,7 +29,6 @@ import {
 import { sql as drizzleSql } from "drizzle-orm";
 import { buildPropertyCallbacks, buildSdkData, resolveCollectionRelations, updateDateAutoValues } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
-import { deriveRowAddress } from "./services/collection-helpers";
 import { HistoryService } from "./history/HistoryService";
 import { mergeDeep } from "@rebasepro/utils";
 import { logger } from "@rebasepro/server";
@@ -548,26 +547,13 @@ export class PostgresBackendDriver implements DataDriver {
         let updatedValues = values;
         const contextForCallback = this.buildCallContext();
 
-        // Fetch previous values for callbacks AND history recording. Same walk
-        // as the saved row the callbacks receive (`fetchOneForRest`), so
-        // `values` and `previousValues` compare like with like — a Date on one
-        // side and its ISO string on the other reads as a change that never
-        // happened.
+        // Fetch previous values for callbacks AND history recording
         let previousValuesForHistory: Partial<M> | undefined;
         if (status === "existing" && id) {
-            try {
-                const existing = await this.dataService.getFetchService()
-                    .fetchOneForRest(path, id, undefined, resolvedCollection?.databaseId);
-                if (existing) {
-                    const { id: _existingId, ...existingValues } = existing;
-                    previousValuesForHistory = existingValues as Partial<M>;
-                }
-            } catch (err) {
-                // Best-effort enrichment: callbacks and history run without
-                // previous values rather than the save failing on a read the
-                // write itself does not need (e.g. a collection whose key the
-                // registry cannot resolve).
-                logger.debug(`[save] Could not fetch previous values for "${path}"`, { detail: err instanceof Error ? err.message : String(err) });
+            const existing = await this.dataService.fetchOne<M>(path, id, resolvedCollection?.databaseId);
+            if (existing) {
+                const { id: _existingId, ...existingValues } = existing;
+                previousValuesForHistory = existingValues as Partial<M>;
             }
         }
 
@@ -666,19 +652,8 @@ export class PostgresBackendDriver implements DataDriver {
                 }
             }
 
-            // The row is exactly its columns, so its address is derived, not read
-            // off it: `savedRow.id` is undefined for every table whose key is not
-            // literally named `id`, and is ordinary data for a table that has such
-            // a column without it being the key.
-            const savedId = deriveRowAddress(
-                savedRow,
-                (resolvedCollection ?? collection) as CollectionConfig,
-                this.registry
-            );
-            // `values` are the row's columns — all of them. For an `id`-keyed table
-            // that includes `id`, which used to be stripped here because it was the
-            // synthesized address rather than the column it now is.
-            const savedValues = savedRow;
+            const savedId = savedRow.id as string | number;
+            const { id: _savedId, ...savedValues } = savedRow;
 
             if (globalCallbacks?.afterSave || callbacks?.afterSave || propertyCallbacks?.afterSave) {
                 // 1. Global callbacks first
@@ -723,7 +698,7 @@ export class PostgresBackendDriver implements DataDriver {
             if (this.historyService && resolvedCollection?.history) {
                 this.historyService.recordHistory({
                     tableName: path,
-                    id: savedId,
+                    id: savedId.toString(),
                     action: status === "new" ? "create" : "update",
                     values: savedValues as Record<string, unknown>,
                     previousValues: previousValuesForHistory as Record<string, unknown> | undefined,
@@ -735,14 +710,14 @@ export class PostgresBackendDriver implements DataDriver {
             if (this._deferNotifications) {
                 this._pendingNotifications.push({
                     path,
-                    id: savedId,
+                    id: savedId.toString(),
                     row: savedRow,
                     databaseId: resolvedCollection?.databaseId
                 });
             } else {
                 await this.realtimeService.notifyUpdate(
                     path,
-                    savedId,
+                    savedId.toString(),
                     savedRow,
                     resolvedCollection?.databaseId
                 );
@@ -868,10 +843,7 @@ export class PostgresBackendDriver implements DataDriver {
                                                           }: DeleteProps<M>): Promise<void> {
 
         const targetPath = row.path;
-        // The callbacks' `row` is the row: its columns, nothing else. The address
-        // travels beside it as `id`, so merging it in here only ever invented an
-        // `id` field for tables that have no such column.
-        const targetRow: Record<string, unknown> = { ...(row.values ?? {}) };
+        const targetRow: Record<string, unknown> = { id: row.id, ...(row.values ?? {}) };
 
         // Resolve from backend registry to restore callbacks lost during WebSocket serialization
         const {

package/src/PostgresBootstrapper.ts

@@ -4,7 +4,7 @@
  * Implements the `BackendBootstrapper` interface for PostgreSQL.
  */
 
-import { Relations, sql } from "drizzle-orm";
+import { getTableName, isTable, Relations, sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { PgEnum, PgTable } from "drizzle-orm/pg-core";
 import type { RebasePgTable } from "./types";
@@ -21,7 +21,6 @@ import {
 } from "@rebasepro/types";
 import { PostgresBackendDriver } from "./PostgresBackendDriver";
 import { RealtimeService } from "./services/realtimeService";
-import { buildCollectionRegistry } from "./collections/buildRegistry";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { createEmailService, type EmailConfig, type EmailService, logger } from "@rebasepro/server";
@@ -65,15 +64,6 @@ export interface PostgresDriverInternals {
     realtimeService: RealtimeService;
     driver: PostgresBackendDriver;
     poolManager?: DatabasePoolManager;
-    /**
-     * Attach CDC triggers to tables that did not exist when the driver
-     * bootstrapped. Only set when database-level capture is actually active.
-     *
-     * Auth owns its own tables and creates them later in boot, so at driver
-     * bootstrap they are legitimately missing and get skipped; without this
-     * they would stay uninstrumented until the next restart.
-     */
-    provisionCdcForTables?: (tables: CdcTableRef[]) => Promise<void>;
 }
 
 // Re-export from shared CLI error utilities
@@ -171,17 +161,30 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             }
 
             const activeCollections = introspectedCollections ?? collections;
+
+            // Create a fresh registry for this driver
+            const registry = new PostgresCollectionRegistry();
+            if (activeCollections) {
+                registry.registerMultiple(activeCollections);
+                logger.info(`📋 [PostgresRegistry] Registered ${registry.getCollections().length} collections: [${registry.getCollections().map(c => c.slug).join(", ")}]`);
+            }
+
             const schemaTables = introspectedTables ?? pgConfig.schema?.tables;
-            const schemaRelations = introspectedRelations ?? (pgConfig.schema?.relations as Record<string, Relations> | undefined);
 
-            // Create a fresh registry for this driver. Registration order is
-            // load-bearing, so it lives in one place — see `buildCollectionRegistry`.
-            const registry = buildCollectionRegistry({
-                collections: activeCollections,
-                tables: schemaTables,
-                enums: pgConfig.schema?.enums as Record<string, PgEnum<[string, ...string[]]>> | undefined,
-                relations: schemaRelations
-            });
+            // Register tables
+            if (schemaTables) {
+                Object.values(schemaTables).forEach((table) => {
+                    if (isTable(table)) {
+                        const tableName = getTableName(table);
+                        registry.registerTable(table as PgTable, tableName);
+                    }
+                });
+            }
+
+            if (pgConfig.schema?.enums) registry.registerEnums(pgConfig.schema.enums as Record<string, PgEnum<[string, ...string[]]>>);
+
+            const schemaRelations = introspectedRelations ?? (pgConfig.schema?.relations as Record<string, Relations> | undefined);
+            if (schemaRelations) registry.registerRelations(schemaRelations);
 
             // Patch Drizzle's PgArray columns to handle NULL values safely.
             // Drizzle's mapFromDriverValue crashes with "value.map is not a function"
@@ -343,7 +346,6 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             const wantsCdc = cdcMode !== "off";
             const explicitCdc = cdcMode === "trigger" || cdcMode === "wal";
             let cdcEnabled = false;
-            let provisionCdcForTables: PostgresDriverInternals["provisionCdcForTables"];
 
             if (wantsCdc && !directUrl) {
                 const reason = "no direct database connection is available for the realtime LISTEN client (set DATABASE_DIRECT_URL)";
@@ -377,11 +379,6 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                     await provisionTriggerCdc(cdcRunSql, cdcTables);
                     await realtimeService.enableCdc(directUrl);
                     cdcEnabled = true;
-                    // Boot steps that create their own tables (auth) run after
-                    // this one and use it to instrument what they just created.
-                    provisionCdcForTables = async (tables) => {
-                        await provisionTriggerCdc(cdcRunSql, tables);
-                    };
                     logger.info(
                         `📡 [CDC] Realtime source = database-level change capture (mode: ${cdcMode === "wal" ? "wal→trigger" : "trigger"}). ` +
                         `All writes now emit realtime events regardless of origin.`
@@ -432,14 +429,6 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                     );
                     const missing: Array<{ slug: string; table: string }> = [];
                     for (const col of registeredCollections) {
-                        // Auth owns its table and creates it later in this same
-                        // boot (initializeAuth → ensureAuthTablesExist), so it is
-                        // legitimately absent right now. Reporting it as drift
-                        // tells the user to `db:push` a table that is about to
-                        // exist — and on an introspected database, one that the
-                        // database was never supposed to hold.
-                        if ((col as { auth?: { enabled?: boolean } }).auth?.enabled) continue;
-
                         const schemaName = "schema" in col && col.schema ? col.schema : "public";
                         const tableName = registry.hasTableForCollection(
                             col.table ?? col.slug
@@ -454,10 +443,8 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                         const checkName = resolvedTable ?? tableName;
                         const fullCheckName = schemaName === "public" ? checkName : `${schemaName}.${checkName}`;
                         if (!dbTables.has(fullCheckName)) {
-                            // Report what was actually looked up: an unqualified
-                            // "users" sends people hunting for public.users.
                             missing.push({ slug: col.slug,
-table: fullCheckName });
+table: checkName });
                         }
                     }
                     if (missing.length > 0) {
@@ -491,8 +478,7 @@ table: fullCheckName });
                 registry,
                 realtimeService,
                 driver,
-                poolManager,
-                provisionCdcForTables
+                poolManager
             };
 
             return {
@@ -521,29 +507,6 @@ table: fullCheckName });
             // ensureAuthTablesExist works with the collection abstraction — no Drizzle leakage.
             await ensureAuthTablesExist(db, authCollection);
 
-            // The driver bootstrapped before these tables existed, so CDC skipped
-            // them. Instrument them now, or writes to the user table emit no
-            // realtime events until the next restart.
-            if (authCollection && internals.provisionCdcForTables) {
-                const authSchema = "schema" in authCollection && typeof authCollection.schema === "string"
-                    ? authCollection.schema
-                    : "rebase";
-                const authTable = "table" in authCollection && typeof authCollection.table === "string"
-                    ? authCollection.table
-                    : authCollection.slug;
-                if (authTable) {
-                    try {
-                        await internals.provisionCdcForTables([{ schema: authSchema, table: authTable }]);
-                    } catch (err) {
-                        logger.warn(
-                            `⚠️ [CDC] Could not attach change-capture to the auth table "${authSchema}.${authTable}" — ` +
-                            "writes to it won't emit database-level events.",
-                            { detail: err instanceof Error ? err.message : String(err) }
-                        );
-                    }
-                }
-            }
-
             let emailService: EmailService | undefined;
             if (authConfig.email) {
                 emailService = createEmailService(authConfig.email as EmailConfig);