@rebasepro/server-postgresql 0.6.0 → 0.7.0

package/test/unmapped-tables-safety.test.ts

@@ -1,353 +1,66 @@
-/**
- * Tests to verify that Rebase schema generation and drizzle-kit configuration
- * never attempt to drop/modify tables, enums, or other database objects
- * that are NOT defined in the managed schema.
- *
- * How the safety mechanism works:
- *
- *   1. `tablesFilter` in drizzle.config.ts tells drizzle-kit which tables to
- *      introspect from the live database. Tables not in the filter are INVISIBLE
- *      to drizzle-kit — they never enter the diff snapshot, so they can't appear
- *      in DROP TABLE statements.
- *
- *   2. `schemaFilter` restricts to the "public" PostgreSQL schema, so tables in
- *      other schemas (extensions, internal, etc.) are also invisible.
- *
- *   3. `entities.roles: false` prevents drizzle-kit from managing database roles.
- *
- *   4. `extensionsFilters: ["postgis"]` ignores extension-managed tables.
- *
- *   5. The CLI always passes `--strict --verbose` to `db push`, so destructive
- *      operations require explicit confirmation even if something slips through.
- *
- * These tests verify:
- *   - The schema generator outputs correct table/enum lists for tablesFilter
- *   - The tablesFilter scoping correctly excludes unmapped tables
- *   - The drizzle-kit diff engine produces no destructive SQL when the previous
- *     snapshot only contains managed tables (simulating what tablesFilter provides)
- *   - Unmapped tables in the raw snapshot DO produce DROP statements (proving
- *     the tablesFilter is the critical safety boundary, not the diff engine)
- */
-import { generateDrizzleJson, generateMigration } from "drizzle-kit/api";
-import { pgTable, varchar, text, integer, boolean, pgEnum } from "drizzle-orm/pg-core";
-import { getTableName, Table } from "drizzle-orm";
-import { EntityCollection } from "@rebasepro/types";
-import { generateSchema } from "../src/schema/generate-drizzle-schema-logic";
-
-// ── Helpers ─────────────────────────────────────────────────────────────
-
-function buildPrevSnapshot(tables: Record<string, any>, enums: Record<string, any> = {}) {
-    return {
-        id: "prev-snapshot",
-        prevId: "prev-prev-snapshot",
-        version: "7",
-        dialect: "postgresql",
-        tables,
-        enums,
-        schemas: {},
-        sequences: {},
-        roles: {},
-        policies: {},
-        views: {},
-        _meta: { schemas: {},
-tables: {},
-columns: {} }
-    };
-}
-
-function snapshotTable(name: string, columns: Record<string, any>) {
-    return {
-        name,
-        schema: "",
-        columns,
-        indexes: {},
-        foreignKeys: {},
-        compositePrimaryKeys: {},
-        uniqueConstraints: {},
-        policies: {},
-        checkConstraints: {},
-        isRLSEnabled: false
-    };
-}
-
-function snapshotColumn(name: string, type: string, opts: {
-    primaryKey?: boolean;
-    notNull?: boolean;
-} = {}) {
-    return {
-        name,
-        type,
-        primaryKey: opts.primaryKey ?? false,
-        notNull: opts.notNull ?? (opts.primaryKey ?? false),
-        default: undefined
-    };
-}
-
-function snapshotEnum(name: string, schema: string, values: string[]) {
-    return { name,
-schema,
-values };
-}
-
-// ── Drizzle schema objects (the "managed" schema) ───────────────────────
-
-const managedUsers = pgTable("users", {
-    id: varchar("id").primaryKey(),
-    name: varchar("name"),
-    email: varchar("email")
-});
-
-const managedPosts = pgTable("posts", {
-    id: varchar("id").primaryKey(),
-    title: varchar("title").notNull(),
-    user_id: varchar("user_id")
-});
-
-// ── Tests ───────────────────────────────────────────────────────────────
-
-describe("Unmapped tables safety", () => {
-
-    describe("tablesFilter scoping", () => {
-
-        it("should extract only managed table names from the tables export", () => {
-            const tables = { managedUsers,
-managedPosts };
-            const tableNames = Object.values(tables).map(t => getTableName(t as Table));
-
-            expect(tableNames).toEqual(["users", "posts"]);
-            expect(tableNames).not.toContain("legacy_orders");
-            expect(tableNames).not.toContain("external_analytics");
-        });
-
-        it("should produce a tablesFilter that excludes unmapped tables", () => {
-            const tables = { managedUsers,
-managedPosts };
-            const tablesFilter = Object.values(tables).map(t => getTableName(t as Table));
-
-            const unmappedTables = [
-                "legacy_orders",
-                "external_analytics",
-                "stripe_webhooks",
-                "audit_log"
-            ];
-
-            for (const unmapped of unmappedTables) {
-                expect(tablesFilter).not.toContain(unmapped);
-            }
-        });
-
-        it("should produce stable, deterministic table names regardless of export key names", () => {
-            // The table name comes from pgTable("table_name", ...), not the JS variable name
-            const weirdVarName = pgTable("actual_table_name", {
-                id: varchar("id").primaryKey()
-            });
-            expect(getTableName(weirdVarName as Table)).toBe("actual_table_name");
-        });
-    });
-
-    describe("tablesFilter as the safety boundary — proof by contradiction", () => {
-
-        it("without tablesFilter: drizzle-kit WOULD drop unmapped tables (proving tablesFilter is essential)", async () => {
-            // If unmapped tables leak into the prev snapshot (i.e. tablesFilter is NOT applied),
-            // drizzle-kit's diff engine WILL generate DROP TABLE statements.
-            // This test proves that tablesFilter is the critical safety layer.
-            const prevWithUnmapped = buildPrevSnapshot({
-                "public.users": snapshotTable("users", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    name: snapshotColumn("name", "varchar"),
-                    email: snapshotColumn("email", "varchar")
-                }),
-                // An unmapped table that leaked into the snapshot
-                "public.legacy_orders": snapshotTable("legacy_orders", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    amount: snapshotColumn("amount", "integer")
-                })
-            });
-
-            const curJson = generateDrizzleJson({ managedUsers });
-            const statements = await generateMigration(prevWithUnmapped as any, curJson as any);
-            const sql = statements.join("\n");
-
-            // WITHOUT tablesFilter, drizzle-kit WOULD drop the unmapped table.
-            // This is expected behavior — it proves tablesFilter is essential.
-            expect(sql).toContain("DROP TABLE");
-            expect(sql).toContain("legacy_orders");
-        });
-
-        it("without tablesFilter: drizzle-kit WOULD drop unmapped enums (proving tablesFilter scope is essential)", async () => {
-            const prevWithUnmappedEnum = buildPrevSnapshot(
-                {
-                    "public.users": snapshotTable("users", {
-                        id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                        name: snapshotColumn("name", "varchar"),
-                        email: snapshotColumn("email", "varchar")
-                    })
-                },
-                {
-                    "public.order_priority": snapshotEnum("order_priority", "public", ["low", "medium", "high"])
-                }
-            );
-
-            const curJson = generateDrizzleJson({ managedUsers });
-            const statements = await generateMigration(prevWithUnmappedEnum as any, curJson as any);
-            const sql = statements.join("\n");
-
-            // Without filtering, drizzle-kit drops the unmapped enum
-            expect(sql).toContain("DROP TYPE");
-            expect(sql).toContain("order_priority");
-        });
-    });
-
-    describe("with tablesFilter applied: only managed tables enter the diff", () => {
-
-        it("should produce zero migration statements when managed schema is unchanged", async () => {
-            // Simulate: tablesFilter ensures only managed tables appear in the snapshot
-            const prevOnlyManaged = buildPrevSnapshot({
-                "public.users": snapshotTable("users", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    name: snapshotColumn("name", "varchar"),
-                    email: snapshotColumn("email", "varchar")
-                }),
-                "public.posts": snapshotTable("posts", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    title: snapshotColumn("title", "varchar", { notNull: true }),
-                    user_id: snapshotColumn("user_id", "varchar")
-                })
-            });
-
-            const curJson = generateDrizzleJson({ managedUsers,
-managedPosts });
-            const statements = await generateMigration(prevOnlyManaged as any, curJson as any);
-
-            // No changes needed — managed schema is identical
-            expect(statements.length).toBe(0);
-        });
-
-        it("should correctly detect changes to managed tables without touching anything else", async () => {
-            // Prev: users has id + name (missing email)
-            const prevOnlyManaged = buildPrevSnapshot({
-                "public.users": snapshotTable("users", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    name: snapshotColumn("name", "varchar")
-                })
-            });
-
-            const curJson = generateDrizzleJson({ managedUsers });
-            const statements = await generateMigration(prevOnlyManaged as any, curJson as any);
-            const sql = statements.join("\n");
-
-            // Should add the email column
-            expect(sql.toLowerCase()).toContain("alter table");
-            expect(sql).toContain("email");
-
-            // Should NOT contain any DROP TABLE
-            expect(sql).not.toContain("DROP TABLE");
-        });
-    });
-
-    describe("schema generation exports correct metadata for tablesFilter", () => {
-
-        it("should export a tables object containing all and only defined collection tables", async () => {
-            const collections: EntityCollection[] = [
-                {
-                    slug: "products",
-                    table: "products",
-                    name: "Products",
-                    properties: {
-                        name: { type: "string" },
-                        price: { type: "number" }
-                    }
-                },
-                {
-                    slug: "categories",
-                    table: "categories",
-                    name: "Categories",
-                    properties: {
-                        title: { type: "string" }
-                    }
-                }
-            ];
-
-            const result = await generateSchema(collections);
-
-            expect(result).toContain("export const tables = {");
-            expect(result).toContain("products");
-            expect(result).toContain("categories");
-            expect(result).not.toContain("legacy_orders");
-        });
-
-        it("should include junction tables in the tables export for M2M relations", async () => {
-            const postsCollection: EntityCollection = {
+import { getTableIncludesFromCollections } from "../src/cli-helpers";
+
+describe("Unmapped tables safety with Atlas", () => {
+    it("should produce include filters only for managed tables and M2M junction tables", async () => {
+        const mockCollections = [
+            {
+                slug: "users",
+                table: "users",
+                properties: { name: { type: "string" } }
+            },
+            {
                 slug: "posts",
                 table: "posts",
-                name: "Posts",
                 properties: {
-                    title: { type: "string" },
-                    tags: { type: "relation",
-relationName: "tags" }
+                    title: { type: "string" }
                 },
-                relations: [{
-                    relationName: "tags",
-                    target: () => tagsCollection,
-                    cardinality: "many",
-                    direction: "owning",
-                    through: {
-                        table: "posts_to_tags",
-                        sourceColumn: "post_id",
-                        targetColumn: "tag_id"
+                relations: [
+                    {
+                        relationName: "tags",
+                        target: () => ({ table: "tags", slug: "tags" }),
+                        cardinality: "many",
+                        direction: "owning",
+                        through: {
+                            table: "posts_to_tags",
+                            sourceColumn: "post_id",
+                            targetColumn: "tag_id"
+                        }
                     }
-                }]
-            };
-            const tagsCollection: EntityCollection = {
-                slug: "tags",
-                table: "tags",
-                name: "Tags",
-                properties: { name: { type: "string" } }
-            };
-
-            const result = await generateSchema([postsCollection, tagsCollection]);
-
-            // Junction table must appear in the tables export
-            expect(result).toContain("export const tables = {");
-            expect(result).toContain("postsToTags");
-        });
+                ]
+            }
+        ];
+
+        const includes = await getTableIncludesFromCollections(mockCollections);
+
+        // Verify only managed tables and their junctions are included
+        expect(includes).toContain("public.users");
+        expect(includes).toContain("public.posts");
+        expect(includes).toContain("public.posts_to_tags");
+
+        // Verify unmapped tables are NOT included, ensuring they are ignored by Atlas --include filters
+        const unmappedTables = [
+            "public.legacy_orders",
+            "public.external_analytics",
+            "public.stripe_webhooks",
+            "public.audit_log"
+        ];
+        for (const unmapped of unmappedTables) {
+            expect(includes).not.toContain(unmapped);
+        }
+    });
 
-        it("should export enums for schema-defined enum types", async () => {
-            const collections: EntityCollection[] = [{
+    it("should support custom schemas in table include paths", async () => {
+        const mockCollections = [
+            {
                 slug: "orders",
                 table: "orders",
-                name: "Orders",
-                properties: {
-                    status: {
-                        type: "string",
-                        enumValues: ["pending", "shipped", "delivered"]
-                    }
-                }
-            }];
-
-            const result = await generateSchema(collections);
-
-            expect(result).toContain("export const enums = {");
-        });
-    });
-
-    describe("drizzle.config.ts safety properties", () => {
-
-        it("schemaFilter should restrict to public schema only", () => {
-            const schemaFilter = ["public"];
-            expect(schemaFilter).toEqual(["public"]);
-            expect(schemaFilter).not.toContain("information_schema");
-            expect(schemaFilter).not.toContain("pg_catalog");
-        });
-
-        it("entities.roles should be false to prevent managing DB roles", () => {
-            const entities = { roles: false };
-            expect(entities.roles).toBe(false);
-        });
+                schema: "sales",
+                properties: { id: { type: "string" } }
+            }
+        ];
 
-        it("extensionsFilters should include postgis", () => {
-            const extensionsFilters = ["postgis"];
-            expect(extensionsFilters).toContain("postgis");
-        });
+        const includes = await getTableIncludesFromCollections(mockCollections);
+        expect(includes).toContain("sales.orders");
+        expect(includes).not.toContain("public.orders");
     });
 });

package/vite.config.ts

@@ -45,6 +45,7 @@ export default defineConfig(() => ({
         lib: {
             entry: path.resolve(__dirname, "src/index.ts"),
             name: "Rebase Backend",
+            formats: ["es"],
             fileName: (format) => `index.${format}.js`
         },
         target: "ESNEXT",
@@ -52,13 +53,14 @@ export default defineConfig(() => ({
         sourcemap: true,
         rollupOptions: {
             external: isExternal,
+            onwarn(warning, warn) {
+                if (warning.code === "MISSING_GLOBAL_NAME") return;
+                if (warning.code === "INEFFECTIVE_DYNAMIC_IMPORT") return;
+                if (warning.code === "EMPTY_IMPORT_META") return;
+                warn(warning);
+            },
             output: {
-                banner: 'import { createRequire as __createRequire } from "module"; import process from "process"; const require = __createRequire(import.meta.url);',
-                globals: {
-                    "json-logic-js": "jsonLogic",
-                    "fast-equals": "fastEquals",
-                    "lodash/cloneDeep.js": "cloneDeep"
-                }
+                banner: 'import { createRequire as __createRequire } from "module"; import process from "process"; const require = __createRequire(import.meta.url);'
             }
         }
     },

package/vitest.e2e.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: "node",
+        include: ["test/e2e/**/*.test.ts"],
+        testTimeout: 180_000 // 3 min — container startup + migrations
+    }
+});

package/build-errors.txt

@@ -1,37 +0,0 @@
-
-> @rebasepro/server-postgresql@0.0.1 build /Users/francesco/rebase/packages/server-postgresql
-> vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json
-
-vite v5.4.21 building for production...
-transforming...
-✓ 328 modules transformed.
-rendering chunks...
-computing gzip size...
-dist/index.es.js  434.54 kB │ gzip: 83.11 kB │ map: 1,031.37 kB
-dist/index.umd.js  459.59 kB │ gzip: 84.58 kB │ map: 1,035.30 kB
-✓ built in 1.23s
-src/auth/services.ts(119,15): error TS2322: Type '{ id: unknown; email: unknown; passwordHash: {} | null; displayName: {} | null; photoUrl: {} | null; provider: unknown; googleId: {} | null; emailVerified: {}; emailVerificationToken: {} | null; emailVerificationSentAt: {} | null; createdAt: unknown; updatedAt: unknown; }[]' is not assignable to type '{ email: string; id: string; createdAt: Date; passwordHash: string | null; displayName: string | null; photoUrl: string | null; provider: string; googleId: string | null; emailVerified: boolean; emailVerificationToken: string | null; emailVerificationSentAt: Date | null; updatedAt: Date; }[]'.
-  Type '{ id: unknown; email: unknown; passwordHash: {} | null; displayName: {} | null; photoUrl: {} | null; provider: unknown; googleId: {} | null; emailVerified: {}; emailVerificationToken: {} | null; emailVerificationSentAt: {} | null; createdAt: unknown; updatedAt: unknown; }' is not assignable to type '{ email: string; id: string; createdAt: Date; passwordHash: string | null; displayName: string | null; photoUrl: string | null; provider: string; googleId: string | null; emailVerified: boolean; emailVerificationToken: string | null; emailVerificationSentAt: Date | null; updatedAt: Date; }'.
-    Types of property 'email' are incompatible.
-      Type 'unknown' is not assignable to type 'string'.
-src/collections/PostgresCollectionRegistry.ts(90,143): error TS2344: Type 'Record<string, unknown>' does not satisfy the constraint 'User'.
-  Type 'Record<string, unknown>' is missing the following properties from type 'User': uid, displayName, email, photoURL, and 2 more.
-src/PostgresBootstrapper.ts(201,59): error TS2345: Argument of type 'number | undefined' is not assignable to parameter of type 'Partial<HistoryRetentionConfig> | undefined'.
-  Type 'number' has no properties in common with type 'Partial<HistoryRetentionConfig>'.
-src/schema/generate-drizzle-schema-logic.ts(455,121): error TS2344: Type 'Record<string, unknown>' does not satisfy the constraint 'User'.
-  Type 'Record<string, unknown>' is missing the following properties from type 'User': uid, displayName, email, photoURL, and 2 more.
-src/services/EntityFetchService.ts(37,72): error TS2344: Type 'Record<string, unknown>' does not satisfy the constraint 'TablesRelationalConfig'.
-  'string' index signatures are incompatible.
-    Type 'unknown' is not assignable to type 'TableRelationalConfig'.
-src/services/EntityFetchService.ts(39,61): error TS2344: Type 'Record<string, unknown>' does not satisfy the constraint 'TablesRelationalConfig'.
-  'string' index signatures are incompatible.
-    Type 'unknown' is not assignable to type 'TableRelationalConfig'.
-src/services/realtimeService.ts(621,21): error TS2322: Type 'Record<string, unknown> | undefined' is not assignable to type 'Partial<Record<string, [WhereFilterOp, unknown]>> | undefined'.
-  Type 'Record<string, unknown>' is not assignable to type 'Partial<Record<string, [WhereFilterOp, unknown]>>'.
-    'string' index signatures are incompatible.
-      Type 'unknown' is not assignable to type '[WhereFilterOp, unknown] | undefined'.
-src/services/realtimeService.ts(630,13): error TS2322: Type 'Record<string, unknown> | undefined' is not assignable to type 'Partial<Record<string, [WhereFilterOp, unknown]>> | undefined'.
-  Type 'Record<string, unknown>' is not assignable to type 'Partial<Record<string, [WhereFilterOp, unknown]>>'.
-    'string' index signatures are incompatible.
-      Type 'unknown' is not assignable to type '[WhereFilterOp, unknown] | undefined'.
- ELIFECYCLE  Command failed with exit code 2.

package/dist/PostgresAdapter.d.ts

@@ -1,6 +0,0 @@
-import { DatabaseAdapter } from "@rebasepro/types";
-import type { PostgresDriverConfig } from "./PostgresBootstrapper";
-/**
- * Creates a Postgres database adapter for Rebase.
- */
-export declare function createPostgresAdapter(pgConfig: PostgresDriverConfig): DatabaseAdapter;

package/dist/PostgresBackendDriver.d.ts

@@ -1,110 +0,0 @@
-import { EntityService } from "./services/entityService";
-import { BranchService } from "./services/BranchService";
-import { RealtimeService } from "./services/realtimeService";
-import { DatabasePoolManager } from "./databasePoolManager";
-import { DrizzleClient } from "./interfaces";
-import { DatabaseAdmin, DataDriver, DeleteEntityProps, Entity, EntityCollection, FetchCollectionProps, FetchEntityProps, ListenCollectionProps, ListenEntityProps, RebaseClient, RebaseData, RestFetchService, SaveEntityProps, TableMetadata, User } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
-import { HistoryService } from "./history/HistoryService";
-export declare class PostgresBackendDriver implements DataDriver {
-    db: DrizzleClient;
-    readonly registry: PostgresCollectionRegistry;
-    poolManager?: DatabasePoolManager | undefined;
-    key: string;
-    initialised: boolean;
-    entityService: EntityService;
-    realtimeService: RealtimeService;
-    historyService?: HistoryService;
-    branchService?: BranchService;
-    user?: User;
-    data: RebaseData;
-    client?: RebaseClient;
-    /**
-     * When true, realtime notifications are deferred until after the
-     * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
-     */
-    _deferNotifications: boolean;
-    _pendingNotifications: Array<{
-        path: string;
-        entityId: string;
-        entity: Entity | null;
-        databaseId?: string;
-    }>;
-    constructor(db: DrizzleClient, realtimeService: RealtimeService, registry: PostgresCollectionRegistry, user?: User, poolManager?: DatabasePoolManager | undefined, historyService?: HistoryService);
-    /**
-     * Typed admin capabilities (SQLAdmin + SchemaAdmin + BranchAdmin).
-     * Implemented as a getter so method references are resolved at call-time,
-     * allowing test spies applied after construction to take effect.
-     */
-    get admin(): DatabaseAdmin;
-    /**
-     * REST-optimised fetch service (include-aware eager-loading).
-     * Delegates to the underlying EntityFetchService which already
-     * implements the matching method signatures.
-     */
-    get restFetchService(): import("./services").EntityFetchService;
-    private buildCallContext;
-    private resolveCollectionCallbacks;
-    fetchCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, vectorSearch }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
-    listenCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
-    fetchEntity<M extends Record<string, unknown>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    listenEntity<M extends Record<string, unknown>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
-    saveEntity<M extends Record<string, unknown>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
-    deleteEntity<M extends Record<string, unknown>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
-    deleteAll(path: string): Promise<void>;
-    checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
-    countEntities<M extends Record<string, unknown>>({ path, collection, filter, searchString }: FetchCollectionProps<M>): Promise<number>;
-    private getTargetDb;
-    executeSql(sqlText: string, options?: {
-        database?: string;
-        role?: string;
-    }): Promise<Record<string, unknown>[]>;
-    fetchAvailableDatabases(): Promise<string[]>;
-    fetchAvailableRoles(): Promise<string[]>;
-    fetchCurrentDatabase(): Promise<string | undefined>;
-    /**
-     * Fetch public tables that are not yet mapped to a collection.
-     * Excludes internal tables (_rebase_*, _auth_*, auth tables, etc.)
-     * and junction/connection tables used for many-to-many relations.
-     */
-    fetchUnmappedTables(mappedPaths?: string[]): Promise<string[]>;
-    /**
-     * Fetch metadata for a given table from information_schema (columns, policies, constraints).
-     */
-    fetchTableMetadata(tableName: string): Promise<TableMetadata>;
-    private generateSubscriptionId;
-    /**
-     * Create a new delegate instance with authenticated context.
-     * Starts a transaction and sets the current_user_id and current_user_roles
-     * configuration parameters for PostgreSQL Row Level Security.
-     */
-    withAuth(user: User): Promise<DataDriver>;
-}
-export declare class AuthenticatedPostgresBackendDriver implements DataDriver {
-    delegate: PostgresBackendDriver;
-    key: string;
-    initialised: boolean;
-    user: User;
-    data: RebaseData;
-    constructor(delegate: PostgresBackendDriver, user: User);
-    /**
-     * Typed admin capabilities — delegates to the base driver.
-     */
-    admin: DatabaseAdmin;
-    get restFetchService(): RestFetchService | undefined;
-    private withTransaction;
-    fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
-    /**
-     * Injects the authenticated user's context into the most recently
-     * registered realtime subscription so RLS-aware polling can apply.
-     */
-    private injectAuthContext;
-    listenCollection<M extends Record<string, unknown>>(props: ListenCollectionProps<M>): () => void;
-    fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void;
-    saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
-    deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
-    deleteAll(path: string): Promise<void>;
-    checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
-    countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
-}

package/dist/PostgresBootstrapper.d.ts

@@ -1,46 +0,0 @@
-/**
- * PostgresBootstrapper
- *
- * Implements the `BackendBootstrapper` interface for PostgreSQL.
- */
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { BackendBootstrapper } from "@rebasepro/types";
-import { PostgresBackendDriver } from "./PostgresBackendDriver";
-import { RealtimeService } from "./services/realtimeService";
-import { DatabasePoolManager } from "./databasePoolManager";
-import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
-export interface PostgresDriverConfig {
-    connectionString?: string;
-    adminConnectionString?: string;
-    readConnectionString?: string;
-    connection?: unknown;
-    schema?: {
-        tables?: Record<string, unknown>;
-        enums?: Record<string, unknown>;
-        relations?: Record<string, unknown>;
-    };
-}
-/**
- * Opaque internals bag that PostgresBootstrapper stores during `initializeDriver()`
- * and re-uses in subsequent lifecycle hooks.
- */
-export interface PostgresDriverInternals {
-    db: NodePgDatabase<any>;
-    readDb?: NodePgDatabase<any>;
-    registry: PostgresCollectionRegistry;
-    realtimeService: RealtimeService;
-    driver: PostgresBackendDriver;
-    poolManager?: DatabasePoolManager;
-}
-/**
- * Default PostgreSQL bootstrapper.
- *
- * Use it to register Postgres with `initializeRebaseBackend()`:
- * ```typescript
- * initializeRebaseBackend({
- *   ...config,
- *   bootstrappers: [postgresBootstrapper()]
- * });
- * ```
- */
-export declare function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): BackendBootstrapper;