@rebasepro/server-postgresql 0.1.0 → 0.2.1

package/src/services/RelationService.ts

@@ -1159,7 +1159,7 @@ export class RelationService {
                 if (parentFKValue !== null && parentFKValue !== undefined) {
                     await tx.update(targetTable)
                         .set({ [targetFKColName]: null })
-                        .where(eq(targetFKCol, parentFKValue as unknown as string));
+                        .where(eq(targetFKCol, String(parentFKValue)));
                 }
                 continue;
             }
@@ -1172,7 +1172,7 @@ export class RelationService {
             if (parentFKValue !== null && parentFKValue !== undefined) {
                 await tx.update(targetTable)
                     .set({ [targetFKColName]: null })
-                    .where(eq(targetFKCol, parentFKValue as unknown as string));
+                    .where(eq(targetFKCol, String(parentFKValue)));
             } else {
                 console.warn(`Cannot set joinPath relation '${relation.relationName}' because parent FK value is null/undefined`);
                 continue;

package/src/services/entity-helpers.ts

@@ -13,7 +13,7 @@ import { getTableName } from "@rebasepro/common";
 
 /**
  * Interface for Drizzle column metadata introspection.
- * Replaces unsafe `as unknown as Record<string, unknown>` double-cast chains.
+ * Replaces unsafe `as Record<string, unknown>` double-cast chains.
  */
 export interface DrizzleColumnMeta {
     columnType?: string;

package/src/services/realtimeService.ts

@@ -23,6 +23,10 @@ export interface SubscriptionAuthContext {
     roles: string[];
 }
 
+interface DataDriverWithData extends DataDriver {
+    data: unknown;
+}
+
 type RealTimeListenCollectionProps = ListenCollectionProps & {
     subscriptionId: string
 };
@@ -283,29 +287,18 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             });
 
             // Send initial data
-            let entities;
-            if (this.driver) {
-                entities = await this.driver.fetchCollection({
-                    path: request.path,
-                    collection: collection,
-                    filter: request.filter,
-                    orderBy: request.orderBy,
-                    order: request.order,
-                    limit: request.limit,
-                    startAfter: request.startAfter,
-                    searchString: request.searchString
-                });
-            } else {
-                entities = await this.entityService.fetchCollection(request.path, {
+            const entities = await this.fetchCollectionWithAuth(
+                request.path,
+                {
                     filter: request.filter,
                     orderBy: request.orderBy,
                     order: request.order,
                     limit: request.limit,
                     startAfter: request.startAfter as Record<string, unknown> | undefined,
-                    databaseId: request.collection?.databaseId,
                     searchString: request.searchString
-                });
-            }
+                },
+                authContext
+            );
 
             this.sendCollectionUpdate(clientId, subscriptionId, entities);
 
@@ -338,20 +331,11 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             });
 
             // Send initial data
-            let entity;
-            if (this.driver) {
-                entity = await this.driver.fetchEntity({
-                    path: request.path,
-                    entityId: request.entityId,
-                    collection: collection
-                });
-            } else {
-                entity = await this.entityService.fetchEntity(
-                    request.path,
-                    request.entityId,
-                    request.collection?.databaseId
-                );
-            }
+            const entity = await this.fetchEntityWithAuth(
+                request.path,
+                String(request.entityId),
+                authContext
+            );
 
             this.sendEntityUpdate(clientId, subscriptionId, entity || null);
 
@@ -565,29 +549,28 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 searchString: collectionRequest.searchString
             });
 
