@rebasepro/server-postgresql 0.2.1 → 0.2.4

package/src/services/realtimeService.ts

@@ -41,6 +41,14 @@ type RealTimeListenEntityProps = ListenEntityProps & { subscriptionId: string };
  */
 export class RealtimeService extends EventEmitter implements RealtimeProvider {
     private clients = new Map<string, WebSocket>();
+
+    // Broadcast channels: channel name → set of client IDs
+    private channels = new Map<string, Set<string>>();
+
+    // Presence: channel → Map<clientId, { state, lastSeen }>
+    private presence = new Map<string, Map<string, { state: Record<string, unknown>; lastSeen: number }>>();
+    private presenceInterval?: ReturnType<typeof setInterval>;
+    private static readonly PRESENCE_TIMEOUT_MS = 30000; // 30s
     private entityService: EntityService;
     // Enhanced subscriptions storage with full request parameters
     private _subscriptions = new Map<string, {
@@ -237,9 +245,24 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 }
             }
         }
+
+        // Remove from all broadcast channels
+        for (const [channel, members] of this.channels.entries()) {
+            if (members.has(clientId)) {
+                members.delete(clientId);
+                this.removePresence(clientId, channel);
+                if (members.size === 0) this.channels.delete(channel);
+            }
+        }
+
+        // Remove from all presence channels
+        for (const [channel] of this.presence) {
+            this.removePresence(clientId, channel);
+        }
     }
 
     private async handleMessage(clientId: string, message: WebSocketMessage, authContext?: SubscriptionAuthContext) {
+        const payload = message.payload as Record<string, unknown> | undefined;
         switch (message.type) {
             case "subscribe_collection":
                 await this.handleCollectionSubscription(clientId, message.payload as RealTimeListenCollectionProps, authContext);
@@ -250,6 +273,40 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             case "unsubscribe":
                 await this.handleUnsubscribe(clientId, message.subscriptionId!);
                 break;
+
+            // ── Broadcast Channels ──
+            case "join_channel":
+                this.joinChannel(clientId, payload?.channel as string);
+                break;
+            case "leave_channel":
+                this.leaveChannel(clientId, payload?.channel as string);
+                break;
+            case "broadcast":
+                this.broadcastToChannel(
+                    clientId,
+                    payload?.channel as string,
+                    payload?.event as string,
+                    payload?.payload
+                );
+                break;
+
+            // ── Presence ──
+            case "presence_track":
+                // Auto-join the channel so presence works without a separate join
+                this.joinChannel(clientId, payload?.channel as string);
+                this.trackPresence(
+                    clientId,
+                    payload?.channel as string,
+                    payload?.state as Record<string, unknown> ?? {}
+                );
+                break;
+            case "presence_untrack":
+                this.removePresence(clientId, payload?.channel as string);
+                break;
+            case "presence_state":
+                this.sendPresenceState(clientId, payload?.channel as string);
+                break;
+
             default:
                 this.sendError(clientId, "Unknown message type " + message.type, message.subscriptionId);
         }
@@ -839,6 +896,153 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
 
         return parentPaths;
     }
