@rebasepro/server-postgresql 0.4.0 → 0.6.0

package/src/PostgresBackendDriver.ts

@@ -1,14 +1,10 @@
-// import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { EntityService } from "./services/entityService";
 import { BranchService } from "./services/BranchService";
 import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { DrizzleClient } from "./interfaces";
-import { User, RebaseClient } from "@rebasepro/types";
-import { sql as drizzleSql } from "drizzle-orm";
-import { buildPropertyCallbacks, updateDateAutoValues } from "@rebasepro/common";
-import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import {
+    DatabaseAdmin,
     DataDriver,
     DeleteEntityProps,
     Entity,
@@ -18,22 +14,23 @@ import {
     ListenCollectionProps,
     ListenEntityProps,
     RebaseCallContext,
-    SaveEntityProps,
+    RebaseClient,
     RebaseData,
-    TableMetadata,
+    RestFetchService,
+    SaveEntityProps,
     TableColumnInfo,
     TableForeignKeyInfo,
     TableJunctionInfo,
+    TableMetadata,
     TablePolicyInfo,
-    SQLAdmin,
-    SchemaAdmin,
-    DatabaseAdmin,
-    RestFetchService
+    User
 } from "@rebasepro/types";
-import { buildRebaseData } from "@rebasepro/common";
-// @ts-ignore
+import { sql as drizzleSql } from "drizzle-orm";
+import { buildPropertyCallbacks, buildRebaseData, updateDateAutoValues } from "@rebasepro/common";
+import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { HistoryService } from "./history/HistoryService";
 import { mergeDeep } from "@rebasepro/utils";
+import { logger } from "@rebasepro/server-core";
 
 export class PostgresBackendDriver implements DataDriver {
     key = "postgres";
@@ -112,15 +109,28 @@ export class PostgresBackendDriver implements DataDriver {
         return this.entityService.getFetchService();
     }
 
+    private buildCallContext(): RebaseCallContext {
+        return {
+            user: this.user,
+            driver: this,
+            data: this.data,
+            client: this.client,
+            storageSource: this.client?.storage
+        } as unknown as RebaseCallContext;
+    }
 
     private resolveCollectionCallbacks<M extends Record<string, unknown>>(collection: EntityCollection<M> | undefined, path: string) {
-        if (!collection && !path) return { collection: undefined,
-callbacks: undefined,
-propertyCallbacks: undefined };
+        if (!collection && !path) return {
+            collection: undefined,
+            callbacks: undefined,
+            propertyCallbacks: undefined
+        };
         const registryCollection = this.registry?.getCollectionByPath(path);
         const resolvedCollection = registryCollection
-            ? { ...collection,
-...registryCollection } as EntityCollection<M>
+            ? {
+                ...collection,
+                ...registryCollection
+            } as EntityCollection<M>
             : collection as EntityCollection<M>;
 
         const callbacks = resolvedCollection?.callbacks;
@@ -137,17 +147,17 @@ propertyCallbacks: undefined };
     }
 
     async fetchCollection<M extends Record<string, unknown>>({
-        path,
-        collection,
-        filter,
-        limit,
-        offset,
-        startAfter,
-        orderBy,
-        searchString,
-        order,
-        vectorSearch
-    }: FetchCollectionProps<M>): Promise<Entity<M>[]> {
+                                                                 path,
+                                                                 collection,
+                                                                 filter,
+                                                                 limit,
+                                                                 offset,
+                                                                 startAfter,
+                                                                 orderBy,
+                                                                 searchString,
+                                                                 order,
+                                                                 vectorSearch
+                                                             }: FetchCollectionProps<M>): Promise<Entity<M>[]> {
 
         const entities = await this.entityService.fetchCollection<M>(path, {
             filter,
@@ -161,16 +171,14 @@ propertyCallbacks: undefined };
             vectorSearch
         });
 
