@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/PostgresBackendDriver.ts

@@ -76,37 +76,40 @@ export class PostgresBackendDriver implements DataDriver {
             this.branchService = new BranchService(db, poolManager);
         }
 
-        // Expose SQL + schema + branch admin capabilities via the typed `admin` property.
-        // The individual methods on `this` are kept for backwards compatibility.
-        this.admin = {
-            executeSql: this.executeSql.bind(this),
-            fetchAvailableDatabases: this.fetchAvailableDatabases.bind(this),
-            fetchAvailableRoles: this.fetchAvailableRoles.bind(this),
-            fetchCurrentDatabase: this.fetchCurrentDatabase.bind(this),
-            fetchUnmappedTables: this.fetchUnmappedTables.bind(this),
-            fetchTableMetadata: this.fetchTableMetadata.bind(this),
+    }
+
+    /**
+     * 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 {
+        return {
+            executeSql: (...args: Parameters<NonNullable<DatabaseAdmin["executeSql"]>>) => this.executeSql(...args),
+            fetchAvailableDatabases: () => this.fetchAvailableDatabases(),
+            fetchAvailableRoles: () => this.fetchAvailableRoles(),
+            fetchCurrentDatabase: () => this.fetchCurrentDatabase(),
+            fetchUnmappedTables: (...args: Parameters<NonNullable<DatabaseAdmin["fetchUnmappedTables"]>>) => this.fetchUnmappedTables(...args),
+            fetchTableMetadata: (...args: Parameters<NonNullable<DatabaseAdmin["fetchTableMetadata"]>>) => this.fetchTableMetadata(...args),
             // Branch operations (only available when poolManager is configured)
             ...(this.branchService ? {
                 createBranch: this.branchService.createBranch.bind(this.branchService),
                 deleteBranch: this.branchService.deleteBranch.bind(this.branchService),
                 listBranches: this.branchService.listBranches.bind(this.branchService),
-                getBranchInfo: this.branchService.getBranchInfo.bind(this.branchService),
-            } : {}),
+                getBranchInfo: this.branchService.getBranchInfo.bind(this.branchService)
+            } : {})
         };
     }
 
-    /**
-     * Typed admin capabilities (SQLAdmin + SchemaAdmin + BranchAdmin).
-     */
-    admin: DatabaseAdmin;
-
-
 
-    private resolveCollectionCallbacks<M extends Record<string, any>>(collection: EntityCollection<M> | undefined, path: string) {
-        if (!collection && !path) return { collection: undefined, callbacks: undefined, propertyCallbacks: undefined };
+    private resolveCollectionCallbacks<M extends Record<string, unknown>>(collection: EntityCollection<M> | undefined, path: string) {
+        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;
@@ -122,11 +125,12 @@ export class PostgresBackendDriver implements DataDriver {
         };
     }
 
-    async fetchCollection<M extends Record<string, any>>({
+    async fetchCollection<M extends Record<string, unknown>>({
         path,
         collection,
         filter,
         limit,
+        offset,
         startAfter,
         orderBy,
         searchString,
@@ -138,6 +142,7 @@ export class PostgresBackendDriver implements DataDriver {
             orderBy,
             order,
             limit,
+            offset,
             startAfter: startAfter as Record<string, unknown> | undefined,
             databaseId: collection?.databaseId,
             searchString
@@ -167,7 +172,7 @@ export class PostgresBackendDriver implements DataDriver {
                         path,
                         entity: fetched,
                         context: contextForCallback
-                    }) ?? fetched;
+                    }) as Entity<M> ?? fetched;
                 }
                 return fetched;
             }));
@@ -176,11 +181,12 @@ export class PostgresBackendDriver implements DataDriver {
         return entities;
     }
 