+
+    // =============================================================================
+    // Broadcast Channels
+    // =============================================================================
+
+    /** Join a broadcast channel */
+    joinChannel(clientId: string, channel: string): void {
+        if (!this.channels.has(channel)) {
+            this.channels.set(channel, new Set());
+        }
+        this.channels.get(channel)!.add(clientId);
+        this.debugLog(`📡 [Broadcast] Client ${clientId} joined channel: ${channel}`);
+    }
+
+    /** Leave a broadcast channel */
+    leaveChannel(clientId: string, channel: string): void {
+        const members = this.channels.get(channel);
+        if (members) {
+            members.delete(clientId);
+            if (members.size === 0) this.channels.delete(channel);
+        }
+        // Also remove presence
+        this.removePresence(clientId, channel);
+    }
+
+    /** Broadcast a message to all clients in a channel except sender */
+    broadcastToChannel(clientId: string, channel: string, event: string, payload: unknown): void {
+        const members = this.channels.get(channel);
+        if (!members) return;
+
+        const message = JSON.stringify({
+            type: "broadcast",
+            channel,
+            event,
+            payload
+        });
+
+        for (const memberId of members) {
+            if (memberId === clientId) continue; // Don't echo back to sender
+            const ws = this.clients.get(memberId);
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(message);
+            }
+        }
+    }
+
+    // =============================================================================
+    // Presence
+    // =============================================================================
+
+    /** Track presence in a channel */
+    trackPresence(clientId: string, channel: string, state: Record<string, unknown>): void {
+        if (!this.presence.has(channel)) {
+            this.presence.set(channel, new Map());
+        }
+
+        const channelPresence = this.presence.get(channel)!;
+        channelPresence.set(clientId, { state, lastSeen: Date.now() });
+
+        // Broadcast join / state update to channel
+        this.broadcastPresenceDiff(channel, { [clientId]: state }, {});
+
+        // Start cleanup interval if not running
+        this.ensurePresenceCleanup();
+    }
+
+    /** Remove presence from a channel */
+    removePresence(clientId: string, channel: string): void {
+        const channelPresence = this.presence.get(channel);
+        if (!channelPresence) return;
+
+        const entry = channelPresence.get(clientId);
+        if (entry) {
+            channelPresence.delete(clientId);
+            this.broadcastPresenceDiff(channel, {}, { [clientId]: entry.state });
+        }
+
+        if (channelPresence.size === 0) {
+            this.presence.delete(channel);
+        }
+    }
+
+    /** Send full presence state to a specific client */
+    sendPresenceState(clientId: string, channel: string): void {
+        const channelPresence = this.presence.get(channel);
+        const presences: Record<string, Record<string, unknown>> = {};
+
+        if (channelPresence) {
+            for (const [id, { state }] of channelPresence) {
+                presences[id] = state;
+            }
+        }
+
+        const ws = this.clients.get(clientId);
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                type: "presence_state",
+                channel,
+                presences
+            }));
+        }
+    }
+
+    /** Broadcast presence diff (joins/leaves) to channel */
+    private broadcastPresenceDiff(
+        channel: string,
+        joins: Record<string, Record<string, unknown>>,
+        leaves: Record<string, Record<string, unknown>>
+    ): void {
+        const members = this.channels.get(channel);
+        if (!members) return;
+
+        const message = JSON.stringify({
+            type: "presence_diff",
+            channel,
+            joins,
+            leaves
+        });
+
+        for (const memberId of members) {
+            const ws = this.clients.get(memberId);
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(message);
+            }
+        }
+    }
+
+    /** Periodic cleanup for stale presences */
+    private ensurePresenceCleanup(): void {
+        if (this.presenceInterval) return;
+        this.presenceInterval = setInterval(() => {
+            const now = Date.now();
+            for (const [channel, channelPresence] of this.presence) {
+                for (const [clientId, entry] of channelPresence) {
+                    if (now - entry.lastSeen > RealtimeService.PRESENCE_TIMEOUT_MS) {
+                        this.removePresence(clientId, channel);
+                    }
+                }
+            }
+            // Stop interval if no presences tracked
+            if (this.presence.size === 0 && this.presenceInterval) {
+                clearInterval(this.presenceInterval);
+                this.presenceInterval = undefined;
+            }
+        }, 10000); // Check every 10s
+    }
+
     // =============================================================================
     // Lifecycle / Cleanup
     // =============================================================================
@@ -865,10 +1069,18 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         this._subscriptions.clear();
         this.subscriptionCallbacks.clear();
 
-        // 3. Disconnect the dedicated LISTEN client
+        // 3. Clear broadcast channels and presence
+        this.channels.clear();
+        this.presence.clear();
+        if (this.presenceInterval) {
+            clearInterval(this.presenceInterval);
+            this.presenceInterval = undefined;
+        }
+
+        // 4. Disconnect the dedicated LISTEN client
         await this.stopListening();
 