-        const { collection: resolvedCollection, callbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
+        const {
+            collection: resolvedCollection,
+            callbacks,
+            propertyCallbacks
+        } = this.resolveCollectionCallbacks(collection, path);
 
         if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
-            const contextForCallback = {
-                user: this.user,
-                driver: this,
-                data: this.data,
-                client: this.client,
-                storageSource: this.client?.storage
-            } as unknown as RebaseCallContext; // Backend context
+            const contextForCallback = this.buildCallContext();
             return Promise.all(entities.map(async (entity) => {
                 let fetched = entity;
                 if (callbacks?.afterRead) {
@@ -197,18 +205,18 @@ propertyCallbacks: undefined };
     }
 
     listenCollection<M extends Record<string, unknown>>({
-        path,
-        collection,
-        filter,
-        limit,
-        offset,
-        startAfter,
-        orderBy,
-        searchString,
-        order,
-        onUpdate,
-        onError
-    }: ListenCollectionProps<M>): () => void {
+                                                            path,
+                                                            collection,
+                                                            filter,
+                                                            limit,
+                                                            offset,
+                                                            startAfter,
+                                                            orderBy,
+                                                            searchString,
+                                                            order,
+                                                            onUpdate,
+                                                            onError
+                                                        }: ListenCollectionProps<M>): () => void {
 
         const subscriptionId = this.generateSubscriptionId();
 
@@ -261,27 +269,25 @@ propertyCallbacks: undefined };
     }
 
     async fetchEntity<M extends Record<string, unknown>>({
-        path,
-        entityId,
-        databaseId,
-        collection
-    }: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
+                                                             path,
+                                                             entityId,
+                                                             databaseId,
+                                                             collection
+                                                         }: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
         let entity = await this.entityService.fetchEntity<M>(
             path,
             entityId,
             databaseId || collection?.databaseId
         );
 
-        const { collection: resolvedCollection, callbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
+        const {
+            collection: resolvedCollection,
+            callbacks,
+            propertyCallbacks
+        } = this.resolveCollectionCallbacks(collection, path);
 
         if (entity && (callbacks?.afterRead || propertyCallbacks?.afterRead)) {
-            const contextForCallback = {
-                user: this.user,
-                driver: this,
-                data: this.data,
-                client: this.client,
-                storageSource: this.client?.storage
-            } as unknown as RebaseCallContext; // Backend context
+            const contextForCallback = this.buildCallContext();
             if (callbacks?.afterRead) {
                 entity = await callbacks.afterRead({
                     collection: resolvedCollection as EntityCollection<M>,
@@ -304,12 +310,12 @@ propertyCallbacks: undefined };
     }
 
     listenEntity<M extends Record<string, unknown>>({
-        path,
-        entityId,
-        collection,
-        onUpdate,
-        onError
-    }: ListenEntityProps<M>): () => void {
+                                                        path,
+                                                        entityId,
+                                                        collection,
+                                                        onUpdate,
+                                                        onError
+                                                    }: ListenEntityProps<M>): () => void {
 
         const subscriptionId = this.generateSubscriptionId();
         const callbackWrapper = (entity: Entity<M> | null) => {
@@ -349,23 +355,21 @@ propertyCallbacks: undefined };
     }
 
     async saveEntity<M extends Record<string, unknown>>({
-        path,
-        entityId,
-        values,
-        collection,
-        status
-    }: SaveEntityProps<M>): Promise<Entity<M>> {
-
-        const { collection: resolvedCollection, callbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
+                                                            path,
+                                                            entityId,
+                                                            values,
+                                                            collection,
+                                                            status
+                                                        }: SaveEntityProps<M>): Promise<Entity<M>> {
+
+        const {
+            collection: resolvedCollection,
+            callbacks,
+            propertyCallbacks
+        } = this.resolveCollectionCallbacks(collection, path);
 
         let updatedValues = values;
-        const contextForCallback = {
-            user: this.user,
-            driver: this,
-            data: this.data,
-            client: this.client,
-            storageSource: this.client?.storage
-        } as unknown as RebaseCallContext;
+        const contextForCallback = this.buildCallContext();
 
         // Fetch previous values for callbacks AND history recording
         let previousValuesForHistory: Partial<Entity<M>["values"]> | undefined;
@@ -528,20 +532,18 @@ propertyCallbacks: undefined };
     }
 
     async deleteEntity<M extends Record<string, unknown>>({
-        entity,
-        collection
-    }: DeleteEntityProps<M>): Promise<void> {
+                                                              entity,
+                                                              collection
+                                                          }: DeleteEntityProps<M>): Promise<void> {
 
         // Resolve from backend registry to restore callbacks lost during WebSocket serialization
-        const { collection: resolvedCollection, callbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, entity.path);
+        const {
+            collection: resolvedCollection,
+            callbacks,
+            propertyCallbacks
+        } = this.resolveCollectionCallbacks(collection, entity.path);
 
-        const contextForCallback = {
-            user: this.user,
-            driver: this,
-            data: this.data,
-            client: this.client,
-            storageSource: this.client?.storage
-        } as unknown as RebaseCallContext;
+        const contextForCallback = this.buildCallContext();
 
         if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
             let preventDefault = false;
@@ -653,17 +655,18 @@ propertyCallbacks: undefined };
         );
     }
 
