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

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@rebasepro/server-mongodb",
+  "type": "module",
+  "version": "0.0.1-canary.09e5ec5",
+  "description": "MongoDB backend for Rebase",
+  "funding": {
+    "url": "https://github.com/sponsors/rebaseco"
+  },
+  "author": "Rebase",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rebasepro/rebase.git",
+    "directory": "packages/server-mongodb"
+  },
+  "main": "./dist/index.umd.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/server-mongodb/src/index.d.ts",
+  "source": "src/index.ts",
+  "engines": {
+    "node": ">=14"
+  },
+  "keywords": [
+    "rebase",
+    "cms",
+    "admin",
+    "admin panel",
+    "mongodb",
+    "backend",
+    "database"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/server-mongodb/src/index.d.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.umd.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "mongodb": "^6.12.0",
+    "realm-web": "^2.0.0",
+    "@rebasepro/types": "0.0.1-canary.09e5ec5"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.10.5",
+    "jest": "^29.7.0",
+    "mongodb-memory-server": "^10.0.0",
+    "ts-jest": "29.4.1",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0",
+    "@rebasepro/types": "0.0.1-canary.09e5ec5"
+  },
+  "peerDependencies": {
+    "@rebasepro/server-core": "0.0.1-canary.09e5ec5"
+  },
+  "peerDependenciesMeta": {
+    "@rebasepro/server-core": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "watch": "vite build --watch",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
+    "test:lint": "eslint \"src/**\" --quiet",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
+  }
+}

package/src/MongoBootstrapper.ts

@@ -0,0 +1,177 @@
+import { Db, MongoClient } from "mongodb";
+import {
+    BackendBootstrapper,
+    InitializedDriver,
+    BootstrappedAuth,
+    DatabaseAdmin,
+    RealtimeProvider,
+    DataDriver,
+    EntityCollection
+} from "@rebasepro/types";
+import { MongoDriver } from "./services/MongoDriver";
+import { MongoRealtimeService } from "./services/MongoRealtimeService";
+import { MongoCollectionRegistry } from "./factory";
+import { MongoAuthRepository, MongoUserService, MongoRoleService } from "./auth/services";
+
+export interface MongoDriverConfig {
+    connection: Db;
+    client: MongoClient;
+}
+
+export interface MongoDriverInternals {
+    db: Db;
+    client: MongoClient;
+    registry: MongoCollectionRegistry;
+    realtimeService: MongoRealtimeService;
+    driver: MongoDriver;
+}
+
+export function createMongoBootstrapper(mongoConfig: MongoDriverConfig): BackendBootstrapper {
+    // Cached admin object, set during getAdmin() and used by initializeWebsockets
+    let cachedAdmin: DatabaseAdmin | undefined;
+
+    return {
+        type: "mongodb",
+
+        async initializeDriver(config: unknown): Promise<InitializedDriver> {
+            const { collections } = config as { collections?: EntityCollection[] };
+
+            const registry = new MongoCollectionRegistry();
+            if (collections) {
+                collections.forEach(collection => registry.register(collection));
+            }
+
+            const db = mongoConfig.connection;
+            const client = mongoConfig.client;
+
+            // Verify connection
+            try {
+                await db.command({ ping: 1 });
+            } catch (err) {
+                console.error("❌ Failed to connect to MongoDB:", err);
+            }
+
+            const realtimeService = new MongoRealtimeService(db);
+            const driver = new MongoDriver(db, realtimeService);
+
+            const internals: MongoDriverInternals = {
+                db,
+                client,
+                registry,
+                realtimeService,
+                driver
+            };
+
+            return {
+                driver,
+                realtimeProvider: realtimeService,
+                collectionRegistry: registry,
+                internals
+            };
+        },
+
+        async initializeAuth(config: unknown, driverResult: InitializedDriver): Promise<BootstrappedAuth | undefined> {
+            const internals = driverResult.internals as MongoDriverInternals;
+            const db = internals.db;
+
+            const { ensureAuthCollectionsExist } = await import("./auth/ensure-collections");
+            await ensureAuthCollectionsExist(db);
+
+            // @ts-ignore
+            const { createEmailService } = await import("@rebasepro/server-core");
+            const authConfig = config as { email?: any } | undefined;
+            let emailService: any;
+            if (authConfig?.email) {
+                emailService = createEmailService(authConfig.email);
+            }
+
+            const userService = new MongoUserService(db);
+            const roleService = new MongoRoleService(db);
+            const authRepository = new MongoAuthRepository(db);
+
+            return {
+                userService,
+                roleService,
+                authRepository,
+                emailService
+            };
+        },
+
+        async initializeHistory(config: unknown, driverResult: InitializedDriver): Promise<{ historyService: any } | undefined> {
+            const historyConfig = config as { retention?: number } | undefined;
+            if (!historyConfig) return undefined;
+
+            const internals = driverResult.internals as MongoDriverInternals;
+            const db = internals.db;
+
+            const { ensureHistoryCollectionExists } = await import("./history/ensure-history-collection");
+            await ensureHistoryCollectionExists(db);
+
+            const { MongoHistoryService } = await import("./services/MongoHistoryService");
+            
+            const retention = typeof historyConfig === "object" && historyConfig !== null ? historyConfig.retention : undefined;
+            const historyService = new MongoHistoryService(db, retention ? { ttlDays: retention } : undefined);
+
+            return { historyService };
+        },
+
+        async initializeRealtime(_config: unknown, driverResult: InitializedDriver): Promise<RealtimeProvider | undefined> {
+            const internals = driverResult.internals as MongoDriverInternals;
+            return internals.realtimeService;
+        },
+
+        getAdmin(driverResult: InitializedDriver): DatabaseAdmin | undefined {
+            const internals = driverResult.internals as MongoDriverInternals;
+            const db = internals.db;
+
+            const admin: DatabaseAdmin = {
+                async executeAggregate(pipeline: Record<string, unknown>[]) {
+                    const firstStage = pipeline[0];
+                    const collName = (firstStage as { $from?: string })?.$from ?? "__admin__";
+                    const cursor = db.collection(collName).aggregate(pipeline);
+                    return await cursor.toArray() as Record<string, unknown>[];
+                },
+                async fetchCollectionStats(collectionName: string) {
+                    const stats = await db.command({ collStats: collectionName }) as { count: number; size: number };
+                    return { count: stats.count, sizeBytes: stats.size };
+                },
+                async fetchUnmappedTables(mappedPaths?: string[]) {
+                    const allCollections = await db.listCollections().toArray();
+                    const names = allCollections.map(c => c.name).filter(n => !n.startsWith("system."));
+                    if (!mappedPaths || mappedPaths.length === 0) return names;
+                    const mappedSet = new Set(mappedPaths.map(p => p.toLowerCase()));
+                    return names.filter(n => !mappedSet.has(n.toLowerCase()));
+                },
+                async fetchTableMetadata(collectionName: string) {
+                    const sample = await db.collection(collectionName).findOne();
+                    if (!sample) return { columns: [], foreignKeys: [], junctions: [], policies: [] };
+                    const columns = Object.entries(sample).map(([key, value]) => ({
+                        column_name: key,
+                        data_type: typeof value,
+                        udt_name: typeof value,
+                        is_nullable: "YES",
+                        column_default: null,
+                        character_maximum_length: null
+                    }));
+                    return { columns, foreignKeys: [], junctions: [], policies: [] };
+                }
+            };
+
+            cachedAdmin = admin;
+            return admin;
+        },
+
+        mountRoutes() {},
+
+        async initializeWebsockets(server: unknown, realtimeService: RealtimeProvider, driver: DataDriver, config?: unknown): Promise<void> {
+            const { createMongoWebSocket } = await import("./websocket");
+            createMongoWebSocket(
+                server as import("http").Server,
+                realtimeService as MongoRealtimeService,
+                driver as MongoDriver,
+                config as Record<string, unknown> | undefined,
+                cachedAdmin
+            );
+        }
+    };
+}

