@event-driven-io/pongo 0.17.0-beta.33 → 0.17.0-beta.35

package/dist/chunk-EQ3T4XHT.cjs

@@ -0,0 +1,1583 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/cache/pongoCacheWrapper.ts
+var pongoCacheWrapper = (options) => {
+  const { provider, hooks } = options;
+  const onError = (error, operation) => {
+    _optionalChain([hooks, 'optionalAccess', _2 => _2.onError, 'optionalCall', _3 => _3(error, operation)]);
+  };
+  let isClosed = false;
+  return {
+    cacheType: provider.cacheType,
+    async get(key) {
+      try {
+        const result = await provider.get(key);
+        if (result !== void 0) {
+          _optionalChain([hooks, 'optionalAccess', _4 => _4.onHit, 'optionalCall', _5 => _5(key)]);
+        } else {
+          _optionalChain([hooks, 'optionalAccess', _6 => _6.onMiss, 'optionalCall', _7 => _7(key)]);
+        }
+        return result;
+      } catch (error) {
+        onError(error, "get");
+        _optionalChain([hooks, 'optionalAccess', _8 => _8.onMiss, 'optionalCall', _9 => _9(key)]);
+        return void 0;
+      }
+    },
+    async getMany(keys) {
+      try {
+        return await provider.getMany(keys);
+      } catch (error) {
+        onError(error, "getMany");
+        return [];
+      }
+    },
+    async set(key, value) {
+      try {
+        await provider.set(key, value);
+      } catch (error) {
+        onError(error, "set");
+      }
+    },
+    async setMany(entries) {
+      try {
+        await provider.setMany(entries);
+      } catch (error) {
+        onError(error, "setMany");
+      }
+    },
+    async update(key, updater) {
+      try {
+        await provider.update(key, updater);
+      } catch (error) {
+        onError(error, "update");
+      }
+    },
+    async updateMany(keys, updater) {
+      try {
+        await provider.updateMany(keys, updater);
+      } catch (error) {
+        onError(error, "updateMany");
+      }
+    },
+    async delete(key) {
+      try {
+        await provider.delete(key);
+        _optionalChain([hooks, 'optionalAccess', _10 => _10.onEvict, 'optionalCall', _11 => _11(key)]);
+      } catch (error) {
+        onError(error, "delete");
+      }
+    },
+    async deleteMany(keys) {
+      try {
+        await provider.deleteMany(keys);
+        for (const key of keys) _optionalChain([hooks, 'optionalAccess', _12 => _12.onEvict, 'optionalCall', _13 => _13(key)]);
+      } catch (error) {
+        onError(error, "deleteMany");
+      }
+    },
+    clear() {
+      return provider.clear();
+    },
+    close() {
+      if (isClosed) return;
+      isClosed = true;
+      return provider.close();
+    }
+  };
+};
+
+// src/core/cache/providers/identityMapCache.ts
+var identityMapCache = () => {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    cacheType: "pongo:cache:identity-map",
+    get: (key) => Promise.resolve(
+      store.has(key) ? store.get(key) : void 0
+    ),
+    getMany: (keys) => keys.map(
+      (k) => store.has(k) ? store.get(k) : void 0
+    ),
+    set: (key, value) => {
+      store.set(key, value);
+    },
+    setMany: (entries) => {
+      for (const { key, value } of entries) store.set(key, value);
+    },
+    update: (key, _updater) => {
+      store.delete(key);
+    },
+    updateMany: (keys, _updater) => {
+      for (const key of keys) store.delete(key);
+    },
+    delete: (key) => {
+      store.delete(key);
+    },
+    deleteMany: (keys) => {
+      for (const key of keys) store.delete(key);
+    },
+    clear: () => {
+      store.clear();
+    },
+    close: () => {
+      store.clear();
+    }
+  };
+};
+
+// src/core/cache/providers/lruCache.ts
+var _lrucache = require('lru-cache');
+var defaultLRUCacheOptions = {
+  max: 1e3
+};
+var lruCache = (options) => {
+  const cache = new (0, _lrucache.LRUCache)({
+    ...defaultLRUCacheOptions,
+    ...options
+  });
+  return {
+    cacheType: "pongo:cache:lru",
+    get: (key) => {
+      const entry = cache.get(key);
+      if (entry === void 0) return void 0;
+      return entry.doc;
+    },
+    getMany: (keys) => keys.map((k) => {
+      const entry = cache.get(k);
+      if (entry === void 0) return void 0;
+      return entry.doc;
+    }),
+    set: (key, value) => {
+      cache.set(key, { doc: value });
+    },
+    setMany: (entries) => {
+      for (const { key, value } of entries) {
+        cache.set(key, { doc: value });
+      }
+    },
+    update: (key, _updater) => {
+      cache.delete(key);
+    },
+    updateMany(keys, _updater) {
+      for (const key of keys) {
+        cache.delete(key);
+      }
+    },
+    delete: (key) => {
+      cache.delete(key);
+    },
+    deleteMany: (keys) => {
+      for (const key of keys) cache.delete(key);
+    },
+    clear: () => {
+      cache.clear();
+    },
+    close: () => {
+      cache.clear();
+    }
+  };
+};
+
+// src/core/cache/providers/noopCache.ts
+var noopCacheProvider = {
+  cacheType: "pongo:cache:no-op",
+  get: () => void 0,
+  set: () => {
+  },
+  update: () => {
+  },
+  delete: () => {
+  },
+  getMany: (keys) => keys.map(() => void 0),
+  setMany: () => {
+  },
+  updateMany: () => {
+  },
+  deleteMany: () => {
+  },
+  clear: () => {
+  },
+  close: () => {
+  }
+};
+
+// src/core/cache/pongoCache.ts
+var DEFAULT_CONFIG = { type: "in-memory" };
+var pongoCache = (options) => {
+  if (options === void 0 || options === "disabled") return noopCacheProvider;
+  if ("cacheType" in options) return options;
+  const config = _nullishCoalesce(options, () => ( DEFAULT_CONFIG));
+  if (config.type === "identity-map") return identityMapCache();
+  const raw = lruCache(config);
+  return pongoCacheWrapper({ provider: raw });
+};
+
+// src/core/cache/transactions/pongoTransactionCache.ts
+var pongoTransactionCache = (options) => {
+  const innerCache = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.cache]), () => ( identityMapCache()));
+  const operations = [];
+  const cache = {
+    type: "pongo:cache:transaction-buffer",
+    get(key) {
+      return innerCache.get(key);
+    },
+    set(key, value, options2) {
+      const { mainCache } = options2;
+      innerCache.set(key, value);
+      operations.push({
+        type: "set",
+        key,
+        value,
+        mainCache
+      });
+    },
+    update(key, updater, options2) {
+      const { mainCache } = options2;
+      innerCache.update(key, updater);
+      operations.push({
+        type: "update",
+        key,
+        updater,
+        mainCache
+      });
+    },
+    delete(key, options2) {
+      innerCache.delete(key);
+      operations.push({ type: "delete", key, mainCache: options2.mainCache });
+    },
+    getMany(keys) {
+      return innerCache.getMany(keys);
+    },
+    setMany(entries, options2) {
+      innerCache.setMany(entries);
+      operations.push({
+        type: "setMany",
+        entries,
+        mainCache: options2.mainCache
+      });
+    },
+    updateMany(keys, updater, options2) {
+      const { mainCache } = options2;
+      innerCache.updateMany(keys, updater);
+      operations.push({
+        type: "updateMany",
+        keys,
+        updater,
+        mainCache
+      });
+    },
+    deleteMany(keys, options2) {
+      innerCache.deleteMany(keys);
+      operations.push({
+        type: "deleteMany",
+        keys,
+        mainCache: options2.mainCache
+      });
+    },
+    clear() {
+      innerCache.clear();
+      operations.length = 0;
+    },
+    async commit() {
+      for (const op of operations) {
+        switch (op.type) {
+          case "set":
+            await op.mainCache.set(op.key, op.value);
+            break;
+          case "setMany":
+            await op.mainCache.setMany(op.entries);
+            break;
+          case "update":
+            await op.mainCache.update(
+              op.key,
+              op.updater
+            );
+            break;
+          case "updateMany":
+            await op.mainCache.updateMany(
+              op.keys,
+              op.updater
+            );
+            break;
+          case "delete":
+            await op.mainCache.delete(op.key);
+            break;
+          case "deleteMany":
+            await op.mainCache.deleteMany(op.keys);
+            break;
+        }
+      }
+      innerCache.clear();
+      operations.length = 0;
+    }
+  };
+  return cache;
+};
+
+// src/core/collection/filters/filters.ts
+var asPlainObjectWithSingleKey = (filter, key) => filter && typeof filter === "object" && !Array.isArray(filter) && Object.keys(filter).length === 1 && key in filter ? filter : void 0;
+var idFromFilter = (filter) => {
+  const idFilter = asPlainObjectWithSingleKey(filter, "_id");
+  return typeof _optionalChain([idFilter, 'optionalAccess', _15 => _15["_id"]]) === "string" ? idFilter["_id"] : void 0;
+};
+var getIdsFromIdOnlyFilter = (filter) => {
+  const idFilter = asPlainObjectWithSingleKey(filter, "_id");
+  if (!idFilter) return void 0;
+  const idValue = idFilter["_id"];
+  if (typeof idValue === "string") return [idValue];
+  const $in = idValue && typeof idValue === "object" && "$in" in idValue ? idValue["$in"] : void 0;
+  return Array.isArray($in) && $in.every((i) => typeof i === "string") ? $in : void 0;
+};
+
+// src/core/collection/pongoCollection.ts
+
+
+
+
+
+var _dumbo = require('@event-driven-io/dumbo');
+var _uuid = require('uuid');
+var enlistIntoTransactionIfActive = async (db, options) => {
+  const transaction = _optionalChain([options, 'optionalAccess', _16 => _16.session, 'optionalAccess', _17 => _17.transaction]);
+  if (!transaction || !transaction.isActive) return null;
+  return await transaction.enlistDatabase(db);
+};
+var transactionExecutorOrDefault = async (db, options, defaultSqlExecutor) => {
+  const existingTransaction = await enlistIntoTransactionIfActive(db, options);
+  return _nullishCoalesce(_optionalChain([existingTransaction, 'optionalAccess', _18 => _18.execute]), () => ( defaultSqlExecutor));
+};
+var pongoCollection = ({
+  db,
+  collectionName,
+  pool,
+  schemaComponent: schemaComponent3,
+  schema,
+  errors,
+  serializer,
+  cache: cacheOptions
+}) => {
+  const SqlFor = schemaComponent3.sqlBuilder;
+  const sqlExecutor = pool.execute;
+  const cache = pongoCache(cacheOptions);
+  const columnMapping = {
+    mapping: {
+      ..._dumbo.mapColumnToJSON.call(void 0, "data", serializer),
+      ..._dumbo.mapColumnToBigint.call(void 0, "_version")
+    }
+  };
+  const command = async (sql, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).command(sql, columnMapping);
+  const query = async (sql, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).query(
+    sql,
+    columnMapping
+  );
+  let shouldMigrate = _optionalChain([schema, 'optionalAccess', _19 => _19.autoMigration]) !== "None";
+  const createCollection = (options) => {
+    shouldMigrate = false;
+    if (_optionalChain([options, 'optionalAccess', _20 => _20.session])) return command(SqlFor.createCollection(), options);
+    else return command(SqlFor.createCollection());
+  };
+  const ensureCollectionCreated = (options) => {
+    if (!shouldMigrate) {
+      return Promise.resolve();
+    }
+    return createCollection(options);
+  };
+  const upcast = _nullishCoalesce(_optionalChain([schema, 'optionalAccess', _21 => _21.versioning, 'optionalAccess', _22 => _22.upcast]), () => ( ((doc) => doc)));
+  const downcast = _nullishCoalesce(_optionalChain([schema, 'optionalAccess', _23 => _23.versioning, 'optionalAccess', _24 => _24.downcast]), () => ( ((doc) => doc)));
+  const rowToDoc = (row) => upcast({
+    ...row.data,
+    _version: row._version
+  });
+  const findOneFromDb = async (filter, options) => {
+    const result = await query(
+      SqlFor.findOne(filter),
+      options
+    );
+    const row = result.rows[0];
+    return row ? rowToDoc(row) : null;
+  };
+  const cacheKey = (id) => `${db.databaseName}:${collectionName}:${id}`;
+  const txCacheFor = (options) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _25 => _25.session, 'optionalAccess', _26 => _26.transaction, 'optionalAccess', _27 => _27.cache]), () => ( null));
+  const resolveFromCache = async (key, options) => {
+    const txCache = txCacheFor(options);
+    if (txCache) {
+      const cached = await txCache.get(key);
+      if (cached !== void 0) return cached;
+    }
+    return cache.get(key);
+  };
+  const findManyFromCache = async (keys, options) => {
+    const txCache = txCacheFor(options);
+    if (!txCache) {
+      return cache.getMany(keys);
+    }
+    const txResults = await txCache.getMany(keys);
+    const mainResults = await cache.getMany(keys);
+    return keys.map(
+      (_, i) => txResults[i] !== void 0 ? txResults[i] : mainResults[i]
+    );
+  };
+  const fetchByIds = async (ids, options) => {
+    const cachedResults = await findManyFromCache(ids.map(cacheKey), options);
+    const missIds = ids.filter((_, i) => cachedResults[i] === void 0);
+    let dbDocsById = /* @__PURE__ */ new Map();
+    if (missIds.length > 0) {
+      const dbResult = await query(
+        SqlFor.find(
+          { _id: { $in: missIds } },
+          options
+        )
+      );
+      const dbDocs = dbResult.rows.map(rowToDoc);
+      dbDocsById = new Map(
+        dbDocs.map((d) => [d["_id"], d])
+      );
+      const leftovers = missIds.map(
+        (id) => [id, _nullishCoalesce(dbDocsById.get(id), () => ( null))]
+      );
+      await cacheSetMany(
+        leftovers.map((d) => d[1]).filter((d) => d !== null),
+        options
+      );
+      await cacheDeleteMany(
+        leftovers.filter(([, doc]) => doc === null).map(([id]) => id),
+        options
+      );
+    }
+    return ids.map((id, i) => {
+      const cached = cachedResults[i];
+      if (cached !== void 0) {
+        return cached !== null ? upcast({ ...cached }) : null;
+      }
+      return _nullishCoalesce(dbDocsById.get(id), () => ( null));
+    });
+  };
+  const findManyByIds = async (ids, options) => {
+    const results = await fetchByIds(ids, options);
+    return results.filter((doc) => doc !== null);
+  };
+  const cacheSet = (value, options) => {
+    const key = cacheKey(value._id);
+    const txCache = txCacheFor(options);
+    if (txCache) return txCache.set(key, value, { mainCache: cache });
+    return cache.set(key, value);
+  };
+  const cacheSetMany = (documents, options) => {
+    const txCache = txCacheFor(options);
+    const entries = documents.map((d) => ({ key: cacheKey(d._id), value: d }));
+    if (txCache) return txCache.setMany(entries, { mainCache: cache });
+    return cache.setMany(entries);
+  };
+  const cacheDelete = (id, options) => {
+    const txCache = txCacheFor(options);
+    const key = cacheKey(id);
+    if (txCache) return txCache.delete(key, { mainCache: cache });
+    return cache.delete(key);
+  };
+  const cacheDeleteMany = (ids, options) => {
+    const txCache = txCacheFor(options);
+    const keys = ids.map(cacheKey);
+    if (txCache) return txCache.deleteMany(keys, { mainCache: cache });
+    return cache.deleteMany(keys);
+  };
+  const deleteManyByIds = async (ids, options) => {
+    await ensureCollectionCreated(options);
+    const result = await command(
+      SqlFor.deleteManyByIds(ids),
+      options
+    );
+    const deletedIds = new Set(
+      result.rows.filter((row) => (_nullishCoalesce(row.deleted, () => ( 1))) > 0).map((row) => row._id)
+    );
+    if (!_optionalChain([options, 'optionalAccess', _28 => _28.skipCache])) {
+      await cacheDeleteMany([...deletedIds], options);
+    }
+    return operationResult(
+      {
+        successful: deletedIds.size > 0,
+        deletedCount: deletedIds.size,
+        matchedCount: ids.length,
+        deletedIds
+      },
+      {
+        operationName: "deleteManyByIds",
+        collectionName,
+        serializer,
+        errors
+      }
+    );
+  };
+  const collection = {
+    dbName: db.databaseName,
+    collectionName,
+    createCollection: async (options) => {
+      await createCollection(options);
+    },
+    insertOne: async (document, options) => {
+      await ensureCollectionCreated(options);
+      const _id = _nullishCoalesce(document._id, () => ( _uuid.v7.call(void 0, )));
+      const _version = _nullishCoalesce(document._version, () => ( 1n));
+      const downcasted = downcast(document);
+      const result = await command(
+        SqlFor.insertOne({
+          ...downcasted,
+          _id,
+          _version
+        }),
+        options
+      );
+      const successful = (_nullishCoalesce(result.rowCount, () => ( 0))) > 0;
+      if (successful && !_optionalChain([options, 'optionalAccess', _29 => _29.skipCache])) {
+        const doc = { ...document, _id, _version };
+        await cacheSet(doc, options);
+      }
+      return operationResult(
+        {
+          successful,
+          insertedId: successful ? _id : null,
+          nextExpectedVersion: _version
+        },
+        { operationName: "insertOne", collectionName, serializer, errors }
+      );
+    },
+    insertMany: async (documents, options) => {
+      await ensureCollectionCreated(options);
+      const documentsWithMetadata = documents.map(
+        (doc) => doc._id && doc._version ? doc : {
+          ...doc,
+          _id: _nullishCoalesce(doc._id, () => ( _uuid.v7.call(void 0, ))),
+          _version: _nullishCoalesce(doc._version, () => ( 1n))
+        }
+      );
+      const rows = documentsWithMetadata.map((d) => ({
+        ...downcast(d),
+        _id: d._id,
+        _version: d._version
+      }));
+      const result = await command(
+        SqlFor.insertMany(
+          rows
+        ),
+        options
+      );
+      if (!_optionalChain([options, 'optionalAccess', _30 => _30.skipCache])) {
+        const insertedIdSet = new Set(result.rows.map((d) => d._id));
+        await cacheSetMany(
+          documentsWithMetadata.filter((d) => insertedIdSet.has(d._id)),
+          options
+        );
+      }
+      return operationResult(
+        {
+          successful: result.rowCount === rows.length,
+          insertedCount: _nullishCoalesce(result.rowCount, () => ( 0)),
+          insertedIds: result.rows.map((d) => d._id)
+        },
+        { operationName: "insertMany", collectionName, serializer, errors }
+      );
+    },
+    updateOne: async (filter, update, options) => {
+      await ensureCollectionCreated(options);
+      const result = await command(
+        SqlFor.updateOne(filter, update, options),
+        options
+      );
+      const opResult = operationResult(
+        {
+          successful: result.rows.length > 0 && result.rows[0].modified === result.rows[0].matched,
+          modifiedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _31 => _31.rows, 'access', _32 => _32[0], 'optionalAccess', _33 => _33.modified]), () => ( 0))),
+          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _34 => _34.rows, 'access', _35 => _35[0], 'optionalAccess', _36 => _36.matched]), () => ( 0))),
+          nextExpectedVersion: BigInt(_nullishCoalesce(_optionalChain([result, 'access', _37 => _37.rows, 'access', _38 => _38[0], 'optionalAccess', _39 => _39.version]), () => ( 0n)))
+        },
+        { operationName: "updateOne", collectionName, serializer, errors }
+      );
+      if (opResult.successful && !_optionalChain([options, 'optionalAccess', _40 => _40.skipCache])) {
+        const id = idFromFilter(filter);
+        if (id) await cacheDelete(id, options);
+      }
+      return opResult;
+    },
+    replaceOne: async (filter, document, options) => {
+      await ensureCollectionCreated(options);
+      const downcasted = downcast(document);
+      const result = await command(
+        SqlFor.replaceOne(filter, downcasted, options),
+        options
+      );
+      const opResult = operationResult(
+        {
+          successful: result.rows.length > 0 && result.rows[0].modified > 0,
+          modifiedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _41 => _41.rows, 'access', _42 => _42[0], 'optionalAccess', _43 => _43.modified]), () => ( 0))),
+          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _44 => _44.rows, 'access', _45 => _45[0], 'optionalAccess', _46 => _46.matched]), () => ( 0))),
+          nextExpectedVersion: BigInt(_nullishCoalesce(_optionalChain([result, 'access', _47 => _47.rows, 'access', _48 => _48[0], 'optionalAccess', _49 => _49.version]), () => ( 0n)))
+        },
+        { operationName: "replaceOne", collectionName, serializer, errors }
+      );
+      if (opResult.successful && !_optionalChain([options, 'optionalAccess', _50 => _50.skipCache])) {
+        const _id = idFromFilter(filter);
+        if (_id) {
+          await cacheSet(
+            {
+              ...document,
+              _id,
+              _version: opResult.nextExpectedVersion
+            },
+            options
+          );
+        }
+      }
+      return opResult;
+    },
+    updateMany: async (filter, update, options) => {
+      await ensureCollectionCreated(options);
+      const result = await command(SqlFor.updateMany(filter, update), options);
+      return operationResult(
+        {
+          successful: true,
+          modifiedCount: _nullishCoalesce(result.rowCount, () => ( 0)),
+          matchedCount: _nullishCoalesce(result.rowCount, () => ( 0))
+        },
+        { operationName: "updateMany", collectionName, serializer, errors }
+      );
+    },
+    deleteOne: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      const result = await command(
+        SqlFor.deleteOne(_nullishCoalesce(filter, () => ( {})), options),
+        options
+      );
+      const opResult = operationResult(
+        {
+          successful: result.rows.length > 0 && result.rows[0].deleted > 0,
+          deletedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _51 => _51.rows, 'access', _52 => _52[0], 'optionalAccess', _53 => _53.deleted]), () => ( 0))),
+          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _54 => _54.rows, 'access', _55 => _55[0], 'optionalAccess', _56 => _56.matched]), () => ( 0)))
+        },
+        { operationName: "deleteOne", collectionName, serializer, errors }
+      );
+      if (opResult.successful && !_optionalChain([options, 'optionalAccess', _57 => _57.skipCache]) && filter) {
+        const id = idFromFilter(filter);
+        if (id) await cacheDelete(id, options);
+      }
+      return opResult;
+    },
+    deleteMany: async (filter, options) => {
+      const ids = filter ? getIdsFromIdOnlyFilter(filter) : null;
+      if (ids)
+        return deleteManyByIds(
+          ids.map((id) => ({ _id: id })),
+          options
+        );
+      await ensureCollectionCreated(options);
+      const result = await command(SqlFor.deleteMany(_nullishCoalesce(filter, () => ( {}))), options);
+      return operationResult(
+        {
+          successful: (_nullishCoalesce(result.rowCount, () => ( 0))) > 0,
+          deletedCount: _nullishCoalesce(result.rowCount, () => ( 0)),
+          matchedCount: _nullishCoalesce(result.rowCount, () => ( 0))
+        },
+        { operationName: "deleteMany", collectionName, serializer, errors }
+      );
+    },
+    findOne: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      const id = filter && !_optionalChain([options, 'optionalAccess', _58 => _58.skipCache]) ? idFromFilter(filter) : null;
+      if (id) {
+        const cached = await resolveFromCache(cacheKey(id), options);
+        if (cached !== void 0)
+          return cached !== null ? upcast({
+            ...cached
+          }) : null;
+        const doc = await findOneFromDb(filter, options);
+        if (doc) await cacheSet(doc, options);
+        else await cacheDelete(id, options);
+        return doc;
+      }
+      return findOneFromDb(_nullishCoalesce(filter, () => ( {})), options);
+    },
+    findOneAndDelete: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      const existingDoc = await collection.findOne(filter, options);
+      if (existingDoc === null) return null;
+      await collection.deleteOne(filter, options);
+      return existingDoc;
+    },
+    findOneAndReplace: async (filter, replacement, options) => {
+      await ensureCollectionCreated(options);
+      const existingDoc = await collection.findOne(filter, options);
+      if (existingDoc === null) return null;
+      await collection.replaceOne(filter, replacement, options);
+      return existingDoc;
+    },
+    findOneAndUpdate: async (filter, update, options) => {
+      await ensureCollectionCreated(options);
+      const existingDoc = await collection.findOne(filter, options);
+      if (existingDoc === null) return null;
+      await collection.updateOne(filter, update, options);
+      return existingDoc;
+    },
+    replaceMany: async (documents, options) => {
+      await ensureCollectionCreated(options);
+      const downcasted = documents.map(
+        (d) => downcast(d)
+      );
+      const result = await command(SqlFor.replaceMany(downcasted), options);
+      const modifiedIds = result.rows.map((row) => row._id);
+      const conflictIds = documents.map((d) => d._id).filter((id) => !modifiedIds.includes(id));
+      const versions = new Map(
+        result.rows.map((row) => [row._id, BigInt(_nullishCoalesce(row.version, () => ( 1n)))])
+      );
+      if (!_optionalChain([options, 'optionalAccess', _59 => _59.skipCache])) {
+        const cacheEntries = documents.filter((d) => modifiedIds.includes(d._id)).map(
+          (doc) => doc._version ? doc : {
+            ...doc,
+            _version: _nullishCoalesce(versions.get(doc._id), () => ( 1n))
+          }
+        );
+        if (cacheEntries.length > 0) await cacheSetMany(cacheEntries, options);
+        if (conflictIds.length > 0)
+          await cacheDeleteMany([...conflictIds], options);
+      }
+      return operationResult(
+        {
+          successful: modifiedIds.length > 0 && conflictIds.length === 0,
+          modifiedCount: modifiedIds.length,
+          matchedCount: documents.length,
+          modifiedIds: [...modifiedIds],
+          conflictIds: [...conflictIds],
+          nextExpectedVersions: versions
+        },
+        { operationName: "replaceMany", collectionName, serializer, errors }
+      );
+    },
+    handle: DocumentCommandHandler({
+      collectionName,
+      serializer,
+      errors,
+      storage: {
+        ensureCollectionCreated,
+        fetchByIds,
+        insertMany: (docs, options) => collection.insertMany(docs, options),
+        replaceMany: (docs, options) => collection.replaceMany(docs, options),
+        deleteManyByIds
+      }
+    }),
+    find: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      if (!_optionalChain([options, 'optionalAccess', _60 => _60.skipCache]) && filter) {
+        const ids = getIdsFromIdOnlyFilter(filter);
+        if (ids && ids.length > 0) return findManyByIds(ids, options);
+      }
+      const result = await query(
+        SqlFor.find(_nullishCoalesce(filter, () => ( {})), options)
+      );
+      return result.rows.map(rowToDoc);
+    },
+    countDocuments: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      const { count } = await _dumbo.single.call(void 0, 
+        query(SqlFor.countDocuments(_nullishCoalesce(filter, () => ( {}))))
+      );
+      return count;
+    },
+    drop: async (options) => {
+      await ensureCollectionCreated(options);
+      const result = await command(SqlFor.drop());
+      return (_nullishCoalesce(_optionalChain([result, 'optionalAccess', _61 => _61.rowCount]), () => ( 0))) > 0;
+    },
+    rename: async (newName, options) => {
+      await ensureCollectionCreated(options);
+      await command(SqlFor.rename(newName));
+      collectionName = newName;
+      return collection;
+    },
+    close: () => cache.close(),
+    sql: {
+      async query(sql, options) {
+        await ensureCollectionCreated(options);
+        const result = await query(sql, options);
+        return result.rows;
+      },
+      async command(sql, options) {
+        await ensureCollectionCreated(options);
+        return command(sql, options);
+      }
+    },
+    schema: {
+      component: schemaComponent3,
+      migrate: (options) => _dumbo.runSQLMigrations.call(void 0, pool, schemaComponent3.migrations, options)
+    }
+  };
+  return collection;
+};
+
+// src/core/collection/pongoCollectionSchemaComponent.ts
+
+
+
+var PongoCollectionSchemaComponent = ({
+  definition,
+  migrationsOrSchemaComponents,
+  sqlBuilder
+}) => ({
+  ..._dumbo.schemaComponent.call(void 0, 
+    `sc:pongo:collection:${definition.name}`,
+    migrationsOrSchemaComponents
+  ),
+  sqlBuilder,
+  definition,
+  collectionName: definition.name
+});
+
+// src/core/collection/query.ts
+var QueryOperators = {
+  $eq: "$eq",
+  $gt: "$gt",
+  $gte: "$gte",
+  $lt: "$lt",
+  $lte: "$lte",
+  $ne: "$ne",
+  $in: "$in",
+  $nin: "$nin",
+  $elemMatch: "$elemMatch",
+  $all: "$all",
+  $size: "$size"
+};
+var OperatorMap = {
+  $gt: ">",
+  $gte: ">=",
+  $lt: "<",
+  $lte: "<=",
+  $ne: "!="
+};
+var isOperator = (key) => key.startsWith("$");
+var hasOperators = (value) => Object.keys(value).some(isOperator);
+
+// src/core/database/pongoDatabaseCache.ts
+
+
+
+var PongoDatabaseCache = ({
+  driver,
+  typedSchema
+}) => {
+  const dbClients = /* @__PURE__ */ new Map();
+  const getDatabaseDefinition = (dbName) => Object.values(_nullishCoalesce(_optionalChain([typedSchema, 'optionalAccess', _62 => _62.dbs]), () => ( {}))).find((d) => d.name === dbName);
+  return {
+    getOrCreate: (createOptions) => {
+      const metadata = _dumbo.getDatabaseMetadata.call(void 0, driver.driverType);
+      const dbName = _nullishCoalesce(_nullishCoalesce(createOptions.databaseName, () => ( _optionalChain([metadata, 'optionalAccess', _63 => _63.parseDatabaseName, 'optionalCall', _64 => _64(
+        "connectionString" in createOptions ? createOptions.connectionString : void 0
+      )]))), () => ( "db:default"));
+      const existing = dbClients.get(dbName);
+      if (existing) return existing;
+      const definition = getDatabaseDefinition(createOptions.databaseName);
+      const newDb = driver.databaseFactory({
+        ...createOptions,
+        databaseName: dbName,
+        schema: {
+          ...createOptions.schema,
+          ...definition ? { definition } : {}
+        }
+      });
+      dbClients.set(dbName, newDb);
+      return newDb;
+    },
+    all: () => Array.from(dbClients.values()),
+    forAll: (func) => {
+      return Promise.all(
+        Array.from(dbClients.values()).map((v) => v).map(func)
+      );
+    }
+  };
+};
+
+// src/core/database/pongoDatabaseSchemaComponent.ts
+
+
+
+
+// src/core/typing/entries.ts
+var objectEntries = (obj) => Object.entries(obj).map(([key, value]) => [key, value]);
+
+// src/core/typing/operations.ts
+
+
+// src/core/errors/index.ts
+var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var PongoError = class _PongoError extends Error {
+  
+  constructor(options) {
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Pongo processing`;
+    super(message);
+    this.errorCode = errorCode;
+    Object.setPrototypeOf(this, _PongoError.prototype);
+  }
+};
+var ConcurrencyError = class _ConcurrencyError extends PongoError {
+  constructor(message) {
+    super({
+      errorCode: 412,
+      message: _nullishCoalesce(message, () => ( `Expected document state does not match current one!`))
+    });
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+
+// src/core/typing/operations.ts
+var ObjectId = (value) => _nullishCoalesce(value, () => ( _uuid.v7.call(void 0, )));
+var DOCUMENT_EXISTS = "DOCUMENT_EXISTS";
+var DOCUMENT_DOES_NOT_EXIST = "DOCUMENT_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var isGeneralExpectedDocumentVersion = (version) => version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
+var expectedVersionValue = (version) => version === void 0 || isGeneralExpectedDocumentVersion(version) ? null : version;
+var expectedVersion = (version) => {
+  return version ? BigInt(version) : NO_CONCURRENCY_CHECK;
+};
+var operationResult = (result, options) => {
+  const operationResult2 = {
+    ...result,
+    acknowledged: true,
+    successful: result.successful,
+    assertSuccessful: (errorMessage) => {
+      const { successful } = result;
+      const { operationName, collectionName } = options;
+      if (!successful)
+        throw new ConcurrencyError(
+          _nullishCoalesce(errorMessage, () => ( `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${options.serializer.serialize(result)}!`))
+        );
+    }
+  };
+  if (_optionalChain([options, 'access', _65 => _65.errors, 'optionalAccess', _66 => _66.throwOnOperationFailures]))
+    operationResult2.assertSuccessful();
+  return operationResult2;
+};
+
+// src/core/schema/index.ts
+var pongoCollectionSchema = (name) => ({
+  name
+});
+pongoCollectionSchema.from = (collectionNames) => collectionNames.reduce(
+  (acc, collectionName) => (acc[collectionName] = pongoSchema.collection(collectionName), acc),
+  {}
+);
+function pongoDbSchema(nameOrCollections, collections) {
+  if (collections === void 0) {
+    if (typeof nameOrCollections === "string") {
+      throw new Error("You need to provide colleciton definition");
+    }
+    return {
+      collections: nameOrCollections
+    };
+  }
+  return nameOrCollections && typeof nameOrCollections === "string" ? {
+    name: nameOrCollections,
+    collections
+  } : { collections };
+}
+pongoDbSchema.from = (databaseName, collectionNames) => databaseName ? pongoDbSchema(databaseName, pongoCollectionSchema.from(collectionNames)) : pongoDbSchema(pongoCollectionSchema.from(collectionNames));
+var pongoClientSchema = (dbs) => ({
+  dbs
+});
+var pongoSchema = {
+  client: pongoClientSchema,
+  db: pongoDbSchema,
+  collection: pongoCollectionSchema
+};
+var proxyPongoDbWithSchema = (pongoDb, dbSchema, collections) => {
+  const collectionNames = Object.keys(dbSchema.collections);
+  for (const collectionName of collectionNames) {
+    collections.set(collectionName, pongoDb.collection(collectionName));
+  }
+  return new Proxy(
+    pongoDb,
+    {
+      get(target, prop) {
+        return _nullishCoalesce(collections.get(prop), () => ( target[prop]));
+      }
+    }
+  );
+};
+var proxyClientWithSchema = (client, schema) => {
+  if (!schema)
+    return client;
+  const dbNames = Object.keys(schema.dbs);
+  return new Proxy(
+    client,
+    {
+      get(target, prop) {
+        if (dbNames.includes(prop)) return client.db(_optionalChain([schema, 'access', _67 => _67.dbs, 'access', _68 => _68[prop], 'optionalAccess', _69 => _69.name]));
+        return target[prop];
+      }
+    }
+  );
+};
+var toDbSchemaMetadata = (schema) => ({
+  name: schema.name,
+  collections: objectEntries(schema.collections).map((c) => ({
+    name: c[1].name
+  }))
+});
+var toClientSchemaMetadata = (schema) => {
+  const databases = objectEntries(schema.dbs).map(
+    (e) => toDbSchemaMetadata(e[1])
+  );
+  return {
+    databases,
+    database: (name) => databases.find((db) => db.name === name)
+  };
+};
+
+// src/core/database/pongoDatabaseSchemaComponent.ts
+var PongoDatabaseSchemaComponent = ({
+  definition,
+  collectionFactory
+}) => {
+  const collections = _nullishCoalesce(Object.values(definition.collections).map(collectionFactory), () => ( []));
+  return {
+    ..._dumbo.schemaComponent.call(void 0, `sc:dumbo:database:${definition.name}`, {
+      components: collections
+    }),
+    definition,
+    collections,
+    collection: (schema) => {
+      const existing = collections.find(
+        (c) => c.collectionName === schema.name
+      );
+      if (existing) return existing;
+      const newCollection = collectionFactory(
+        pongoSchema.collection(schema.name)
+      );
+      collections.push(newCollection);
+      definition.collections[schema.name] = schema;
+      return newCollection;
+    }
+  };
+};
+
+// src/core/database/pongoDb.ts
+
+
+
+var PongoDatabase = (options) => {
+  const {
+    databaseName,
+    schemaComponent: schemaComponent3,
+    pool,
+    cache: cacheOptions,
+    serializer
+  } = options;
+  const cache = cacheOptions === "disabled" || cacheOptions === void 0 ? "disabled" : pongoCache(cacheOptions);
+  const collections = /* @__PURE__ */ new Map();
+  const command = async (sql, options2) => (await transactionExecutorOrDefault(db, options2, pool.execute)).command(sql, options2);
+  const query = async (sql, options2) => (await transactionExecutorOrDefault(db, options2, pool.execute)).query(
+    sql,
+    options2
+  );
+  const driverType = pool.driverType;
+  const db = {
+    driverType,
+    databaseName,
+    connect: () => Promise.resolve(),
+    close: async () => {
+      await Promise.allSettled([
+        pool.close(),
+        cache !== "disabled" ? cache.close() : Promise.resolve(),
+        ...collections.values().map((collection) => collection.close())
+      ]);
+    },
+    collections: () => [...collections.values()],
+    collection: (collectionName, collectionOptions) => _nullishCoalesce(collections.get(collectionName), () => ( pongoCollection({
+      collectionName,
+      db,
+      pool,
+      schemaComponent: schemaComponent3.collection(
+        pongoSchema.collection(collectionName)
+      ),
+      schema: { ...options.schema, ..._optionalChain([collectionOptions, 'optionalAccess', _70 => _70.schema]) },
+      serializer,
+      errors: { ...options.errors, ..._optionalChain([collectionOptions, 'optionalAccess', _71 => _71.errors]) },
+      cache: _optionalChain([collectionOptions, 'optionalAccess', _72 => _72.cache]) !== void 0 ? collectionOptions.cache : cache
+    }))),
+    transaction: () => pool.transaction(),
+    withTransaction: (handle) => pool.withTransaction(handle),
+    schema: {
+      component: schemaComponent3,
+      migrate: (options2) => _dumbo.runSQLMigrations.call(void 0, pool, schemaComponent3.migrations, options2)
+    },
+    sql: {
+      async query(sql, options2) {
+        const result = await query(sql, options2);
+        return result.rows;
+      },
+      async command(sql, options2) {
+        return command(sql, options2);
+      }
+    }
+  };
+  const dbSchema = _optionalChain([options, 'optionalAccess', _73 => _73.schema, 'optionalAccess', _74 => _74.definition]);
+  if (dbSchema) {
+    return proxyPongoDbWithSchema(db, dbSchema, collections);
+  }
+  return db;
+};
+
+// src/core/drivers/databaseDriver.ts
+var PongoDriverRegistry = () => {
+  const drivers = /* @__PURE__ */ new Map();
+  const register = (driverType, driver) => {
+    const entry = drivers.get(driverType);
+    if (entry && (typeof entry !== "function" || typeof driver === "function")) {
+      return;
+    }
+    drivers.set(driverType, driver);
+  };
+  const tryResolve = async (driverType) => {
+    const entry = drivers.get(driverType);
+    if (!entry) return null;
+    if (typeof entry !== "function") return entry;
+    const driver = await entry();
+    register(driverType, driver);
+    return driver;
+  };
+  const tryGet = (driverType) => {
+    const entry = drivers.get(driverType);
+    return entry && typeof entry !== "function" ? entry : null;
+  };
+  const has = (driverType) => drivers.has(driverType);
+  return {
+    register,
+    tryResolve,
+    tryGet,
+    has,
+    get databaseDriverTypes() {
+      return Array.from(drivers.keys());
+    }
+  };
+};
+var pongoDriverRegistry = globalThis.pongoDriverRegistry = _nullishCoalesce(globalThis.pongoDriverRegistry, () => ( PongoDriverRegistry()));
+
+// src/core/pongoClient.ts
+
+
+// src/core/pongoTransaction.ts
+var pongoTransaction = (options) => {
+  let isCommitted = false;
+  let isRolledBack = false;
+  let databaseName = null;
+  let transaction = null;
+  const cache = pongoTransactionCache();
+  return {
+    cache,
+    enlistDatabase: async (db) => {
+      if (transaction && databaseName !== db.databaseName)
+        throw new Error(
+          "There's already other database assigned to transaction"
+        );
+      if (transaction && databaseName === db.databaseName) return transaction;
+      databaseName = db.databaseName;
+      transaction = db.transaction();
+      await transaction.begin();
+      return transaction;
+    },
+    commit: async () => {
+      if (isCommitted) return;
+      if (isRolledBack) throw new Error("Transaction is not active!");
+      isCommitted = true;
+      if (transaction) {
+        await transaction.commit();
+        transaction = null;
+      }
+      await cache.commit();
+    },
+    rollback: async (error) => {
+      if (isCommitted) throw new Error("Cannot rollback commited transaction!");
+      if (isRolledBack) return;
+      isRolledBack = true;
+      if (transaction) {
+        await transaction.rollback(error);
+        transaction = null;
+      }
+      cache.clear();
+    },
+    databaseName,
+    isStarting: false,
+    isCommitted,
+    get isActive() {
+      return !isCommitted && !isRolledBack;
+    },
+    get sqlExecutor() {
+      if (transaction === null)
+        throw new Error("No database transaction was started");
+      return transaction.execute;
+    },
+    options
+  };
+};
+
+// src/core/pongoSession.ts
+var isActive = (transaction) => _optionalChain([transaction, 'optionalAccess', _75 => _75.isActive]) === true;
+function assertInActiveTransaction(transaction) {
+  if (!isActive(transaction)) throw new Error("No active transaction exists!");
+}
+function assertNotInActiveTransaction(transaction) {
+  if (isActive(transaction))
+    throw new Error("Active transaction already exists!");
+}
+var pongoSession = (options) => {
+  const explicit = _optionalChain([options, 'optionalAccess', _76 => _76.explicit]) === true;
+  const defaultTransactionOptions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _77 => _77.defaultTransactionOptions]), () => ( {
+    get snapshotEnabled() {
+      return false;
+    }
+  }));
+  let transaction = null;
+  let hasEnded = false;
+  const startTransaction = (options2) => {
+    assertNotInActiveTransaction(transaction);
+    transaction = pongoTransaction(_nullishCoalesce(options2, () => ( defaultTransactionOptions)));
+  };
+  const commitTransaction = async () => {
+    assertInActiveTransaction(transaction);
+    await transaction.commit();
+  };
+  const abortTransaction = async () => {
+    assertInActiveTransaction(transaction);
+    await transaction.rollback();
+  };
+  const endSession = async () => {
+    if (hasEnded) return;
+    hasEnded = true;
+    if (isActive(transaction)) await transaction.rollback();
+  };
+  const session = {
+    get hasEnded() {
+      return hasEnded;
+    },
+    explicit,
+    defaultTransactionOptions: _nullishCoalesce(defaultTransactionOptions, () => ( {
+      get snapshotEnabled() {
+        return false;
+      }
+    })),
+    get transaction() {
+      return transaction;
+    },
+    get snapshotEnabled() {
+      return defaultTransactionOptions.snapshotEnabled;
+    },
+    endSession,
+    incrementTransactionNumber: () => {
+    },
+    inTransaction: () => isActive(transaction),
+    startTransaction,
+    commitTransaction,
+    abortTransaction,
+    withTransaction: async (fn, options2) => {
+      startTransaction(options2);
+      try {
+        const result = await fn(session);
+        await commitTransaction();
+        return result;
+      } catch (error) {
+        await abortTransaction();
+        throw error;
+      }
+    }
+  };
+  return session;
+};
+
+// src/core/pongoClient.ts
+var pongoClient = (options) => {
+  const {
+    driver,
+    schema,
+    errors,
+    cache: cacheOptions,
+    serialization,
+    ...connectionOptions
+  } = options;
+  const dbClients = PongoDatabaseCache({
+    driver,
+    typedSchema: _optionalChain([schema, 'optionalAccess', _78 => _78.definition])
+  });
+  const serializer = _dumbo.JSONSerializer.from(options);
+  const cache = cacheOptions === "disabled" || cacheOptions === void 0 ? "disabled" : pongoCache(cacheOptions);
+  const pongoClient2 = {
+    driverType: driver.driverType,
+    connect: async () => {
+      await dbClients.forAll((db) => db.connect());
+      return pongoClient2;
+    },
+    close: async () => {
+      await dbClients.forAll((db) => db.close());
+    },
+    db: (dbName, options2) => {
+      const db = dbClients.getOrCreate({
+        ...connectionOptions,
+        databaseName: dbName,
+        serializer,
+        errors,
+        cache: _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _79 => _79.cache]), () => ( cache)),
+        serialization
+      });
+      return db;
+    },
+    startSession: pongoSession,
+    withSession: async (callback) => {
+      const session = pongoSession();
+      try {
+        return await callback(session);
+      } finally {
+        await session.endSession();
+      }
+    }
+  };
+  return proxyClientWithSchema(pongoClient2, _optionalChain([schema, 'optionalAccess', _80 => _80.definition]));
+};
+
+// src/core/utils/deepEquals.ts
+var deepEquals = (left, right) => {
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return left === right;
+  }
+  if (Array.isArray(right)) return false;
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+    return false;
+  for (const key in left) {
+    if (left[key] instanceof Function && right[key] instanceof Function)
+      continue;
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var isEquatable = (left) => {
+  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+
+// src/core/utils/mapAsync.ts
+async function mapSequential(items, fn) {
+  const results = [];
+  for (let i = 0; i < items.length; i++) {
+    results.push(await fn(items[i], i));
+  }
+  return results;
+}
+var mapParallel = (items, fn) => Promise.all(items.map(fn));
+var mapAsync = (items, fn, options = { parallel: false }) => _optionalChain([options, 'optionalAccess', _81 => _81.parallel]) ? mapParallel(items, fn) : mapSequential(items, fn);
+
+// src/core/collection/handle.ts
+function DocumentCommandHandler(deps) {
+  const fn = async (input, handler, options) => {
+    const changes = await handleDocuments(
+      deps.storage,
+      normalizeInput(input),
+      handler,
+      options
+    );
+    const results = changes.map(
+      ({ change, result: outcome }) => toHandleResult(deps, change, outcome)
+    );
+    return Array.isArray(input) ? results : results[0];
+  };
+  return fn;
+}
+async function handleDocuments(storage, inputs, handler, options) {
+  if (inputs.length === 0) return [];
+  const { parallel, ...operationOptions } = _nullishCoalesce(options, () => ( {}));
+  await storage.ensureCollectionCreated(operationOptions);
+  const docs = await storage.fetchByIds(
+    inputs.map((i) => i._id),
+    operationOptions
+  );
+  const changes = await mapAsync(
+    inputs,
+    (item, i) => handleDocument(
+      {
+        ...item,
+        existing: _nullishCoalesce(docs[i], () => ( null))
+      },
+      handler
+    ),
+    { parallel }
+  );
+  return await executeStorageChanges(storage, changes, operationOptions);
+}
+async function handleDocument(item, handler) {
+  const { _id: id, existing, expectedVersion: expectedVersion2 } = item;
+  if (hasVersionMismatch(existing, expectedVersion2))
+    return { type: "noop", existing, versionMismatch: true };
+  const result = await handler(existing ? { ...existing } : null, id);
+  return toDocumentChange(id, existing, result);
+}
+async function executeStorageChanges(storage, changes, operationOptions) {
+  const toInsert = changes.flatMap(
+    (c) => c.type === "insert" ? [c.doc] : []
+  );
+  const toReplace = changes.flatMap((c) => {
+    if (c.type !== "replace") return [];
+    const { _version: _, ...cleanResult } = c.result;
+    return [
+      c._version !== void 0 ? { ...cleanResult, _version: c._version } : cleanResult
+    ];
+  });
+  const toDelete = changes.flatMap(
+    (c) => c.type === "delete" ? [
+      c._version !== void 0 ? { _id: c.docId, _version: c._version } : { _id: c.docId }
+    ] : []
+  );
+  const insertedIds = toInsert.length > 0 ? new Set(
+    (await storage.insertMany(toInsert, operationOptions)).insertedIds
+  ) : /* @__PURE__ */ new Set();
+  const replaceResult = toReplace.length > 0 ? await storage.replaceMany(toReplace, operationOptions) : null;
+  const deletedIds = toDelete.length > 0 ? (await storage.deleteManyByIds(toDelete, operationOptions)).deletedIds : /* @__PURE__ */ new Set();
+  const toDocumentHandlerResult = (change) => {
+    if (change.type === "noop") return { succeeded: !change.versionMismatch };
+    if (change.type === "insert")
+      return { succeeded: insertedIds.has(change.doc._id), newVersion: 1n };
+    if (change.type === "delete")
+      return { succeeded: deletedIds.has(change.docId) };
+    const id = change.result._id;
+    return {
+      succeeded: _nullishCoalesce(_optionalChain([replaceResult, 'optionalAccess', _82 => _82.modifiedIds, 'access', _83 => _83.includes, 'call', _84 => _84(id)]), () => ( false)),
+      newVersion: _nullishCoalesce(_optionalChain([replaceResult, 'optionalAccess', _85 => _85.nextExpectedVersions, 'access', _86 => _86.get, 'call', _87 => _87(id)]), () => ( 0n))
+    };
+  };
+  return changes.map((change) => ({
+    change,
+    result: toDocumentHandlerResult(change)
+  }));
+}
+function normalizeInput(input) {
+  if (typeof input === "string") return [{ _id: input }];
+  if (!Array.isArray(input)) return [input];
+  return input.map((item) => typeof item === "string" ? { _id: item } : item);
+}
+function hasVersionMismatch(existing, version) {
+  const expected = expectedVersionValue(version);
+  return existing == null && version === "DOCUMENT_EXISTS" || existing == null && expected != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expected !== null && existing._version !== expected;
+}
+function toDocumentChange(docId, existing, result) {
+  if (deepEquals(existing, result))
+    return { type: "noop", existing };
+  if (!existing && result)
+    return {
+      type: "insert",
+      doc: { ...result, _id: docId }
+    };
+  if (existing && !result)
+    return {
+      type: "delete",
+      docId,
+      _version: existing._version
+    };
+  return {
+    type: "replace",
+    existing,
+    result: { ...result, _id: docId },
+    _version: existing._version
+  };
+}
+function toHandleResult(deps, change, { succeeded, newVersion }) {
+  const opMeta = {
+    operationName: "handle",
+    collectionName: deps.collectionName,
+    serializer: deps.serializer,
+    errors: deps.errors
+  };
+  const toResult = (op, document) => ({
+    ...operationResult(op, opMeta),
+    document
+  });
+  if (change.type === "noop")
+    return toResult({ successful: succeeded }, change.existing);
+  if (change.type === "insert")
+    return toResult(
+      {
+        successful: succeeded,
+        insertedId: succeeded ? change.doc._id : null,
+        nextExpectedVersion: 1n
+      },
+      succeeded ? { ...change.doc, _version: 1n } : null
+    );
+  if (change.type === "delete")
+    return toResult(
+      {
+        successful: succeeded,
+        deletedCount: succeeded ? 1 : 0,
+        matchedCount: 1
+      },
+      null
+    );
+  return toResult(
+    {
+      successful: succeeded,
+      modifiedCount: succeeded ? 1 : 0,
+      matchedCount: 1,
+      nextExpectedVersion: _nullishCoalesce(newVersion, () => ( 0n))
+    },
+    succeeded ? { ...change.result, _version: newVersion } : change.existing
+  );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.pongoCacheWrapper = pongoCacheWrapper; exports.identityMapCache = identityMapCache; exports.lruCache = lruCache; exports.noopCacheProvider = noopCacheProvider; exports.pongoCache = pongoCache; exports.pongoTransactionCache = pongoTransactionCache; exports.idFromFilter = idFromFilter; exports.getIdsFromIdOnlyFilter = getIdsFromIdOnlyFilter; exports.DocumentCommandHandler = DocumentCommandHandler; exports.transactionExecutorOrDefault = transactionExecutorOrDefault; exports.pongoCollection = pongoCollection; exports.PongoCollectionSchemaComponent = PongoCollectionSchemaComponent; exports.QueryOperators = QueryOperators; exports.OperatorMap = OperatorMap; exports.isOperator = isOperator; exports.hasOperators = hasOperators; exports.PongoDatabaseCache = PongoDatabaseCache; exports.objectEntries = objectEntries; exports.isNumber = isNumber; exports.isString = isString; exports.PongoError = PongoError; exports.ConcurrencyError = ConcurrencyError; exports.ObjectId = ObjectId; exports.DOCUMENT_EXISTS = DOCUMENT_EXISTS; exports.DOCUMENT_DOES_NOT_EXIST = DOCUMENT_DOES_NOT_EXIST; exports.NO_CONCURRENCY_CHECK = NO_CONCURRENCY_CHECK; exports.isGeneralExpectedDocumentVersion = isGeneralExpectedDocumentVersion; exports.expectedVersionValue = expectedVersionValue; exports.expectedVersion = expectedVersion; exports.operationResult = operationResult; exports.pongoSchema = pongoSchema; exports.proxyPongoDbWithSchema = proxyPongoDbWithSchema; exports.proxyClientWithSchema = proxyClientWithSchema; exports.toDbSchemaMetadata = toDbSchemaMetadata; exports.toClientSchemaMetadata = toClientSchemaMetadata; exports.PongoDatabaseSchemaComponent = PongoDatabaseSchemaComponent; exports.PongoDatabase = PongoDatabase; exports.PongoDriverRegistry = PongoDriverRegistry; exports.pongoDriverRegistry = pongoDriverRegistry; exports.pongoTransaction = pongoTransaction; exports.pongoSession = pongoSession; exports.pongoClient = pongoClient; exports.deepEquals = deepEquals; exports.isEquatable = isEquatable; exports.mapSequential = mapSequential; exports.mapParallel = mapParallel; exports.mapAsync = mapAsync;
+//# sourceMappingURL=chunk-EQ3T4XHT.cjs.map