-
     async countEntities<M extends Record<string, unknown>>({
-        path,
-        collection,
-        filter,
-        searchString
-    }: FetchCollectionProps<M>): Promise<number> {
+                                                               path,
+                                                               collection,
+                                                               filter,
+                                                               searchString
+                                                           }: FetchCollectionProps<M>): Promise<number> {
         return this.entityService.countEntities(
             path,
-            { filter,
-searchString }
+            {
+                filter,
+                searchString
+            }
         );
     }
 
@@ -679,7 +682,10 @@ searchString }
         return this.poolManager.getDrizzle(databaseName);
     }
 
-    async executeSql(sqlText: string, options?: { database?: string, role?: string }): Promise<Record<string, unknown>[]> {
+    async executeSql(sqlText: string, options?: {
+        database?: string,
+        role?: string
+    }): Promise<Record<string, unknown>[]> {
         if (!options?.database && !options?.role) {
             return this.entityService.executeSql(sqlText);
         }
@@ -704,7 +710,7 @@ searchString }
             }
 
             if (needsRoleSwitch && options?.role) {
-                const safeRole = options.role.replace(/"/g, '""');
+                const safeRole = options.role.replace(/"/g, "\"\"");
                 return await targetDb.transaction(async (tx) => {
                     await tx.execute(drizzleSql.raw(`SET LOCAL ROLE "${safeRole}"`));
                     const result = await tx.execute(drizzleSql.raw(sqlText));
@@ -817,7 +823,7 @@ searchString }
             `);
             junctionTables = new Set(junctionResult.map((r: Record<string, unknown>) => r.table_name as string));
         } catch (e) {
-            console.warn("Could not detect junction tables:", e);
+            logger.warn("Could not detect junction tables", { error: e });
         }
 
         const filteredTables = allTables.filter(name => !junctionTables.has(name));
@@ -828,7 +834,6 @@ searchString }
         return filteredTables.filter((name: string) => !mappedSet.has(name.toLowerCase()));
     }
 
-
     /**
      * Fetch metadata for a given table from information_schema (columns, policies, constraints).
      */
@@ -972,31 +977,35 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
             fetchCollectionForRest: async (collectionPath, options, include) => {
                 return this.withTransaction(async (delegate) => {
                     return delegate.restFetchService.fetchCollectionForRest(collectionPath, options, include);
-                });
+                }, { accessMode: "read only" });
             },
             fetchEntityForRest: async (collectionPath, entityId, include, databaseId) => {
                 return this.withTransaction(async (delegate) => {
                     return delegate.restFetchService.fetchEntityForRest(collectionPath, entityId, include, databaseId);
-                });
+                }, { accessMode: "read only" });
             }
         };
     }
 
     private async withTransaction<T>(
-        operation: (delegate: PostgresBackendDriver) => Promise<T>
+        operation: (delegate: PostgresBackendDriver) => Promise<T>,
+        options?: {
+            accessMode?: "read only" | "read write";
+            isolationLevel?: "read uncommitted" | "read committed" | "repeatable read" | "serializable"
+        }
     ): Promise<T> {
         const pendingNotifications: PostgresBackendDriver["_pendingNotifications"] = [];
 
         const result = await this.delegate.db.transaction(async (tx) => {
             let userId = this.user?.uid;
             if (!userId) {
-                console.warn("[DataDriver] User ID (uid) is missing for authenticated delegate. Using 'anonymous'. User object:", this.user);
+                logger.warn("[DataDriver] User ID (uid) is missing for authenticated delegate. Using 'anonymous'. User object", { detail: this.user });
                 userId = "anonymous";
             }
 
             const userRoles = this.user?.roles ?? [];
             if (!this.user?.roles) {
-                console.warn("[DataDriver] User roles are missing for authenticated delegate. Using empty array. User object:", this.user);
+                logger.warn("[DataDriver] User roles are missing for authenticated delegate. Using empty array. User object", { detail: this.user });
             }
             const normalizedRoles = userRoles.map((r: unknown) =>
                 typeof r === "string" ? r : (r as Record<string, unknown>)?.id ?? String(r)
@@ -1007,8 +1016,10 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
                 SELECT 
                     set_config('app.user_id', ${userId}, true),
                     set_config('app.user_roles', ${rolesString}, true),
-                    set_config('app.jwt', ${JSON.stringify({ sub: userId,
-roles: userRoles })}, true)
+                    set_config('app.jwt', ${JSON.stringify({
+                sub: userId,
+                roles: userRoles
+            })}, true)
             `);
 
             const txEntityService = new EntityService(tx, this.delegate.registry);
@@ -1020,7 +1031,7 @@ roles: userRoles })}, true)
             txDelegate.client = this.delegate.client;
 
             return await operation(txDelegate);