package/src/auth/ensure-collections.ts

@@ -0,0 +1,94 @@
+import { Db } from "mongodb";
+
+/**
+ * Default roles to seed on first run
+ */
+const DEFAULT_ROLES = [
+    {
+        _id: "admin",
+        id: "admin",
+        name: "Admin",
+        is_admin: true,
+        default_permissions: { read: true, create: true, edit: true, delete: true },
+        config: { createCollections: true, editCollections: "all", deleteCollections: "all" },
+        created_at: new Date()
+    },
+    {
+        _id: "editor",
+        id: "editor",
+        name: "Editor",
+        is_admin: false,
+        default_permissions: { read: true, create: true, edit: true, delete: true },
+        config: { createCollections: true, editCollections: "own", deleteCollections: "own" },
+        created_at: new Date()
+    },
+    {
+        _id: "viewer",
+        id: "viewer",
+        name: "Viewer",
+        is_admin: false,
+        default_permissions: { read: true, create: false, edit: false, delete: false },
+        config: null,
+        created_at: new Date()
+    }
+];
+
+export async function ensureAuthCollectionsExist(db: Db): Promise<void> {
+    console.log("🔍 Checking MongoDB auth collections and indexes...");
+
+    try {
+        // Users
+        const users = db.collection("__rebase_users");
+        await users.createIndex({ email: 1 }, { unique: true });
+
+        // User Identities
+        const identities = db.collection("__rebase_user_identities");
+        await identities.createIndex({ provider: 1, provider_id: 1 }, { unique: true });
+        await identities.createIndex({ user_id: 1 });
+
+        // User Roles (junction collection)
+        const userRoles = db.collection("__rebase_user_roles");
+        await userRoles.createIndex({ user_id: 1, role_id: 1 }, { unique: true });
+        await userRoles.createIndex({ user_id: 1 });
+
+        // Refresh Tokens
+        const refreshTokens = db.collection("__rebase_refresh_tokens");
+        await refreshTokens.createIndex({ token_hash: 1 }, { unique: true });
+        await refreshTokens.createIndex({ user_id: 1, user_agent: 1, ip_address: 1 }, { unique: true });
+        await refreshTokens.createIndex({ user_id: 1 });
+
+        // Password Reset Tokens
+        const resetTokens = db.collection("__rebase_password_reset_tokens");
+        await resetTokens.createIndex({ token_hash: 1 }, { unique: true });
+        await resetTokens.createIndex({ user_id: 1 });
+
+        // Seed roles
+        await seedDefaultRoles(db);
+
+        console.log("✅ MongoDB Auth collections ready");
+    } catch (error) {
+        console.error("❌ Failed to set up MongoDB auth collections:", error);
+    }
+}
+
+async function seedDefaultRoles(db: Db): Promise<void> {
+    const roles = db.collection("__rebase_roles");
+    const count = await roles.countDocuments();
+
+    if (count > 0) {
+        console.log(`📋 Found ${count} existing roles`);
+        return;
+    }
+
+    console.log("🌱 Seeding default roles...");
+
+    for (const role of DEFAULT_ROLES) {
+        await roles.updateOne(
+            { id: role.id },
+            { $setOnInsert: role },
+            { upsert: true }
+        );
+    }
+
+    console.log("✅ Default roles created: admin, editor, viewer");
+}