liwi-mongo 13.4.0 → 14.1.0

package/dist/memory-node.mjs

@@ -0,0 +1,849 @@
+import mongodb from 'mongodb';
+import { updateOne, Query, find, aggregate, ProcessingMode } from 'mingo';
+import { MingoError } from 'mingo/util';
+
+const isBSONValue = (value) => "_bsontype" in value;
+const listEntries = (value) => value instanceof Map ? [...value.entries()] : Object.entries(value);
+const cloneAsStored = (value) => {
+  if (value === void 0) return null;
+  if (typeof value !== "object" || value === null) return value;
+  if (value instanceof Date) return new Date(value);
+  if (value instanceof RegExp || isBSONValue(value)) return value;
+  if (value instanceof Uint8Array) {
+    return new mongodb.Binary(Uint8Array.from(value));
+  }
+  if (Array.isArray(value)) return value.map(cloneAsStored);
+  return Object.fromEntries(
+    listEntries(value).filter(([, fieldValue]) => typeof fieldValue !== "function").map(([field, fieldValue]) => [field, cloneAsStored(fieldValue)])
+  );
+};
+const cloneDocument = (document) => cloneAsStored(document);
+
+const createServerError = (code, codeName, errmsg, details = {}) => new mongodb.MongoServerError({ ok: 0, errmsg, code, codeName, ...details });
+const formatKeyValue = (keyValue) => `{ ${Object.entries(keyValue).map(([field, value]) => `${field}: ${JSON.stringify(value) ?? "null"}`).join(", ")} }`;
+const createDuplicateKeyError = ({
+  namespace,
+  indexName,
+  keyPattern,
+  keyValue
+}) => createServerError(
+  11e3,
+  "DuplicateKey",
+  `E11000 duplicate key error collection: ${namespace} index: ${indexName} dup key: ${formatKeyValue(keyValue)}`,
+  { keyPattern, keyValue }
+);
+const createNamespaceNotFoundError = (namespace) => createServerError(26, "NamespaceNotFound", `ns does not exist: ${namespace}`);
+const createIndexNotFoundError = (name) => createServerError(27, "IndexNotFound", `index not found with name [${name}]`);
+const createInvalidOptionsError = (message) => createServerError(72, "InvalidOptions", message);
+const createIndexOptionsConflictError = (message) => createServerError(85, "IndexOptionsConflict", message);
+const createIndexKeySpecsConflictError = (message) => createServerError(86, "IndexKeySpecsConflict", message);
+const createImmutableIdError = () => createServerError(
+  66,
+  "ImmutableField",
+  "Performing an update on the path '_id' would modify the immutable field '_id'"
+);
+const mingoUpdateErrorCodes = [
+  [/immutable field/, 66, "ImmutableField"],
+  [/would create a conflict/, 40, "ConflictingUpdateOperators"],
+  [/Unknown update operator/, 9, "FailedToParse"]
+];
+const toServerError = (error) => {
+  if (!(error instanceof MingoError)) return error;
+  const [, code, codeName] = mingoUpdateErrorCodes.find(
+    ([pattern]) => pattern.test(error.message)
+  ) ?? [void 0, 2, "BadValue"];
+  return createServerError(code, codeName, error.message);
+};
+const createUnsupportedError = (feature) => new TypeError(`liwi-mongo/memory: ${feature} is not supported`);
+
+const queryOptions = { idKey: "_id" };
+
+const serializeKey = (value) => typeof value === "string" ? `s:${value}` : mongodb.BSON.EJSON.stringify({ value }, { relaxed: false });
+
+const isOperatorObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && !("_bsontype" in value) && Object.keys(value).some((key) => key.startsWith("$"));
+const assertUpdate = (update) => {
+  if (Array.isArray(update)) return;
+  const operators = Object.keys(update);
+  if (operators.length === 0 || !operators.every((operator) => operator.startsWith("$"))) {
+    throw new mongodb.MongoInvalidArgumentError(
+      "Update document requires atomic operators"
+    );
+  }
+};
+const omitField = (document, omitted) => Object.fromEntries(
+  Object.entries(document).filter(([field]) => field !== omitted)
+);
+const prepareModifier = (update, isInsert) => {
+  const $setOnInsert = update.$setOnInsert;
+  const modifier = omitField(update, "$setOnInsert");
+  if (isInsert && $setOnInsert) {
+    return {
+      ...modifier,
+      $set: { ...modifier.$set, ...$setOnInsert }
+    };
+  }
+  return Object.keys(modifier).length === 0 ? void 0 : modifier;
+};
+const omitIdWrite = (modifier, working) => {
+  const $set = modifier.$set;
+  if (!$set || !("_id" in $set)) return modifier;
+  const id = $set._id;
+  if (working._id === void 0) {
+    working._id = id;
+  } else if (serializeKey(id) !== serializeKey(working._id)) {
+    return modifier;
+  }
+  return { ...modifier, $set: omitField($set, "_id") };
+};
+const setPath = (document, path, value) => {
+  const fields = path.split(".");
+  const lastField = fields.pop();
+  let parent = document;
+  for (const field of fields) {
+    parent[field] ??= {};
+    parent = parent[field];
+  }
+  parent[lastField] = value;
+};
+const createUpsertBase = (filter) => {
+  const base = {};
+  const collect = (criteria) => {
+    Object.entries(criteria).forEach(([field, condition]) => {
+      if (field === "$and") {
+        condition.forEach(collect);
+        return;
+      }
+      if (field.startsWith("$") || condition instanceof RegExp) return;
+      if (!isOperatorObject(condition)) {
+        setPath(base, field, condition);
+      } else if ("$eq" in condition) {
+        setPath(base, field, condition.$eq);
+      }
+    });
+  };
+  collect(filter);
+  return cloneDocument(base);
+};
+const applyUpdate = (document, update, { filter, arrayFilters, isInsert }) => {
+  const storedUpdate = cloneAsStored(update);
+  const modifier = Array.isArray(storedUpdate) ? storedUpdate : prepareModifier(storedUpdate, isInsert);
+  if (!modifier) return { next: document, isModified: false };
+  const working = cloneDocument(document);
+  const documents = [working];
+  try {
+    const { modifiedCount } = updateOne(
+      documents,
+      isInsert ? {} : cloneDocument(filter),
+      Array.isArray(modifier) ? modifier : omitIdWrite(modifier, working),
+      { arrayFilters: cloneAsStored(arrayFilters) },
+      queryOptions
+    );
+    return {
+      next: cloneDocument(documents[0]),
+      isModified: modifiedCount > 0
+    };
+  } catch (error) {
+    throw toServerError(error);
+  }
+};
+
+const settle = (run) => new Promise((resolve) => {
+  resolve(run());
+});
+
+const createMemoryCursor = (run) => {
+  let pending;
+  const take = () => {
+    pending ??= run();
+    return pending;
+  };
+  const next = () => settle(() => take().shift() ?? null);
+  return {
+    isStarted: () => pending !== void 0,
+    next,
+    tryNext: next,
+    hasNext: () => settle(() => take().length > 0),
+    toArray: () => settle(() => take().splice(0)),
+    forEach: (iterator) => settle(() => {
+      for (const document of take().splice(0)) {
+        if (iterator(document) === false) return;
+      }
+    }),
+    close: () => settle(() => {
+      pending = [];
+    }),
+    // oxlint-disable-next-line typescript/require-await -- the protocol `for await` reads, nothing to wait for
+    async *[Symbol.asyncIterator]() {
+      const documents = take();
+      while (documents.length > 0) yield documents.shift();
+    }
+  };
+};
+const createMemoryFindCursor = (run, initialOptions) => {
+  const options = { ...initialOptions };
+  const { isStarted, ...cursor } = createMemoryCursor(() => run(options));
+  const configure = (option, value) => {
+    if (isStarted()) throw new mongodb.MongoCursorInUseError();
+    Object.assign(options, { [option]: value });
+    return findCursor;
+  };
+  const findCursor = {
+    ...cursor,
+    sort: (sort) => configure("sort", sort),
+    project: (projection) => configure("projection", projection),
+    skip: (skip) => configure("skip", skip),
+    limit: (limit) => configure("limit", limit)
+  };
+  return findCursor;
+};
+
+const probedProperties = /* @__PURE__ */ new Set([
+  "then",
+  "toJSON",
+  "asymmetricMatch",
+  "$$typeof",
+  "nodeType"
+]);
+const guardUnsupported = (target, label) => new Proxy(target, {
+  get: (object, property, receiver) => {
+    if (typeof property === "symbol" || property in object) {
+      return Reflect.get(object, property, receiver);
+    }
+    if (probedProperties.has(property)) return void 0;
+    throw createUnsupportedError(`${label}.${property}`);
+  }
+});
+
+const buildIndexName = (key) => Object.entries(key).map(([field, direction]) => `${field}_${direction}`).join("_");
+
+const textKeyEntries = [
+  ["_fts", "text"],
+  ["_ftsx", 1]
+];
+const toKeyRecord = (key) => key instanceof Map ? Object.fromEntries(key) : key;
+const toStoredKey = (key) => {
+  const entries = Object.entries(key);
+  const firstTextIndex = entries.findIndex(
+    ([, direction]) => direction === "text"
+  );
+  if (firstTextIndex === -1) return key;
+  const otherEntries = entries.filter(([, direction]) => direction !== "text");
+  const textPosition = entries.slice(0, firstTextIndex).filter(([, direction]) => direction !== "text").length;
+  return Object.fromEntries([
+    ...otherEntries.slice(0, textPosition),
+    ...textKeyEntries,
+    ...otherEntries.slice(textPosition)
+  ]);
+};
+const buildTextOptions = (key, description) => ({
+  weights: {
+    ...Object.fromEntries(
+      Object.entries(key).filter(([, direction]) => direction === "text").map(([field]) => [field, 1])
+    ),
+    ...description.weights
+  },
+  // oxlint-disable-next-line eslint-js/camelcase -- mongo option name
+  default_language: description.default_language ?? "english",
+  // oxlint-disable-next-line eslint-js/camelcase -- mongo option name
+  language_override: description.language_override ?? "language",
+  textIndexVersion: 3
+});
+const isText = (key) => Object.values(key).includes("text");
+const createIndexInfo = (description) => {
+  const key = toKeyRecord(description.key);
+  const { key: _key, name, version: _version, ...options } = description;
+  const definedOptions = Object.fromEntries(
+    Object.entries(options).filter(([, value]) => value !== void 0)
+  );
+  return {
+    v: 2,
+    key: toStoredKey(key),
+    name: name ?? buildIndexName(key),
+    ...definedOptions,
+    ...isText(key) ? buildTextOptions(key, description) : {}
+  };
+};
+const idIndexInfo = {
+  v: 2,
+  key: { _id: 1 },
+  name: "_id_"
+};
+
+const emptyArray = /* @__PURE__ */ Symbol("empty array");
+const isDocument = (value) => typeof value === "object" && value !== null && !(value instanceof Date) && !(value instanceof RegExp) && !("_bsontype" in value);
+const valuesAtPath = (value, path) => {
+  if (path.length === 0) {
+    if (!Array.isArray(value)) return [value];
+    return value.length === 0 ? [emptyArray] : value;
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => valuesAtPath(item, path));
+  }
+  if (!isDocument(value)) return [void 0];
+  const [field, ...rest] = path;
+  return valuesAtPath(value[field], rest);
+};
+const cartesianProduct = (lists) => {
+  let combinations = [[]];
+  for (const list of lists) {
+    combinations = combinations.flatMap(
+      (combination) => list.map((value) => [...combination, value])
+    );
+  }
+  return combinations;
+};
+const createStringFolder = (collation) => {
+  const strength = collation?.strength ?? 3;
+  if (!collation || strength >= 3) return (value) => value;
+  const locale = collation.locale === "simple" ? void 0 : collation.locale;
+  if (strength === 2) return (value) => value.toLocaleLowerCase(locale);
+  return (value) => value.normalize("NFD").replaceAll(new RegExp("\\p{Diacritic}", "gu"), "").toLocaleLowerCase(locale);
+};
+const createUniqueConstraint = ({
+  namespace,
+  indexName,
+  description
+}) => {
+  const keyPattern = Object.fromEntries(
+    Object.entries(description.key).filter(
+      ([, direction]) => direction !== "text"
+    )
+  );
+  const paths = Object.keys(keyPattern).map((field) => field.split("."));
+  const partialFilter = description.partialFilterExpression ? new Query(description.partialFilterExpression, { idKey: "_id" }) : void 0;
+  const foldString = createStringFolder(description.collation);
+  const owners = /* @__PURE__ */ new Map();
+  const serializeValue = (value) => {
+    if (value === emptyArray) return "[]";
+    if (value === void 0) return serializeKey(null);
+    return serializeKey(typeof value === "string" ? foldString(value) : value);
+  };
+  const listEntries = (document) => {
+    if (partialFilter && !partialFilter.test(document)) return [];
+    const valuesByField = paths.map((path) => valuesAtPath(document, path));
+    const isMissingEveryField = valuesByField.every(
+      (values) => values.every((value) => value === void 0)
+    );
+    if (description.sparse && isMissingEveryField) return [];
+    const entries = /* @__PURE__ */ new Map();
+    cartesianProduct(valuesByField).forEach((values) => {
+      const key = JSON.stringify(values.map(serializeValue));
+      entries.set(key, { key, values });
+    });
+    return [...entries.values()];
+  };
+  const toKeyValue = (values) => Object.fromEntries(
+    Object.keys(keyPattern).map((field, index) => {
+      const value = values[index];
+      return [field, value === emptyArray ? [] : value ?? null];
+    })
+  );
+  return {
+    assertCanWrite: (documentKey, document) => {
+      listEntries(document).forEach(({ key, values }) => {
+        const owner = owners.get(key);
+        if (owner === void 0 || owner === documentKey) return;
+        throw createDuplicateKeyError({
+          namespace,
+          indexName,
+          keyPattern,
+          keyValue: toKeyValue(values)
+        });
+      });
+    },
+    write: (documentKey, previous, next) => {
+      if (previous) {
+        listEntries(previous).forEach(({ key }) => {
+          if (owners.get(key) === documentKey) owners.delete(key);
+        });
+      }
+      if (next) {
+        listEntries(next).forEach(({ key }) => owners.set(key, documentKey));
+      }
+    },
+    clear: () => {
+      owners.clear();
+    }
+  };
+};
+
+const serializeSpec = ({
+  v: _version,
+  ...info
+}) => serializeKey(
+  Object.fromEntries(
+    Object.entries(info).toSorted(
+      ([fieldA], [fieldB]) => fieldA.localeCompare(fieldB)
+    )
+  )
+);
+const isSameKeySpace = (a, b) => serializeKey(a.key) === serializeKey(b.key) && serializeKey(a.partialFilterExpression ?? null) === serializeKey(b.partialFilterExpression ?? null) && serializeKey(a.collation ?? null) === serializeKey(b.collation ?? null);
+const isTextInfo = (info) => "_fts" in info.key;
+const createMemoryIndexes = (namespace) => {
+  const indexes = /* @__PURE__ */ new Map();
+  const listInfos = () => [
+    idIndexInfo,
+    ...[...indexes.values()].map(({ info }) => info)
+  ];
+  const isAlreadyCreated = (info) => {
+    const sameName = listInfos().find(({ name }) => name === info.name);
+    if (sameName) {
+      if (serializeSpec(sameName) === serializeSpec(info)) return true;
+      throw createIndexKeySpecsConflictError(
+        `An existing index has the same name as the requested index. Requested index: ${JSON.stringify(info)}, existing index: ${JSON.stringify(sameName)}`
+      );
+    }
+    const sameKey = listInfos().find(
+      (existing) => isSameKeySpace(existing, info)
+    );
+    if (sameKey) {
+      throw createIndexOptionsConflictError(
+        `Index already exists with a different name: ${String(sameKey.name)}`
+      );
+    }
+    const otherText = isTextInfo(info) && listInfos().find(isTextInfo);
+    if (otherText) {
+      throw createIndexOptionsConflictError(
+        `An equivalent index already exists with a different name and options. Requested index: ${JSON.stringify(info)}, existing index: ${JSON.stringify(otherText)}`
+      );
+    }
+    return false;
+  };
+  const buildIndex = (description, info, documents) => {
+    if (!description.unique) return { info };
+    const unique = createUniqueConstraint({
+      namespace,
+      indexName: info.name,
+      description
+    });
+    documents.forEach((document, documentKey) => {
+      unique.assertCanWrite(documentKey, document);
+      unique.write(documentKey, void 0, document);
+    });
+    return { info, unique };
+  };
+  const getIndex = (name) => {
+    const index = indexes.get(name);
+    if (!index) throw createIndexNotFoundError(name);
+    return index;
+  };
+  const listUniqueConstraints = () => [...indexes.values()].flatMap(({ unique }) => unique ? [unique] : []);
+  return {
+    list: listInfos,
+    create: (descriptions, documents) => {
+      const created = descriptions.map((description) => ({
+        description,
+        info: createIndexInfo(description)
+      })).filter(({ info }) => !isAlreadyCreated(info)).map(
+        ({ description, info }) => buildIndex(description, info, documents)
+      );
+      created.forEach((index) => indexes.set(index.info.name, index));
+      return descriptions.map(
+        (description) => createIndexInfo(description).name
+      );
+    },
+    drop: (name) => {
+      if (name === idIndexInfo.name) {
+        throw createInvalidOptionsError("cannot drop _id index");
+      }
+      getIndex(name);
+      indexes.delete(name);
+    },
+    dropAll: () => {
+      indexes.clear();
+    },
+    modify: ({ name, hidden, expireAfterSeconds }) => {
+      const { info } = getIndex(name);
+      if (hidden === true) info.hidden = true;
+      if (hidden === false) delete info.hidden;
+      if (expireAfterSeconds !== void 0) {
+        info.expireAfterSeconds = expireAfterSeconds;
+      }
+    },
+    assertCanWrite: (documentKey, document) => {
+      listUniqueConstraints().forEach((unique) => {
+        unique.assertCanWrite(documentKey, document);
+      });
+    },
+    write: (documentKey, previous, next) => {
+      listUniqueConstraints().forEach((unique) => {
+        unique.write(documentKey, previous, next);
+      });
+    },
+    clearDocuments: () => {
+      listUniqueConstraints().forEach((unique) => {
+        unique.clear();
+      });
+    }
+  };
+};
+
+const toDirection = (direction) => {
+  switch (direction) {
+    case 1:
+    case "asc":
+    case "ascending":
+      return 1;
+    case -1:
+    case "desc":
+    case "descending":
+      return -1;
+    default:
+      throw createUnsupportedError(`sort ${JSON.stringify(direction)}`);
+  }
+};
+const sortDirections = /* @__PURE__ */ new Set([
+  1,
+  -1,
+  "asc",
+  "ascending",
+  "desc",
+  "descending"
+]);
+const isSortPair = (sort) => sort.length === 2 && typeof sort[0] === "string" && sortDirections.has(sort[1]);
+const listSortEntries = (sort) => {
+  if (typeof sort === "string") return [[sort, 1]];
+  if (sort instanceof Map) {
+    return [...sort.entries()];
+  }
+  if (Array.isArray(sort)) {
+    if (isSortPair(sort)) return [sort];
+    return sort.map(
+      (entry) => typeof entry === "string" ? [entry, 1] : entry
+    );
+  }
+  return Object.entries(sort);
+};
+const normalizeSort = (sort) => Object.fromEntries(
+  listSortEntries(sort).map(([field, direction]) => [
+    field,
+    toDirection(direction)
+  ])
+);
+
+const toStoredDocument = (document) => {
+  const stored = cloneDocument(document);
+  return Object.fromEntries([
+    ["_id", stored._id],
+    ...Object.entries(stored).filter(([field]) => field !== "_id")
+  ]);
+};
+const createMemoryCollection = ({
+  databaseName,
+  collectionName,
+  resolveCollection
+}) => {
+  const namespace = `${databaseName}.${collectionName}`;
+  const documents = /* @__PURE__ */ new Map();
+  const indexes = createMemoryIndexes(namespace);
+  let exists = false;
+  const listDocuments = () => [...documents.values()];
+  const findStored = (filter = {}, { sort, projection, skip, limit } = {}) => {
+    const cursor = find(
+      listDocuments(),
+      cloneDocument(filter),
+      projection,
+      queryOptions
+    );
+    if (sort) cursor.sort(normalizeSort(sort));
+    if (skip) cursor.skip(skip);
+    if (limit) cursor.limit(Math.abs(limit));
+    return cursor.all();
+  };
+  const findFirstStored = (filter, sort) => findStored(filter, { sort, limit: 1 })[0];
+  const project = (document, projection) => cloneDocument(
+    projection ? find([document], {}, projection, queryOptions).all()[0] : document
+  );
+  const insertStored = (document) => {
+    const documentKey = serializeKey(document._id);
+    if (documents.has(documentKey)) {
+      throw createDuplicateKeyError({
+        namespace,
+        indexName: "_id_",
+        keyPattern: { _id: 1 },
+        keyValue: { _id: document._id }
+      });
+    }
+    indexes.assertCanWrite(documentKey, document);
+    indexes.write(documentKey, void 0, document);
+    documents.set(documentKey, document);
+    exists = true;
+  };
+  const replaceStored = (previous, next) => {
+    const documentKey = serializeKey(previous._id);
+    if (serializeKey(next._id) !== documentKey) throw createImmutableIdError();
+    indexes.assertCanWrite(documentKey, next);
+    indexes.write(documentKey, previous, next);
+    documents.set(documentKey, next);
+  };
+  const removeStored = (document) => {
+    const documentKey = serializeKey(document._id);
+    indexes.write(documentKey, document, void 0);
+    documents.delete(documentKey);
+  };
+  const assignId = (document) => {
+    if (document._id === void 0) document._id = new mongodb.ObjectId();
+    return document;
+  };
+  const updateStored = (previous, { filter, update, arrayFilters }) => {
+    const { next, isModified } = applyUpdate(previous, update, {
+      filter,
+      arrayFilters,
+      isInsert: false
+    });
+    if (!isModified) return void 0;
+    const stored = toStoredDocument(next);
+    replaceStored(previous, stored);
+    return stored;
+  };
+  const upsertStored = ({
+    filter,
+    update,
+    arrayFilters
+  }) => {
+    const { next } = applyUpdate(createUpsertBase(filter), update, {
+      filter,
+      arrayFilters,
+      isInsert: true
+    });
+    const stored = toStoredDocument(assignId(next));
+    insertStored(stored);
+    return stored;
+  };
+  const updateMatching = (write, { upsert, sort }, limit) => {
+    assertUpdate(write.update);
+    const matched = findStored(write.filter, { sort, limit });
+    if (matched.length === 0 && upsert) {
+      const inserted = upsertStored(write);
+      return {
+        acknowledged: true,
+        matchedCount: 0,
+        modifiedCount: 0,
+        upsertedCount: 1,
+        upsertedId: inserted._id
+      };
+    }
+    const modifiedCount = matched.filter(
+      (previous) => updateStored(previous, write)
+    ).length;
+    return {
+      acknowledged: true,
+      matchedCount: matched.length,
+      modifiedCount,
+      upsertedCount: 0,
+      upsertedId: null
+    };
+  };
+  const assertExists = () => {
+    if (!exists) throw createNamespaceNotFoundError(namespace);
+  };
+  const createIndexes = (descriptions) => {
+    const names = indexes.create(descriptions, documents);
+    exists = true;
+    return names;
+  };
+  const listIndexes = () => {
+    assertExists();
+    return indexes.list().map(cloneDocument);
+  };
+  const drop = () => {
+    documents.clear();
+    indexes.dropAll();
+    exists = false;
+  };
+  const api = {
+    collectionName,
+    dbName: databaseName,
+    namespace,
+    insertOne: (document) => settle(() => {
+      const stored = toStoredDocument(assignId(document));
+      insertStored(stored);
+      return { acknowledged: true, insertedId: stored._id };
+    }),
+    insertMany: (newDocuments) => settle(() => {
+      const insertedIds = Object.fromEntries(
+        newDocuments.map((document, index) => {
+          const stored = toStoredDocument(assignId(document));
+          insertStored(stored);
+          return [index, stored._id];
+        })
+      );
+      return {
+        acknowledged: true,
+        insertedCount: newDocuments.length,
+        insertedIds
+      };
+    }),
+    findOne: (filter, options = {}) => settle(() => {
+      const [document] = findStored(filter, { ...options, limit: 1 });
+      return document ? cloneDocument(document) : null;
+    }),
+    find: (filter, options = {}) => createMemoryFindCursor(
+      (findOptions) => findStored(filter, findOptions).map(cloneDocument),
+      options
+    ),
+    countDocuments: (filter, { skip, limit } = {}) => settle(() => findStored(filter, { skip, limit }).length),
+    estimatedDocumentCount: () => settle(() => documents.size),
+    aggregate: (pipeline = []) => createMemoryCursor(
+      () => aggregate(listDocuments(), pipeline, {
+        ...queryOptions,
+        processingMode: ProcessingMode.CLONE_INPUT,
+        collectionResolver: resolveCollection
+      }).map(cloneDocument)
+    ),
+    updateOne: (filter, update, options = {}) => settle(
+      () => updateMatching(
+        { filter, update, arrayFilters: options.arrayFilters },
+        options,
+        1
+      )
+    ),
+    updateMany: (filter, update, options = {}) => settle(
+      () => updateMatching(
+        { filter, update, arrayFilters: options.arrayFilters },
+        options,
+        void 0
+      )
+    ),
+    findOneAndUpdate: (filter, update, {
+      upsert,
+      arrayFilters,
+      sort,
+      returnDocument = "before",
+      projection
+    } = {}) => settle(() => {
+      assertUpdate(update);
+      const write = { filter, update, arrayFilters };
+      const previous = findFirstStored(filter, sort);
+      if (!previous) {
+        if (!upsert) return null;
+        const inserted = upsertStored(write);
+        return returnDocument === "after" ? project(inserted, projection) : null;
+      }
+      const next = updateStored(previous, write) ?? previous;
+      return project(
+        returnDocument === "after" ? next : previous,
+        projection
+      );
+    }),
+    deleteOne: (filter) => settle(() => {
+      const document = findFirstStored(filter, void 0);
+      if (document) removeStored(document);
+      return { acknowledged: true, deletedCount: document ? 1 : 0 };
+    }),
+    deleteMany: (filter) => settle(() => {
+      const matched = findStored(filter);
+      matched.forEach(removeStored);
+      return { acknowledged: true, deletedCount: matched.length };
+    }),
+    findOneAndDelete: (filter, { sort, projection } = {}) => settle(() => {
+      const document = findFirstStored(filter, sort);
+      if (!document) return null;
+      removeStored(document);
+      return project(document, projection);
+    }),
+    createIndexes: (descriptions) => settle(() => createIndexes(descriptions)),
+    createIndex: (key, options = {}) => settle(() => createIndexes([{ ...options, key }])[0]),
+    listIndexes: () => createMemoryCursor(listIndexes),
+    indexes: () => settle(listIndexes),
+    dropIndex: (name) => settle(() => {
+      assertExists();
+      indexes.drop(name);
+      return { ok: 1 };
+    }),
+    drop: () => settle(() => {
+      drop();
+      return true;
+    })
+  };
+  return {
+    api: guardUnsupported(api, `collection(${collectionName})`),
+    listDocuments,
+    modifyIndex: (changes) => {
+      assertExists();
+      indexes.modify(changes);
+    },
+    clear: () => {
+      documents.clear();
+      indexes.clearDocuments();
+    },
+    drop
+  };
+};
+
+const createMemoryDb = (databaseName) => {
+  const collections = /* @__PURE__ */ new Map();
+  const getCollection = (collectionName) => {
+    const existing = collections.get(collectionName);
+    if (existing) return existing;
+    const collection = createMemoryCollection({
+      databaseName,
+      collectionName,
+      resolveCollection: (otherName) => getCollection(otherName).listDocuments().map(cloneDocument)
+    });
+    collections.set(collectionName, collection);
+    return collection;
+  };
+  const runCommand = (command) => {
+    if ("ping" in command) return { ok: 1 };
+    if ("collMod" in command && "index" in command) {
+      getCollection(command.collMod).modifyIndex(
+        command.index
+      );
+      return { ok: 1 };
+    }
+    throw createUnsupportedError(
+      `db.command({ ${Object.keys(command)[0] ?? ""} })`
+    );
+  };
+  const api = {
+    databaseName,
+    collection: (collectionName) => getCollection(collectionName).api,
+    command: (command) => settle(() => runCommand(command)),
+    dropDatabase: () => settle(() => {
+      collections.forEach((collection) => {
+        collection.drop();
+      });
+      return true;
+    })
+  };
+  return {
+    api: guardUnsupported(api, `db(${databaseName})`),
+    clear: () => {
+      collections.forEach((collection) => {
+        collection.clear();
+      });
+    }
+  };
+};
+
+const createMemoryMongoClient = ({
+  database = "liwi-memory"
+} = {}) => {
+  const databases = /* @__PURE__ */ new Map();
+  const getDb = (databaseName) => {
+    const existing = databases.get(databaseName);
+    if (existing) return existing;
+    const db = createMemoryDb(databaseName);
+    databases.set(databaseName, db);
+    return db;
+  };
+  const target = {
+    db: (databaseName = database) => getDb(databaseName).api,
+    close: () => Promise.resolve()
+  };
+  const client = guardUnsupported(target, "client");
+  target.connect = () => Promise.resolve(client);
+  target.on = () => client;
+  return {
+    client,
+    clear: () => {
+      databases.forEach((db) => {
+        db.clear();
+      });
+    }
+  };
+};
+
+export { createMemoryMongoClient };
+//# sourceMappingURL=memory-node.mjs.map