@event-driven-io/pongo 0.17.0-alpha.6 → 0.17.0-beta.10

package/dist/{chunk-OO7GMTMP.js → chunk-RBJRJFQY.js}

@@ -1,157 +1,597 @@
-// src/storage/postgresql/sqlBuilder/index.ts
-import {
-  isSQL,
-  JSONSerializer as JSONSerializer4,
-  rawSql,
-  sql as sql3,
-  sqlMigration
-} from "@event-driven-io/dumbo";
-
 // src/core/collection/pongoCollection.ts
 import {
-  schemaComponent as schemaComponent2,
+  mapColumnToJSON,
+  runSQLMigrations as runSQLMigrations2,
   single
 } from "@event-driven-io/dumbo";
-import { runPostgreSQLMigrations as runPostgreSQLMigrations2 } from "@event-driven-io/dumbo/pg";
-import { v7 as uuid } from "uuid";
+import { v7 as uuid2 } from "uuid";
+
+// src/core/collection/pongoCollectionSchema.ts
+import "@event-driven-io/dumbo";
 
-// src/storage/postgresql/dbClient.ts
+// src/core/collection/pongoCollectionSchemaComponent.ts
 import {
   schemaComponent
 } from "@event-driven-io/dumbo";
+var PongoCollectionSchemaComponent = ({
+  definition,
+  migrationsOrSchemaComponents,
+  sqlBuilder
+}) => ({
+  ...schemaComponent(
+    `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(typedSchema?.dbs ?? {}).find((d) => d.name === dbName);
+  return {
+    getOrCreate: (createOptions) => {
+      const dbName = createOptions.databaseName ?? (driver.getDatabaseNameOrDefault ? driver.getDatabaseNameOrDefault(createOptions) : "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
+import {
+  schemaComponent as schemaComponent2
+} from "@event-driven-io/dumbo";
+
+// src/core/typing/entries.ts
+var objectEntries = (obj) => Object.entries(obj).map(([key, value]) => [key, value]);
+
+// src/core/typing/operations.ts
 import {
-  dumbo,
-  getDatabaseNameOrDefault,
-  NodePostgresConnectorType,
-  runPostgreSQLMigrations
-} from "@event-driven-io/dumbo/pg";
-var isPostgresClientOptions = (options) => options.connector === NodePostgresConnectorType;
-var postgresDb = (options) => {
-  const { connectionString, dbName } = options;
-  const databaseName = dbName ?? getDatabaseNameOrDefault(connectionString);
-  const pool = dumbo({
-    connectionString,
-    ...options.connectionOptions
-  });
+  JSONSerializer
+} from "@event-driven-io/dumbo";
+import { v7 as uuid } from "uuid";
+
+// 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 {
+  errorCode;
+  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: message ?? `Expected document state does not match current one!`
+    });
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+
+// src/core/typing/operations.ts
+var ObjectId = (value) => value ?? uuid();
+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(
+          errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`
+        );
+    }
+  };
+  if (options.errors?.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 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(schema.dbs[prop]?.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 = Object.values(definition.collections).map(collectionFactory) ?? [];
+  return {
+    ...schemaComponent2(`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
+import {
+  runSQLMigrations
+} from "@event-driven-io/dumbo";
+var PongoDatabase = (options) => {
+  const { databaseName, schemaComponent: schemaComponent3, pool } = options;
   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 command = async (sql, options2) => (await transactionExecutorOrDefault(db, options2, pool.execute)).command(sql);
+  const query = async (sql, options2) => (await transactionExecutorOrDefault(db, options2, pool.execute)).query(
+    sql
   );
+  const driverType = pool.driverType;
   const db = {
-    connector: options.connector,
+    driverType,
     databaseName,
     connect: () => Promise.resolve(),
     close: () => pool.close(),
     collections: () => [...collections.values()],
-    collection: (collectionName) => pongoCollection({
+    collection: (collectionName) => collections.get(collectionName) ?? pongoCollection({
       collectionName,
       db,
       pool,
-      sqlBuilder: postgresSQLBuilder(collectionName),
+      schemaComponent: schemaComponent3.collection(
+        pongoSchema.collection(collectionName)
+      ),
       schema: options.schema ? options.schema : {},
       errors: options.errors ? options.errors : {}
     }),
     transaction: () => pool.transaction(),
     withTransaction: (handle) => pool.withTransaction(handle),
     schema: {
-      get component() {
-        return schemaComponent("pongoDb", {
-          components: [...collections.values()].map((c) => c.schema.component)
-        });
-      },
-      migrate: () => runPostgreSQLMigrations(
-        pool,
-        [...collections.values()].flatMap(
-          (c) => (
-            // TODO: This needs to change to support more connectors
-            c.schema.component.migrations({ connector: "PostgreSQL:pg" })
-          )
-        )
-      )
+      component: schemaComponent3,
+      migrate: () => runSQLMigrations(pool, schemaComponent3.migrations)
     },
     sql: {
-      async query(sql4, options2) {
-        const result = await query(sql4, options2);
+      async query(sql, options2) {
+        const result = await query(sql, options2);
         return result.rows;
       },
-      async command(sql4, options2) {
-        return command(sql4, options2);
+      async command(sql, options2) {
+        return command(sql, options2);
       }
     }
   };
-  const dbsSchema = options?.schema?.definition?.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);
+  const dbSchema = options?.schema?.definition;
+  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 schemaComponent("pongo:schema_component:db", {
-    components
-  });
-};
 
-// src/core/collection/pongoCollection.ts
-var enlistIntoTransactionIfActive = async (db, options) => {
-  const transaction = options?.session?.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 existingTransaction?.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 = schema?.autoMigration !== "None";
-  const createCollection2 = (options) => {
-    shouldMigrate = false;
-    if (options?.session) return command(SqlFor.createCollection(), options);
-    else return command(SqlFor.createCollection());
+// src/core/drivers/databaseDriver.ts
+var PongoDatabaseDriverRegistry = () => {
+  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 ensureCollectionCreated = (options) => {
-    if (!shouldMigrate) {
-      return Promise.resolve();
+  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());
     }
-    return createCollection2(options);
   };
-  const collection = {
-    dbName: db.databaseName,
-    collectionName,
-    createCollection: async (options) => {
-      await createCollection2(options);
+};
+var pongoDatabaseDriverRegistry = globalThis.pongoDatabaseDriverRegistry = globalThis.pongoDatabaseDriverRegistry ?? PongoDatabaseDriverRegistry();
+
+// 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;
     },
-    insertOne: async (document, options) => {
-      await ensureCollectionCreated(options);
-      const _id = document._id ?? uuid();
-      const _version = document._version ?? 1n;
-      const result = await command(
-        SqlFor.insertOne({
-          ...document,
-          _id,
-          _version
-        }),
-        options
-      );
-      const successful = (result.rowCount ?? 0) > 0;
-      return operationResult(
-        {
+    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) => transaction?.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 = options?.explicit === true;
+  const defaultTransactionOptions = options?.defaultTransactionOptions ?? {
+    get snapshotEnabled() {
+      return false;
+    }
+  };
+  let transaction = null;
+  let hasEnded = false;
+  const startTransaction = (options2) => {
+    assertNotInActiveTransaction(transaction);
+    transaction = pongoTransaction(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: 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: schema?.definition
+  });
+  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,
+        errors
+      });
+      return db;
+    },
+    startSession: pongoSession,
+    withSession: async (callback) => {
+      const session = pongoSession();
+      try {
+        return await callback(session);
+      } finally {
+        await session.endSession();
+      }
+    }
+  };
+  return proxyClientWithSchema(pongoClient2, schema?.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 = options?.session?.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 existingTransaction?.execute ?? defaultSqlExecutor;
+};
+var columnMapping = {
+  mapping: {
+    ...mapColumnToJSON("data")
+    //...mapColumnToJSON('metadata'),
+    //...mapColumnToBigint('_version'),
+  }
+};
+var pongoCollection = ({
+  db,
+  collectionName,
+  pool,
+  schemaComponent: schemaComponent3,
+  schema,
+  errors
+}) => {
+  const SqlFor = schemaComponent3.sqlBuilder;
+  const sqlExecutor = pool.execute;
+  const command = async (sql, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).command(sql);
+  const query = async (sql, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).query(
+    sql,
+    columnMapping
+  );
+  let shouldMigrate = schema?.autoMigration !== "None";
+  const createCollection = (options) => {
+    shouldMigrate = false;
+    if (options?.session) return command(SqlFor.createCollection(), options);
+    else return command(SqlFor.createCollection());
+  };
+  const ensureCollectionCreated = (options) => {
+    if (!shouldMigrate) {
+      return Promise.resolve();
+    }
+    return createCollection(options);
+  };
+  const collection = {
+    dbName: db.databaseName,
+    collectionName,
+    createCollection: async (options) => {
+      await createCollection(options);
+    },
+    insertOne: async (document, options) => {
+      await ensureCollectionCreated(options);
+      const _id = document._id ?? uuid2();
+      const _version = document._version ?? 1n;
+      const result = await command(
+        SqlFor.insertOne({
+          ...document,
+          _id,
+          _version
+        }),
+        options
+      );
+      const successful = (result.rowCount ?? 0) > 0;
+      return operationResult(
+        {
           successful,
           insertedId: successful ? _id : null,
           nextExpectedVersion: _version
@@ -163,7 +603,7 @@ var pongoCollection = ({
       await ensureCollectionCreated(options);
       const rows = documents.map((doc) => ({
         ...doc,
-        _id: doc._id ?? uuid(),
+        _id: doc._id ?? uuid2(),
         _version: doc._version ?? 1n
       }));
       const result = await command(
@@ -190,7 +630,7 @@ var pongoCollection = ({
           successful: result.rows.length > 0 && result.rows[0].modified === result.rows[0].matched,
           modifiedCount: Number(result.rows[0]?.modified ?? 0),
           matchedCount: Number(result.rows[0]?.matched ?? 0),
-          nextExpectedVersion: result.rows[0]?.version ?? 0n
+          nextExpectedVersion: BigInt(result.rows[0]?.version ?? 0n)
         },
         { operationName: "updateOne", collectionName, errors }
       );
@@ -206,7 +646,7 @@ var pongoCollection = ({
           successful: result.rows.length > 0 && result.rows[0].modified > 0,
           modifiedCount: Number(result.rows[0]?.modified ?? 0),
           matchedCount: Number(result.rows[0]?.matched ?? 0),
-          nextExpectedVersion: result.rows[0]?.version ?? 0n
+          nextExpectedVersion: BigInt(result.rows[0]?.version ?? 0n)
         },
         { operationName: "replaceOne", collectionName, errors }
       );
@@ -374,786 +814,38 @@ var pongoCollection = ({
       return collection;
     },
     sql: {
-      async query(sql4, options) {
+      async query(sql, options) {
         await ensureCollectionCreated(options);
-        const result = await query(sql4, options);
+        const result = await query(sql, options);
         return result.rows;
       },
-      async command(sql4, options) {
+      async command(sql, options) {
         await ensureCollectionCreated(options);
-        return command(sql4, options);
+        return command(sql, options);
       }
     },
     schema: {
-      get component() {
-        return schemaComponent2("pongo:schema_component:collection", {
-          migrations: SqlFor.migrations
-        });
-      },
-      migrate: () => runPostgreSQLMigrations2(pool, SqlFor.migrations())
-      // TODO: This needs to change to support more connectors
+      component: schemaComponent3,
+      migrate: () => runSQLMigrations2(pool, schemaComponent3.migrations)
     }
   };
   return collection;
 };
-var pongoCollectionSchemaComponent = (collectionName) => schemaComponent2("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 {
-  errorCode;
-  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: message ?? `Expected document state does not match current one!`
-    });
-    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
-  }
-};
-
-// src/core/pongoClient.ts
-import "@event-driven-io/dumbo";
-import {
-  NodePostgresConnectorType as NodePostgresConnectorType2
-} from "@event-driven-io/dumbo/pg";
-import "pg";
-
-// src/core/pongoDb.ts
-var getPongoDb = (options) => {
-  const { connector } = options;
-  if (!isPostgresClientOptions(options))
-    throw new Error(`Unsupported db type: ${connector}`);
-  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) => transaction?.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 = options?.explicit === true;
-  const defaultTransactionOptions = options?.defaultTransactionOptions ?? {
-    get snapshotEnabled() {
-      return false;
-    }
-  };
-  let transaction = null;
-  let hasEnded = false;
-  const startTransaction = (options2) => {
-    assertNotInActiveTransaction(transaction);
-    transaction = pongoTransaction(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: 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
-import {
-  JSONSerializer
-} from "@event-driven-io/dumbo";
-import { v7 as uuid2 } from "uuid";
-var ObjectId = (value) => value ?? uuid2();
-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(
-          errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`
-        );
-    }
-  };
-  if (options.errors?.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 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(schema.dbs[prop]?.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 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, options?.schema?.definition);
-};
-var clientToDbOptions = (options) => {
-  const postgreSQLOptions = {
-    connector: NodePostgresConnectorType2,
-    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/storage/postgresql/sqlBuilder/filter/queryOperators.ts
-import { JSONSerializer as JSONSerializer2, sql } from "@event-driven-io/dumbo";
-var handleOperator = (path, operator, value) => {
-  if (path === "_id" || path === "_version") {
-    return handleMetadataOperator(path, operator, value);
-  }
-  switch (operator) {
-    case "$eq":
-      return sql(
-        `(data @> %L::jsonb OR jsonb_path_exists(data, '$.%s[*] ? (@ == %s)'))`,
-        JSONSerializer2.serialize(buildNestedObject(path, value)),
-        path,
-        JSONSerializer2.serialize(value)
-      );
-    case "$gt":
-    case "$gte":
-    case "$lt":
-    case "$lte":
-    case "$ne":
-      return sql(
-        `data #>> %L ${OperatorMap[operator]} %L`,
-        `{${path.split(".").join(",")}}`,
-        value
-      );
-    case "$in":
-      return sql(
-        "data #>> %L IN (%s)",
-        `{${path.split(".").join(",")}}`,
-        value.map((v) => sql("%L", v)).join(", ")
-      );
-    case "$nin":
-      return sql(
-        "data #>> %L NOT IN (%s)",
-        `{${path.split(".").join(",")}}`,
-        value.map((v) => sql("%L", v)).join(", ")
-      );
-    case "$elemMatch": {
-      const subQuery = objectEntries(value).map(
-        ([subKey, subValue]) => sql(`@."%s" == %s`, subKey, JSONSerializer2.serialize(subValue))
-      ).join(" && ");
-      return sql(`jsonb_path_exists(data, '$.%s[*] ? (%s)')`, path, subQuery);
-    }
-    case "$all":
-      return sql(
-        "data @> %L::jsonb",
-        JSONSerializer2.serialize(buildNestedObject(path, value))
-      );
-    case "$size":
-      return sql(
-        "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 sql(`${fieldName} = %L`, value);
-    case "$gt":
-    case "$gte":
-    case "$lt":
-    case "$lte":
-    case "$ne":
-      return sql(`${fieldName} ${OperatorMap[operator]} %L`, value);
-    case "$in":
-      return sql(
-        `${fieldName} IN (%s)`,
-        value.map((v) => sql("%L", v)).join(", ")
-      );
-    case "$nin":
-      return sql(
-        `${fieldName} NOT IN (%s)`,
-        value.map((v) => sql("%L", v)).join(", ")
-      );
-    default:
-      throw new Error(`Unsupported operator: ${operator}`);
-  }
-};
-var buildNestedObject = (path, value) => path.split(".").reverse().reduce((acc, key) => ({ [key]: acc }), value);
-
-// src/storage/postgresql/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/storage/postgresql/sqlBuilder/update/index.ts
-import { JSONSerializer as JSONSerializer3, sql as sql2 } from "@event-driven-io/dumbo";
-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;
-  }
-}, sql2("data"));
-var buildSetQuery = (set, currentUpdateQuery) => sql2("%s || %L::jsonb", currentUpdateQuery, JSONSerializer3.serialize(set));
-var buildUnsetQuery = (unset, currentUpdateQuery) => sql2(
-  "%s - %L",
-  currentUpdateQuery,
-  Object.keys(unset).map((k) => `{${k}}`).join(", ")
-);
-var buildIncQuery = (inc, currentUpdateQuery) => {
-  for (const [key, value] of Object.entries(inc)) {
-    currentUpdateQuery = sql2(
-      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 = sql2(
-      "jsonb_set(%s, '{%s}', (coalesce(data->'%s', '[]'::jsonb) || %L::jsonb), true)",
-      currentUpdateQuery,
-      key,
-      key,
-      JSONSerializer3.serialize([value])
-    );
-  }
-  return currentUpdateQuery;
-};
-
-// src/storage/postgresql/sqlBuilder/index.ts
-var createCollection = (collectionName) => sql3(
-  `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) => [
-  sqlMigration(`pongoCollection:${collectionName}:001:createtable`, [
-    createCollection(collectionName)
-  ])
-];
-var postgresSQLBuilder = (collectionName) => ({
-  migrations: () => pongoCollectionPostgreSQLMigrations(collectionName),
-  createCollection: () => createCollection(collectionName),
-  insertOne: (document) => {
-    return sql3(
-      "INSERT INTO %I (_id, data, _version) VALUES (%L, %L, %L) ON CONFLICT(_id) DO NOTHING;",
-      collectionName,
-      document._id,
-      JSONSerializer4.serialize(document),
-      document._version ?? 1n
-    );
-  },
-  insertMany: (documents) => {
-    const values = documents.map(
-      (doc) => sql3(
-        "(%L, %L, %L)",
-        doc._id,
-        JSONSerializer4.serialize(doc),
-        doc._version ?? 1n
-      )
-    ).join(", ");
-    return sql3(
-      `INSERT INTO %I (_id, data, _version) VALUES %s 
-      ON CONFLICT(_id) DO NOTHING
-      RETURNING _id;`,
-      collectionName,
-      values
-    );
-  },
-  updateOne: (filter, update, options) => {
-    const expectedVersion2 = expectedVersionValue(options?.expectedVersion);
-    const expectedVersionUpdate = expectedVersion2 != null ? "AND %I._version = %L" : "";
-    const expectedVersionParams = expectedVersion2 != null ? [collectionName, expectedVersion2] : [];
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    const updateQuery = isSQL(update) ? update : buildUpdateQuery(update);
-    return sql3(
-      `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(options?.expectedVersion);
-    const expectedVersionUpdate = expectedVersion2 != null ? "AND %I._version = %L" : "";
-    const expectedVersionParams = expectedVersion2 != null ? [collectionName, expectedVersion2] : [];
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    return sql3(
-      `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,
-      JSONSerializer4.serialize(document),
-      collectionName,
-      collectionName,
-      ...expectedVersionParams,
-      collectionName,
-      collectionName
-    );
-  },
-  updateMany: (filter, update) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    const updateQuery = isSQL(update) ? update : buildUpdateQuery(update);
-    return sql3(
-      `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(options?.expectedVersion);
-    const expectedVersionUpdate = expectedVersion2 != null ? "AND %I._version = %L" : "";
-    const expectedVersionParams = expectedVersion2 != null ? [collectionName, expectedVersion2] : [];
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    return sql3(
-      `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 = isSQL(filter) ? filter : constructFilterQuery(filter);
-    return sql3("DELETE FROM %I %s", collectionName, where(filterQuery));
-  },
-  findOne: (filter) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    return sql3(
-      "SELECT data FROM %I %s LIMIT 1;",
-      collectionName,
-      where(filterQuery)
-    );
-  },
-  find: (filter, options) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    const query = [];
-    query.push(sql3("SELECT data FROM %I", collectionName));
-    const whereStmt = where(filterQuery);
-    if (whereStmt.length > 0) {
-      query.push(sql3("%s", whereStmt));
-    }
-    if (options?.limit) {
-      query.push(sql3("LIMIT %s", options.limit));
-    }
-    if (options?.skip) {
-      query.push(sql3("OFFSET %s", options.skip));
-    }
-    return sql3(query.join(" ") + ";");
-  },
-  countDocuments: (filter) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter);
-    return sql3(
-      "SELECT COUNT(1) as count FROM %I %s;",
-      collectionName,
-      where(filterQuery)
-    );
-  },
-  rename: (newName) => sql3("ALTER TABLE %I RENAME TO %I;", collectionName, newName),
-  drop: (targetName = collectionName) => sql3("DROP TABLE IF EXISTS %I", targetName)
-});
-var where = (filter) => filter.length > 0 ? sql3("WHERE %s", filter) : rawSql("");
 
 export {
-  pongoCollectionPostgreSQLMigrations,
-  postgresSQLBuilder,
-  isPostgresClientOptions,
-  postgresDb,
-  pongoDbSchemaComponent,
   transactionExecutorOrDefault,
   pongoCollection,
-  pongoCollectionSchemaComponent,
+  PongoCollectionSchemaComponent,
   QueryOperators,
   OperatorMap,
   isOperator,
   hasOperators,
+  PongoDatabaseCache,
+  objectEntries,
   isNumber,
   isString,
   PongoError,
   ConcurrencyError,
-  getPongoDb,
-  pongoTransaction,
-  pongoSession,
-  objectEntries,
   ObjectId,
   DOCUMENT_EXISTS,
   DOCUMENT_DOES_NOT_EXIST,
@@ -1167,9 +859,14 @@ export {
   proxyClientWithSchema,
   toDbSchemaMetadata,
   toClientSchemaMetadata,
+  PongoDatabaseSchemaComponent,
+  PongoDatabase,
+  PongoDatabaseDriverRegistry,
+  pongoDatabaseDriverRegistry,
+  pongoTransaction,
+  pongoSession,
   pongoClient,
-  clientToDbOptions,
   deepEquals,
   isEquatable
 };
-//# sourceMappingURL=chunk-OO7GMTMP.js.map
+//# sourceMappingURL=chunk-RBJRJFQY.js.map