-    listenCollection<M extends Record<string, any>>({
+    listenCollection<M extends Record<string, unknown>>({
         path,
         collection,
         filter,
         limit,
+        offset,
         startAfter,
         orderBy,
         searchString,
@@ -206,6 +212,7 @@ export class PostgresBackendDriver implements DataDriver {
                 orderBy,
                 order,
                 limit,
+                offset,
                 startAfter: startAfter as Record<string, unknown> | undefined,
                 databaseId: collection?.databaseId,
                 searchString
@@ -221,6 +228,7 @@ export class PostgresBackendDriver implements DataDriver {
             collection,
             filter,
             limit,
+            offset,
             startAfter,
             orderBy,
             searchString,
@@ -237,7 +245,7 @@ export class PostgresBackendDriver implements DataDriver {
         };
     }
 
-    async fetchEntity<M extends Record<string, any>>({
+    async fetchEntity<M extends Record<string, unknown>>({
         path,
         entityId,
         databaseId,
@@ -271,14 +279,14 @@ export class PostgresBackendDriver implements DataDriver {
                     path,
                     entity,
                     context: contextForCallback
-                }) ?? entity;
+                }) as Entity<M> ?? entity;
             }
         }
 
         return entity;
     }
 
-    listenEntity<M extends Record<string, any>>({
+    listenEntity<M extends Record<string, unknown>>({
         path,
         entityId,
         collection,
@@ -323,7 +331,7 @@ export class PostgresBackendDriver implements DataDriver {
         };
     }
 
-    async saveEntity<M extends Record<string, any>>({
+    async saveEntity<M extends Record<string, unknown>>({
         path,
         entityId,
         values,
@@ -401,7 +409,7 @@ export class PostgresBackendDriver implements DataDriver {
                         path,
                         entity: savedEntity,
                         context: contextForCallback
-                    }) ?? savedEntity;
+                    }) as Entity<M> ?? savedEntity;
                 }
             }
 
@@ -411,7 +419,7 @@ export class PostgresBackendDriver implements DataDriver {
                         collection: resolvedCollection as EntityCollection<M>,
                         path,
                         entityId: savedEntity.id,
-                        values: updatedValues,
+                        values: savedEntity.values,
                         previousValues: previousValuesForHistory,
                         status,
                         context: contextForCallback
@@ -422,7 +430,7 @@ export class PostgresBackendDriver implements DataDriver {
                         collection: resolvedCollection as EntityCollection<M>,
                         path,
                         entityId: savedEntity.id,
-                        values: updatedValues,
+                        values: savedEntity.values,
                         previousValues: previousValuesForHistory,
                         status,
                         context: contextForCallback
@@ -489,7 +497,7 @@ export class PostgresBackendDriver implements DataDriver {
         }
     }
 
-    async deleteEntity<M extends Record<string, any>>({
+    async deleteEntity<M extends Record<string, unknown>>({
         entity,
         collection
     }: DeleteEntityProps<M>): Promise<void> {
@@ -598,14 +606,16 @@ export class PostgresBackendDriver implements DataDriver {
     }
 
 
-    async countEntities<M extends Record<string, any>>({
+    async countEntities<M extends Record<string, unknown>>({
         path,
         collection,
-        filter
+        filter,
+        searchString
     }: FetchCollectionProps<M>): Promise<number> {
         return this.entityService.countEntities(
             path,
-            { filter }
+            { filter,
+searchString }
         );
     }
 
@@ -676,7 +686,7 @@ export class PostgresBackendDriver implements DataDriver {
     }
 
     async fetchAvailableRoles(): Promise<string[]> {
-        const result = await this.executeSql(`SELECT rolname FROM pg_roles;`);
+        const result = await this.executeSql("SELECT rolname FROM pg_roles;");
         return result.map((r: Record<string, unknown>) => r.rolname as string);
     }
 
@@ -752,7 +762,7 @@ export class PostgresBackendDriver implements DataDriver {
         return filteredTables.filter((name: string) => !mappedSet.has(name.toLowerCase()));
     }
 
-    
+
     /**
      * Fetch metadata for a given table from information_schema (columns, policies, constraints).
      */
@@ -890,17 +900,17 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
         operation: (delegate: PostgresBackendDriver) => Promise<T>
     ): 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);
-                userId = 'anonymous';
+                console.warn("[DataDriver] User ID (uid) is missing for authenticated delegate. Using 'anonymous'. User object:", this.user);
+                userId = "anonymous";
             }
 
-            let userRoles = this.user?.roles ?? [];
+            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);
+                console.warn("[DataDriver] User roles are missing for authenticated delegate. Using empty array. User object:", this.user);
             }
             const normalizedRoles = userRoles.map((r: unknown) =>
                 typeof r === "string" ? r : (r as Record<string, unknown>)?.id ?? String(r)
@@ -911,12 +921,13 @@ 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);
             const txDelegate = new PostgresBackendDriver(tx, this.delegate.realtimeService, this.delegate.registry, this.user, this.delegate.poolManager, this.delegate.historyService);
-            
+
             txDelegate.entityService = txEntityService;
             txDelegate._deferNotifications = true;
             txDelegate._pendingNotifications = pendingNotifications;
@@ -940,7 +951,7 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
         return result;
     }
 
-    async fetchCollection<M extends Record<string, any>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]> {
+    async fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]> {
         return this.withTransaction((delegate) => delegate.fetchCollection(props));
     }
 
@@ -949,7 +960,8 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
      * 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;
@@ -959,23 +971,23 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
         return unsubscribe;
     }
 
-    listenCollection<M extends Record<string, any>>(props: ListenCollectionProps<M>): () => void {
+    listenCollection<M extends Record<string, unknown>>(props: ListenCollectionProps<M>): () => void {
         return this.injectAuthContext(this.delegate.listenCollection(props));
     }
 
-    async fetchEntity<M extends Record<string, any>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
+    async fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
         return this.withTransaction((delegate) => delegate.fetchEntity(props));
     }
 
-    listenEntity<M extends Record<string, any>>(props: ListenEntityProps<M>): () => void {
+    listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void {
         return this.injectAuthContext(this.delegate.listenEntity(props));
     }
 
-    async saveEntity<M extends Record<string, any>>(props: SaveEntityProps<M>): Promise<Entity<M>> {
+    async saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>> {
         return this.withTransaction((delegate) => delegate.saveEntity(props));
     }
 
-    async deleteEntity<M extends Record<string, any>>(props: DeleteEntityProps<M>): Promise<void> {
+    async deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void> {
         return this.withTransaction((delegate) => delegate.deleteEntity(props));
     }
 
@@ -989,36 +1001,8 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
         return this.withTransaction((delegate) => delegate.checkUniqueField(path, name, value, entityId, collection));
     }
 
-    async countEntities<M extends Record<string, any>>(props: FetchCollectionProps<M>): Promise<number> {
+    async countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number> {
         return this.withTransaction((delegate) => delegate.countEntities(props));
     }
 
-    /**
-     * Intentionally delegates to the base delegate WITHOUT RLS wrapping.
-     * executeSql is an admin-only feature; access control should be enforced
-     * at the API route level, not via database-level RLS.
-     */
-    async executeSql(sqlText: string, options?: { database?: string, role?: string }): Promise<Record<string, unknown>[]> {
-        return this.delegate.executeSql(sqlText, options);
-    }
-
-    async fetchAvailableDatabases(): Promise<string[]> {
-        return this.delegate.fetchAvailableDatabases();
-    }
-
-    async fetchAvailableRoles(): Promise<string[]> {
-        return this.delegate.fetchAvailableRoles();
-    }
-
-    async fetchCurrentDatabase(): Promise<string | undefined> {
-        return this.delegate.fetchCurrentDatabase();
-    }
-
-    async fetchUnmappedTables(mappedPaths?: string[]): Promise<string[]> {
-        return this.delegate.fetchUnmappedTables(mappedPaths);
-    }
-
-    async fetchTableMetadata(tableName: string) {
-        return this.delegate.fetchTableMetadata(tableName);
-    }
 }

package/src/PostgresBootstrapper.ts

@@ -26,7 +26,6 @@ import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import {
-    configureGoogleOAuth,
     createAuthRoutes,
     createAdminRoutes,
     requireAuth,
@@ -87,6 +86,7 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             const registry = new PostgresCollectionRegistry();
             if (collections) {
                 registry.registerMultiple(collections);
+                console.log(`📋 [PostgresRegistry] Registered ${registry.getCollections().length} collections: [${registry.getCollections().map(c => c.slug).join(", ")}]`);
             }
 
             // Register tables
@@ -159,7 +159,7 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                 driver,
                 realtimeProvider: realtimeService,
                 collectionRegistry: registry,
-                internals,
+                internals
             };
         },
 
@@ -172,10 +172,6 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
 
             await ensureAuthTablesExist(db);
 
-            if (authConfig.google?.clientId) {
-                configureGoogleOAuth(authConfig.google.clientId);
-            }
-
             let emailService: EmailService | undefined;
             if (authConfig.email) {
                 emailService = createEmailService(authConfig.email);
@@ -185,7 +181,10 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             const roleService = new RoleService(db);
             const authRepository = new PostgresAuthRepository(db);
 
-            return { userService, roleService, emailService, authRepository };
+            return { userService,
+roleService,
+emailService,
+authRepository };
         },
 
         async initializeHistory(config: unknown, driverResult: InitializedDriver): Promise<{ historyService: HistoryService } | undefined> {
@@ -196,7 +195,7 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             const db = internals.db;
 
             await ensureHistoryTableExists(db);
-            
+
             const retention = typeof historyConfig === "object" && historyConfig !== null ? (historyConfig as { retention?: number }).retention : undefined;
             const historyService = new HistoryService(db, retention ? { ttlDays: retention } : undefined);