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

package/dist/index.es.js

@@ -0,0 +1,1734 @@
+import { MongoClient, ObjectId } from "mongodb";
+class MongoDBConnection {
+  constructor(db, client) {
+    this.db = db;
+    this.client = client;
+  }
+  type = "mongodb";
+  get isConnected() {
+    try {
+      const clientInternal = this.client;
+      return clientInternal.topology?.isConnected?.() ?? false;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    await this.client.close();
+  }
+}
+async function createMongoDBConnection(connectionString, databaseName) {
+  const client = new MongoClient(connectionString);
+  await client.connect();
+  const db = client.db(databaseName);
+  return new MongoDBConnection(db, client);
+}
+const REBASE_TO_MONGO_OP = {
+  "<": "$lt",
+  "<=": "$lte",
+  "==": "$eq",
+  "!=": "$ne",
+  ">=": "$gte",
+  ">": "$gt",
+  "array-contains": "$elemMatch",
+  "array-contains-any": "$in",
+  "in": "$in",
+  "not-in": "$nin"
+};
+class MongoConditionBuilder {
+  /**
+   * Build MongoDB filter conditions from Rebase FilterValues
+   *
+   * @param filter - Rebase filter values
+   * @returns Array of MongoDB filter objects
+   */
+  static buildFilterConditions(filter) {
+    if (!filter) return [];
+    const conditions = [];
+    for (const [field, filterParam] of Object.entries(filter)) {
+      if (!filterParam) continue;
+      const [op, value] = filterParam;
+      const mongoOp = REBASE_TO_MONGO_OP[op];
+      if (!mongoOp) {
+        console.warn(`Unsupported filter operator: ${op}`);
+        continue;
+      }
+      if (op === "array-contains") {
+        conditions.push({
+          [field]: { $elemMatch: { $eq: value } }
+        });
+      } else {
+        conditions.push({
+          [field]: { [mongoOp]: value }
+        });
+      }
+    }
+    return conditions;
+  }
+  /**
+   * Build search conditions for text search
+   *
+   * @param searchString - Text to search for
+   * @param properties - Properties to search in
+   * @returns Array of MongoDB filter objects for text search
+   */
+  static buildSearchConditions(searchString, properties) {
+    if (!searchString) return [];
+    const orConditions = [];
+    const searchRegex = new RegExp(searchString, "i");
+    for (const [key, prop] of Object.entries(properties)) {
+      if (prop?.dataType === "string" || typeof prop === "string") {
+        orConditions.push({
+          [key]: { $regex: searchRegex }
+        });
+      }
+    }
+    if (orConditions.length === 0) {
+      return [{ $text: { $search: searchString } }];
+    }
+    return orConditions;
+  }
+  /**
+   * Combine multiple conditions with AND operator
+   *
+   * @param conditions - Array of filter conditions
+   * @returns Combined filter or undefined if empty
+   */
+  static combineConditionsWithAnd(conditions) {
+    if (conditions.length === 0) return void 0;
+    if (conditions.length === 1) return conditions[0];
+    return { $and: conditions };
+  }
+  /**
+   * Combine multiple conditions with OR operator
+   *
+   * @param conditions - Array of filter conditions
+   * @returns Combined filter or undefined if empty
+   */
+  static combineConditionsWithOr(conditions) {
+    if (conditions.length === 0) return void 0;
+    if (conditions.length === 1) return conditions[0];
+    return { $or: conditions };
+  }
+  /**
+   * Build a complete MongoDB query from Rebase options
+   *
+   * @param options - Rebase fetch options
+   * @returns MongoDB filter object
+   */
+  static buildQuery(options) {
+    const conditions = [];
+    if (options.filter) {
+      const filterConditions = this.buildFilterConditions(options.filter);
+      conditions.push(...filterConditions);
+    }
+    if (options.searchString && options.properties) {
+      const searchConditions = this.buildSearchConditions(
+        options.searchString,
+        options.properties
+      );
+      if (searchConditions.length > 0) {
+        const searchFilter = this.combineConditionsWithOr(searchConditions);
+        if (searchFilter) {
+          conditions.push(searchFilter);
+        }
+      }
+    }
+    return this.combineConditionsWithAnd(conditions) ?? {};
+  }
+  /**
+   * Build MongoDB sort options from Rebase options
+   *
+   * @param orderBy - Field to order by
+   * @param order - Sort direction
+   * @returns MongoDB sort object
+   */
+  static buildSort(orderBy, order) {
+    if (!orderBy) return void 0;
+    return { [orderBy]: order === "desc" ? -1 : 1 };
+  }
+}
+class MongoEntityService {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Get a MongoDB collection by its path
+   */
+  getCollection(collectionPath) {
+    const collectionName = collectionPath.replace(/\//g, "_");
+    return this.db.collection(collectionName);
+  }
+  /**
+   * Convert a string ID to ObjectId if it's a valid ObjectId string
+   */
+  toObjectId(id) {
+    if (typeof id === "string" && ObjectId.isValid(id) && id.length === 24) {
+      return new ObjectId(id);
+    }
+    return id;
+  }
+  /**
+   * Convert a MongoDB document to a Rebase Entity
+   */
+  documentToEntity(doc, path) {
+    const { _id, ...values } = doc;
+    return {
+      id: _id.toString(),
+      path,
+      values: this.convertFromMongoValues(values)
+    };
+  }
+  /**
+   * Convert values from MongoDB format to Rebase format
+   */
+  convertFromMongoValues(values) {
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+      result[key] = this.convertFromMongoValue(value);
+    }
+    return result;
+  }
+  /**
+   * Convert a single value from MongoDB format
+   */
+  convertFromMongoValue(value) {
+    if (value === null || value === void 0) return value;
+    if (value instanceof ObjectId) {
+      return value.toString();
+    }
+    if (value instanceof Date) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.convertFromMongoValue(v));
+    }
+    if (typeof value === "object" && "path" in value && "id" in value) {
+      return {
+        path: value.path,
+        id: value.id instanceof ObjectId ? value.id.toString() : value.id
+      };
+    }
+    if (typeof value === "object") {
+      return this.convertFromMongoValues(value);
+    }
+    return value;
+  }
+  /**
+   * Convert values to MongoDB format for storage
+   */
+  convertToMongoValues(values) {
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+      result[key] = this.convertToMongoValue(value);
+    }
+    return result;
+  }
+  /**
+   * Convert a single value to MongoDB format
+   */
+  convertToMongoValue(value) {
+    if (value === null || value === void 0) return value;
+    if (typeof value === "object" && value.isEntityReference?.()) {
+      return {
+        id: ObjectId.isValid(value.id) ? new ObjectId(value.id) : value.id,
+        path: value.path
+      };
+    }
+    if (value instanceof Date) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.convertToMongoValue(v));
+    }
+    if (typeof value === "object") {
+      return this.convertToMongoValues(value);
+    }
+    return value;
+  }
+  // =============================================================
+  // EntityRepository Implementation
+  // =============================================================
+  /**
+   * Fetch a single entity by ID
+   */
+  async fetchEntity(collectionPath, entityId, _databaseId) {
+    const collection = this.getCollection(collectionPath);
+    const id = this.toObjectId(entityId);
+    const doc = await collection.findOne({ _id: id });
+    if (!doc) return void 0;
+    return this.documentToEntity(doc, collectionPath);
+  }
+  /**
+   * Fetch a collection of entities with optional filtering, ordering, and pagination
+   */
+  async fetchCollection(collectionPath, options = {}) {
+    const collection = this.getCollection(collectionPath);
+    const query = MongoConditionBuilder.buildQuery({
+      filter: options.filter,
+      searchString: options.searchString,
+      properties: options.collection?.properties ?? {}
+    });
+    const findOptions = {};
+    const sort = MongoConditionBuilder.buildSort(options.orderBy, options.order);
+    if (sort) {
+      findOptions.sort = sort;
+    }
+    if (options.limit) {
+      findOptions.limit = options.limit;
+    }
+    if (options.startAfter !== void 0) {
+      findOptions.skip = Number(options.startAfter);
+    }
+    const docs = await collection.find(query, findOptions).toArray();
+    return docs.map((doc) => this.documentToEntity(doc, collectionPath));
+  }
+  /**
+   * Search entities by text
+   */
+  async searchEntities(collectionPath, searchString, options = {}) {
+    return this.fetchCollection(collectionPath, {
+      ...options,
+      searchString
+    });
+  }
+  /**
+   * Count entities in a collection
+   */
+  async countEntities(collectionPath, options = {}) {
+    const collection = this.getCollection(collectionPath);
+    const query = options.filter ? MongoConditionBuilder.buildQuery({ filter: options.filter }) : {};
+    return collection.countDocuments(query);
+  }
+  /**
+   * Save an entity (create or update)
+   */
+  async saveEntity(collectionPath, values, entityId, _databaseId) {
+    const collection = this.getCollection(collectionPath);
+    const mongoValues = this.convertToMongoValues(values);
+    if (entityId) {
+      const id = this.toObjectId(entityId);
+      await collection.updateOne(
+        { _id: id },
+        { $set: mongoValues },
+        { upsert: true }
+      );
+      return {
+        id: entityId.toString(),
+        path: collectionPath,
+        values
+      };
+    } else {
+      const newId = new ObjectId();
+      await collection.insertOne({
+        _id: newId,
+        ...mongoValues
+      });
+      return {
+        id: newId.toString(),
+        path: collectionPath,
+        values
+      };
+    }
+  }
+  /**
+   * Delete an entity by ID
+   */
+  async deleteEntity(collectionPath, entityId, _databaseId) {
+    const collection = this.getCollection(collectionPath);
+    const id = this.toObjectId(entityId);
+    const result = await collection.deleteOne({ _id: id });
+    if (result.deletedCount === 0) {
+      console.warn(`Entity ${entityId} not found in collection ${collectionPath}`);
+    }
+  }
+  /**
+   * Check if a field value is unique in a collection
+   */
+  async checkUniqueField(collectionPath, fieldName, value, excludeEntityId, _databaseId) {
+    const collection = this.getCollection(collectionPath);
+    const query = { [fieldName]: value };
+    if (excludeEntityId) {
+      const id = this.toObjectId(excludeEntityId);
+      query._id = { $ne: id };
+    }
+    const count = await collection.countDocuments(query);
+    return count === 0;
+  }
+  /**
+   * Generate a new entity ID
+   */
+  generateEntityId() {
+    return new ObjectId().toString();
+  }
+}
+class MongoRealtimeService {
+  constructor(db) {
+    this.db = db;
+    this.entityService = new MongoEntityService(db);
+  }
+  subscriptions = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Map();
+  entityService;
+  /**
+   * Get the collection name from a path
+   */
+  getCollectionName(path) {
+    return path.replace(/\//g, "_");
+  }
+  /**
+   * Subscribe to collection changes
+   */
+  subscribeToCollection(subscriptionId, config, callback) {
+    this.unsubscribe(subscriptionId);
+    const collectionName = this.getCollectionName(config.path);
+    const collection = this.db.collection(collectionName);
+    const pipeline = [];
+    pipeline.push({
+      $match: {
+        operationType: { $in: ["insert", "update", "replace", "delete"] }
+      }
+    });
+    try {
+      const changeStream = collection.watch(pipeline, {
+        fullDocument: "updateLookup"
+      });
+      const subscription = {
+        type: "collection",
+        config,
+        changeStream,
+        callback
+      };
+      this.subscriptions.set(subscriptionId, subscription);
+      this.fetchAndNotifyCollection(subscriptionId, config, callback);
+      changeStream.on("change", async (change) => {
+        await this.fetchAndNotifyCollection(subscriptionId, config, callback);
+      });
+      changeStream.on("error", (error) => {
+        console.error(`Change stream error for subscription ${subscriptionId}:`, error);
+      });
+    } catch (error) {
+      console.warn("Change streams not available, falling back to polling:", error);
+      const subscription = {
+        type: "collection",
+        config,
+        callback
+      };
+      this.subscriptions.set(subscriptionId, subscription);
+      this.fetchAndNotifyCollection(subscriptionId, config, callback);
+    }
+  }
+  /**
+   * Fetch collection and notify callback
+   */
+  async fetchAndNotifyCollection(subscriptionId, config, callback) {
+    try {
+      const entities = await this.entityService.fetchCollection(config.path, {
+        filter: config.filter,
+        orderBy: config.orderBy,
+        order: config.order,
+        limit: config.limit,
+        startAfter: config.startAfter,
+        searchString: config.searchString
+      });
+      if (callback) {
+        callback(entities);
+      }
+    } catch (error) {
+      console.error(`Error fetching collection for subscription ${subscriptionId}:`, error);
+    }
+  }
+  /**
+   * Subscribe to single entity changes
+   */
+  subscribeToEntity(subscriptionId, config, callback) {
+    this.unsubscribe(subscriptionId);
+    const collectionName = this.getCollectionName(config.path);
+    const collection = this.db.collection(collectionName);
+    const entityId = typeof config.entityId === "string" && ObjectId.isValid(config.entityId) ? new ObjectId(config.entityId) : config.entityId;
+    const pipeline = [
+      {
+        $match: {
+          "documentKey._id": entityId,
+          operationType: { $in: ["insert", "update", "replace", "delete"] }
+        }
+      }
+    ];
+    try {
+      const changeStream = collection.watch(pipeline, {
+        fullDocument: "updateLookup"
+      });
+      const subscription = {
+        type: "entity",
+        config,
+        changeStream,
+        callback
+      };
+      this.subscriptions.set(subscriptionId, subscription);
+      this.fetchAndNotifyEntity(subscriptionId, config, callback);
+      changeStream.on("change", async (change) => {
+        if (change.operationType === "delete") {
+          if (callback) {
+            callback(null);
+          }
+        } else {
+          await this.fetchAndNotifyEntity(subscriptionId, config, callback);
+        }
+      });
+      changeStream.on("error", (error) => {
+        console.error(`Change stream error for subscription ${subscriptionId}:`, error);
+      });
+    } catch (error) {
+      console.warn("Change streams not available, falling back to polling:", error);
+      const subscription = {
+        type: "entity",
+        config,
+        callback
+      };
+      this.subscriptions.set(subscriptionId, subscription);
+      this.fetchAndNotifyEntity(subscriptionId, config, callback);
+    }
+  }
+  /**
+   * Fetch entity and notify callback
+   */
+  async fetchAndNotifyEntity(subscriptionId, config, callback) {
+    try {
+      const entity = await this.entityService.fetchEntity(config.path, config.entityId);
+      if (callback) {
+        callback(entity || null);
+      }
+    } catch (error) {
+      console.error(`Error fetching entity for subscription ${subscriptionId}:`, error);
+    }
+  }
+  /**
+   * Unsubscribe from a subscription
+   */
+  unsubscribe(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (subscription) {
+      if (subscription.changeStream) {
+        subscription.changeStream.close().catch(console.error);
+      }
+      this.subscriptions.delete(subscriptionId);
+    }
+  }
+  /**
+   * Notify all relevant subscribers of an entity update
+   * This is called after save/delete operations to push updates
+   */
+  async notifyEntityUpdate(path, entityId, entity, _databaseId) {
+    for (const [subscriptionId, subscription] of this.subscriptions) {
+      if (subscription.type === "entity") {
+        const config = subscription.config;
+        if (config.path === path && config.entityId.toString() === entityId) {
+          if (subscription.callback) {
+            subscription.callback(entity);
+          }
+        }
+      } else if (subscription.type === "collection") {
+        const config = subscription.config;
+        if (config.path === path) {
+          await this.fetchAndNotifyCollection(subscriptionId, config, subscription.callback);
+        }
+      }
+    }
+  }
+  /**
+   * Get all active subscriptions (for debugging)
+   */
+  getSubscriptions() {
+    return this.subscriptions;
+  }
+  /**
+   * Close all subscriptions
+   */
+  async closeAll() {
+    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, ws) {
+    this.clients.set(clientId, ws);
+    ws.on("close", () => {
+      this.removeClient(clientId);
+    });
+    ws.on("error", (error) => {
+      console.error("WebSocket error for client", clientId, error);
+      this.removeClient(clientId);
+    });
+  }
+  /**
+   * Remove a WebSocket client and clean up its subscriptions
+   */
+  removeClient(clientId) {
+    this.clients.delete(clientId);
+  }
+  /**
+   * Handle an incoming WebSocket message for subscription management
+   */
+  async handleClientMessage(clientId, message, _authContext) {
+    const ws = this.clients.get(clientId);
+    if (!ws) return;
+    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
+          },
+          (entities) => {
+            ws.send(JSON.stringify({
+              type: "collection_update",
+              subscriptionId,
+              entities
+            }));
+          }
+        );
+        break;
+      }
+      case "subscribe_entity": {
+        const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+        if (!subscriptionId) return;
+        this.subscribeToEntity(
+          subscriptionId,
+          {
+            clientId,
+            path: message.payload?.path,
+            entityId: message.payload?.entityId
+          },
+          (entity) => {
+            ws.send(JSON.stringify({
+              type: "entity_update",
+              subscriptionId,
+              entity
+            }));
+          }
+        );
+        break;
+      }
+      case "unsubscribe": {
+        const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+        if (subscriptionId) {
+          this.unsubscribe(subscriptionId);
+        }
+        break;
+      }
+    }
+  }
+}
+function findChangedFields(oldValues, newValues) {
+  const changed = [];
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(oldValues),
+    ...Object.keys(newValues)
+  ]);
+  for (const key of allKeys) {
+    const oldVal = oldValues[key];
+    const newVal = newValues[key];
+    if (key.startsWith("__")) continue;
+    if (oldVal !== newVal) {
+      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;
+}
+const DEFAULT_RETENTION = {
+  maxEntries: 200,
+  ttlDays: 90
+};
+class MongoHistoryService {
+  constructor(db, retention) {
+    this.db = db;
+    this.retention = { ...DEFAULT_RETENTION, ...retention };
+  }
+  retention;
+  async recordHistory(params) {
+    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 = {
+        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: /* @__PURE__ */ new Date()
+      };
+      await this.db.collection("__rebase_history").insertOne(entry);
+      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);
+    }
+  }
+  async pruneHistory(entityId, tableName) {
+    const collection = this.db.collection("__rebase_history");
+    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 } });
+      }
+    }
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - this.retention.ttlDays);
+    await collection.deleteMany({
+      entity_id: entityId,
+      table_name: tableName,
+      updated_at: { $lt: cutoffDate }
+    });
+  }
+}
+const MongoHistoryService$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MongoHistoryService,
+  findChangedFields
+}, Symbol.toStringTag, { value: "Module" }));
+class MongoDriver {
+  constructor(db, realtimeService, historyService) {
+    this.db = db;
+    this.entityService = new MongoEntityService(db);
+    this.realtimeService = realtimeService ?? new MongoRealtimeService(db);
+    this.historyService = historyService ?? new MongoHistoryService(db);
+  }
+  key = "mongodb";
+  initialised = true;
+  entityService;
+  realtimeService;
+  historyService;
+  /**
+   * Get the current timestamp
+   */
+  currentTime() {
+    return /* @__PURE__ */ new Date();
+  }
+  /**
+   * Fetch a collection of entities
+   */
+  async fetchCollection({
+    path,
+    collection,
+    filter,
+    limit,
+    startAfter,
+    orderBy,
+    searchString,
+    order
+  }) {
+    return this.entityService.fetchCollection(path, {
+      filter,
+      limit,
+      startAfter,
+      orderBy,
+      order,
+      searchString,
+      collection
+    });
+  }
+  /**
+   * Listen to collection changes
+   */
+  listenCollection({
+    path,
+    collection,
+    filter,
+    limit,
+    startAfter,
+    orderBy,
+    searchString,
+    order,
+    onUpdate,
+    onError
+  }) {
+    const subscriptionId = this.generateSubscriptionId();
+    const callback = (entities) => {
+      try {
+        onUpdate(entities);
+      } 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 () => {
+      this.realtimeService.unsubscribe(subscriptionId);
+    };
+  }
+  /**
+   * Fetch a single entity
+   */
+  async fetchEntity({
+    path,
+    entityId,
+    databaseId,
+    collection
+  }) {
+    return this.entityService.fetchEntity(path, entityId, databaseId);
+  }
+  /**
+   * Listen to entity changes
+   */
+  listenEntity({
+    path,
+    entityId,
+    collection,
+    onUpdate,
+    onError
+  }) {
+    const subscriptionId = this.generateSubscriptionId();
+    const callback = (entity) => {
+      try {
+        onUpdate(entity);
+      } 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 () => {
+      this.realtimeService.unsubscribe(subscriptionId);
+    };
+  }
+  /**
+   * Save an entity (create or update)
+   */
+  async saveEntity({
+    path,
+    entityId,
+    values,
+    previousValues,
+    collection,
+    status
+  }) {
+    const isNew = status === "new" || !previousValues;
+    const entity = await this.entityService.saveEntity(path, values, entityId);
+    if (collection?.history) {
+      this.historyService.recordHistory({
+        action: isNew ? "create" : "update",
+        entityId: String(entity.id),
+        tableName: path,
+        values: entity.values,
+        previousValues: isNew ? void 0 : previousValues
+      }).catch((err) => {
+        console.error(`Failed to record history for ${path}/${entity.id}:`, err);
+      });
+    }
+    await this.realtimeService.notifyEntityUpdate(path, String(entity.id), entity);
+    return entity;
+  }
+  /**
+   * Delete an entity
+   */
+  async deleteEntity({
+    entity,
+    collection
+  }) {
+    await this.entityService.deleteEntity(entity.path, entity.id);
+    if (collection?.history) {
+      this.historyService.recordHistory({
+        action: "delete",
+        entityId: String(entity.id),
+        tableName: entity.path,
+        previousValues: entity.values
+      }).catch((err) => {
+        console.error(`Failed to record history for ${entity.path}/${entity.id}:`, err);
+      });
+    }
+    await this.realtimeService.notifyEntityUpdate(entity.path, String(entity.id), null);
+  }
+  /**
+   * Check if a field value is unique
+   */
+  async checkUniqueField(path, name, value, entityId, collection) {
+    return this.entityService.checkUniqueField(path, name, value, entityId);
+  }
+  /**
+   * Generate a new entity ID
+   */
+  generateEntityId(path, collection) {
+    return this.entityService.generateEntityId();
+  }
+  /**
+   * Count entities in a collection
+   */
+  async countEntities({
+    path,
+    collection,
+    filter
+  }) {
+    return this.entityService.countEntities(path, { filter });
+  }
+  /**
+   * Generate a unique subscription ID
+   */
+  generateSubscriptionId() {
+    return `mongo_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Check if the delegate is ready
+   */
+  isReady() {
+    return this.initialised;
+  }
+  /**
+   * Get the underlying entity service for direct access
+   */
+  getEntityService() {
+    return this.entityService;
+  }
+  /**
+   * Get the underlying realtime service for direct access
+   */
+  getRealtimeService() {
+    return this.realtimeService;
+  }
+}
+class MongoCollectionRegistry {
+  collections = /* @__PURE__ */ new Map();
+  /**
+   * Register a collection
+   */
+  register(collection) {
+    this.collections.set(collection.name, collection);
+  }
+  /**
+   * Get a collection by its path
+   */
+  getCollectionByPath(path) {
+    return this.collections.get(path);
+  }
+  /**
+   * Get all registered collections
+   */
+  getCollections() {
+    return Array.from(this.collections.values());
+  }
+}
+function createMongoBackend(config) {
+  const { connection: db, client, collections } = config;
+  const collectionRegistry = new MongoCollectionRegistry();
+  if (collections) {
+    collections.forEach((collection) => collectionRegistry.register(collection));
+  }
+  const entityService = new MongoEntityService(db);
+  const realtimeService = new MongoRealtimeService(db);
+  const historyService = new MongoHistoryService(db, config.historyRetention);
+  const driver = new MongoDriver(db, realtimeService, historyService);
+  const mongoConnection = new MongoDBConnection(db, client);
+  const admin = {
+    async executeAggregate(pipeline) {
+      const firstStage = pipeline[0];
+      const collName = typeof firstStage.$from === "string" ? firstStage.$from : "__admin__";
+      const cursor = db.collection(collName).aggregate(pipeline);
+      return await cursor.toArray();
+    },
+    async fetchCollectionStats(collectionName) {
+      const stats = await db.command({ collStats: collectionName });
+      return {
+        count: stats.count,
+        sizeBytes: stats.size
+      };
+    },
+    async fetchUnmappedTables(mappedPaths) {
+      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) {
+      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: []
+      };
+    }
+  };
+  return {
+    // Abstract interface implementations
+    connection: mongoConnection,
+    entityRepository: entityService,
+    realtimeProvider: realtimeService,
+    collectionRegistry,
+    admin,
+    // Lifecycle
+    async initialize() {
+    },
+    async healthCheck() {
+      const start = Date.now();
+      try {
+        await db.command({ ping: 1 });
+        return {
+          healthy: true,
+          latencyMs: Date.now() - start
+        };
+      } catch {
+        return {
+          healthy: false,
+          latencyMs: Date.now() - start
+        };
+      }
+    },
+    async destroy() {
+      await client.close();
+    },
+    // MongoDB-specific accessors
+    db,
+    client,
+    driver,
+    entityService,
+    realtimeService
+  };
+}
+function createMongoDelegate(db, realtimeService, historyService) {
+  const realtime = realtimeService ?? new MongoRealtimeService(db);
+  const history = historyService ?? new MongoHistoryService(db);
+  return new MongoDriver(db, realtime, history);
+}
+function createMongoRealtimeService(db) {
+  return new MongoRealtimeService(db);
+}
+function createMongoEntityRepository(db) {
+  return new MongoEntityService(db);
+}
+function isMongoBackendConfig(config) {
+  return config.type === "mongodb" && typeof config.connection !== "undefined" && typeof config.client !== "undefined";
+}
+function isMongoDriverConfig(obj) {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "mongodb" && "connection" in obj && "client" in obj;
+}
+function toUser(doc) {
+  return {
+    id: doc._id || doc.id,
+    email: doc.email,
+    passwordHash: doc.passwordHash ?? null,
+    displayName: doc.displayName ?? null,
+    photoUrl: doc.photoUrl ?? null,
+    emailVerified: doc.emailVerified ?? false,
+    emailVerificationToken: doc.emailVerificationToken ?? null,
+    emailVerificationSentAt: doc.emailVerificationSentAt ? new Date(doc.emailVerificationSentAt) : null,
+    createdAt: new Date(doc.createdAt),
+    updatedAt: new Date(doc.updatedAt)
+  };
+}
+class MongoUserService {
+  constructor(db) {
+    this.db = db;
+  }
+  get collection() {
+    return this.db.collection("rebase_users");
+  }
+  get identitiesCollection() {
+    return this.db.collection("rebase_user_identities");
+  }
+  get userRolesCollection() {
+    return this.db.collection("rebase_user_roles");
+  }
+  get rolesCollection() {
+    return this.db.collection("rebase_roles");
+  }
+  async createUser(data) {
+    const id = new ObjectId().toString();
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      _id: id,
+      id,
+      email: data.email.toLowerCase(),
+      passwordHash: data.passwordHash ?? null,
+      displayName: data.displayName ?? null,
+      photoUrl: data.photoUrl ?? null,
+      emailVerified: data.emailVerified ?? false,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.collection.insertOne(doc);
+    return toUser(doc);
+  }
+  async getUserById(id) {
+    const doc = await this.collection.findOne({ id });
+    return doc ? toUser(doc) : null;
+  }
+  async getUserByEmail(email) {
+    const doc = await this.collection.findOne({ email: email.toLowerCase() });
+    return doc ? toUser(doc) : null;
+  }
+  async getUserByIdentity(provider, providerId) {
+    const identity = await this.identitiesCollection.findOne({ provider, providerId });
+    if (!identity) return null;
+    return this.getUserById(identity.userId);
+  }
+  async getUserIdentities(userId) {
+    const docs = await this.identitiesCollection.find({ userId }).toArray();
+    return docs.map((doc) => ({
+      id: doc.id,
+      userId: doc.userId,
+      provider: doc.provider,
+      providerId: doc.providerId,
+      profileData: doc.profileData ?? null,
+      createdAt: new Date(doc.createdAt),
+      updatedAt: new Date(doc.updatedAt)
+    }));
+  }
+  async linkUserIdentity(userId, provider, providerId, profileData) {
+    const now = /* @__PURE__ */ new Date();
+    await this.identitiesCollection.updateOne(
+      { provider, providerId },
+      {
+        $setOnInsert: {
+          _id: new ObjectId().toString(),
+          id: new ObjectId().toString(),
+          userId,
+          provider,
+          providerId,
+          createdAt: now
+        },
+        $set: {
+          profileData: profileData ?? null,
+          updatedAt: now
+        }
+      },
+      { upsert: true }
+    );
+  }
+  async updateUser(id, data) {
+    const updateData = { ...data, updatedAt: /* @__PURE__ */ new Date() };
+    if (typeof updateData.email === "string") updateData.email = updateData.email.toLowerCase();
+    await this.collection.updateOne({ id }, { $set: updateData });
+    return this.getUserById(id);
+  }
+  async deleteUser(id) {
+    await this.collection.deleteOne({ id });
+    await this.identitiesCollection.deleteMany({ userId: id });
+    await this.userRolesCollection.deleteMany({ userId: id });
+  }
+  async listUsers() {
+    const docs = await this.collection.find().toArray();
+    return docs.map(toUser);
+  }
+  async listUsersPaginated(options) {
+    const limit = options?.limit ?? 25;
+    const offset = options?.offset ?? 0;
+    const search = options?.search?.trim() || "";
+    const orderBy = options?.orderBy || "createdAt";
+    const orderDir = options?.orderDir || "desc";
+    const roleId = options?.roleId;
+    const query = {};
+    if (search) {
+      query.$or = [
+        { email: { $regex: search, $options: "i" } },
+        { displayName: { $regex: search, $options: "i" } }
+      ];
+    }
+    if (roleId) {
+      const userRoles = await this.userRolesCollection.find({ roleId }).toArray();
+      const userIds = userRoles.map((ur) => ur.userId);
+      query.id = { $in: userIds };
+    }
+    const sort = {};
+    sort[orderBy] = orderDir === "asc" ? 1 : -1;
+    const total = await this.collection.countDocuments(query);
+    const docs = await this.collection.find(query).sort(sort).skip(offset).limit(limit).toArray();
+    return {
+      users: docs.map(toUser),
+      total,
+      limit,
+      offset
+    };
+  }
+  async updatePassword(id, passwordHash) {
+    await this.collection.updateOne(
+      { id },
+      { $set: { passwordHash, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
+  async setEmailVerified(id, verified) {
+    await this.collection.updateOne(
+      { id },
+      { $set: { emailVerified: verified, emailVerificationToken: null, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
+  async setVerificationToken(id, token) {
+    await this.collection.updateOne(
+      { id },
+      { $set: { emailVerificationToken: token, emailVerificationSentAt: token ? /* @__PURE__ */ new Date() : null, updatedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
+  async getUserByVerificationToken(token) {
+    const doc = await this.collection.findOne({ emailVerificationToken: token });
+    return doc ? toUser(doc) : null;
+  }
+  async getUserRoles(userId) {
+    const userRoles = await this.userRolesCollection.find({ userId }).toArray();
+    const roleIds = userRoles.map((ur) => ur.roleId);
+    if (roleIds.length === 0) return [];
+    const roles = await this.rolesCollection.find({ id: { $in: roleIds } }).toArray();
+    return roles.map((r) => ({
+      id: r.id,
+      name: r.name,
+      isAdmin: r.isAdmin ?? false,
+      defaultPermissions: r.defaultPermissions ?? null,
+      collectionPermissions: r.collectionPermissions ?? null,
+      config: r.config ?? null
+    }));
+  }
+  async getUserRoleIds(userId) {
+    const userRoles = await this.userRolesCollection.find({ userId }).toArray();
+    return userRoles.map((ur) => ur.roleId);
+  }
+  async setUserRoles(userId, roleIds) {
+    await this.userRolesCollection.deleteMany({ userId });
+    if (roleIds.length > 0) {
+      const docs = roleIds.map((roleId) => ({
+        _id: new ObjectId().toString(),
+        userId,
+        roleId
+      }));
+      await this.userRolesCollection.insertMany(docs);
+    }
+  }
+  async assignDefaultRole(userId, roleId) {
+    await this.userRolesCollection.updateOne(
+      { userId, roleId },
+      { $setOnInsert: { _id: new ObjectId().toString(), userId, roleId } },
+      { upsert: true }
+    );
+  }
+  async getUserWithRoles(userId) {
+    const user = await this.getUserById(userId);
+    if (!user) return null;
+    const roles = await this.getUserRoles(userId);
+    return { user, roles };
+  }
+}
+class MongoRoleService {
+  constructor(db) {
+    this.db = db;
+  }
+  get collection() {
+    return this.db.collection("rebase_roles");
+  }
+  async getRoleById(id) {
+    const doc = await this.collection.findOne({ id });
+    if (!doc) return null;
+    return {
+      id: doc.id,
+      name: doc.name,
+      isAdmin: doc.isAdmin ?? false,
+      defaultPermissions: doc.defaultPermissions ?? null,
+      collectionPermissions: doc.collectionPermissions ?? null,
+      config: doc.config ?? null
+    };
+  }
+  async listRoles() {
+    const docs = await this.collection.find().sort({ name: 1 }).toArray();
+    return docs.map((doc) => ({
+      id: doc.id,
+      name: doc.name,
+      isAdmin: doc.isAdmin ?? false,
+      defaultPermissions: doc.defaultPermissions ?? null,
+      collectionPermissions: doc.collectionPermissions ?? null,
+      config: doc.config ?? null
+    }));
+  }
+  async createRole(data) {
+    const doc = {
+      _id: data.id,
+      id: data.id,
+      name: data.name,
+      isAdmin: data.isAdmin ?? false,
+      defaultPermissions: data.defaultPermissions ?? null,
+      collectionPermissions: data.collectionPermissions ?? null,
+      config: data.config ?? null
+    };
+    await this.collection.insertOne(doc);
+    return { ...doc };
+  }
+  async updateRole(id, data) {
+    await this.collection.updateOne({ id }, { $set: data });
+    return this.getRoleById(id);
+  }
+  async deleteRole(id) {
+    await this.collection.deleteOne({ id });
+    await this.db.collection("rebase_user_roles").deleteMany({ roleId: id });
+  }
+}
+class MongoRefreshTokenService {
+  constructor(db) {
+    this.db = db;
+  }
+  get collection() {
+    return this.db.collection("rebase_refresh_tokens");
+  }
+  async createToken(userId, tokenHash, expiresAt, userAgent, ipAddress) {
+    const safeUserAgent = userAgent || "";
+    const safeIpAddress = ipAddress || "";
+    await this.collection.deleteMany({
+      userId,
+      userAgent: safeUserAgent,
+      ipAddress: safeIpAddress
+    });
+    await this.collection.insertOne({
+      _id: new ObjectId().toString(),
+      id: new ObjectId().toString(),
+      userId,
+      tokenHash,
+      expiresAt,
+      createdAt: /* @__PURE__ */ new Date(),
+      userAgent: safeUserAgent,
+      ipAddress: safeIpAddress
+    });
+  }
+  async findByHash(tokenHash) {
+    const doc = await this.collection.findOne({ tokenHash });
+    if (!doc) return null;
+    return {
+      id: doc.id,
+      userId: doc.userId,
+      tokenHash: doc.tokenHash,
+      expiresAt: new Date(doc.expiresAt),
+      createdAt: new Date(doc.createdAt),
+      userAgent: doc.userAgent,
+      ipAddress: doc.ipAddress
+    };
+  }
+  async deleteByHash(tokenHash) {
+    await this.collection.deleteOne({ tokenHash });
+  }
+  async deleteAllForUser(userId) {
+    await this.collection.deleteMany({ userId });
+  }
+  async listForUser(userId) {
+    const docs = await this.collection.find({ userId }).sort({ createdAt: 1 }).toArray();
+    return docs.map((doc) => ({
+      id: doc.id,
+      userId: doc.userId,
+      tokenHash: doc.tokenHash,
+      expiresAt: new Date(doc.expiresAt),
+      createdAt: new Date(doc.createdAt),
+      userAgent: doc.userAgent,
+      ipAddress: doc.ipAddress
+    }));
+  }
+  async deleteById(id, userId) {
+    await this.collection.deleteOne({ id, userId });
+  }
+}
+class MongoPasswordResetTokenService {
+  constructor(db) {
+    this.db = db;
+  }
+  get collection() {
+    return this.db.collection("rebase_password_reset_tokens");
+  }
+  async createToken(userId, tokenHash, expiresAt) {
+    await this.collection.deleteMany({ userId, usedAt: null });
+    await this.collection.insertOne({
+      _id: new ObjectId().toString(),
+      userId,
+      tokenHash,
+      expiresAt,
+      usedAt: null
+    });
+  }
+  async findValidByHash(tokenHash) {
+    const doc = await this.collection.findOne({
+      tokenHash,
+      usedAt: null,
+      expiresAt: { $gt: /* @__PURE__ */ new Date() }
+    });
+    if (!doc) return null;
+    return {
+      userId: doc.userId,
+      expiresAt: new Date(doc.expiresAt)
+    };
+  }
+  async markAsUsed(tokenHash) {
+    await this.collection.updateOne(
+      { tokenHash },
+      { $set: { usedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
+  async deleteAllForUser(userId) {
+    await this.collection.deleteMany({ userId });
+  }
+  async deleteExpired() {
+    await this.collection.deleteMany({ expiresAt: { $lt: /* @__PURE__ */ new Date() } });
+  }
+}
+class MongoTokenRepository {
+  constructor(db) {
+    this.db = db;
+    this.refreshTokenService = new MongoRefreshTokenService(db);
+    this.passwordResetTokenService = new MongoPasswordResetTokenService(db);
+  }
+  refreshTokenService;
+  passwordResetTokenService;
+  async createRefreshToken(userId, tokenHash, expiresAt, userAgent, ipAddress) {
+    await this.refreshTokenService.createToken(userId, tokenHash, expiresAt, userAgent, ipAddress);
+  }
+  async findRefreshTokenByHash(tokenHash) {
+    return this.refreshTokenService.findByHash(tokenHash);
+  }
+  async deleteRefreshToken(tokenHash) {
+    await this.refreshTokenService.deleteByHash(tokenHash);
+  }
+  async deleteAllRefreshTokensForUser(userId) {
+    await this.refreshTokenService.deleteAllForUser(userId);
+  }
+  async listRefreshTokensForUser(userId) {
+    return this.refreshTokenService.listForUser(userId);
+  }
+  async deleteRefreshTokenById(id, userId) {
+    await this.refreshTokenService.deleteById(id, userId);
+  }
+  async createPasswordResetToken(userId, tokenHash, expiresAt) {
+    await this.passwordResetTokenService.createToken(userId, tokenHash, expiresAt);
+  }
+  async findValidPasswordResetToken(tokenHash) {
+    return this.passwordResetTokenService.findValidByHash(tokenHash);
+  }
+  async markPasswordResetTokenUsed(tokenHash) {
+    await this.passwordResetTokenService.markAsUsed(tokenHash);
+  }
+  async deleteAllPasswordResetTokensForUser(userId) {
+    await this.passwordResetTokenService.deleteAllForUser(userId);
+  }
+  async deleteExpiredTokens() {
+    await this.passwordResetTokenService.deleteExpired();
+  }
+}
+class MongoAuthRepository {
+  constructor(db) {
+    this.db = db;
+    this.userService = new MongoUserService(db);
+    this.roleService = new MongoRoleService(db);
+    this.tokenRepository = new MongoTokenRepository(db);
+  }
+  userService;
+  roleService;
+  tokenRepository;
+  async createUser(data) {
+    return this.userService.createUser(data);
+  }
+  async getUserById(id) {
+    return this.userService.getUserById(id);
+  }
+  async getUserByEmail(email) {
+    return this.userService.getUserByEmail(email);
+  }
+  async getUserByIdentity(provider, providerId) {
+    return this.userService.getUserByIdentity(provider, providerId);
+  }
+  async getUserIdentities(userId) {
+    return this.userService.getUserIdentities(userId);
+  }
+  async linkUserIdentity(userId, provider, providerId, profileData) {
+    return this.userService.linkUserIdentity(userId, provider, providerId, profileData);
+  }
+  async updateUser(id, data) {
+    return this.userService.updateUser(id, data);
+  }
+  async deleteUser(id) {
+    await this.userService.deleteUser(id);
+  }
+  async listUsers() {
+    return this.userService.listUsers();
+  }
+  async listUsersPaginated(options) {
+    return this.userService.listUsersPaginated(options);
+  }
+  async updatePassword(id, passwordHash) {
+    await this.userService.updatePassword(id, passwordHash);
+  }
+  async setEmailVerified(id, verified) {
+    await this.userService.setEmailVerified(id, verified);
+  }
+  async setVerificationToken(id, token) {
+    await this.userService.setVerificationToken(id, token);
+  }
+  async getUserByVerificationToken(token) {
+    return this.userService.getUserByVerificationToken(token);
+  }
+  async getUserRoles(userId) {
+    return this.userService.getUserRoles(userId);
+  }
+  async getUserRoleIds(userId) {
+    return this.userService.getUserRoleIds(userId);
+  }
+  async setUserRoles(userId, roleIds) {
+    await this.userService.setUserRoles(userId, roleIds);
+  }
+  async assignDefaultRole(userId, roleId) {
+    await this.userService.assignDefaultRole(userId, roleId);
+  }
+  async getUserWithRoles(userId) {
+    return this.userService.getUserWithRoles(userId);
+  }
+  async getRoleById(id) {
+    return this.roleService.getRoleById(id);
+  }
+  async listRoles() {
+    return this.roleService.listRoles();
+  }
+  async createRole(data) {
+    return this.roleService.createRole(data);
+  }
+  async updateRole(id, data) {
+    return this.roleService.updateRole(id, data);
+  }
+  async deleteRole(id) {
+    await this.roleService.deleteRole(id);
+  }
+  async createRefreshToken(userId, tokenHash, expiresAt, userAgent, ipAddress) {
+    await this.tokenRepository.createRefreshToken(userId, tokenHash, expiresAt, userAgent, ipAddress);
+  }
+  async findRefreshTokenByHash(tokenHash) {
+    return this.tokenRepository.findRefreshTokenByHash(tokenHash);
+  }
+  async deleteRefreshToken(tokenHash) {
+    await this.tokenRepository.deleteRefreshToken(tokenHash);
+  }
+  async deleteAllRefreshTokensForUser(userId) {
+    await this.tokenRepository.deleteAllRefreshTokensForUser(userId);
+  }
+  async listRefreshTokensForUser(userId) {
+    return this.tokenRepository.listRefreshTokensForUser(userId);
+  }
+  async deleteRefreshTokenById(id, userId) {
+    await this.tokenRepository.deleteRefreshTokenById(id, userId);
+  }
+  async createPasswordResetToken(userId, tokenHash, expiresAt) {
+    await this.tokenRepository.createPasswordResetToken(userId, tokenHash, expiresAt);
+  }
+  async findValidPasswordResetToken(tokenHash) {
+    return this.tokenRepository.findValidPasswordResetToken(tokenHash);
+  }
+  async markPasswordResetTokenUsed(tokenHash) {
+    await this.tokenRepository.markPasswordResetTokenUsed(tokenHash);
+  }
+  async deleteAllPasswordResetTokensForUser(userId) {
+    await this.tokenRepository.deleteAllPasswordResetTokensForUser(userId);
+  }
+  async deleteExpiredTokens() {
+    await this.tokenRepository.deleteExpiredTokens();
+  }
+}
+function createMongoBootstrapper(mongoConfig) {
+  let cachedAdmin;
+  return {
+    type: "mongodb",
+    async initializeDriver(config) {
+      const { collections } = config;
+      const registry = new MongoCollectionRegistry();
+      if (collections) {
+        collections.forEach((collection) => registry.register(collection));
+      }
+      const db = mongoConfig.connection;
+      const client = mongoConfig.client;
+      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 = {
+        db,
+        client,
+        registry,
+        realtimeService,
+        driver
+      };
+      return {
+        driver,
+        realtimeProvider: realtimeService,
+        collectionRegistry: registry,
+        internals
+      };
+    },
+    async initializeAuth(config, driverResult) {
+      const internals = driverResult.internals;
+      const db = internals.db;
+      const { ensureAuthCollectionsExist } = await import("./ensure-collections-CNrcwVgY.js");
+      await ensureAuthCollectionsExist(db);
+      const { createEmailService } = await import("@rebasepro/server-core");
+      const authConfig = config;
+      let emailService;
+      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, driverResult) {
+      const historyConfig = config;
+      if (!historyConfig) return void 0;
+      const internals = driverResult.internals;
+      const db = internals.db;
+      const { ensureHistoryCollectionExists } = await import("./ensure-history-collection-DBIiwmCm.js");
+      await ensureHistoryCollectionExists(db);
+      const { MongoHistoryService: MongoHistoryService2 } = await Promise.resolve().then(() => MongoHistoryService$1);
+      const retention = typeof historyConfig === "object" && historyConfig !== null ? historyConfig.retention : void 0;
+      const historyService = new MongoHistoryService2(db, retention ? { ttlDays: retention } : void 0);
+      return { historyService };
+    },
+    async initializeRealtime(_config, driverResult) {
+      const internals = driverResult.internals;
+      return internals.realtimeService;
+    },
+    getAdmin(driverResult) {
+      const internals = driverResult.internals;
+      const db = internals.db;
+      const admin = {
+        async executeAggregate(pipeline) {
+          const firstStage = pipeline[0];
+          const collName = firstStage?.$from ?? "__admin__";
+          const cursor = db.collection(collName).aggregate(pipeline);
+          return await cursor.toArray();
+        },
+        async fetchCollectionStats(collectionName) {
+          const stats = await db.command({ collStats: collectionName });
+          return { count: stats.count, sizeBytes: stats.size };
+        },
+        async fetchUnmappedTables(mappedPaths) {
+          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) {
+          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, realtimeService, driver, config) {
+      const { createMongoWebSocket } = await import("./websocket-BZlPuJrt.js");
+      createMongoWebSocket(
+        server,
+        realtimeService,
+        driver,
+        config,
+        cachedAdmin
+      );
+    }
+  };
+}
+export {
+  MongoCollectionRegistry,
+  MongoConditionBuilder,
+  MongoDBConnection,
+  MongoDriver,
+  MongoEntityService,
+  MongoRealtimeService,
+  createMongoBackend,
+  createMongoBootstrapper,
+  createMongoDBConnection,
+  createMongoDelegate,
+  createMongoEntityRepository,
+  createMongoRealtimeService,
+  isMongoBackendConfig,
+  isMongoDriverConfig
+};
+//# sourceMappingURL=index.es.js.map