-            // If we have auth context, wrap in a transaction with session vars
-            if (authContext) {
-                return await this.db.transaction(async (tx) => {
-                    await tx.execute(drizzleSql`SELECT set_config('app.user_id', ${authContext.userId}, true)`);
-                    await tx.execute(drizzleSql`SELECT set_config('app.user_roles', ${authContext.roles.join(",")}, true)`);
-                    await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: authContext.userId,
-roles: authContext.roles })}, true)`);
-                    const txEntityService = new EntityService(tx, this.registry);
-                    let fetchedEntities;
-                    if (collectionRequest.searchString) {
-                        fetchedEntities = await txEntityService.searchEntities(
-                            notifyPath,
-                            collectionRequest.searchString,
-                            {
+            // Always wrap in a transaction with session vars, defaulting to anonymous context if missing
+            const activeAuth = authContext || { userId: "anon", roles: ["anon"] };
+            return await this.db.transaction(async (tx) => {
+                await tx.execute(drizzleSql`SELECT set_config('app.user_id', ${activeAuth.userId}, true)`);
+                await tx.execute(drizzleSql`SELECT set_config('app.user_roles', ${activeAuth.roles.join(",")}, true)`);
+                await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: activeAuth.userId, roles: activeAuth.roles })}, true)`);
+                const txEntityService = new EntityService(tx, this.registry);
+                let fetchedEntities;
+                if (collectionRequest.searchString) {
+                    fetchedEntities = await txEntityService.searchEntities(
+                        notifyPath,
+                        collectionRequest.searchString,
+                        {
                             filter: collectionRequest.filter as FilterValues<string>,
                             orderBy: collectionRequest.orderBy,
                             order: collectionRequest.order,
                             limit: collectionRequest.limit,
                             databaseId: collectionRequest.databaseId
                         }
-                        );
-                    } else {
-                        fetchedEntities = await txEntityService.fetchCollection(notifyPath, {
+                    );
+                } else {
+                    fetchedEntities = await txEntityService.fetchCollection(notifyPath, {
                         filter: collectionRequest.filter as FilterValues<string>,
                         orderBy: collectionRequest.orderBy,
                         order: collectionRequest.order,
@@ -596,52 +579,48 @@ roles: authContext.roles })}, true)`);
                         startAfter: collectionRequest.startAfter,
                         databaseId: collectionRequest.databaseId
                     });
-                    }
+                }
 
-                    // Re-apply `afterRead` lifecycle hooks to ensure consistent data structures
-                    // between the initial driver fetch and this RLS-bound refetch.
-                    const registryCollection = this.registry.getCollectionByPath(notifyPath);
-                    const resolvedCollection = collection ? { ...collection,
+                // Re-apply `afterRead` lifecycle hooks to ensure consistent data structures
+                // between the initial driver fetch and this RLS-bound refetch.
+                const registryCollection = this.registry.getCollectionByPath(notifyPath);
+                const resolvedCollection = collection ? { ...collection,
 ...registryCollection } as EntityCollection : registryCollection as EntityCollection;
 
-                    const callbacks = resolvedCollection?.callbacks;
-                    const propertyCallbacks = resolvedCollection?.properties ? buildPropertyCallbacks(resolvedCollection.properties) : undefined;
-
-                    if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
-                        const contextForCallback = {
-                            user: { uid: authContext.userId,
-roles: authContext.roles },
-                            driver: this.driver,
-                            data: this.driver ? (this.driver as unknown as Record<string, unknown>).data : undefined
-                        } as unknown as RebaseCallContext;
-
-                        return await Promise.all(fetchedEntities.map(async (entity) => {
-                            let processedEntity = entity;
-                            if (callbacks?.afterRead) {
-                                processedEntity = await callbacks.afterRead({
-                                    collection: resolvedCollection,
-                                    path: notifyPath,
-                                    entity: processedEntity,
-                                    context: contextForCallback
-                                }) ?? processedEntity;
-                            }
-                            if (propertyCallbacks?.afterRead) {
-                                processedEntity = await propertyCallbacks.afterRead({
-                                    collection: resolvedCollection,
-                                    path: notifyPath,
-                                    entity: processedEntity,
-                                    context: contextForCallback
-                                }) ?? processedEntity;
-                            }
-                            return processedEntity;
-                        }));
-                    }
-
-                    return fetchedEntities;
-                });
-            }
+                const callbacks = resolvedCollection?.callbacks;
+                const propertyCallbacks = resolvedCollection?.properties ? buildPropertyCallbacks(resolvedCollection.properties) : undefined;
+
+                if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
+                    const contextForCallback = {
+                        user: { uid: activeAuth.userId, roles: activeAuth.roles },
+                        driver: this.driver,
+                        data: (this.driver && "data" in this.driver) ? (this.driver as DataDriverWithData).data : undefined
+                    } as unknown as RebaseCallContext;
+
+                    return await Promise.all(fetchedEntities.map(async (entity) => {
+                        let processedEntity = entity;
+                        if (callbacks?.afterRead) {
+                            processedEntity = await callbacks.afterRead({
+                                collection: resolvedCollection,
+                                path: notifyPath,
+                                entity: processedEntity,
+                                context: contextForCallback
+                            }) ?? processedEntity;
+                        }
+                        if (propertyCallbacks?.afterRead) {
+                            processedEntity = await propertyCallbacks.afterRead({
+                                collection: resolvedCollection,
+                                path: notifyPath,
+                                entity: processedEntity,
+                                context: contextForCallback
+                            }) ?? processedEntity;
+                        }
+                        return processedEntity;
+                    }));
+                }
 
-            return fetchFn();
+                return fetchedEntities;
+            });
         }
 
         // No driver — use entityService directly (no auth wrapping possible)
@@ -726,7 +705,7 @@ roles: authContext.roles },
      */
     private async fetchEntityWithAuth(
         notifyPath: string,
-        entityId: string,
+        entityId: string | number,
         authContext?: SubscriptionAuthContext
     ): Promise<Entity | undefined> {
         if (this.driver) {
@@ -737,56 +716,51 @@ roles: authContext.roles },
                 collection
             });
 
-            // If we have auth context, wrap in a transaction with session vars
-            if (authContext) {
-                return await this.db.transaction(async (tx) => {
-                    await tx.execute(drizzleSql`SELECT set_config('app.user_id', ${authContext.userId}, true)`);
-                    await tx.execute(drizzleSql`SELECT set_config('app.user_roles', ${authContext.roles.join(",")}, true)`);
-                    await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: authContext.userId,
-roles: authContext.roles })}, true)`);
-                    const txEntityService = new EntityService(tx, this.registry);
-                    let processedEntity = await txEntityService.fetchEntity(notifyPath, entityId, collection?.databaseId);
-
-                    if (processedEntity) {
-                        const registryCollection = this.registry.getCollectionByPath(notifyPath);
-                        const resolvedCollection = collection ? { ...collection,
+            // Always wrap in a transaction with session vars, defaulting to anonymous context if missing
+            const activeAuth = authContext || { userId: "anon", roles: ["anon"] };
+            return await this.db.transaction(async (tx) => {
+                await tx.execute(drizzleSql`SELECT set_config('app.user_id', ${activeAuth.userId}, true)`);
+                await tx.execute(drizzleSql`SELECT set_config('app.user_roles', ${activeAuth.roles.join(",")}, true)`);
+                await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: activeAuth.userId, roles: activeAuth.roles })}, true)`);
+                const txEntityService = new EntityService(tx, this.registry);
+                let processedEntity = await txEntityService.fetchEntity(notifyPath, entityId, collection?.databaseId);
+
+                if (processedEntity) {
+                    const registryCollection = this.registry.getCollectionByPath(notifyPath);
+                    const resolvedCollection = collection ? { ...collection,
 ...registryCollection } as EntityCollection : registryCollection as EntityCollection;
 
-                        const callbacks = resolvedCollection?.callbacks;
-                        const propertyCallbacks = resolvedCollection?.properties ? buildPropertyCallbacks(resolvedCollection.properties) : undefined;
-
-                        if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
-                            const contextForCallback = {
-                                user: { uid: authContext.userId,
-roles: authContext.roles },
-                                driver: this.driver,
-                                data: this.driver ? (this.driver as unknown as Record<string, unknown>).data : undefined
-                            } as unknown as RebaseCallContext;
-
-                            if (callbacks?.afterRead) {
-                                processedEntity = await callbacks.afterRead({
-                                    collection: resolvedCollection,
-                                    path: notifyPath,
-                                    entity: processedEntity,
-                                    context: contextForCallback
-                                }) ?? processedEntity;
-                            }
-                            if (propertyCallbacks?.afterRead) {
-                                processedEntity = await propertyCallbacks.afterRead({
-                                    collection: resolvedCollection,
-                                    path: notifyPath,
-                                    entity: processedEntity,
-                                    context: contextForCallback
-                                }) ?? processedEntity;
-                            }
+                    const callbacks = resolvedCollection?.callbacks;
+                    const propertyCallbacks = resolvedCollection?.properties ? buildPropertyCallbacks(resolvedCollection.properties) : undefined;
+
+                    if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
+                        const contextForCallback = {
+                            user: { uid: activeAuth.userId, roles: activeAuth.roles },
+                            driver: this.driver,
+                            data: (this.driver && "data" in this.driver) ? (this.driver as DataDriverWithData).data : undefined
+                        } as unknown as RebaseCallContext;
+
+                        if (callbacks?.afterRead) {
+                            processedEntity = await callbacks.afterRead({
+                                collection: resolvedCollection,
+                                path: notifyPath,
+                                entity: processedEntity,
+                                context: contextForCallback
+                            }) ?? processedEntity;
+                        }
+                        if (propertyCallbacks?.afterRead) {
+                            processedEntity = await propertyCallbacks.afterRead({
+                                collection: resolvedCollection,
+                                path: notifyPath,
+                                entity: processedEntity,
+                                context: contextForCallback
+                            }) ?? processedEntity;
                         }
                     }
+                }
 
-                    return processedEntity;
-                });
-            }
-
-            return fetchFn();
+                return processedEntity;
+            });
         }
 
         return await this.entityService.fetchEntity(notifyPath, entityId);
@@ -865,6 +839,41 @@ roles: authContext.roles },
 
         return parentPaths;
     }
+    // =============================================================================
+    // Lifecycle / Cleanup
+    // =============================================================================
+
+    /**
+     * Gracefully tear down all realtime resources.
+     *
+     * This MUST be called during process shutdown, **before** `pool.end()`.
+     * It ensures:
+     *  1. All debounced refetch timers are cancelled (prevents queries after pool closes).
+     *  2. All subscription state and callbacks are cleared.
+     *  3. The dedicated LISTEN client (outside the pool) is disconnected.
+     *  4. All WebSocket clients are removed (but not forcefully closed — the
+     *     HTTP server close will handle that).
+     */
+    async destroy(): Promise<void> {
+        // 1. Cancel every pending debounced refetch timer
+        for (const [key, timer] of this.refetchTimers) {
+            clearTimeout(timer);
+            this.refetchTimers.delete(key);
+        }
+
+        // 2. Clear subscriptions and callbacks
+        this._subscriptions.clear();
+        this.subscriptionCallbacks.clear();
+
+        // 3. Disconnect the dedicated LISTEN client
+        await this.stopListening();
+
+        // 4. Drop client references (don't close — server.close drains them)
+        this.clients.clear();
+
+        this.debugLog("🧹 [RealtimeService] destroy() complete — all resources released.");
+    }
+
     // =============================================================================
     // Cross-Instance LISTEN/NOTIFY
     // =============================================================================

package/src/utils/drizzle-conditions.ts

@@ -1,5 +1,5 @@
 import { and, eq, or, sql, SQL, ilike, inArray } from "drizzle-orm";
-import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
+import { AnyPgColumn, PgTable, PgVarchar, PgText, PgChar } from "drizzle-orm/pg-core";
 import { FilterValues, WhereFilterOp, Relation, JoinStep } from "@rebasepro/types";
 import { getColumnName, resolveCollectionRelations } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
@@ -64,8 +64,14 @@ export class DrizzleConditionBuilder {
     ): SQL | null {
         switch (op) {
             case "==":
+                if (value === null || value === undefined) {
+                    return sql`${column} IS NULL`;
+                }
                 return eq(column, value);
             case "!=":
+                if (value === null || value === undefined) {
+                    return sql`${column} IS NOT NULL`;
+                }
                 return sql`${column} != ${value}`;
             case ">":
                 return sql`${column} > ${value}`;
@@ -647,7 +653,15 @@ export class DrizzleConditionBuilder {
             if (p.type === "string" && !p.enum && p.isId !== "uuid") {
                 const fieldColumn = table[key as keyof typeof table] as AnyPgColumn;
                 if (fieldColumn) {
-                    searchConditions.push(ilike(fieldColumn, `%${searchString}%`));
+                    // Verify that the underlying database column supports string pattern-matching
+                    const supportsILike = 
+                        fieldColumn instanceof PgVarchar || 
+                        fieldColumn instanceof PgText || 
+                        fieldColumn instanceof PgChar ||
+                        (fieldColumn && typeof fieldColumn === "object" && !("columnType" in fieldColumn));
+                    if (supportsILike) {
+                        searchConditions.push(ilike(fieldColumn, `%${searchString}%`));
+                    }
                 }
             }
         }