-        // 4. Drop client references (don't close — server.close drains them)
+        // 5. Drop client references (don't close — server.close drains them)
         this.clients.clear();
 
         this.debugLog("🧹 [RealtimeService] destroy() complete — all resources released.");

package/src/utils/drizzle-conditions.ts

@@ -38,7 +38,15 @@ export class DrizzleConditionBuilder {
             if (!filterParam) continue;
 
             const [op, value] = filterParam as [WhereFilterOp, any];
-            const fieldColumn = table[field as keyof typeof table] as AnyPgColumn;
+            let fieldColumn = table[field as keyof typeof table] as AnyPgColumn;
+
+            if (!fieldColumn) {
+                // Fallback for relations (e.g. project -> project_id)
+                const relationKey = `${field}_id`;
+                if (relationKey in table) {
+                    fieldColumn = table[relationKey as keyof typeof table] as AnyPgColumn;
+                }
+            }
 
             if (!fieldColumn) {
                 console.warn(`Filtering by field '${field}', but it does not exist in table for collection '${collectionPath}'`);
@@ -87,8 +95,22 @@ export class DrizzleConditionBuilder {
                 }
                 return null;
             case "array-contains":
-                // For JSONB arrays
+                // For JSONB arrays: checks if the column contains the given value
+                return sql`${column} @> ${JSON.stringify([value])}`;
+            case "array-contains-any":
+                // For JSONB arrays: checks if the column contains any of the given values
+                if (Array.isArray(value) && value.length > 0) {
+                    // Use the ?| operator for JSONB overlap with text array
+                    const textValues = value.map(v => String(v));
+                    return sql`${column} ?| array[${sql.join(textValues.map(v => sql`${v}`), sql`, `)}]`;
+                }
+                // Single value fallback: treat as array-contains
                 return sql`${column} @> ${JSON.stringify([value])}`;
+            case "not-in":
+                if (Array.isArray(value) && value.length > 0) {
+                    return sql`${column} NOT IN (${sql.join(value.map(v => sql`${v}`), sql`, `)})`;
+                }
+                return null;
             default:
                 console.warn(`Unsupported filter operation: ${op}`);
                 return null;
@@ -1005,6 +1027,55 @@ export class DrizzleConditionBuilder {
             return null;
         }
     }
+
+    /**
+     * Build vector similarity search expressions for pgvector.
+     *
+     * Returns:
+     * - `orderBy`: SQL expression to ORDER BY distance (ascending = closest first)
+     * - `filter`: optional WHERE clause for distance threshold
+     * - `distanceSelect`: SQL expression for selecting the distance as `_distance`
+     */
+    static buildVectorSearchConditions(
+        table: PgTable<any>,
+        vectorSearch: {
+            property: string;
+            vector: number[];
+            distance?: "cosine" | "l2" | "inner_product";
+            threshold?: number;
+        }
+    ): { orderBy: SQL; filter?: SQL; distanceSelect: SQL } {
+        const column = table[vectorSearch.property as keyof typeof table] as AnyPgColumn;
+        if (!column) {
+            throw new Error(`Vector column '${vectorSearch.property}' not found in table`);
+        }
+
+        const vectorLiteral = `'[${vectorSearch.vector.join(",")}]'::vector`;
+        const distanceFn = vectorSearch.distance || "cosine";
+
+        let operator: string;
+        switch (distanceFn) {
+            case "cosine":
+                operator = "<=>";
+                break;
+            case "l2":
+                operator = "<->";
+                break;
+            case "inner_product":
+                operator = "<#>";
+                break;
+        }
+
+        const distanceExpr = sql`${column} ${sql.raw(operator)} ${sql.raw(vectorLiteral)}`;
+
+        return {
+            orderBy: distanceExpr,
+            filter: vectorSearch.threshold != null
+                ? sql`(${column} ${sql.raw(operator)} ${sql.raw(vectorLiteral)}) < ${vectorSearch.threshold}`
+                : undefined,
+            distanceSelect: sql`(${column} ${sql.raw(operator)} ${sql.raw(vectorLiteral)})`,
+        };
+    }
 }
 
 /**
@@ -1012,3 +1083,4 @@ export class DrizzleConditionBuilder {
  * This allows code to use PostgresConditionBuilder alongside future MongoConditionBuilder, etc.
  */
 export const PostgresConditionBuilder = DrizzleConditionBuilder;
