@rebasepro/server-mongodb 0.0.1-canary.09e5ec5

package/src/services/MongoDriver.ts.backup

@@ -0,0 +1,266 @@
+/**
+ * MongoDB DataDriver Delegate
+ *
+ * Implements the DataDriver interface for Rebase frontend integration.
+ * This is the main entry point for Rebase to interact with MongoDB.
+ */
+
+import { Db, ObjectId } from "mongodb";
+import {
+    DataDriver,
+    DeleteEntityProps,
+    Entity,
+    EntityCollection,
+    FetchCollectionProps,
+    FetchEntityProps,
+    ListenCollectionProps,
+    ListenEntityProps,
+    SaveEntityProps
+} from "@rebasepro/types";
+import { MongoEntityService } from "../db/MongoEntityService";
+import { MongoRealtimeService } from "./MongoRealtimeService";
+
+/**
+ * MongoDB DataDriver Delegate
+ *
+ * Implements the DataDriver interface for Rebase.
+ * Provides all data operations needed by the Rebase frontend.
+ */
+export class MongoDriver implements DataDriver {
+    key = "mongodb";
+    initialised = true;
+
+    private entityService: MongoEntityService;
+    private realtimeService: MongoRealtimeService;
+
+
+    constructor(
+        private db: Db,
+        realtimeService?: MongoRealtimeService
+    ) {
+        this.entityService = new MongoEntityService(db);
+        this.realtimeService = realtimeService ?? new MongoRealtimeService(db);
+    }
+
+
+    /**
+     * Get the current timestamp
+     */
+    currentTime(): Date {
+        return new Date();
+    }
+
+    /**
+     * Fetch a collection of entities
+     */
+    async fetchCollection<M extends Record<string, any>>({
+        path,
+        collection,
+        filter,
+        limit,
+        startAfter,
+        orderBy,
+        searchString,
+        order
+    }: FetchCollectionProps<M>): Promise<Entity<M>[]> {
+        return this.entityService.fetchCollection<M>(path, {
+            filter,
+            limit,
+            startAfter,
+            orderBy,
+            order,
+            searchString,
+            collection: collection as unknown as EntityCollection
+        });
+    }
+
+    /**
+     * Listen to collection changes
+     */
+    listenCollection<M extends Record<string, any>>({
+        path,
+        collection,
+        filter,
+        limit,
+        startAfter,
+        orderBy,
+        searchString,
+        order,
+        onUpdate,
+        onError
+    }: ListenCollectionProps<M>): () => void {
+        const subscriptionId = this.generateSubscriptionId();
+
+        const callback = (entities: Entity<any>[]) => {
+            try {
+                onUpdate(entities as Entity<M>[]);
+            } catch (error) {
+                console.error("Error in collection update callback:", error);
+                if (onError) {
+                    onError(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        };
+
+        this.realtimeService.subscribeToCollection(
+            subscriptionId,
+            {
+                clientId: "driver",
+                path,
+                filter,
+                orderBy,
+                order,
+                limit,
+                startAfter,
+                searchString
+            },
+            callback
+        );
+
+        // Return unsubscribe function
+        return () => {
+            this.realtimeService.unsubscribe(subscriptionId);
+        };
+    }
+
+    /**
+     * Fetch a single entity
+     */
+    async fetchEntity<M extends Record<string, any>>({
+        path,
+        entityId,
+        databaseId,
+        collection
+    }: FetchEntityProps<M>): Promise<Entity<M> | undefined> {
+        return this.entityService.fetchEntity<M>(path, entityId, databaseId);
+    }
+
+    /**
+     * Listen to entity changes
+     */
+    listenEntity<M extends Record<string, any>>({
+        path,
+        entityId,
+        collection,
+        onUpdate,
+        onError
+    }: ListenEntityProps<M>): () => void {
+        const subscriptionId = this.generateSubscriptionId();
+
+        const callback = (entity: Entity<any> | null) => {
+            try {
+                onUpdate(entity as Entity<M>);
+            } catch (error) {
+                console.error("Error in entity update callback:", error);
+                if (onError) {
+                    onError(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        };
+
+        this.realtimeService.subscribeToEntity(
+            subscriptionId,
+            {
+                clientId: "driver",
+                path,
+                entityId
+            },
+            callback
+        );
+
+        // Return unsubscribe function
+        return () => {
+            this.realtimeService.unsubscribe(subscriptionId);
+        };
+    }
+
+    /**
+     * Save an entity (create or update)
+     */
+    async saveEntity<M extends Record<string, any>>({
+        path,
+        entityId,
+        values,
+        collection,
+        status
+    }: SaveEntityProps<M>): Promise<Entity<M>> {
+        const entity = await this.entityService.saveEntity<M>(path, values, entityId);
+
+        // Notify subscribers of the update
+        await this.realtimeService.notifyEntityUpdate(path, String(entity.id), entity);
+
+        return entity;
+    }
+
+    /**
+     * Delete an entity
+     */
+    async deleteEntity<M extends Record<string, any>>({
+        entity,
+        collection
+    }: DeleteEntityProps<M>): Promise<void> {
+        await this.entityService.deleteEntity(entity.path, entity.id);
+
+        // Notify subscribers of the deletion
+        await this.realtimeService.notifyEntityUpdate(entity.path, String(entity.id), null);
+    }
+
+    /**
+     * Check if a field value is unique
+     */
+    async checkUniqueField(
+        path: string,
+        name: string,
+        value: any,
+        entityId?: string,
+        collection?: EntityCollection
+    ): Promise<boolean> {
+        return this.entityService.checkUniqueField(path, name, value, entityId);
+    }
+
+    /**
+     * Generate a new entity ID
+     */
+    generateEntityId(path: string, collection?: EntityCollection): string {
+        return this.entityService.generateEntityId();
+    }
+
+    /**
+     * Count entities in a collection
+     */
+    async countEntities<M extends Record<string, any>>({
+        path,
+        collection,
+        filter
+    }: FetchCollectionProps<M>): Promise<number> {
+        return this.entityService.countEntities<M>(path, { filter });
+    }
+
+    /**
+     * Generate a unique subscription ID
+     */
+    private generateSubscriptionId(): string {
+        return `mongo_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+
+    /**
+     * Check if the delegate is ready
+     */
+    isReady(): boolean {
+        return this.initialised;
+    }
+
+    /**
+     * Get the underlying entity service for direct access
+     */
+    getEntityService(): MongoEntityService {
+        return this.entityService;
+    }
+
+    /**
+     * Get the underlying realtime service for direct access
+     */
+    getRealtimeService(): MongoRealtimeService {
+        return this.realtimeService;
+    }
+}

package/src/services/MongoHistoryService.ts

@@ -0,0 +1,154 @@
+import { Db, ObjectId } from "mongodb";
+
+/**
+ * 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 JSON comparison
+            if (
+                typeof oldVal === "object" && oldVal !== null &&
+                typeof newVal === "object" && newVal !== null
+            ) {
+                if (JSON.stringify(oldVal) !== JSON.stringify(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;
+    entityId: 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,
+            entityId,
+            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(entityId),
+                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 entity
+            this.pruneHistory(String(entityId), tableName).catch(e => {
+                console.error(`[HistoryService] Failed to prune history for ${tableName}/${entityId}:`, e);
+            });
+        } catch (error) {
+            console.error(`[HistoryService] Failed to record history for ${tableName}/${entityId}:`, error);
+        }
+    }
+
+    private async pruneHistory(entityId: string, tableName: string): Promise<void> {
+        const collection = this.db.collection("__rebase_history");
+
+        // 1. Enforce maxEntries
+        const count = await collection.countDocuments({ entity_id: entityId, table_name: tableName });
+        if (count > this.retention.maxEntries) {
+            const toDelete = count - this.retention.maxEntries;
+            const oldestEntries = await collection
+                .find({ entity_id: entityId, 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: entityId,
+            table_name: tableName,
+            updated_at: { $lt: cutoffDate }
+        });
+    }
+}