@event-driven-io/pongo 0.16.4-alpha.1 → 0.16.4-alpha.2

package/dist/chunk-HZVM5GBH.cjs

@@ -0,0 +1,1160 @@
+"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/postgres/sqlBuilder/index.ts
+
+
+
+
+
+
+var _dumbo = require('@event-driven-io/dumbo');
+
+// src/core/collection/pongoCollection.ts
+
+
+
+
+
+var _uuid = require('uuid');
+
+// src/postgres/dbClient.ts
+
+
+
+
+
+
+
+var isPostgresClientOptions = (options) => options.connectorType === _dumbo.NodePostgresConnectorType;
+var postgresDb = (options) => {
+  const { connectionString, dbName } = options;
+  const databaseName = _nullishCoalesce(dbName, () => ( _dumbo.getDatabaseNameOrDefault.call(void 0, connectionString)));
+  const pool = _dumbo.dumbo.call(void 0, {
+    connectionString,
+    ...options.connectionOptions
+  });
+  const collections = /* @__PURE__ */ new Map();
+  const command = async (sql4, options2) => (await transactionExecutorOrDefault(db, options2, pool.execute)).command(sql4);
+  const query = async (sql4, options2) => (await transactionExecutorOrDefault(db, options2, pool.execute)).query(
+    sql4
+  );
+  const db = {
+    connectorType: options.connectorType,
+    databaseName,
+    connect: () => Promise.resolve(),
+    close: () => pool.close(),
+    collections: () => [...collections.values()],
+    collection: (collectionName) => pongoCollection({
+      collectionName,
+      db,
+      pool,
+      sqlBuilder: postgresSQLBuilder(collectionName),
+      schema: options.schema ? options.schema : {},
+      errors: options.errors ? options.errors : {}
+    }),
+    transaction: () => pool.transaction(),
+    withTransaction: (handle) => pool.withTransaction(handle),
+    schema: {
+      get component() {
+        return _dumbo.schemaComponent.call(void 0, "pongoDb", {
+          components: [...collections.values()].map((c) => c.schema.component)
+        });
+      },
+      migrate: () => _dumbo.runPostgreSQLMigrations.call(void 0, 
+        pool,
+        [...collections.values()].flatMap(
+          (c) => (
+            // TODO: This needs to change to support more connectors
+            c.schema.component.migrations({ connector: "PostgreSQL:pg" })
+          )
+        )
+      )
+    },
+    sql: {
+      async query(sql4, options2) {
+        const result = await query(sql4, options2);
+        return result.rows;
+      },
+      async command(sql4, options2) {
+        return command(sql4, options2);
+      }
+    }
+  };
+  const dbsSchema = _optionalChain([options, 'optionalAccess', _ => _.schema, 'optionalAccess', _2 => _2.definition, 'optionalAccess', _3 => _3.dbs]);
+  if (dbsSchema) {
+    const dbSchema = objectEntries(dbsSchema).map((e) => e[1]).find((db2) => db2.name === dbName || db2.name === databaseName);
+    if (dbSchema) return proxyPongoDbWithSchema(db, dbSchema, collections);
+  }
+  return db;
+};
+var pongoDbSchemaComponent = (collections) => {
+  const components = collections.length > 0 && typeof collections[0] === "string" ? collections.map(
+    (collectionName) => pongoCollectionSchemaComponent(collectionName)
+  ) : collections;
+  return _dumbo.schemaComponent.call(void 0, "pongo:schema_component:db", {
+    components
+  });
+};
+
+// src/core/collection/pongoCollection.ts
+var enlistIntoTransactionIfActive = async (db, options) => {
+  const transaction = _optionalChain([options, 'optionalAccess', _4 => _4.session, 'optionalAccess', _5 => _5.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', _6 => _6.execute]), () => ( defaultSqlExecutor));
+};
+var pongoCollection = ({
+  db,
+  collectionName,
+  pool,
+  sqlBuilder: SqlFor,
+  schema,
+  errors
+}) => {
+  const sqlExecutor = pool.execute;
+  const command = async (sql4, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).command(sql4);
+  const query = async (sql4, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).query(
+    sql4
+  );
+  let shouldMigrate = _optionalChain([schema, 'optionalAccess', _7 => _7.autoMigration]) !== "None";
+  const createCollection2 = (options) => {
+    shouldMigrate = false;
+    if (_optionalChain([options, 'optionalAccess', _8 => _8.session])) return command(SqlFor.createCollection(), options);
+    else return command(SqlFor.createCollection());
+  };
+  const ensureCollectionCreated = (options) => {
+    if (!shouldMigrate) {
+      return Promise.resolve();
+    }
+    return createCollection2(options);
+  };
+  const collection = {
+    dbName: db.databaseName,
+    collectionName,
+    createCollection: async (options) => {
+      await createCollection2(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 result = await command(
+        SqlFor.insertOne({
+          ...document,
+          _id,
+          _version
+        }),
+        options
+      );
+      const successful = (_nullishCoalesce(result.rowCount, () => ( 0))) > 0;
+      return operationResult(
+        {
+          successful,
+          insertedId: successful ? _id : null,
+          nextExpectedVersion: _version
+        },
+        { operationName: "insertOne", collectionName, errors }
+      );
+    },
+    insertMany: async (documents, options) => {
+      await ensureCollectionCreated(options);
+      const rows = documents.map((doc) => ({
+        ...doc,
+        _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, 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', _9 => _9.rows, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.modified]), () => ( 0))),
+          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _12 => _12.rows, 'access', _13 => _13[0], 'optionalAccess', _14 => _14.matched]), () => ( 0))),
+          nextExpectedVersion: _nullishCoalesce(_optionalChain([result, 'access', _15 => _15.rows, 'access', _16 => _16[0], 'optionalAccess', _17 => _17.version]), () => ( 0n))
+        },
+        { operationName: "updateOne", collectionName, errors }
+      );
+    },
+    replaceOne: async (filter, document, options) => {
+      await ensureCollectionCreated(options);
+      const result = await command(
+        SqlFor.replaceOne(filter, document, options),
+        options
+      );
+      return operationResult(
+        {
+          successful: result.rows.length > 0 && result.rows[0].modified > 0,
+          modifiedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _18 => _18.rows, 'access', _19 => _19[0], 'optionalAccess', _20 => _20.modified]), () => ( 0))),
+          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _21 => _21.rows, 'access', _22 => _22[0], 'optionalAccess', _23 => _23.matched]), () => ( 0))),
+          nextExpectedVersion: _nullishCoalesce(_optionalChain([result, 'access', _24 => _24.rows, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.version]), () => ( 0n))
+        },
+        { operationName: "replaceOne", collectionName, 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, 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', _27 => _27.rows, 'access', _28 => _28[0], 'optionalAccess', _29 => _29.deleted]), () => ( 0))),
+          matchedCount: Number(_nullishCoalesce(_optionalChain([result, 'access', _30 => _30.rows, 'access', _31 => _31[0], 'optionalAccess', _32 => _32.matched]), () => ( 0)))
+        },
+        { operationName: "deleteOne", collectionName, 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, errors }
+      );
+    },
+    findOne: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      const result = await query(SqlFor.findOne(_nullishCoalesce(filter, () => ( {}))), options);
+      return _nullishCoalesce(_optionalChain([result, 'access', _33 => _33.rows, 'access', _34 => _34[0], 'optionalAccess', _35 => _35.data]), () => ( null));
+    },
+    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, errors }
+        );
+      }
+      const result = await handle(
+        existing !== null ? { ...existing } : null
+      );
+      if (deepEquals(existing, result))
+        return operationResult(
+          {
+            successful: true,
+            document: existing
+          },
+          { operationName: "handle", collectionName, 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, errors }
+      );
+    },
+    find: async (filter, options) => {
+      await ensureCollectionCreated(options);
+      const result = await query(SqlFor.find(_nullishCoalesce(filter, () => ( {}))));
+      return result.rows.map((row) => row.data);
+    },
+    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', _36 => _36.rowCount]), () => ( 0))) > 0;
+    },
+    rename: async (newName, options) => {
+      await ensureCollectionCreated(options);
+      await command(SqlFor.rename(newName));
+      collectionName = newName;
+      return collection;
+    },
+    sql: {
+      async query(sql4, options) {
+        await ensureCollectionCreated(options);
+        const result = await query(sql4, options);
+        return result.rows;
+      },
+      async command(sql4, options) {
+        await ensureCollectionCreated(options);
+        return command(sql4, options);
+      }
+    },
+    schema: {
+      get component() {
+        return _dumbo.schemaComponent.call(void 0, "pongo:schema_component:collection", {
+          migrations: SqlFor.migrations
+        });
+      },
+      migrate: () => _dumbo.runPostgreSQLMigrations.call(void 0, pool, SqlFor.migrations())
+      // TODO: This needs to change to support more connectors
+    }
+  };
+  return collection;
+};
+var pongoCollectionSchemaComponent = (collectionName) => _dumbo.schemaComponent.call(void 0, "pongo:schema_component:collection", {
+  migrations: () => pongoCollectionPostgreSQLMigrations(collectionName)
+  // TODO: This needs to change to support more connectors
+});
+
+// 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/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/pongoClient.ts
+
+
+
+require('pg');
+
+// src/core/pongoDb.ts
+var getPongoDb = (options) => {
+  const { connectorType: type } = options;
+  if (!isPostgresClientOptions(options))
+    throw new Error(`Unsupported db type: ${type}`);
+  return postgresDb(options);
+};
+
+// 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', _37 => _37.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', _38 => _38.explicit]) === true;
+  const defaultTransactionOptions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.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/typing/entries.ts
+var objectEntries = (obj) => Object.entries(obj).map(([key, value]) => [key, value]);
+
+// 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: ${_dumbo.JSONSerializer.serialize(result)}!`))
+        );
+    }
+  };
+  if (_optionalChain([options, 'access', _40 => _40.errors, 'optionalAccess', _41 => _41.throwOnOperationFailures]))
+    operationResult2.assertSuccessful();
+  return operationResult2;
+};
+
+// src/core/schema/index.ts
+var pongoCollectionSchema = (name) => ({
+  name
+});
+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 };
+}
+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', _42 => _42.dbs, 'access', _43 => _43[prop], 'optionalAccess', _44 => _44.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/pongoClient.ts
+var pongoClient = (connectionString, options = {}) => {
+  const dbClients = /* @__PURE__ */ new Map();
+  const dbClient = getPongoDb(
+    clientToDbOptions({
+      connectionString,
+      clientOptions: options
+    })
+  );
+  dbClients.set(dbClient.databaseName, dbClient);
+  const pongoClient2 = {
+    connect: async () => {
+      await dbClient.connect();
+      return pongoClient2;
+    },
+    close: async () => {
+      for (const db of dbClients.values()) {
+        await db.close();
+      }
+    },
+    db: (dbName) => {
+      if (!dbName) return dbClient;
+      return _nullishCoalesce(dbClients.get(dbName), () => ( dbClients.set(
+        dbName,
+        getPongoDb(
+          clientToDbOptions({
+            connectionString,
+            dbName,
+            clientOptions: options
+          })
+        )
+      ).get(dbName)));
+    },
+    startSession: pongoSession,
+    withSession: async (callback) => {
+      const session = pongoSession();
+      try {
+        return await callback(session);
+      } finally {
+        await session.endSession();
+      }
+    }
+  };
+  return proxyClientWithSchema(pongoClient2, _optionalChain([options, 'optionalAccess', _45 => _45.schema, 'optionalAccess', _46 => _46.definition]));
+};
+var clientToDbOptions = (options) => {
+  const postgreSQLOptions = {
+    connectorType: _dumbo.NodePostgresConnectorType,
+    connectionString: options.connectionString,
+    dbName: options.dbName,
+    ...options.clientOptions
+  };
+  return postgreSQLOptions;
+};
+
+// 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/postgres/sqlBuilder/filter/queryOperators.ts
+
+var handleOperator = (path, operator, value) => {
+  if (path === "_id" || path === "_version") {
+    return handleMetadataOperator(path, operator, value);
+  }
+  switch (operator) {
+    case "$eq":
+      return _dumbo.sql.call(void 0, 
+        `(data @> %L::jsonb OR jsonb_path_exists(data, '$.%s[*] ? (@ == %s)'))`,
+        _dumbo.JSONSerializer.serialize(buildNestedObject(path, value)),
+        path,
+        _dumbo.JSONSerializer.serialize(value)
+      );
+    case "$gt":
+    case "$gte":
+    case "$lt":
+    case "$lte":
+    case "$ne":
+      return _dumbo.sql.call(void 0, 
+        `data #>> %L ${OperatorMap[operator]} %L`,
+        `{${path.split(".").join(",")}}`,
+        value
+      );
+    case "$in":
+      return _dumbo.sql.call(void 0, 
+        "data #>> %L IN (%s)",
+        `{${path.split(".").join(",")}}`,
+        value.map((v) => _dumbo.sql.call(void 0, "%L", v)).join(", ")
+      );
+    case "$nin":
+      return _dumbo.sql.call(void 0, 
+        "data #>> %L NOT IN (%s)",
+        `{${path.split(".").join(",")}}`,
+        value.map((v) => _dumbo.sql.call(void 0, "%L", v)).join(", ")
+      );
+    case "$elemMatch": {
+      const subQuery = objectEntries(value).map(
+        ([subKey, subValue]) => _dumbo.sql.call(void 0, `@."%s" == %s`, subKey, _dumbo.JSONSerializer.serialize(subValue))
+      ).join(" && ");
+      return _dumbo.sql.call(void 0, `jsonb_path_exists(data, '$.%s[*] ? (%s)')`, path, subQuery);
+    }
+    case "$all":
+      return _dumbo.sql.call(void 0, 
+        "data @> %L::jsonb",
+        _dumbo.JSONSerializer.serialize(buildNestedObject(path, value))
+      );
+    case "$size":
+      return _dumbo.sql.call(void 0, 
+        "jsonb_array_length(data #> %L) = %L",
+        `{${path.split(".").join(",")}}`,
+        value
+      );
+    default:
+      throw new Error(`Unsupported operator: ${operator}`);
+  }
+};
+var handleMetadataOperator = (fieldName, operator, value) => {
+  switch (operator) {
+    case "$eq":
+      return _dumbo.sql.call(void 0, `${fieldName} = %L`, value);
+    case "$gt":
+    case "$gte":
+    case "$lt":
+    case "$lte":
+    case "$ne":
+      return _dumbo.sql.call(void 0, `${fieldName} ${OperatorMap[operator]} %L`, value);
+    case "$in":
+      return _dumbo.sql.call(void 0, 
+        `${fieldName} IN (%s)`,
+        value.map((v) => _dumbo.sql.call(void 0, "%L", v)).join(", ")
+      );
+    case "$nin":
+      return _dumbo.sql.call(void 0, 
+        `${fieldName} NOT IN (%s)`,
+        value.map((v) => _dumbo.sql.call(void 0, "%L", v)).join(", ")
+      );
+    default:
+      throw new Error(`Unsupported operator: ${operator}`);
+  }
+};
+var buildNestedObject = (path, value) => path.split(".").reverse().reduce((acc, key) => ({ [key]: acc }), value);
+
+// src/postgres/sqlBuilder/filter/index.ts
+var AND = "AND";
+var constructFilterQuery = (filter) => Object.entries(filter).map(
+  ([key, value]) => isRecord(value) ? constructComplexFilterQuery(key, value) : handleOperator(key, "$eq", value)
+).join(` ${AND} `);
+var constructComplexFilterQuery = (key, value) => {
+  const isEquality = !hasOperators(value);
+  return objectEntries(value).map(
+    ([nestedKey, val]) => isEquality ? handleOperator(`${key}.${nestedKey}`, QueryOperators.$eq, val) : handleOperator(key, nestedKey, val)
+    // operator
+  ).join(` ${AND} `);
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+// src/postgres/sqlBuilder/update/index.ts
+
+var buildUpdateQuery = (update) => objectEntries(update).reduce((currentUpdateQuery, [op, value]) => {
+  switch (op) {
+    case "$set":
+      return buildSetQuery(value, currentUpdateQuery);
+    case "$unset":
+      return buildUnsetQuery(value, currentUpdateQuery);
+    case "$inc":
+      return buildIncQuery(value, currentUpdateQuery);
+    case "$push":
+      return buildPushQuery(value, currentUpdateQuery);
+    default:
+      return currentUpdateQuery;
+  }
+}, _dumbo.sql.call(void 0, "data"));
+var buildSetQuery = (set, currentUpdateQuery) => _dumbo.sql.call(void 0, "%s || %L::jsonb", currentUpdateQuery, _dumbo.JSONSerializer.serialize(set));
+var buildUnsetQuery = (unset, currentUpdateQuery) => _dumbo.sql.call(void 0, 
+  "%s - %L",
+  currentUpdateQuery,
+  Object.keys(unset).map((k) => `{${k}}`).join(", ")
+);
+var buildIncQuery = (inc, currentUpdateQuery) => {
+  for (const [key, value] of Object.entries(inc)) {
+    currentUpdateQuery = _dumbo.sql.call(void 0, 
+      typeof value === "bigint" ? "jsonb_set(%s, '{%s}', to_jsonb((COALESCE((data->>'%s')::BIGINT, 0) + %L)::TEXT), true)" : "jsonb_set(%s, '{%s}', to_jsonb(COALESCE((data->>'%s')::NUMERIC, 0) + %L), true)",
+      currentUpdateQuery,
+      key,
+      key,
+      value
+    );
+  }
+  return currentUpdateQuery;
+};
+var buildPushQuery = (push, currentUpdateQuery) => {
+  for (const [key, value] of Object.entries(push)) {
+    currentUpdateQuery = _dumbo.sql.call(void 0, 
+      "jsonb_set(%s, '{%s}', (coalesce(data->'%s', '[]'::jsonb) || %L::jsonb), true)",
+      currentUpdateQuery,
+      key,
+      key,
+      _dumbo.JSONSerializer.serialize([value])
+    );
+  }
+  return currentUpdateQuery;
+};
+
+// src/postgres/sqlBuilder/index.ts
+var createCollection = (collectionName) => _dumbo.sql.call(void 0, 
+  `CREATE TABLE IF NOT EXISTS %I (
+      _id           TEXT           PRIMARY KEY, 
+      data          JSONB          NOT NULL, 
+      metadata      JSONB          NOT NULL     DEFAULT '{}',
+      _version      BIGINT         NOT NULL     DEFAULT 1,
+      _partition    TEXT           NOT NULL     DEFAULT 'png_global',
+      _archived     BOOLEAN        NOT NULL     DEFAULT FALSE,
+      _created      TIMESTAMPTZ    NOT NULL     DEFAULT now(),
+      _updated      TIMESTAMPTZ    NOT NULL     DEFAULT now()
+  )`,
+  collectionName
+);
+var pongoCollectionPostgreSQLMigrations = (collectionName) => [
+  _dumbo.sqlMigration.call(void 0, `pongoCollection:${collectionName}:001:createtable`, [
+    createCollection(collectionName)
+  ])
+];
+var postgresSQLBuilder = (collectionName) => ({
+  migrations: () => pongoCollectionPostgreSQLMigrations(collectionName),
+  createCollection: () => createCollection(collectionName),
+  insertOne: (document) => {
+    return _dumbo.sql.call(void 0, 
+      "INSERT INTO %I (_id, data, _version) VALUES (%L, %L, %L) ON CONFLICT(_id) DO NOTHING;",
+      collectionName,
+      document._id,
+      _dumbo.JSONSerializer.serialize(document),
+      _nullishCoalesce(document._version, () => ( 1n))
+    );
+  },
+  insertMany: (documents) => {
+    const values = documents.map(
+      (doc) => _dumbo.sql.call(void 0, 
+        "(%L, %L, %L)",
+        doc._id,
+        _dumbo.JSONSerializer.serialize(doc),
+        _nullishCoalesce(doc._version, () => ( 1n))
+      )
+    ).join(", ");
+    return _dumbo.sql.call(void 0, 
+      `INSERT INTO %I (_id, data, _version) VALUES %s 
+      ON CONFLICT(_id) DO NOTHING
+      RETURNING _id;`,
+      collectionName,
+      values
+    );
+  },
+  updateOne: (filter, update, options) => {
+    const expectedVersion2 = expectedVersionValue(_optionalChain([options, 'optionalAccess', _47 => _47.expectedVersion]));
+    const expectedVersionUpdate = expectedVersion2 != null ? "AND %I._version = %L" : "";
+    const expectedVersionParams = expectedVersion2 != null ? [collectionName, expectedVersion2] : [];
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    const updateQuery = _dumbo.isSQL.call(void 0, update) ? update : buildUpdateQuery(update);
+    return _dumbo.sql.call(void 0, 
+      `WITH existing AS (
+        SELECT _id, _version as current_version
+        FROM %I %s 
+        LIMIT 1
+      ),
+      updated AS (
+        UPDATE %I 
+        SET 
+          data = %s || jsonb_build_object('_id', %I._id) || jsonb_build_object('_version', (_version + 1)::text),
+          _version = _version + 1
+        FROM existing 
+        WHERE %I._id = existing._id ${expectedVersionUpdate}
+        RETURNING %I._id, %I._version
+      )
+      SELECT 
+        existing._id,
+        COALESCE(updated._version, existing.current_version) AS version,
+        COUNT(existing._id) over() AS matched,
+        COUNT(updated._id) over() AS modified
+      FROM existing
+      LEFT JOIN updated 
+      ON existing._id = updated._id;`,
+      collectionName,
+      where(filterQuery),
+      collectionName,
+      updateQuery,
+      collectionName,
+      collectionName,
+      ...expectedVersionParams,
+      collectionName,
+      collectionName
+    );
+  },
+  replaceOne: (filter, document, options) => {
+    const expectedVersion2 = expectedVersionValue(_optionalChain([options, 'optionalAccess', _48 => _48.expectedVersion]));
+    const expectedVersionUpdate = expectedVersion2 != null ? "AND %I._version = %L" : "";
+    const expectedVersionParams = expectedVersion2 != null ? [collectionName, expectedVersion2] : [];
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    return _dumbo.sql.call(void 0, 
+      `WITH existing AS (
+        SELECT _id, _version as current_version
+        FROM %I %s 
+        LIMIT 1
+      ),
+      updated AS (
+        UPDATE %I        
+        SET 
+          data = %L || jsonb_build_object('_id', %I._id) || jsonb_build_object('_version', (_version + 1)::text),
+          _version = _version + 1
+        FROM existing 
+        WHERE %I._id = existing._id ${expectedVersionUpdate}
+        RETURNING %I._id, %I._version
+      )
+      SELECT 
+        existing._id,
+        COALESCE(updated._version, existing.current_version) AS version,
+        COUNT(existing._id) over() AS matched,
+        COUNT(updated._id) over() AS modified
+      FROM existing
+      LEFT JOIN updated 
+      ON existing._id = updated._id;`,
+      collectionName,
+      where(filterQuery),
+      collectionName,
+      _dumbo.JSONSerializer.serialize(document),
+      collectionName,
+      collectionName,
+      ...expectedVersionParams,
+      collectionName,
+      collectionName
+    );
+  },
+  updateMany: (filter, update) => {
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    const updateQuery = _dumbo.isSQL.call(void 0, update) ? update : buildUpdateQuery(update);
+    return _dumbo.sql.call(void 0, 
+      `UPDATE %I 
+      SET 
+        data = %s || jsonb_build_object('_version', (_version + 1)::text),
+        _version = _version + 1
+      %s;`,
+      collectionName,
+      updateQuery,
+      where(filterQuery)
+    );
+  },
+  deleteOne: (filter, options) => {
+    const expectedVersion2 = expectedVersionValue(_optionalChain([options, 'optionalAccess', _49 => _49.expectedVersion]));
+    const expectedVersionUpdate = expectedVersion2 != null ? "AND %I._version = %L" : "";
+    const expectedVersionParams = expectedVersion2 != null ? [collectionName, expectedVersion2] : [];
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    return _dumbo.sql.call(void 0, 
+      `WITH existing AS (
+        SELECT _id
+        FROM %I %s 
+        LIMIT 1
+      ),
+      deleted AS (
+        DELETE FROM %I
+        USING existing
+        WHERE %I._id = existing._id ${expectedVersionUpdate}
+        RETURNING %I._id
+      )
+      SELECT 
+        existing._id,
+        COUNT(existing._id) over() AS matched,
+        COUNT(deleted._id) over() AS deleted
+      FROM existing
+      LEFT JOIN deleted 
+      ON existing._id = deleted._id;`,
+      collectionName,
+      where(filterQuery),
+      collectionName,
+      collectionName,
+      ...expectedVersionParams,
+      collectionName
+    );
+  },
+  deleteMany: (filter) => {
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    return _dumbo.sql.call(void 0, "DELETE FROM %I %s", collectionName, where(filterQuery));
+  },
+  findOne: (filter) => {
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    return _dumbo.sql.call(void 0, 
+      "SELECT data FROM %I %s LIMIT 1;",
+      collectionName,
+      where(filterQuery)
+    );
+  },
+  find: (filter) => {
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    return _dumbo.sql.call(void 0, "SELECT data FROM %I %s;", collectionName, where(filterQuery));
+  },
+  countDocuments: (filter) => {
+    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
+    return _dumbo.sql.call(void 0, 
+      "SELECT COUNT(1) as count FROM %I %s;",
+      collectionName,
+      where(filterQuery)
+    );
+  },
+  rename: (newName) => _dumbo.sql.call(void 0, "ALTER TABLE %I RENAME TO %I;", collectionName, newName),
+  drop: (targetName = collectionName) => _dumbo.sql.call(void 0, "DROP TABLE IF EXISTS %I", targetName)
+});
+var where = (filter) => filter.length > 0 ? _dumbo.sql.call(void 0, "WHERE %s", filter) : _dumbo.rawSql.call(void 0, "");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.pongoCollectionPostgreSQLMigrations = pongoCollectionPostgreSQLMigrations; exports.postgresSQLBuilder = postgresSQLBuilder; exports.isPostgresClientOptions = isPostgresClientOptions; exports.postgresDb = postgresDb; exports.pongoDbSchemaComponent = pongoDbSchemaComponent; exports.transactionExecutorOrDefault = transactionExecutorOrDefault; exports.pongoCollection = pongoCollection; exports.pongoCollectionSchemaComponent = pongoCollectionSchemaComponent; exports.QueryOperators = QueryOperators; exports.OperatorMap = OperatorMap; exports.isOperator = isOperator; exports.hasOperators = hasOperators; exports.isNumber = isNumber; exports.isString = isString; exports.PongoError = PongoError; exports.ConcurrencyError = ConcurrencyError; exports.getPongoDb = getPongoDb; exports.pongoTransaction = pongoTransaction; exports.pongoSession = pongoSession; exports.objectEntries = objectEntries; 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.pongoClient = pongoClient; exports.clientToDbOptions = clientToDbOptions; exports.deepEquals = deepEquals; exports.isEquatable = isEquatable;
+//# sourceMappingURL=chunk-HZVM5GBH.cjs.map