-        });
+        }, options);
 
         for (const notification of pendingNotifications) {
             try {
@@ -1031,7 +1042,7 @@ roles: userRoles })}, true)
                     notification.databaseId
                 );
             } catch (e) {
-                console.error("[DataDriver] Error flushing deferred notification:", e);
+                logger.error("[DataDriver] Error flushing deferred notification", { error: e });
             }
         }
 
@@ -1039,7 +1050,7 @@ roles: userRoles })}, true)
     }
 
     async fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]> {
-        return this.withTransaction((delegate) => delegate.fetchCollection(props));
+        return this.withTransaction((delegate) => delegate.fetchCollection(props), { accessMode: "read only" });
     }
 
     /**
@@ -1047,8 +1058,10 @@ roles: userRoles })}, true)
      * registered realtime subscription so RLS-aware polling can apply.
      */
     private injectAuthContext(unsubscribe: () => void): () => void {
-        const authContext = { userId: this.user?.uid || "anonymous",
-roles: this.user?.roles ?? [] };
+        const authContext = {
+            userId: this.user?.uid || "anonymous",
+            roles: this.user?.roles ?? []
+        };
         const entries = Array.from(this.delegate.realtimeService.subscriptions.entries());
         const lastEntry = entries[entries.length - 1];
         const lastSub = lastEntry?.[1] as Record<string, unknown> | undefined;
@@ -1063,7 +1076,7 @@ roles: this.user?.roles ?? [] };
     }
 
     async fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
