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

package/dist/chunk-BZRKCNRY.cjs

@@ -1,905 +0,0 @@
-"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/collection/pongoCollection.ts
-
-
-
-
-
-var _dumbo = require('@event-driven-io/dumbo');
-var _uuid = require('uuid');
-
-// 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', _ => _.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', _2 => _2.parseDatabaseName, 'optionalCall', _3 => _3(
-        "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', _4 => _4.errors, 'optionalAccess', _5 => _5.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', _6 => _6.dbs, 'access', _7 => _7[prop], 'optionalAccess', _8 => _8.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, serializer } = options;
-  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: () => pool.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', _9 => _9.schema]) },
-      serializer,
-      errors: { ...options.errors, ..._optionalChain([collectionOptions, 'optionalAccess', _10 => _10.errors]) }
-    }))),
-    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', _11 => _11.schema, 'optionalAccess', _12 => _12.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;
-  return {
-    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 (!transaction) throw new Error("No database transaction started!");
-      if (isCommitted) return;
-      if (isRolledBack) throw new Error("Transaction is not active!");
-      isCommitted = true;
-      await transaction.commit();
-      transaction = null;
-    },
-    rollback: async (error) => {
-      if (!transaction) throw new Error("No database transaction started!");
-      if (isCommitted) throw new Error("Cannot rollback commited transaction!");
-      if (isRolledBack) return;
-      isRolledBack = true;
-      await transaction.rollback(error);
-      transaction = null;
-    },
-    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', _13 => _13.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', _14 => _14.explicit]) === true;
-  const defaultTransactionOptions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.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, ...connectionOptions } = options;
-  const dbClients = PongoDatabaseCache({
-    driver,
-    typedSchema: _optionalChain([schema, 'optionalAccess', _16 => _16.definition])
-  });
-  const serializer = _dumbo.JSONSerializer.from(options);
-  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) => {
-      const db = dbClients.getOrCreate({
-        ...connectionOptions,
-        databaseName: dbName,
-        serializer,
-        errors
-      });
-      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', _17 => _17.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/collection/pongoCollection.ts
-var enlistIntoTransactionIfActive = async (db, options) => {
-  const transaction = _optionalChain([options, 'optionalAccess', _18 => _18.session, 'optionalAccess', _19 => _19.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', _20 => _20.execute]), () => ( defaultSqlExecutor));
-};
-var pongoCollection = ({
-  db,
-  collectionName,
-  pool,
-  schemaComponent: schemaComponent3,
-  schema,
-  errors,
-  serializer
-}) => {
-  const SqlFor = schemaComponent3.sqlBuilder;
-  const sqlExecutor = pool.execute;
-  const columnMapping = {
-    mapping: {
-      ..._dumbo.mapColumnToJSON.call(void 0, "data", serializer),
-      //...mapColumnToJSON('metadata'),
-      ..._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', _21 => _21.autoMigration]) !== "None";
-  const createCollection = (options) => {
-    shouldMigrate = false;
-    if (_optionalChain([options, 'optionalAccess', _22 => _22.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', _23 => _23.versioning, 'optionalAccess', _24 => _24.upcast]), () => ( ((doc) => doc)));
-  const downcast = _nullishCoalesce(_optionalChain([schema, 'optionalAccess', _25 => _25.versioning, 'optionalAccess', _26 => _26.downcast]), () => ( ((doc) => doc)));
-  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;
-      return operationResult(
-        {
-          successful,
-          insertedId: successful ? _id : null,
-          nextExpectedVersion: _version
-        },
-        { operationName: "insertOne", collectionName, serializer, errors }
-      );
-    },
-    insertMany: async (documents, options) => {
-      await ensureCollectionCreated(options);
-      const rows = documents.map((doc) => {
-        const downcasted = downcast(doc);
-        return {
-          ...downcasted,
-          _id: _nullishCoalesce(doc._id, () => ( _uuid.v7.call(void 0, ))),
-          _version: _nullishCoalesce(doc._version, () => ( 1n))
-        };
-      });
-      const result = await command(
-        SqlFor.insertMany(
-          rows
-        ),
-        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
-      );
-      return operationResult(
-        {
-          successful: result.rows.length > 0 && result.rows[0].modified === result.rows[0].matched,
-          modifiedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _27 => _27.rows, 'access', _28 => _28[0], 'optionalAccess', _29 => _29.modified]), () => ( 0))),
-          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _30 => _30.rows, 'access', _31 => _31[0], 'optionalAccess', _32 => _32.matched]), () => ( 0))),
-          nextExpectedVersion: BigInt(_nullishCoalesce(_optionalChain([result, 'access', _33 => _33.rows, 'access', _34 => _34[0], 'optionalAccess', _35 => _35.version]), () => ( 0n)))
-        },
-        { operationName: "updateOne", collectionName, serializer, errors }
-      );
-    },
-    replaceOne: async (filter, document, options) => {
-      await ensureCollectionCreated(options);
-      const downcasted = downcast(document);
-      const result = await command(
-        SqlFor.replaceOne(filter, downcasted, options),
-        options
-      );
-      return operationResult(
-        {
-          successful: result.rows.length > 0 && result.rows[0].modified > 0,
-          modifiedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _36 => _36.rows, 'access', _37 => _37[0], 'optionalAccess', _38 => _38.modified]), () => ( 0))),
-          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _39 => _39.rows, 'access', _40 => _40[0], 'optionalAccess', _41 => _41.matched]), () => ( 0))),
-          nextExpectedVersion: BigInt(_nullishCoalesce(_optionalChain([result, 'access', _42 => _42.rows, 'access', _43 => _43[0], 'optionalAccess', _44 => _44.version]), () => ( 0n)))
-        },
-        { operationName: "replaceOne", collectionName, serializer, errors }
-      );
-    },
-    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
-      );
-      return operationResult(
-        {
-          successful: result.rows.length > 0 && result.rows[0].deleted > 0,
-          deletedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _45 => _45.rows, 'access', _46 => _46[0], 'optionalAccess', _47 => _47.deleted]), () => ( 0))),
-          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _48 => _48.rows, 'access', _49 => _49[0], 'optionalAccess', _50 => _50.matched]), () => ( 0)))
-        },
-        { operationName: "deleteOne", collectionName, serializer, errors }
-      );
-    },
-    deleteMany: async (filter, 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 result = await query(
-        SqlFor.findOne(_nullishCoalesce(filter, () => ( {}))),
-        options
-      );
-      const row = result.rows[0];
-      if (row === void 0 || row === null) return null;
-      return upcast({
-        ...row.data,
-        _version: row._version
-      });
-    },
-    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;
-    },
-    handle: async (id, handle, options) => {
-      const { expectedVersion: version, ...operationOptions } = _nullishCoalesce(options, () => ( {}));
-      await ensureCollectionCreated(options);
-      const byId = { _id: id };
-      const existing = await collection.findOne(
-        byId,
-        options
-      );
-      const expectedVersion2 = expectedVersionValue(version);
-      if (existing == null && version === "DOCUMENT_EXISTS" || existing == null && expectedVersion2 != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expectedVersion2 !== null && existing._version !== expectedVersion2) {
-        return operationResult(
-          {
-            successful: false,
-            document: existing
-          },
-          { operationName: "handle", collectionName, serializer, errors }
-        );
-      }
-      const result = await handle(
-        existing !== null ? { ...existing } : null
-      );
-      if (deepEquals(existing, result))
-        return operationResult(
-          {
-            successful: true,
-            document: existing
-          },
-          { operationName: "handle", collectionName, serializer, errors }
-        );
-      if (!existing && result) {
-        const newDoc = { ...result, _id: id };
-        const insertResult = await collection.insertOne(
-          { ...newDoc, _id: id },
-          {
-            ...operationOptions,
-            expectedVersion: "DOCUMENT_DOES_NOT_EXIST"
-          }
-        );
-        return {
-          ...insertResult,
-          document: {
-            ...newDoc,
-            _version: insertResult.nextExpectedVersion
-          }
-        };
-      }
-      if (existing && !result) {
-        const deleteResult = await collection.deleteOne(byId, {
-          ...operationOptions,
-          expectedVersion: _nullishCoalesce(expectedVersion2, () => ( "DOCUMENT_EXISTS"))
-        });
-        return { ...deleteResult, document: null };
-      }
-      if (existing && result) {
-        const replaceResult = await collection.replaceOne(byId, result, {
-          ...operationOptions,
-          expectedVersion: _nullishCoalesce(expectedVersion2, () => ( "DOCUMENT_EXISTS"))
-        });
-        return {
-          ...replaceResult,
-          document: {
-            ...result,
-            _version: replaceResult.nextExpectedVersion
-          }
-        };
-      }
-      return operationResult(
-        {
-          successful: true,
-          document: existing
-        },
-        { operationName: "handle", collectionName, serializer, errors }
-      );
-    },
-    find: async (filter, options) => {
-      await ensureCollectionCreated(options);
-      const result = await query(
-        SqlFor.find(_nullishCoalesce(filter, () => ( {})), options)
-      );
-      return result.rows.map(
-        (row) => upcast({
-          ...row.data,
-          _version: row._version
-        })
-      );
-    },
-    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', _51 => _51.rowCount]), () => ( 0))) > 0;
-    },
-    rename: async (newName, options) => {
-      await ensureCollectionCreated(options);
-      await command(SqlFor.rename(newName));
-      collectionName = newName;
-      return collection;
-    },
-    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;
-};
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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;
-//# sourceMappingURL=chunk-BZRKCNRY.cjs.map