+

package/src/websocket.ts

@@ -550,8 +550,16 @@ colors: true }));
                     // Route subscription messages to RealtimeService
                     case "subscribe_collection":
                     case "subscribe_entity":
-                    case "unsubscribe": {
-                        wsDebug("🔄 [WebSocket Server] Routing subscription message to RealtimeService:", type);
+                    case "unsubscribe":
+                    // Broadcast channels
+                    case "join_channel":
+                    case "leave_channel":
+                    case "broadcast":
+                    // Presence
+                    case "presence_track":
+                    case "presence_untrack":
+                    case "presence_state": {
+                        wsDebug("🔄 [WebSocket Server] Routing realtime message to RealtimeService:", type);
                         // Attach auth context from the WS session so RLS-aware refetches work
                         const session = clientSessions.get(clientId);
                         const authContext = session?.user

package/test/auth-services.test.ts

@@ -37,6 +37,7 @@ function mockUserData(overrides: Partial<UserData>): UserData {
         createdAt: expect.any(Date),
         updatedAt: expect.any(Date),
         metadata: {},
+        isAnonymous: false,
         ...overrides
     };
 }
@@ -348,14 +349,12 @@ describe("Auth Services", () => {
                             name: "Admin",
                             is_admin: true,
                             default_permissions: null,
-                            collection_permissions: null,
-                            config: null },
+                            collection_permissions: null },
                         { id: "editor",
                             name: "Editor",
                             is_admin: false,
                             default_permissions: { edit: true },
-                            collection_permissions: null,
-                            config: null }
+                            collection_permissions: null }
                     ]
                 });
 
@@ -367,8 +366,7 @@ describe("Auth Services", () => {
                     name: "Admin",
                     isAdmin: true,
                     defaultPermissions: null,
-                    collectionPermissions: null,
-                    config: null
+                    collectionPermissions: null
                 });
             });
         });
@@ -381,8 +379,7 @@ describe("Auth Services", () => {
                             name: "Admin",
                             is_admin: true,
                             default_permissions: null,
-                            collection_permissions: null,
-                            config: null }
+                            collection_permissions: null }
                     ]
                 });
 
@@ -426,8 +423,7 @@ describe("Auth Services", () => {
                         name: "Admin",
                         is_admin: true,
                         default_permissions: null,
-                        collection_permissions: null,
-                        config: null }]
+                        collection_permissions: null }]
                 });
 
                 const result = await userService.getUserWithRoles("user-123");
@@ -438,8 +434,7 @@ describe("Auth Services", () => {
                         name: "Admin",
                         isAdmin: true,
                         defaultPermissions: null,
-                        collectionPermissions: null,
-                        config: null }]
+                        collectionPermissions: null }]
                 });
             });
 
@@ -491,8 +486,7 @@ describe("Auth Services", () => {
 name: "Admin",
 is_admin: true,
 default_permissions: null,
-collection_permissions: null,
-config: null }]
+collection_permissions: null }]
                 });
 
                 const result = await roleService.getRoleById("admin");
@@ -502,8 +496,7 @@ config: null }]
                     name: "Admin",
                     isAdmin: true,
                     defaultPermissions: null,
-                    collectionPermissions: null,
-                    config: null
+                    collectionPermissions: null
                 });
             });
 
@@ -524,14 +517,12 @@ config: null }]
 name: "Admin",
 is_admin: true,
 default_permissions: null,
