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

package/dist/PostgresBackendDriver.d.ts

@@ -3,7 +3,7 @@ import { BranchService } from "./services/BranchService";
 import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { DrizzleClient } from "./interfaces";
-import { DatabaseAdmin, DataDriver, DeleteProps, CollectionConfig, FetchCollectionProps, FetchOneProps, ListenCollectionProps, ListenOneProps, RebaseClient, RebaseSdkData, RestFetchService, SaveManyProps, SaveProps, TableMetadata, User } from "@rebasepro/types";
+import { DatabaseAdmin, DataDriver, DeleteProps, CollectionConfig, FetchCollectionProps, FetchOneProps, ListenCollectionProps, ListenOneProps, RebaseClient, RebaseSdkData, RestFetchService, SaveProps, TableMetadata, User } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { HistoryService } from "./history/HistoryService";
 export declare class PostgresBackendDriver implements DataDriver {
@@ -88,20 +88,7 @@ export declare class PostgresBackendDriver implements DataDriver {
     listenCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
     fetchOne<M extends Record<string, unknown>>({ path, id, databaseId, collection }: FetchOneProps<M>): Promise<Record<string, unknown> | undefined>;
     listenOne<M extends Record<string, unknown>>({ path, id, collection, onUpdate, onError }: ListenOneProps<M>): () => void;
-    save<M extends Record<string, unknown>>({ path, id, values, collection, status, upsert }: SaveProps<M>): Promise<Record<string, unknown>>;
-    /**
-     * Write many rows through the same pipeline as {@link save}.
-     *
-     * The batch runs in one transaction of its own, so a failure part-way leaves
-     * nothing behind — the point of a batch is that a re-run starts from a known
-     * state. When this driver is already inside a transaction (the authenticated
-     * path, via `withTransaction`) the nested call becomes a savepoint, which is
-     * still atomic and still commits once.
-     *
-     * Rows are applied in order, so a batch that touches the same key twice ends
-     * with the last write winning, exactly as separate calls would.
-     */
-    saveMany<M extends Record<string, unknown>>({ path, rows, collection, upsert }: SaveManyProps<M>): Promise<Record<string, unknown>[]>;
+    save<M extends Record<string, unknown>>({ path, id, values, collection, status }: SaveProps<M>): Promise<Record<string, unknown>>;
     delete<M extends Record<string, unknown>>({ row, collection }: DeleteProps<M>): Promise<void>;
     deleteAll(path: string): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, id?: string, collection?: CollectionConfig): Promise<boolean>;
@@ -156,16 +143,6 @@ export declare class AuthenticatedPostgresBackendDriver implements DataDriver {
     fetchOne<M extends Record<string, unknown>>(props: FetchOneProps<M>): Promise<Record<string, unknown> | undefined>;
     listenOne<M extends Record<string, unknown>>(props: ListenOneProps<M>): () => void;
     save<M extends Record<string, unknown>>(props: SaveProps<M>): Promise<Record<string, unknown>>;
-    /**
-     * One transaction for the whole batch, rather than one per row.
-     *
-     * This is the point of the method: `save` opens a transaction per call, so
-     * importing 10k rows through it means 10k transactions (and, over HTTP, 10k
-     * round trips). Here the RLS context is established once and every row lands
-     * or none does. Realtime notifications are already deferred to commit by
-     * `withTransaction`, so a batch does not flood subscribers mid-flight.
-     */
-    saveMany<M extends Record<string, unknown>>(props: SaveManyProps<M>): Promise<Record<string, unknown>[]>;
     delete<M extends Record<string, unknown>>(props: DeleteProps<M>): Promise<void>;
     deleteAll(path: string): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, id?: string, collection?: CollectionConfig): Promise<boolean>;

package/dist/PostgresBootstrapper.d.ts

@@ -9,7 +9,6 @@ import { PostgresBackendDriver } from "./PostgresBackendDriver";
 import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
-import { type CdcTableRef } from "./services/cdc/trigger-cdc";
 export interface PostgresDriverConfig {
     connectionString?: string;
     adminConnectionString?: string;
@@ -37,15 +36,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>;
 }
 /**
  * Default PostgreSQL bootstrapper.

package/dist/auth/services.d.ts

@@ -19,22 +19,6 @@ export declare class UserService implements UserRepository {
     private userIdentitiesTable;
     constructor(db: NodePgDatabase, tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>);
     private getQualifiedUsersTableName;
-    /**
-     * Run a privileged auth write with an explicitly cleared RLS context.
-     *
-     * The auth services run on the base/owner connection, which by design
-     * carries a NULL `app.user_id` so the `auth.uid() IS NULL` server-escape
-     * in the default policies applies. That NULL is normally guaranteed by
-     * `set_config(..., is_local = true)` resetting at transaction end — but a
-     * GUC that survives on a pooled connection (or a connection role that
-     * doesn't bypass RLS: FORCE ROW LEVEL SECURITY, or a non-owner role)
-     * turns the trusted write into an RLS-scoped one and denies it with
-     * SQLSTATE 42501. Clearing the GUCs here, transaction-locally at the
-     * single chokepoint, makes the server context deterministic instead of
-     * trusting whatever state the pool hands us. `auth.uid()` reads '' as
-     * NULL via NULLIF, so '' is the server context.
-     */
-    private withServerContext;
     private mapRowToUser;
     private mapPayload;
     createUser(data: CreateUserData): Promise<UserData>;

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/connection.d.ts

@@ -19,27 +19,6 @@ export interface PostgresPoolConfig {
     /** Enable TCP keep-alive (default: true) */
     keepAlive?: boolean;
 }
-/**
- * Destroy pool clients that are released while still inside a transaction.
- *
- * pg-pool returns a client to the idle list whenever `release()` is called
- * without an error — even if the connection is still mid-transaction (status
- * `T`/`E`). That happens in practice: drizzle's pool transaction releases in
- * a `finally` after attempting ROLLBACK, and if the ROLLBACK itself fails
- * (e.g. it was queued behind a statement that hit the client-side
- * query_timeout), the client goes back dirty. The next checkout then runs
- * its statements inside the zombie transaction — with the previous request's
- * `app.*` RLS GUCs still applied, which turns unrelated queries into
- * RLS-scoped ones (observed in production as registration failing with
- * SQLSTATE 42501 under a leaked anonymous context).
- *
- * pg-pool emits `release` before it consults its private `_expired` set, so
- * marking the client expired here makes `_release()` destroy it instead of
- * pooling it. Both `client._txStatus` (pg ≥ 8.16) and `pool._expired` are
- * private APIs — feature-detect and fall back to loud logging so an upstream
- * change degrades to observability, never to silent corruption.
- */
-export declare function guardPoolAgainstDirtyRelease(pool: Pool, label: string): void;
 /**
  * Create a Drizzle-backed Postgres connection with a production-grade
  * connection pool.

package/dist/data-transformer.d.ts

@@ -12,19 +12,12 @@ import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegi
 export interface SerializedEntityData {
     /** Scalar column values ready for INSERT/UPDATE. */
     scalarData: Record<string, unknown>;
-    /**
-     * Inverse relation updates that must be applied to target tables.
-     *
-     * No address here: the row being written does not know its own. These are
-     * applied by `PersistService`, which addresses them with the id it holds —
-     * the one it was given for an update, or the one the INSERT returned — and
-     * that is the authority. This item used to carry a `currentId` derived from
-     * the *input* values, which nothing ever read.
-     */
+    /** Inverse relation updates that must be applied to target tables. */
     inverseRelationUpdates: Array<{
         relationKey: string;
         relation: Relation;
         newValue: unknown;
+        currentId?: string | number;
     }>;
     /** JoinPath relation updates that require multi-hop writes. */
     joinPathRelationUpdates: Array<{