@objectstack/driver-mongodb 1.0.0

package/dist/index.js

@@ -0,0 +1,815 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MongoDBDriver: () => MongoDBDriver,
+  buildAggregationPipeline: () => buildAggregationPipeline,
+  default: () => index_default,
+  postProcessAggregation: () => postProcessAggregation,
+  translateFilter: () => translateFilter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mongodb-driver.ts
+var import_mongodb = require("mongodb");
+var import_nanoid = require("nanoid");
+
+// src/mongodb-filter.ts
+function translateFilter(where) {
+  if (!where) return {};
+  if (Array.isArray(where)) {
+    return translateArrayFilter(where);
+  }
+  if (typeof where !== "object") return {};
+  return translateCondition(where);
+}
+function translateCondition(condition) {
+  const mongoFilter = {};
+  const andClauses = [];
+  for (const [key, value] of Object.entries(condition)) {
+    switch (key) {
+      case "$and":
+        if (Array.isArray(value)) {
+          andClauses.push({
+            $and: value.map((sub) => translateCondition(sub))
+          });
+        }
+        break;
+      case "$or":
+        if (Array.isArray(value)) {
+          andClauses.push({
+            $or: value.map((sub) => translateCondition(sub))
+          });
+        }
+        break;
+      case "$not":
+        if (value && typeof value === "object") {
+          const inner = translateCondition(value);
+          andClauses.push({ $nor: [inner] });
+        }
+        break;
+      default:
+        if (["limit", "offset", "fields", "orderBy"].includes(key)) continue;
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          const objValue = value;
+          const hasOps = Object.keys(objValue).some((k) => k.startsWith("$"));
+          if (hasOps) {
+            mongoFilter[key] = translateFieldOperators(objValue);
+          } else {
+            mongoFilter[key] = value;
+          }
+        } else {
+          mongoFilter[key] = value;
+        }
+    }
+  }
+  if (andClauses.length > 0) {
+    if (Object.keys(mongoFilter).length > 0) {
+      return { $and: [mongoFilter, ...andClauses] };
+    }
+    if (andClauses.length === 1) {
+      return andClauses[0];
+    }
+    return { $and: andClauses };
+  }
+  return mongoFilter;
+}
+function translateFieldOperators(ops) {
+  const result = {};
+  for (const [op, value] of Object.entries(ops)) {
+    switch (op) {
+      // Direct mappings (ObjectStack → MongoDB are identical)
+      case "$eq":
+      case "$ne":
+      case "$gt":
+      case "$gte":
+      case "$lt":
+      case "$lte":
+      case "$in":
+      case "$nin":
+      case "$exists":
+        result[op] = value;
+        break;
+      // String operators → $regex
+      case "$contains":
+        result.$regex = escapeRegex(String(value));
+        result.$options = "i";
+        break;
+      case "$notContains":
+        result.$not = { $regex: escapeRegex(String(value)), $options: "i" };
+        break;
+      case "$startsWith":
+        result.$regex = `^${escapeRegex(String(value))}`;
+        result.$options = "i";
+        break;
+      case "$endsWith":
+        result.$regex = `${escapeRegex(String(value))}$`;
+        result.$options = "i";
+        break;
+      // Range operator → $gte + $lte
+      case "$between":
+        if (Array.isArray(value) && value.length === 2) {
+          result.$gte = value[0];
+          result.$lte = value[1];
+        }
+        break;
+      // Null check
+      case "$null":
+        if (value === true) {
+          result.$eq = null;
+        } else {
+          result.$ne = null;
+        }
+        break;
+      default:
+        result[op] = value;
+    }
+  }
+  return result;
+}
+function translateArrayFilter(filters) {
+  if (filters.length === 0) return {};
+  if (filters.length === 3 && typeof filters[0] === "string" && typeof filters[1] === "string" && !Array.isArray(filters[0]) && (typeof filters[2] !== "object" || filters[2] === null || Array.isArray(filters[2]))) {
+    const possibleOp = filters[1];
+    const isOperator = [
+      "=",
+      "!=",
+      "<>",
+      ">",
+      ">=",
+      "<",
+      "<=",
+      "in",
+      "nin",
+      "eq",
+      "ne",
+      "gt",
+      "gte",
+      "lt",
+      "lte",
+      "contains",
+      "like"
+    ].includes(possibleOp) || possibleOp.startsWith("$");
+    if (isOperator) {
+      return translateComparison(filters[0], possibleOp, filters[2]);
+    }
+  }
+  const groups = [];
+  let nextLogic = "and";
+  for (const item of filters) {
+    if (typeof item === "string") {
+      const lower = item.toLowerCase();
+      if (lower === "or") nextLogic = "or";
+      else if (lower === "and") nextLogic = "and";
+      continue;
+    }
+    if (Array.isArray(item)) {
+      const isTuple = item.length === 3 && typeof item[0] === "string" && typeof item[1] === "string" && !Array.isArray(item[2]);
+      const translated = isTuple ? translateComparison(item[0], item[1], item[2]) : translateArrayFilter(item);
+      groups.push({ logic: nextLogic, filter: translated });
+      nextLogic = "and";
+    }
+  }
+  if (groups.length === 0) return {};
+  if (groups.length === 1) return groups[0].filter;
+  const hasOr = groups.some((g) => g.logic === "or");
+  if (!hasOr) {
+    return { $and: groups.map((g) => g.filter) };
+  }
+  const orGroups = [[]];
+  for (const g of groups) {
+    if (g.logic === "or") {
+      orGroups.push([g.filter]);
+    } else {
+      orGroups[orGroups.length - 1].push(g.filter);
+    }
+  }
+  const orClauses = orGroups.map((group) => {
+    if (group.length === 1) return group[0];
+    return { $and: group };
+  });
+  if (orClauses.length === 1) return orClauses[0];
+  return { $or: orClauses };
+}
+function translateComparison(field, op, value) {
+  const mappedField = mapFieldName(field);
+  switch (op) {
+    case "=":
+    case "eq":
+      return { [mappedField]: value };
+    case "!=":
+    case "<>":
+    case "ne":
+      return { [mappedField]: { $ne: value } };
+    case ">":
+    case "gt":
+      return { [mappedField]: { $gt: value } };
+    case ">=":
+    case "gte":
+      return { [mappedField]: { $gte: value } };
+    case "<":
+    case "lt":
+      return { [mappedField]: { $lt: value } };
+    case "<=":
+    case "lte":
+      return { [mappedField]: { $lte: value } };
+    case "in":
+      return { [mappedField]: { $in: value } };
+    case "nin":
+      return { [mappedField]: { $nin: value } };
+    case "contains":
+    case "like":
+      return { [mappedField]: { $regex: escapeRegex(String(value)), $options: "i" } };
+    default:
+      return { [mappedField]: { [`$${op}`]: value } };
+  }
+}
+function mapFieldName(field) {
+  if (field === "createdAt") return "created_at";
+  if (field === "updatedAt") return "updated_at";
+  return field;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/mongodb-aggregation.ts
+function buildAggregationPipeline(opts) {
+  const pipeline = [];
+  if (opts.where) {
+    const matchFilter = translateFilter(opts.where);
+    if (Object.keys(matchFilter).length > 0) {
+      pipeline.push({ $match: matchFilter });
+    }
+  }
+  if (opts.aggregations && opts.aggregations.length > 0) {
+    const groupId = {};
+    const groupAccumulators = {};
+    if (opts.groupBy && opts.groupBy.length > 0) {
+      for (const field of opts.groupBy) {
+        groupId[field] = `$${field}`;
+      }
+    }
+    for (const agg of opts.aggregations) {
+      groupAccumulators[agg.alias] = buildAccumulator(agg);
+    }
+    pipeline.push({
+      $group: {
+        _id: Object.keys(groupId).length > 0 ? groupId : null,
+        ...groupAccumulators
+      }
+    });
+    if (opts.groupBy && opts.groupBy.length > 0) {
+      const project = { _id: 0 };
+      for (const field of opts.groupBy) {
+        project[field] = `$_id.${field}`;
+      }
+      for (const agg of opts.aggregations) {
+        project[agg.alias] = 1;
+      }
+      pipeline.push({ $project: project });
+    }
+  }
+  if (opts.orderBy && opts.orderBy.length > 0) {
+    const sort = {};
+    for (const item of opts.orderBy) {
+      sort[item.field] = item.order === "desc" ? -1 : 1;
+    }
+    pipeline.push({ $sort: sort });
+  }
+  if (opts.offset !== void 0 && opts.offset > 0) {
+    pipeline.push({ $skip: opts.offset });
+  }
+  if (opts.limit !== void 0) {
+    pipeline.push({ $limit: opts.limit });
+  }
+  return pipeline;
+}
+function buildAccumulator(agg) {
+  const fieldRef = agg.field ? `$${agg.field}` : null;
+  switch (agg.function) {
+    case "count":
+      return { $sum: 1 };
+    case "sum":
+      return { $sum: fieldRef ?? 0 };
+    case "avg":
+      return { $avg: fieldRef ?? 0 };
+    case "min":
+      return { $min: fieldRef ?? 0 };
+    case "max":
+      return { $max: fieldRef ?? 0 };
+    case "count_distinct":
+      return { $addToSet: fieldRef ?? null };
+    case "array_agg":
+      return { $push: fieldRef ?? "$$ROOT" };
+    case "string_agg":
+      return { $push: fieldRef ?? "" };
+    default:
+      return { $sum: fieldRef ?? 0 };
+  }
+}
+function postProcessAggregation(results, aggregations) {
+  const countDistinctFields = aggregations.filter((a) => a.function === "count_distinct").map((a) => a.alias);
+  const stringAggFields = aggregations.filter((a) => a.function === "string_agg").map((a) => a.alias);
+  if (countDistinctFields.length === 0 && stringAggFields.length === 0) {
+    return results;
+  }
+  return results.map((row) => {
+    const processed = { ...row };
+    for (const field of countDistinctFields) {
+      if (Array.isArray(processed[field])) {
+        processed[field] = processed[field].length;
+      }
+    }
+    for (const field of stringAggFields) {
+      if (Array.isArray(processed[field])) {
+        processed[field] = processed[field].join(", ");
+      }
+    }
+    return processed;
+  });
+}
+
+// src/mongodb-schema.ts
+async function syncCollectionSchema(db, collectionName, schema) {
+  const collections = await db.listCollections({ name: collectionName }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection(collectionName);
+  }
+  const collection = db.collection(collectionName);
+  const indexOps = [
+    { spec: { id: 1 }, options: { unique: true, name: "idx_id_unique" } },
+    { spec: { created_at: 1 }, options: { name: "idx_created_at" } },
+    { spec: { updated_at: 1 }, options: { name: "idx_updated_at" } }
+  ];
+  if (schema.fields) {
+    for (const [fieldName, field] of Object.entries(schema.fields)) {
+      if (field.unique) {
+        indexOps.push({
+          spec: { [fieldName]: 1 },
+          options: { unique: true, sparse: true, name: `idx_${fieldName}_unique` }
+        });
+      } else if (field.indexed) {
+        indexOps.push({
+          spec: { [fieldName]: 1 },
+          options: { name: `idx_${fieldName}` }
+        });
+      }
+      if (field.type === "lookup" && field.reference_to) {
+        indexOps.push({
+          spec: { [fieldName]: 1 },
+          options: { name: `idx_${fieldName}_lookup` }
+        });
+      }
+    }
+  }
+  for (const { spec, options } of indexOps) {
+    try {
+      await collection.createIndex(spec, options);
+    } catch (error) {
+      if (error.codeName === "IndexOptionsConflict" || error.code === 85) {
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+async function dropCollection(db, collectionName) {
+  const collections = await db.listCollections({ name: collectionName }).toArray();
+  if (collections.length > 0) {
+    await db.dropCollection(collectionName);
+  }
+}
+
+// src/mongodb-driver.ts
+var DEFAULT_ID_LENGTH = 16;
+var MongoDBDriver = class {
+  constructor(config) {
+    this.name = "com.objectstack.driver.mongodb";
+    this.version = "1.0.0";
+    this.supports = {
+      // Basic CRUD Operations
+      create: true,
+      read: true,
+      update: true,
+      delete: true,
+      // Bulk Operations
+      bulkCreate: true,
+      bulkUpdate: true,
+      bulkDelete: true,
+      // Transaction & Connection Management
+      transactions: true,
+      savepoints: false,
+      // Query Operations
+      queryFilters: true,
+      queryAggregations: true,
+      querySorting: true,
+      queryPagination: true,
+      queryWindowFunctions: false,
+      querySubqueries: false,
+      queryCTE: false,
+      joins: false,
+      // Advanced Features
+      fullTextSearch: true,
+      jsonQuery: true,
+      geospatialQuery: true,
+      streaming: true,
+      jsonFields: true,
+      arrayFields: true,
+      vectorSearch: false,
+      // Schema Management
+      schemaSync: true,
+      batchSchemaSync: true,
+      migrations: false,
+      indexes: true,
+      // Performance & Optimization
+      connectionPooling: true,
+      preparedStatements: false,
+      queryCache: false
+    };
+    this.config = config;
+    const clientOptions = {
+      maxPoolSize: config.maxPoolSize ?? 10,
+      minPoolSize: config.minPoolSize ?? 1,
+      connectTimeoutMS: config.connectTimeoutMS ?? 1e4,
+      serverSelectionTimeoutMS: config.serverSelectionTimeoutMS ?? 5e3,
+      ...config.options
+    };
+    this.client = new import_mongodb.MongoClient(config.url, clientOptions);
+  }
+  // ===========================================================================
+  // Lifecycle
+  // ===========================================================================
+  async connect() {
+    await this.client.connect();
+    const dbName = this.config.database || this.extractDatabaseName(this.config.url);
+    this.db = this.client.db(dbName);
+  }
+  async disconnect() {
+    await this.client.close();
+  }
+  async checkHealth() {
+    try {
+      await this.db.command({ ping: 1 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getPoolStats() {
+    return void 0;
+  }
+  // ===========================================================================
+  // Raw Execution
+  // ===========================================================================
+  async execute(command, _parameters, options) {
+    const session = this.getSession(options);
+    if (typeof command === "object" && command !== null) {
+      return await this.db.command(command, { session });
+    }
+    return command;
+  }
+  // ===========================================================================
+  // CRUD Operations
+  // ===========================================================================
+  async find(object, query, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const filter = translateFilter(query.where);
+    const findOptions = { session };
+    if (query.fields && query.fields.length > 0) {
+      const projection = {};
+      for (const field of query.fields) {
+        projection[field] = 1;
+      }
+      projection.id = 1;
+      projection._id = 0;
+      findOptions.projection = projection;
+    } else {
+      findOptions.projection = { _id: 0 };
+    }
+    if (query.orderBy && Array.isArray(query.orderBy)) {
+      const sort = {};
+      for (const item of query.orderBy) {
+        if (item.field) {
+          sort[this.mapFieldName(item.field)] = item.order === "desc" ? -1 : 1;
+        }
+      }
+      findOptions.sort = sort;
+    }
+    if (query.offset !== void 0) findOptions.skip = query.offset;
+    if (query.limit !== void 0) findOptions.limit = query.limit;
+    const cursor = collection.find(filter, findOptions);
+    const results = await cursor.toArray();
+    return results;
+  }
+  async findOne(object, query, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const filter = translateFilter(query.where);
+    const result = await collection.findOne(filter, {
+      session,
+      projection: { _id: 0 }
+    });
+    return result;
+  }
+  findStream(object, query, options) {
+    return this._findStream(object, query, options);
+  }
+  async *_findStream(object, query, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const filter = translateFilter(query.where);
+    const findOptions = {
+      session,
+      projection: { _id: 0 }
+    };
+    if (query.orderBy && Array.isArray(query.orderBy)) {
+      const sort = {};
+      for (const item of query.orderBy) {
+        if (item.field) {
+          sort[this.mapFieldName(item.field)] = item.order === "desc" ? -1 : 1;
+        }
+      }
+      findOptions.sort = sort;
+    }
+    if (query.offset !== void 0) findOptions.skip = query.offset;
+    if (query.limit !== void 0) findOptions.limit = query.limit;
+    const cursor = collection.find(filter, findOptions);
+    for await (const doc of cursor) {
+      yield doc;
+    }
+  }
+  async create(object, data, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const { _id, ...rest } = data;
+    const toInsert = { ...rest };
+    if (toInsert.id === void 0) {
+      toInsert.id = (0, import_nanoid.nanoid)(DEFAULT_ID_LENGTH);
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (toInsert.created_at === void 0) toInsert.created_at = now;
+    if (toInsert.updated_at === void 0) toInsert.updated_at = now;
+    await collection.insertOne(toInsert, { session });
+    const { _id: insertedId, ...result } = toInsert;
+    return result;
+  }
+  async update(object, id, data, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const { _id, id: dataId, ...updateData } = data;
+    updateData.updated_at = /* @__PURE__ */ new Date();
+    await collection.updateOne(
+      { id: String(id) },
+      { $set: updateData },
+      { session }
+    );
+    const updated = await collection.findOne(
+      { id: String(id) },
+      { session, projection: { _id: 0 } }
+    );
+    return updated || { id: String(id), ...updateData };
+  }
+  async upsert(object, data, conflictKeys, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const { _id, ...rest } = data;
+    const toUpsert = { ...rest };
+    if (toUpsert.id === void 0) {
+      toUpsert.id = (0, import_nanoid.nanoid)(DEFAULT_ID_LENGTH);
+    }
+    const now = /* @__PURE__ */ new Date();
+    toUpsert.updated_at = now;
+    const mergeKeys = conflictKeys && conflictKeys.length > 0 ? conflictKeys : ["id"];
+    const filter = {};
+    for (const key of mergeKeys) {
+      if (toUpsert[key] !== void 0) {
+        filter[key] = toUpsert[key];
+      }
+    }
+    await collection.updateOne(
+      filter,
+      {
+        $set: toUpsert,
+        $setOnInsert: { created_at: now }
+      },
+      { upsert: true, session }
+    );
+    const result = await collection.findOne(
+      { id: toUpsert.id },
+      { session, projection: { _id: 0 } }
+    );
+    return result || toUpsert;
+  }
+  async delete(object, id, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const result = await collection.deleteOne({ id: String(id) }, { session });
+    return result.deletedCount > 0;
+  }
+  async count(object, query, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const filter = query?.where ? translateFilter(query.where) : {};
+    return await collection.countDocuments(filter, { session });
+  }
+  // ===========================================================================
+  // Bulk Operations
+  // ===========================================================================
+  async bulkCreate(object, dataArray, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const now = /* @__PURE__ */ new Date();
+    const docs = dataArray.map((data) => {
+      const { _id, ...rest } = data;
+      const doc = { ...rest };
+      if (doc.id === void 0) doc.id = (0, import_nanoid.nanoid)(DEFAULT_ID_LENGTH);
+      if (doc.created_at === void 0) doc.created_at = now;
+      if (doc.updated_at === void 0) doc.updated_at = now;
+      return doc;
+    });
+    await collection.insertMany(docs, { session });
+    return docs.map(({ _id, ...rest }) => rest);
+  }
+  async bulkUpdate(object, updates, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const now = /* @__PURE__ */ new Date();
+    const bulkOps = updates.map(({ id, data }) => {
+      const { _id, id: dataId, ...updateData } = data;
+      updateData.updated_at = now;
+      return {
+        updateOne: {
+          filter: { id: String(id) },
+          update: { $set: updateData }
+        }
+      };
+    });
+    await collection.bulkWrite(bulkOps, { session });
+    const ids = updates.map((u) => String(u.id));
+    const results = await collection.find(
+      { id: { $in: ids } },
+      { session, projection: { _id: 0 } }
+    ).toArray();
+    return results;
+  }
+  async bulkDelete(object, ids, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    await collection.deleteMany(
+      { id: { $in: ids.map(String) } },
+      { session }
+    );
+  }
+  async updateMany(object, query, data, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const filter = translateFilter(query.where);
+    const { _id, id, ...updateData } = data;
+    updateData.updated_at = /* @__PURE__ */ new Date();
+    const result = await collection.updateMany(
+      filter,
+      { $set: updateData },
+      { session }
+    );
+    return result.modifiedCount;
+  }
+  async deleteMany(object, query, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const filter = translateFilter(query.where);
+    const result = await collection.deleteMany(filter, { session });
+    return result.deletedCount;
+  }
+  // ===========================================================================
+  // Aggregation
+  // ===========================================================================
+  async aggregate(object, query, options) {
+    const collection = this.getCollection(object);
+    const session = this.getSession(options);
+    const aggregations = query.aggregations || query.aggregate || [];
+    const pipeline = buildAggregationPipeline({
+      where: query.where,
+      aggregations,
+      groupBy: query.groupBy,
+      orderBy: query.orderBy,
+      limit: query.limit,
+      offset: query.offset
+    });
+    const results = await collection.aggregate(pipeline, { session }).toArray();
+    return postProcessAggregation(results, aggregations);
+  }
+  // ===========================================================================
+  // Transactions
+  // ===========================================================================
+  async beginTransaction(_options) {
+    const session = this.client.startSession();
+    session.startTransaction();
+    return session;
+  }
+  async commit(transaction) {
+    const session = transaction;
+    await session.commitTransaction();
+    await session.endSession();
+  }
+  async rollback(transaction) {
+    const session = transaction;
+    await session.abortTransaction();
+    await session.endSession();
+  }
+  // ===========================================================================
+  // Schema Management
+  // ===========================================================================
+  async syncSchema(object, schema, _options) {
+    const objectDef = schema;
+    await syncCollectionSchema(this.db, object, objectDef);
+  }
+  async syncSchemasBatch(schemas, options) {
+    for (const { object, schema } of schemas) {
+      await this.syncSchema(object, schema, options);
+    }
+  }
+  async dropTable(object, _options) {
+    await dropCollection(this.db, object);
+  }
+  // ===========================================================================
+  // Query Plan Analysis
+  // ===========================================================================
+  async explain(object, query, _options) {
+    const collection = this.getCollection(object);
+    const filter = translateFilter(query.where);
+    const explanation = await collection.find(filter).explain("executionStats");
+    return explanation;
+  }
+  // ===========================================================================
+  // Helpers
+  // ===========================================================================
+  /** Get the underlying Db instance for advanced usage. */
+  getDb() {
+    return this.db;
+  }
+  /** Get the underlying MongoClient for advanced usage. */
+  getClient() {
+    return this.client;
+  }
+  getCollection(name) {
+    return this.db.collection(name);
+  }
+  getSession(options) {
+    return options?.transaction;
+  }
+  mapFieldName(field) {
+    if (field === "createdAt") return "created_at";
+    if (field === "updatedAt") return "updated_at";
+    return field;
+  }
+  extractDatabaseName(url) {
+    const match = url.match(/\/\/[^/]*\/([^?/]+)/);
+    if (match) return match[1];
+    return "objectstack";
+  }
+};
+
+// src/index.ts
+var index_default = {
+  id: "com.objectstack.driver.mongodb",
+  version: "1.0.0",
+  onEnable: async (context) => {
+    const { logger, config, drivers } = context;
+    logger.info("[MongoDB Driver] Initializing...");
+    if (drivers) {
+      const driver = new MongoDBDriver(config);
+      drivers.register(driver);
+      logger.info(`[MongoDB Driver] Registered driver: ${driver.name}`);
+    } else {
+      logger.warn("[MongoDB Driver] No driver registry found in context.");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoDBDriver,
+  buildAggregationPipeline,
+  postProcessAggregation,
+  translateFilter
+});
+//# sourceMappingURL=index.js.map