-        return this.withTransaction((delegate) => delegate.fetchEntity(props));
+        return this.withTransaction((delegate) => delegate.fetchEntity(props), { accessMode: "read only" });
     }
 
     listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void {
@@ -1079,7 +1092,7 @@ roles: this.user?.roles ?? [] };
     }
 
     async deleteAll(path: string): Promise<void> {
-        return this.delegate.deleteAll(path);
+        return this.withTransaction((delegate) => delegate.deleteAll(path));
     }
 
     async checkUniqueField(
@@ -1089,11 +1102,11 @@ roles: this.user?.roles ?? [] };
         entityId?: string,
         collection?: EntityCollection
     ): Promise<boolean> {
-        return this.withTransaction((delegate) => delegate.checkUniqueField(path, name, value, entityId, collection));
+        return this.withTransaction((delegate) => delegate.checkUniqueField(path, name, value, entityId, collection), { accessMode: "read only" });
     }
 
     async countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number> {
-        return this.withTransaction((delegate) => delegate.countEntities(props));
+        return this.withTransaction((delegate) => delegate.countEntities(props), { accessMode: "read only" });
     }
 
 }

package/src/PostgresBootstrapper.ts

@@ -6,7 +6,8 @@
 
 import { getTableName, isTable, Relations, sql, Table } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { PgEnum, PgTable, getTableConfig, AnyPgColumn } from "drizzle-orm/pg-core";
+import { PgEnum, PgTable, getTableConfig } from "drizzle-orm/pg-core";
+import type { RebasePgTable } from "./types";
 import {
     BackendBootstrapper,
     InitializedDriver,
@@ -15,7 +16,8 @@ import {
     RealtimeProvider,
     type DataDriver,
     type AuthAdapter,
-    EntityCollection
+    EntityCollection,
+    PostgresCollection
 } from "@rebasepro/types";
 import { PostgresBackendDriver } from "./PostgresBackendDriver";
 import { RealtimeService } from "./services/realtimeService";
@@ -23,28 +25,33 @@ import { DatabasePoolManager } from "./databasePoolManager";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import {
     createAuthRoutes,
-    createAdminRoutes,
     requireAuth,
     requireAdmin,
     logger
-// @ts-ignore
 } from "@rebasepro/server-core";
 import { ensureAuthTablesExist } from "./auth/ensure-tables";
 import { UserService, PostgresAuthRepository, AuthSchemaTables } from "./auth/services";
 import { createAuthSchema } from "./schema/auth-schema";
 
-// @ts-ignore
 import { createEmailService, type EmailConfig, type EmailService } from "@rebasepro/server-core";
-// @ts-ignore
 import { createHistoryRoutes } from "@rebasepro/server-core";
 import { HistoryService } from "./history/HistoryService";
 import { ensureHistoryTableExists } from "./history/ensure-history-table";
-// @ts-ignore
-import type { AuthConfig, PostgresDriverConfig, HistoryConfig } from "@rebasepro/server-core";
 import type { Hono } from "hono";
-// @ts-ignore
 import type { HonoEnv } from "@rebasepro/server-core";
 
+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.
@@ -107,9 +114,10 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                 ...(pgConfig.schema?.relations || {})
             };
             const { drizzle: createDrizzle } = await import("drizzle-orm/node-postgres");
-            const rawClient = ("$client" in pgConfig.connection
-                ? (pgConfig.connection as Record<string, unknown>).$client
-                : pgConfig.connection) as import("pg").Pool;
+            const connection = pgConfig.connection;
+            const rawClient = (connection && typeof connection === "object" && "$client" in connection
+                ? (connection as Record<string, unknown>).$client
+                : connection) as import("pg").Pool;
             const schemaAwareDb = createDrizzle(rawClient, { schema: mergedSchema });
 
             // Verify connection
@@ -162,6 +170,72 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                 }
             }
 
