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

package/dist/index.es.js

@@ -0,0 +1,875 @@
+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();
+  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);
+    }
+  }
+}
+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;
+}
+export {
+  MongoCollectionRegistry,
+  MongoConditionBuilder,
+  MongoDBConnection,
+  MongoDriver,
+  MongoEntityService,
+  MongoRealtimeService,
+  createMongoBackend,
+  createMongoDBConnection,
+  createMongoDelegate,
+  createMongoEntityRepository,
+  createMongoRealtimeService,
+  isMongoBackendConfig,
+  isMongoDriverConfig
+};
+//# sourceMappingURL=index.es.js.map