@rebasepro/server-mongo 0.0.1-canary.4829d6e

package/src/services/MongoHistoryService.ts

@@ -0,0 +1,181 @@
+import { Db, ObjectId } from "mongodb";
+import { logger } from "@rebasepro/server";
+
+/**
+ * Deep equality without JSON.stringify.
+ * Handles primitives, arrays, Dates, and plain objects recursively.
+ */
+function deepEqual(a: unknown, b: unknown): boolean {
+    if (a === b) return true;
+    if (a == null || b == null) return false;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) return false;
+        return a.every((v, i) => deepEqual(v, b[i]));
+    }
+    if (typeof a === "object" && typeof b === "object") {
+        const aObj = a as Record<string, unknown>;
+        const bObj = b as Record<string, unknown>;
+        const aKeys = Object.keys(aObj);
+        const bKeys = Object.keys(bObj);
+        if (aKeys.length !== bKeys.length) return false;
+        return aKeys.every(k => deepEqual(aObj[k], bObj[k]));
+    }
+    return false;
+}
+
+/**
+ * Shallow comparison to find top-level keys that changed between two objects.
+ */
+export function findChangedFields(
+    oldValues: Record<string, unknown>,
+    newValues: Record<string, unknown>
+): string[] | null {
+    const changed: string[] = [];
+    const allKeys = new Set([
+        ...Object.keys(oldValues),
+        ...Object.keys(newValues)
+    ]);
+
+    for (const key of allKeys) {
+        const oldVal = oldValues[key];
+        const newVal = newValues[key];
+
+        // Skip internal metadata
+        if (key.startsWith("__")) continue;
+
+        if (oldVal !== newVal) {
+            // For objects/arrays, use structural comparison
+            if (
+                typeof oldVal === "object" && oldVal !== null &&
+                typeof newVal === "object" && newVal !== null
+            ) {
+                if (!deepEqual(oldVal, newVal)) {
+                    changed.push(key);
+                }
+            } else {
+                changed.push(key);
+            }
+        }
+    }
+
+    return changed.length > 0 ? changed : null;
+}
+
+export interface HistoryEntry {
+    _id?: ObjectId;
+    id: string;
+    table_name: string;
+    entity_id: string;
+    action: "create" | "update" | "delete";
+    changed_fields: string[] | null;
+    values: Record<string, unknown> | null;
+    previous_values: Record<string, unknown> | null;
+    updated_by: string | null;
+    updated_at: Date;
+}
+
+export interface RecordHistoryParams {
+    tableName: string;
+    id: string;
+    action: "create" | "update" | "delete";
+    values?: Record<string, unknown> | null;
+    previousValues?: Record<string, unknown> | null;
+    updatedBy?: string | null;
+}
+
+export interface HistoryRetentionConfig {
+    maxEntries: number;
+    ttlDays: number;
+}
+
+const DEFAULT_RETENTION: HistoryRetentionConfig = {
+    maxEntries: 200,
+    ttlDays: 90
+};
+
+export class MongoHistoryService {
+    public retention: HistoryRetentionConfig;
+
+    constructor(
+        private db: Db,
+        retention?: Partial<HistoryRetentionConfig>
+    ) {
+        this.retention = { ...DEFAULT_RETENTION,
+...retention };
+    }
+
+    async recordHistory(params: RecordHistoryParams): Promise<void> {
+        const {
+            tableName,
+            id,
+            action,
+            values,
+            previousValues,
+            updatedBy
+        } = params;
+
+        const changedFields = previousValues && values
+            ? findChangedFields(previousValues, values)
+            : null;
+
+        if (action === "update" && (!changedFields || changedFields.length === 0)) {
+            return;
+        }
+
+        try {
+            const entry: HistoryEntry = {
+                id: new ObjectId().toString(),
+                table_name: tableName,
+                entity_id: String(id),
+                action,
+                changed_fields: changedFields,
+                values: values || null,
+                previous_values: previousValues || null,
+                updated_by: updatedBy || null,
+                updated_at: new Date()
+            };
+
+            await this.db.collection("__rebase_history").insertOne(entry);
+
+            // Non-blocking prune for this specific row
+            this.pruneHistory(String(id), tableName).catch(e => {
+                logger.error(`[HistoryService] Failed to prune history for ${tableName}/${id}`, { error: e });
+            });
+        } catch (error) {
+            logger.error(`[HistoryService] Failed to record history for ${tableName}/${id}`, { error: error });
+        }
+    }
+
+    private async pruneHistory(id: string, tableName: string): Promise<void> {
+        const collection = this.db.collection("__rebase_history");
+
+        // 1. Enforce maxEntries
+        const count = await collection.countDocuments({ entity_id: id,
+table_name: tableName });
+        if (count > this.retention.maxEntries) {
+            const toDelete = count - this.retention.maxEntries;
+            const oldestEntries = await collection
+                .find({ entity_id: id,
+table_name: tableName })
+                .sort({ updated_at: 1 })
+                .limit(toDelete)
+                .toArray();
+
+            if (oldestEntries.length > 0) {
+                const idsToDelete = oldestEntries.map(entry => entry._id);
+                await collection.deleteMany({ _id: { $in: idsToDelete } });
+            }
+        }
+
+        // 2. Enforce ttlDays
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - this.retention.ttlDays);
+
+        await collection.deleteMany({
+            entity_id: id,
+            table_name: tableName,
+            updated_at: { $lt: cutoffDate }
+        });
+    }
+}