-collection_permissions: null,
-config: null },
+collection_permissions: null },
                         { id: "editor",
 name: "Editor",
 is_admin: false,
 default_permissions: null,
-collection_permissions: null,
-config: null }
+collection_permissions: null }
                     ]
                 });
 
@@ -548,15 +539,13 @@ config: null }
 name: "Custom Role",
 is_admin: false,
 default_permissions: null,
-collection_permissions: null,
-config: null }]
+collection_permissions: null }]
                 });
 
                 const role = await roleService.createRole({
                     id: "custom",
                     name: "Custom Role",
-                    defaultPermissions: null,
-                    config: null
+                    defaultPermissions: null
                 });
 
                 expect(role.id).toBe("custom");
@@ -571,15 +560,13 @@ config: null }]
 name: "Admin",
 is_admin: true,
 default_permissions: null,
-collection_permissions: null,
-config: null }] })
+collection_permissions: null }] })
                     .mockResolvedValueOnce({ rows: [] })
                     .mockResolvedValueOnce({ rows: [{ id: "admin",
 name: "Super Admin",
 is_admin: true,
 default_permissions: null,
-collection_permissions: null,
-config: null }] });
+collection_permissions: null }] });
 
                 const result = await roleService.updateRole("admin", { name: "Super Admin" });
 

package/test/drizzle-conditions.test.ts

@@ -893,3 +893,171 @@ describe("DrizzleConditionBuilder - Many-to-Many Relations", () => {
         });
     });
 });
+
+describe("DrizzleConditionBuilder - Filter Operators", () => {
+    // Mock table for filter tests
+    const mockUsersTable = pgTable("users", {
+        id: serial("id").primaryKey(),
+        name: varchar("name").notNull(),
+        email: varchar("email").notNull(),
+        age: integer("age")
+    });
+
+    describe("buildSingleFilterCondition - array-contains", () => {
+        it("should generate a non-null condition for a single value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "array-contains",
+                "featured"
+            );
+            expect(condition).not.toBeNull();
+        });
+    });
+
+    describe("buildSingleFilterCondition - array-contains-any", () => {
+        it("should generate a non-null condition for an array of values", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "array-contains-any",
+                ["featured", "popular", "trending"]
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should fallback to array-contains for a single (non-array) value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "array-contains-any",
+                "featured"
+            );
+            expect(condition).not.toBeNull();
+        });
+    });
+
+    describe("buildSingleFilterCondition - not-in", () => {
+        it("should generate a non-null condition for an array of values", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "not-in",
+                [1, 2, 3]
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should return null for empty array", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "not-in",
+                []
+            );
+            expect(condition).toBeNull();
+        });
+
+        it("should return null for non-array value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "not-in",
+                42
+            );
+            expect(condition).toBeNull();
+        });
+    });
+
+    describe("buildSingleFilterCondition - existing operators", () => {
+        it("should generate a condition for equality", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "==",
+                "alice"
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should generate IS NULL for equality with null", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "==",
+                null
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should generate IS NOT NULL for inequality with null", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "!=",
+                null
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should handle in operator with array", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "in",
+                [18, 21, 25]
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should return null for in operator with empty array", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "in",
+                []
+            );
+            expect(condition).toBeNull();
+        });
+
+        it("should warn and return null for unsupported operators", () => {
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "unknown-op" as any,
+                42
+            );
+            expect(condition).toBeNull();
+            expect(warnSpy).toHaveBeenCalledWith("Unsupported filter operation: unknown-op");
+            warnSpy.mockRestore();
+        });
+    });
+
+    describe("buildFilterConditions - integration with array operators", () => {
+        it("should build filter with array-contains operator", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { name: ["array-contains", "featured"] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(1);
+        });
+
+        it("should build filter with array-contains-any operator", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { name: ["array-contains-any", ["featured", "popular"]] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(1);
+        });
+
+        it("should build filter with not-in operator", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { age: ["not-in", [1, 2, 3]] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(1);
+        });
+
+        it("should skip not-in filter with empty array", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { age: ["not-in", []] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(0);
+        });
+    });
+});
+