@rebasepro/server-mongodb 0.0.1-canary.4d4fb3e

package/dist/index.umd.js

@@ -0,0 +1,878 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("mongodb")) : typeof define === "function" && define.amd ? define(["exports", "mongodb"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase MongoDB"] = {}, global.mongodb));
+})(this, function(exports2, mongodb) {
+  "use strict";
+  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 mongodb.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" && mongodb.ObjectId.isValid(id) && id.length === 24) {
+        return new mongodb.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 mongodb.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 mongodb.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: mongodb.ObjectId.isValid(value.id) ? new mongodb.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 mongodb.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 mongodb.ObjectId().toString();
+    }
+  }
+  class MongoRealtimeService {
+    constructor(db) {
+      this.db = db;
+      this.entityService = new MongoEntityService(db);
+    }
+    subscriptions = /* @__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" && mongodb.ObjectId.isValid(config.entityId) ? new mongodb.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);
+      }
+    }
+  }
+  class MongoDriver {
+    constructor(db, realtimeService) {
+      this.db = db;
+      this.entityService = new MongoEntityService(db);
+      this.realtimeService = realtimeService ?? new MongoRealtimeService(db);
+    }
+    key = "mongodb";
+    initialised = true;
+    entityService;
+    realtimeService;
+    /**
+     * 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,
+      collection,
+      status
+    }) {
+      const entity = await this.entityService.saveEntity(path, values, entityId);
+      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);
+      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 driver = new MongoDriver(db, realtimeService);
+    const mongoConnection = new MongoDBConnection(db, client);
+    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: [] };
+      }
+    };
+    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) {
+    const realtime = realtimeService ?? new MongoRealtimeService(db);
+    return new MongoDriver(db, realtime);
+  }
+  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;
+  }
+  exports2.MongoCollectionRegistry = MongoCollectionRegistry;
+  exports2.MongoConditionBuilder = MongoConditionBuilder;
+  exports2.MongoDBConnection = MongoDBConnection;
+  exports2.MongoDriver = MongoDriver;
+  exports2.MongoEntityService = MongoEntityService;
+  exports2.MongoRealtimeService = MongoRealtimeService;
+  exports2.createMongoBackend = createMongoBackend;
+  exports2.createMongoDBConnection = createMongoDBConnection;
+  exports2.createMongoDelegate = createMongoDelegate;
+  exports2.createMongoEntityRepository = createMongoEntityRepository;
+  exports2.createMongoRealtimeService = createMongoRealtimeService;
+  exports2.isMongoBackendConfig = isMongoBackendConfig;
+  exports2.isMongoDriverConfig = isMongoDriverConfig;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=index.umd.js.map