package/src/services/MongoRealtimeService.ts

@@ -0,0 +1,446 @@
+/**
+ * MongoDB Realtime Service
+ *
+ * Implements RealtimeProvider interface using MongoDB Change Streams.
+ * Provides real-time subscriptions to collection and row changes.
+ */
+
+import { Db, ChangeStream, ChangeStreamDocument, Document, ObjectId } from "mongodb";
+import {
+    FilterValues,
+    RealtimeProvider,
+    CollectionSubscriptionConfig,
+    SingleSubscriptionConfig,
+    WebSocketMessage,
+    User
+} from "@rebasepro/types";
+import { WebSocket } from "ws";
+import { MongoDataService } from "../db/MongoDataService";
+
+import { MongoDriver } from "./MongoDriver";
+import { logger } from "@rebasepro/server";
+
+interface Subscription {
+    type: "collection" | "single";
+    config: CollectionSubscriptionConfig | SingleSubscriptionConfig;
+    changeStream?: ChangeStream;
+    callback?: (data: any) => void;
+    authContext?: { userId: string; roles: string[] };
+}
+
+/**
+ * MongoDB Realtime Service
+ *
+ * Implements real-time subscriptions using MongoDB Change Streams.
+ * Requires MongoDB replica set for change streams to work.
+ */
+export class MongoRealtimeService implements RealtimeProvider {
+    private subscriptions = new Map<string, Subscription>();
+    private clients = new Map<string, WebSocket>();
+    private dataService: MongoDataService;
+    private driver?: MongoDriver;
+
+    constructor(private db: Db) {
+        this.dataService = new MongoDataService(db);
+    }
+
+    setDataDriver(driver: MongoDriver) {
+        this.driver = driver;
+    }
+
+    /**
+     * Get the collection name from a path
+     */
+    private getCollectionName(path: string): string {
+        return path.replace(/\//g, "_");
+    }
+
+    /**
+     * Subscribe to collection changes
+     */
+    subscribeToCollection(
+        subscriptionId: string,
+        config: CollectionSubscriptionConfig & { authContext?: { userId: string; roles: string[] } },
+        callback?: (rows: Record<string, unknown>[]) => void
+    ): void {
+        // Clean up existing subscription if any
+        this.unsubscribe(subscriptionId);
+
+        const collectionName = this.getCollectionName(config.path);
+        const collection = this.db.collection(collectionName);
+
+        // Build pipeline for change stream filtering
+        const pipeline: Document[] = [];
+
+        // Filter by operation types we care about
+        pipeline.push({
+            $match: {
+                operationType: { $in: ["insert", "update", "replace", "delete"] }
+            }
+        });
+
+        try {
+            // Create change stream
+            const changeStream = collection.watch(pipeline, {
+                fullDocument: "updateLookup"
+            });
+
+            const subscription: Subscription = {
+                type: "collection",
+                config,
+                changeStream,
+                callback,
+                authContext: config.authContext
+            };
+
+            this.subscriptions.set(subscriptionId, subscription);
+
+            // Fetch initial data
+            this.fetchAndNotifyCollection(subscriptionId, config, callback);
+
+            // Listen for changes
+            changeStream.on("change", async (change: ChangeStreamDocument) => {
+                // Re-fetch the entire collection when any change happens
+                // This is simpler and ensures consistent sorting/filtering
+                await this.fetchAndNotifyCollection(subscriptionId, config, callback);
+            });
+
+            changeStream.on("error", (error: Error) => {
+                logger.error(`Change stream error for subscription ${subscriptionId}`, { error: error });
+            });
+
+        } catch (error) {
+            // Change streams might not be available (e.g., standalone MongoDB)
+            logger.warn("Change streams not available, falling back to polling", { error: error });
+
+            // Store subscription without change stream for manual notifications
+            const subscription: Subscription = {
+                type: "collection",
+                config,
+                callback,
+                authContext: config.authContext
+            };
+
+            this.subscriptions.set(subscriptionId, subscription);
+
+            // Fetch initial data
+            this.fetchAndNotifyCollection(subscriptionId, config, callback);
+        }
+    }
+
+    /**
+     * Fetch collection and notify callback
+     */
+    private async fetchAndNotifyCollection(
+        subscriptionId: string,
+        config: CollectionSubscriptionConfig & { authContext?: { userId: string; roles: string[] } },
+        callback?: (rows: Record<string, unknown>[]) => void
+    ): Promise<void> {
+        try {
+            let rows;
+            const registryCollection = this.driver?.registry?.getCollectionByPath(config.path);
+
+            if (config.authContext && this.driver) {
+                const mockUser = { uid: config.authContext.userId,
+roles: config.authContext.roles } as User;
+                const authenticatedDriver = await this.driver.withAuth(mockUser);
+                rows = await authenticatedDriver.fetchCollection({
+                    path: config.path,
+                    collection: registryCollection,
+                    filter: config.filter as FilterValues<string> | undefined,
+                    orderBy: config.orderBy,
+                    order: config.order,
+                    limit: config.limit,
+                    startAfter: config.startAfter,
+                    searchString: config.searchString
+                });
+            } else {
+                rows = await this.dataService.fetchCollection(config.path, {
+                    filter: config.filter as FilterValues<string> | undefined,
+                    orderBy: config.orderBy,
+                    order: config.order,
+                    limit: config.limit,
+                    startAfter: config.startAfter,
+                    searchString: config.searchString,
+                    collection: registryCollection
+                });
+            }
+
+            if (callback) {
+                callback(rows);
+            }
+        } catch (error) {
+            logger.error(`Error fetching collection for subscription ${subscriptionId}`, { error: error });
+        }
+    }
+
+    /**
+     * Subscribe to single row changes
+     */
+    subscribeToOne(
+        subscriptionId: string,
+        config: SingleSubscriptionConfig & { authContext?: { userId: string; roles: string[] } },
+        callback?: (row: Record<string, unknown> | null) => void
+    ): void {
+        // Clean up existing subscription if any
+        this.unsubscribe(subscriptionId);
+
+        const collectionName = this.getCollectionName(config.path);
+        const collection = this.db.collection(collectionName);
+
+        // Build pipeline to watch specific document
+        const id = typeof config.id === "string" && ObjectId.isValid(config.id)
+            ? new ObjectId(config.id)
+            : config.id;
+
+        const pipeline: Document[] = [
+            {
+                $match: {
+                    "documentKey._id": id,
+                    operationType: { $in: ["insert", "update", "replace", "delete"] }
+                }
+            }
+        ];
+
+        try {
+            const changeStream = collection.watch(pipeline, {
+                fullDocument: "updateLookup"
+            });
+
+            const subscription: Subscription = {
+                type: "single",
+                config,
+                changeStream,
+                callback,
+                authContext: config.authContext
+            };
+
+            this.subscriptions.set(subscriptionId, subscription);
+
+            // Fetch initial data
+            this.fetchAndNotifyOne(subscriptionId, config, callback);
+
+            // Listen for changes
+            changeStream.on("change", async (change: ChangeStreamDocument) => {
+                if (change.operationType === "delete") {
+                    if (callback) {
+                        callback(null);
+                    }
+                } else {
+                    await this.fetchAndNotifyOne(subscriptionId, config, callback);
+                }
+            });
+
+            changeStream.on("error", (error: Error) => {
+                logger.error(`Change stream error for subscription ${subscriptionId}`, { error: error });
+            });
+
+        } catch (error) {
+            logger.warn("Change streams not available, falling back to polling", { error: error });
+
+            const subscription: Subscription = {
+                type: "single",
+                config,
+                callback,
+                authContext: config.authContext
+            };
+
+            this.subscriptions.set(subscriptionId, subscription);
+
+            // Fetch initial data
+            this.fetchAndNotifyOne(subscriptionId, config, callback);
+        }
+    }
+
+    /**
+     * Fetch row and notify callback
+     */
+    private async fetchAndNotifyOne(
+        subscriptionId: string,
+        config: SingleSubscriptionConfig & { authContext?: { userId: string; roles: string[] } },
+        callback?: (row: Record<string, unknown> | null) => void
+    ): Promise<void> {
+        try {
+            let row;
+            const registryCollection = this.driver?.registry?.getCollectionByPath(config.path);
+
+            if (config.authContext && this.driver) {
+                const mockUser = { uid: config.authContext.userId,
+roles: config.authContext.roles } as User;
+                const authenticatedDriver = await this.driver.withAuth(mockUser);
+                row = await authenticatedDriver.fetchOne({
+                    path: config.path,
+                    id: config.id,
+                    collection: registryCollection
+                });
+            } else {
+                row = await this.dataService.fetchOne(config.path, config.id);
+            }
+
+            if (callback) {
+                callback(row || null);
+            }
+        } catch (error) {
+            logger.error(`Error fetching row for subscription ${subscriptionId}`, { error: error });
+        }
+    }
+
+    /**
+     * Unsubscribe from a subscription
+     */
+    unsubscribe(subscriptionId: string): void {
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (subscription) {
+            if (subscription.changeStream) {
+                subscription.changeStream.close().catch((err) => logger.error("Operation failed", { error: err }));
+            }
+            this.subscriptions.delete(subscriptionId);
+        }
+    }
+
+    /**
+     * Notify all relevant subscribers of an row update
+     * This is called after save/delete operations to push updates
+     */
+    async notifyUpdate(
+        path: string,
+        id: string,
+        row: Record<string, unknown> | null,
+        _databaseId?: string
+    ): Promise<void> {
+        // Find all subscriptions that might be affected by this update
+        for (const [subscriptionId, subscription] of this.subscriptions) {
+            if (subscription.type === "single") {
+                const config = subscription.config as SingleSubscriptionConfig;
+                if (config.path === path && config.id.toString() === id) {
+                    if (subscription.callback) {
+                        subscription.callback(row);
+                    }
+                }
+            } else if (subscription.type === "collection") {
+                const config = subscription.config as CollectionSubscriptionConfig;
+                if (config.path === path) {
+                    // Re-fetch the collection to get updated data
+                    await this.fetchAndNotifyCollection(subscriptionId, config, subscription.callback);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get all active subscriptions (for debugging)
+     */
+    getSubscriptions(): Map<string, Subscription> {
+        return this.subscriptions;
+    }
+
+    /**
+     * Close all subscriptions
+     */
+    async closeAll(): Promise<void> {
+        for (const [subscriptionId] of this.subscriptions) {
+            this.unsubscribe(subscriptionId);
+        }
+    }
+
+    // =============================================================================
+    // WebSocket Client Management (parity with PostgreSQL RealtimeService)
+    // =============================================================================
+
+    /**
+     * Register a WebSocket client for real-time communication
+     */
+    addClient(clientId: string, ws: WebSocket) {
+        this.clients.set(clientId, ws);
+
+        ws.on("close", () => {
+            this.removeClient(clientId);
+        });
+
+        ws.on("error", (error) => {
+            logger.error("WebSocket error for client", { detail: clientId, error });
+            this.removeClient(clientId);
+        });
+    }
+
+    /**
+     * Remove a WebSocket client and clean up its subscriptions
+     */
+    private removeClient(clientId: string) {
+        this.clients.delete(clientId);
+    }
+
+    /**
+     * Handle an incoming WebSocket message for subscription management
+     */
+    async handleClientMessage(
+        clientId: string,
+        message: { type: string; payload?: any; subscriptionId?: string },
+        _authContext?: { userId: string; roles: unknown[] }
+    ): Promise<void> {
+        const ws = this.clients.get(clientId);
+        if (!ws) return;
+
+        const authContext = _authContext ? { userId: _authContext.userId,
+roles: (_authContext.roles ?? []).map(String) } : undefined;
+
+        switch (message.type) {
+            case "subscribe_collection": {
+                const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+                if (!subscriptionId) return;
+
+                this.subscribeToCollection(
+                    subscriptionId,
+                    {
+                        clientId,
+                        path: message.payload?.path,
+                        filter: message.payload?.filter,
+                        orderBy: message.payload?.orderBy,
+                        order: message.payload?.order,
+                        limit: message.payload?.limit,
+                        startAfter: message.payload?.startAfter,
+                        searchString: message.payload?.searchString,
+                        authContext
+                    },
+                    (rows) => {
+                        ws.send(JSON.stringify({
+                            type: "collection_update",
+                            subscriptionId,
+                            rows
+                        }));
+                    }
+                );
+                break;
+            }
+            case "subscribe_one": {
+                const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+                if (!subscriptionId) return;
+
+                this.subscribeToOne(
+                    subscriptionId,
+                    {
+                        clientId,
+                        path: message.payload?.path,
+                        id: message.payload?.id,
+                        authContext
+                    },
+                    (row) => {
+                        ws.send(JSON.stringify({
+                            type: "single_update",
+                            subscriptionId,
+                            row
+                        }));
+                    }
+                );
+                break;
+            }
+            case "unsubscribe": {
+                const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+                if (subscriptionId) {
+                    this.unsubscribe(subscriptionId);
+                }
+                break;
+            }
+        }
+    }
+}