+            // ── Startup Schema Validation ────────────────────────────────────
+            // One-directional: only checks collections → DB (extra DB tables
+            // that aren't mapped to collections are perfectly fine).
+            try {
+                const registeredCollections = registry.getCollections();
+                if (registeredCollections.length > 0) {
+                    const schemasToCheck = Array.from(new Set(
+                        registeredCollections.map(c => "schema" in c && c.schema ? c.schema : "public")
+                    ));
+                    const schemasList = schemasToCheck.map(s => `'${s}'`).join(",");
+                    const result = await schemaAwareDb.execute(sql.raw(`
+                        SELECT table_name, table_schema
+                        FROM information_schema.tables
+                        WHERE table_schema IN (${schemasList})
+                          AND table_type = 'BASE TABLE'
+                    `));
+                    const dbTables = new Set(
+                        (result.rows as Array<{ table_name: string; table_schema: string }>).map(r =>
+                            r.table_schema === "public" ? r.table_name : `${r.table_schema}.${r.table_name}`
+                        )
+                    );
+                    const missing: Array<{ slug: string; table: string }> = [];
+                    for (const col of registeredCollections) {
+                        const schemaName = "schema" in col && col.schema ? col.schema : "public";
+                        const tableName = registry.hasTableForCollection(
+                            col.table ?? col.slug
+                        )
+                            ? (col.table ?? col.slug)
+                            : col.slug;
+                        // Resolve the actual table name the registry stored
+                        const resolvedTable = registry.getTableNames().find((k) =>
+                            k === tableName ||
+                            k === col.slug
+                        );
+                        const checkName = resolvedTable ?? tableName;
+                        const fullCheckName = schemaName === "public" ? checkName : `${schemaName}.${checkName}`;
+                        if (!dbTables.has(fullCheckName)) {
+                            missing.push({ slug: col.slug,
+table: checkName });
+                        }
+                    }
+                    if (missing.length > 0) {
+                        const lines = missing.map(
+                            m => `    • collection "${m.slug}" → table "${m.table}"`
+                        );
+                        logger.warn([
+                            "",
+                            "┌──────────────────────────────────────────────────────────────┐",
+                            "│  ⚠️  SCHEMA DRIFT — Missing tables in database               │",
+                            "├──────────────────────────────────────────────────────────────┤",
+                            ...lines.map(l => `│ ${l.padEnd(60)}│`),
+                            "├──────────────────────────────────────────────────────────────┤",
+                            "│  Run one of:                                                 │",
+                            "│    pnpm db:push      (dev — fast, no migration files)        │",
+                            "│    pnpm db:migrate   (prod — creates migration files)        │",
+                            "└──────────────────────────────────────────────────────────────┘",
+                            ""
+                        ].join("\n"));
+                    }
+                }
+            } catch (err) {
+                logger.warn("⚠️ Startup schema validation could not run", {
+                    error: err instanceof Error ? err.message : String(err)
+                });
+            }
+
             const internals: PostgresDriverInternals = {
                 db: schemaAwareDb,
                 readDb,
@@ -207,7 +281,7 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                     : authCollection.slug)
                 : undefined;
             const usersTable = tableName
-                ? registry.getTable(tableName) as (PgTable & Record<string, AnyPgColumn>) | undefined
+                ? registry.getTable(tableName) as RebasePgTable | undefined
                 : undefined;
 
             let usersSchemaName = "rebase";
@@ -217,7 +291,7 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
 
             const authTables = createAuthSchema(usersSchemaName) as unknown as AuthSchemaTables;
             if (usersTable) {
-                authTables.users = usersTable as unknown as PgTable & Record<string, AnyPgColumn>;
+                authTables.users = usersTable as RebasePgTable;
             }
 
             const userService = new UserService(db, authTables);
@@ -230,7 +304,7 @@ authRepository };
         },
 
         async initializeHistory(config: unknown, driverResult: InitializedDriver): Promise<{ historyService: HistoryService } | undefined> {
-            const historyConfig = config as HistoryConfig | boolean | undefined;
+            const historyConfig = config as { retention?: number } | boolean | undefined;
             if (!historyConfig) return undefined;
 
             const internals = driverResult.internals as PostgresDriverInternals;
@@ -266,7 +340,7 @@ authRepository };
                 server as import("http").Server,
                 realtimeService as RealtimeService,
                 driver as PostgresBackendDriver,
-                config as AuthConfig,
+                config as { requireAuth?: boolean },
                 adapter as AuthAdapter | undefined
             );
         }