@event-driven-io/pongo 0.17.0-beta.4 → 0.17.0-beta.40

package/dist/pg.cjs

@@ -1,154 +1,133 @@
-"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; }
-
-
-
-
-
-
-
-
-
-
-var _chunk4BL6YWLWcjs = require('./chunk-4BL6YWLW.cjs');
-
-// src/storage/postgresql/core/sqlBuilder/index.ts
-
-
-
-
-
-var _dumbo = require('@event-driven-io/dumbo');
-
-// src/storage/postgresql/core/sqlBuilder/filter/index.ts
-
-
-// src/storage/postgresql/core/sqlBuilder/filter/queryOperators.ts
-
-var handleOperator = (path, operator, value) => {
-  if (path === "_id" || path === "_version") {
-    return handleMetadataOperator(path, operator, value);
-  }
-  switch (operator) {
-    case "$eq": {
-      const nestedPath = _dumbo.JSONSerializer.serialize(
-        buildNestedObject(path, value)
-      );
-      const serializedValue = _dumbo.JSONSerializer.serialize(value);
-      return _dumbo.SQL`(data @> ${nestedPath}::jsonb OR jsonb_path_exists(data, '$.${_dumbo.SQL.plain(path)}[*] ? (@ == ${_dumbo.SQL.plain(serializedValue)})'))`;
-    }
-    case "$gt":
-    case "$gte":
-    case "$lt":
-    case "$lte":
-    case "$ne": {
-      const jsonPath = _dumbo.SQL.plain(path.split(".").join(","));
-      return _dumbo.SQL`data ->> '${jsonPath}' ${_dumbo.SQL.plain(_chunk4BL6YWLWcjs.OperatorMap[operator])} ${value}`;
-    }
-    case "$in": {
-      const jsonPath = `{${path.split(".").join(",")}}`;
-      return _dumbo.SQL`data #>> ${jsonPath} IN ${value}`;
-    }
-    case "$nin": {
-      const jsonPath = `{${path.split(".").join(",")}}`;
-      return _dumbo.SQL`data #>> ${jsonPath} NOT IN ${value}`;
-    }
-    case "$elemMatch": {
-      const subQuery = _chunk4BL6YWLWcjs.objectEntries.call(void 0, value).map(
-        ([subKey, subValue]) => `@."${subKey}" == ${_dumbo.JSONSerializer.serialize(subValue)}`
-      ).join(" && ");
-      return _dumbo.SQL`jsonb_path_exists(data, '$.${_dumbo.SQL.plain(path)}[*] ? (${_dumbo.SQL.plain(subQuery)})')`;
-    }
-    case "$all": {
-      const nestedPath = _dumbo.JSONSerializer.serialize(
-        buildNestedObject(path, value)
-      );
-      return _dumbo.SQL`data @> ${nestedPath}::jsonb`;
-    }
-    case "$size": {
-      const jsonPath = `{${path.split(".").join(",")}}`;
-      return _dumbo.SQL`jsonb_array_length(data #> ${jsonPath}) = ${value}`;
-    }
-    default:
-      throw new Error(`Unsupported operator: ${operator}`);
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-C9SB3XMx.cjs');
+const require_cli = require('./cli.cjs');
+let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
+let _event_driven_io_dumbo_pg = require("@event-driven-io/dumbo/pg");
+
+//#region src/storage/postgresql/core/sqlBuilder/filter/queryOperators.ts
+const handleOperator = (path, operator, value, serializer) => {
+	if (path === "_id" || path === "_version") return handleMetadataOperator(path, operator, value);
+	switch (operator) {
+		case "$eq": {
+			const nestedPath = serializer.serialize(buildNestedObject(path, value));
+			const serializedValue = serializer.serialize(value);
+			return _event_driven_io_dumbo.SQL`(data @> ${nestedPath}::jsonb OR jsonb_path_exists(data, '$.${_event_driven_io_dumbo.SQL.plain(path)}[*] ? (@ == ${_event_driven_io_dumbo.SQL.plain(serializedValue)})'))`;
+		}
+		case "$gt":
+		case "$gte":
+		case "$lt":
+		case "$lte":
+		case "$ne": return _event_driven_io_dumbo.SQL`data ->> '${_event_driven_io_dumbo.SQL.plain(path.split(".").join(","))}' ${_event_driven_io_dumbo.SQL.plain(require_core.OperatorMap[operator])} ${value}`;
+		case "$in": return _event_driven_io_dumbo.SQL`data #>> ${`{${path.split(".").join(",")}}`} = ANY (${value})`;
+		case "$nin": return _event_driven_io_dumbo.SQL`data #>> ${`{${path.split(".").join(",")}}`} != ALL (${value})`;
+		case "$elemMatch": {
+			const subQuery = require_core.objectEntries(value).map(([subKey, subValue]) => `@."${subKey}" == ${serializer.serialize(subValue)}`).join(" && ");
+			return _event_driven_io_dumbo.SQL`jsonb_path_exists(data, '$.${_event_driven_io_dumbo.SQL.plain(path)}[*] ? (${_event_driven_io_dumbo.SQL.plain(subQuery)})')`;
+		}
+		case "$all": return _event_driven_io_dumbo.SQL`data @> ${serializer.serialize(buildNestedObject(path, value))}::jsonb`;
+		case "$size": return _event_driven_io_dumbo.SQL`jsonb_array_length(data #> ${`{${path.split(".").join(",")}}`}) = ${value}`;
+		default: throw new Error(`Unsupported operator: ${operator}`);
+	}
 };
-var handleMetadataOperator = (fieldName, operator, value) => {
-  switch (operator) {
-    case "$eq":
-      return _dumbo.SQL`${_dumbo.SQL.plain(fieldName)} = ${value}`;
-    case "$gt":
-    case "$gte":
-    case "$lt":
-    case "$lte":
-    case "$ne":
-      return _dumbo.SQL`${_dumbo.SQL.plain(fieldName)} ${_dumbo.SQL.plain(_chunk4BL6YWLWcjs.OperatorMap[operator])} ${value}`;
-    case "$in":
-      return _dumbo.SQL`${_dumbo.SQL.plain(fieldName)} IN ${value}`;
-    case "$nin":
-      return _dumbo.SQL`${_dumbo.SQL.plain(fieldName)} NOT IN ${value}`;
-    default:
-      throw new Error(`Unsupported operator: ${operator}`);
-  }
+const handleMetadataOperator = (fieldName, operator, value) => {
+	switch (operator) {
+		case "$eq": return _event_driven_io_dumbo.SQL`${_event_driven_io_dumbo.SQL.plain(fieldName)} = ${value}`;
+		case "$gt":
+		case "$gte":
+		case "$lt":
+		case "$lte":
+		case "$ne": return _event_driven_io_dumbo.SQL`${_event_driven_io_dumbo.SQL.plain(fieldName)} ${_event_driven_io_dumbo.SQL.plain(require_core.OperatorMap[operator])} ${value}`;
+		case "$in": return _event_driven_io_dumbo.SQL`${_event_driven_io_dumbo.SQL.plain(fieldName)} = ANY (${value})`;
+		case "$nin": return _event_driven_io_dumbo.SQL`${_event_driven_io_dumbo.SQL.plain(fieldName)} != ALL (${value})`;
+		default: throw new Error(`Unsupported operator: ${operator}`);
+	}
 };
-var buildNestedObject = (path, value) => path.split(".").reverse().reduce((acc, key) => ({ [key]: acc }), value);
-
-// src/storage/postgresql/core/sqlBuilder/filter/index.ts
-var AND = "AND";
-var constructFilterQuery = (filter) => _dumbo.SQL.merge(
-  Object.entries(filter).map(
-    ([key, value]) => isRecord(value) ? constructComplexFilterQuery(key, value) : handleOperator(key, "$eq", value)
-  ),
-  ` ${AND} `
-);
-var constructComplexFilterQuery = (key, value) => {
-  const isEquality = !_chunk4BL6YWLWcjs.hasOperators.call(void 0, value);
-  return _dumbo.SQL.merge(
-    _chunk4BL6YWLWcjs.objectEntries.call(void 0, value).map(
-      ([nestedKey, val]) => isEquality ? handleOperator(`${key}.${nestedKey}`, _chunk4BL6YWLWcjs.QueryOperators.$eq, val) : handleOperator(key, nestedKey, val)
-    ),
-    ` ${AND} `
-  );
+const buildNestedObject = (path, value) => path.split(".").reverse().reduce((acc, key) => ({ [key]: acc }), value);
+
+//#endregion
+//#region src/storage/postgresql/core/sqlBuilder/filter/index.ts
+const AND = "AND";
+const OR = "OR";
+const unsupportedRootOperators = [
+	"$text",
+	"$where",
+	"$comment"
+];
+const constructFilterQuery = (filter, serializer) => {
+	ensureSupportedRootOperators(filter);
+	const parts = [];
+	const fieldFilterQuery = constructFieldFilterQuery(filter, serializer);
+	if (!_event_driven_io_dumbo.SQL.check.isEmpty(fieldFilterQuery)) parts.push(fieldFilterQuery);
+	const orFilterQuery = constructLogicalFilterQuery(filter.$or, OR, serializer);
+	if (!_event_driven_io_dumbo.SQL.check.isEmpty(orFilterQuery)) parts.push(orFilterQuery);
+	const andFilterQuery = constructLogicalFilterQuery(filter.$and, AND, serializer);
+	if (!_event_driven_io_dumbo.SQL.check.isEmpty(andFilterQuery)) parts.push(andFilterQuery);
+	const norFilterQuery = constructNorFilterQuery(filter.$nor, serializer);
+	if (!_event_driven_io_dumbo.SQL.check.isEmpty(norFilterQuery)) parts.push(norFilterQuery);
+	return _event_driven_io_dumbo.SQL.merge(parts, ` ${AND} `);
 };
-var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-
-// src/storage/postgresql/core/sqlBuilder/update/index.ts
-
-var buildUpdateQuery = (update) => _chunk4BL6YWLWcjs.objectEntries.call(void 0, 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`data`
-);
-var buildSetQuery = (set, currentUpdateQuery) => _dumbo.SQL`${currentUpdateQuery} || ${_dumbo.JSONSerializer.serialize(set)}::jsonb`;
-var buildUnsetQuery = (unset, currentUpdateQuery) => _dumbo.SQL`${currentUpdateQuery} - ${Object.keys(unset).map((k) => `{${k}}`).join(", ")}`;
-var buildIncQuery = (inc, currentUpdateQuery) => {
-  for (const [key, value] of Object.entries(inc)) {
-    currentUpdateQuery = typeof value === "bigint" ? _dumbo.SQL`jsonb_set(${currentUpdateQuery}, '{${_dumbo.SQL.plain(key)}}', to_jsonb((COALESCE((data->>'${_dumbo.SQL.plain(key)}')::BIGINT, 0) + ${value})::TEXT), true)` : _dumbo.SQL`jsonb_set(${currentUpdateQuery}, '{${_dumbo.SQL.plain(key)}}', to_jsonb(COALESCE((data->>'${_dumbo.SQL.plain(key)}')::NUMERIC, 0) + ${value}), true)`;
-  }
-  return currentUpdateQuery;
+const constructFieldFilterQuery = (filter, serializer) => _event_driven_io_dumbo.SQL.merge(require_core.objectEntries(filter).flatMap(([key, value]) => isLogicalRootOperator(key) ? [] : [isRecord(value) ? constructComplexFilterQuery(key, value, serializer) : handleOperator(key, require_core.QueryOperators.$eq, value, serializer)]), ` ${AND} `);
+const constructLogicalFilterQuery = (filters, joinOperator, serializer) => {
+	if (!filters?.length) return _event_driven_io_dumbo.SQL.EMPTY;
+	const subFilterQueries = filters.reduce((queries, filter) => {
+		const query = constructFilterQuery(filter, serializer);
+		if (!_event_driven_io_dumbo.SQL.check.isEmpty(query)) queries.push(query);
+		return queries;
+	}, []);
+	if (subFilterQueries.length === 0) return _event_driven_io_dumbo.SQL.EMPTY;
+	if (subFilterQueries.length === 1) return wrapFilterQuery(subFilterQueries[0]);
+	return _event_driven_io_dumbo.SQL`(${_event_driven_io_dumbo.SQL.merge(subFilterQueries.map(wrapFilterQuery), ` ${joinOperator} `)})`;
 };
-var buildPushQuery = (push, currentUpdateQuery) => {
-  for (const [key, value] of Object.entries(push)) {
-    const serializedValue = _dumbo.JSONSerializer.serialize([value]);
-    currentUpdateQuery = _dumbo.SQL`jsonb_set(${currentUpdateQuery}, '{${_dumbo.SQL.plain(key)}}', (coalesce(data->'${_dumbo.SQL.plain(key)}', '[]'::jsonb) || ${serializedValue}::jsonb), true)`;
-  }
-  return currentUpdateQuery;
+const constructNorFilterQuery = (filters, serializer) => {
+	if (!filters?.length) return _event_driven_io_dumbo.SQL.EMPTY;
+	const logicalFilterQuery = constructLogicalFilterQuery(filters, OR, serializer);
+	return _event_driven_io_dumbo.SQL.check.isEmpty(logicalFilterQuery) ? _event_driven_io_dumbo.SQL.EMPTY : _event_driven_io_dumbo.SQL`NOT ${logicalFilterQuery}`;
+};
+const constructComplexFilterQuery = (key, value, serializer) => {
+	const isEquality = !require_core.hasOperators(value);
+	return _event_driven_io_dumbo.SQL.merge(require_core.objectEntries(value).map(([nestedKey, val]) => isEquality ? handleOperator(`${key}.${nestedKey}`, require_core.QueryOperators.$eq, val, serializer) : handleOperator(key, nestedKey, val, serializer)), ` ${AND} `);
+};
+const wrapFilterQuery = (filterQuery) => _event_driven_io_dumbo.SQL`(${filterQuery})`;
+const ensureSupportedRootOperators = (filter) => {
+	for (const operator of unsupportedRootOperators) if (operator in filter) throw new Error(`Unsupported root operator: ${operator}`);
+};
+const isLogicalRootOperator = (key) => key === "$and" || key === "$nor" || key === "$or";
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+//#endregion
+//#region src/storage/postgresql/core/sqlBuilder/update/index.ts
+const buildUpdateQuery = (update, serializer) => require_core.objectEntries(update).reduce((currentUpdateQuery, [op, value]) => {
+	switch (op) {
+		case "$set": return buildSetQuery(value, currentUpdateQuery, serializer);
+		case "$unset": return buildUnsetQuery(value, currentUpdateQuery);
+		case "$inc": return buildIncQuery(value, currentUpdateQuery);
+		case "$push": return buildPushQuery(value, currentUpdateQuery, serializer);
+		default: return currentUpdateQuery;
+	}
+}, _event_driven_io_dumbo.SQL`data`);
+const buildSetQuery = (set, currentUpdateQuery, serializer) => _event_driven_io_dumbo.SQL`${currentUpdateQuery} || ${serializer.serialize(set)}::jsonb`;
+const buildUnsetQuery = (unset, currentUpdateQuery) => _event_driven_io_dumbo.SQL`${currentUpdateQuery} - ${Object.keys(unset).map((k) => `{${k}}`).join(", ")}`;
+const buildIncQuery = (inc, currentUpdateQuery) => {
+	for (const [key, value] of Object.entries(inc)) currentUpdateQuery = typeof value === "bigint" ? _event_driven_io_dumbo.SQL`jsonb_set(${currentUpdateQuery}, '{${_event_driven_io_dumbo.SQL.plain(key)}}', to_jsonb((COALESCE((data->>'${_event_driven_io_dumbo.SQL.plain(key)}')::BIGINT, 0) + ${value})::TEXT), true)` : _event_driven_io_dumbo.SQL`jsonb_set(${currentUpdateQuery}, '{${_event_driven_io_dumbo.SQL.plain(key)}}', to_jsonb(COALESCE((data->>'${_event_driven_io_dumbo.SQL.plain(key)}')::NUMERIC, 0) + ${value}), true)`;
+	return currentUpdateQuery;
+};
+const buildPushQuery = (push, currentUpdateQuery, serializer) => {
+	for (const [key, value] of Object.entries(push)) {
+		const serializedValue = serializer.serialize([value]);
+		currentUpdateQuery = _event_driven_io_dumbo.SQL`jsonb_set(${currentUpdateQuery}, '{${_event_driven_io_dumbo.SQL.plain(key)}}', (coalesce(data->'${_event_driven_io_dumbo.SQL.plain(key)}', '[]'::jsonb) || ${serializedValue}::jsonb), true)`;
+	}
+	return currentUpdateQuery;
 };
 
-// src/storage/postgresql/core/sqlBuilder/index.ts
-var createCollection = (collectionName) => _dumbo.SQL`
-    CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.identifier(collectionName)} (
+//#endregion
+//#region src/storage/postgresql/core/sqlBuilder/index.ts
+const versionCheckClause = (collectionName, expectedVersion) => {
+	const col = _event_driven_io_dumbo.SQL.identifier(collectionName);
+	const predicate = require_core.expectedVersionPredicate(expectedVersion);
+	return predicate.operator === "none" ? _event_driven_io_dumbo.SQL.EMPTY : _event_driven_io_dumbo.SQL`AND ${col}._version = ${predicate.value}`;
+};
+const createCollection = (collectionName) => _event_driven_io_dumbo.SQL`
+    CREATE TABLE IF NOT EXISTS ${_event_driven_io_dumbo.SQL.identifier(collectionName)} (
       _id           TEXT           PRIMARY KEY, 
       data          JSONB          NOT NULL, 
       metadata      JSONB          NOT NULL     DEFAULT '{}',
@@ -158,52 +137,54 @@ var createCollection = (collectionName) => _dumbo.SQL`
       _created      TIMESTAMPTZ    NOT NULL     DEFAULT now(),
       _updated      TIMESTAMPTZ    NOT NULL     DEFAULT now()
   )`;
-var pongoCollectionPostgreSQLMigrations = (collectionName) => [
-  _dumbo.sqlMigration.call(void 0, `pongoCollection:${collectionName}:001:createtable`, [
-    createCollection(collectionName)
-  ])
-];
-var postgresSQLBuilder = (collectionName) => ({
-  createCollection: () => createCollection(collectionName),
-  insertOne: (document) => {
-    const serialized = _dumbo.JSONSerializer.serialize(document);
-    const id = document._id;
-    const version = _nullishCoalesce(document._version, () => ( 1n));
-    return _dumbo.SQL`
-      INSERT INTO ${_dumbo.SQL.identifier(collectionName)} (_id, data, _version) 
+const pongoCollectionPostgreSQLMigrations = (collectionName) => [(0, _event_driven_io_dumbo.sqlMigration)(`pongoCollection:${collectionName}:001:createtable`, [createCollection(collectionName)])];
+const postgresSQLBuilder = (collectionName, serializer) => ({
+	createCollection: () => createCollection(collectionName),
+	insertOne: (document) => {
+		const serialized = serializer.serialize(document);
+		const id = document._id;
+		const version = document._version ?? 1n;
+		return _event_driven_io_dumbo.SQL`
+      INSERT INTO ${_event_driven_io_dumbo.SQL.identifier(collectionName)} (_id, data, _version) 
       VALUES (${id}, ${serialized}, ${version}) ON CONFLICT(_id) DO NOTHING;`;
-  },
-  insertMany: (documents) => {
-    const values = _dumbo.SQL.merge(
-      documents.map(
-        (doc) => _dumbo.SQL`(${doc._id}, ${_dumbo.JSONSerializer.serialize(doc)}, ${_nullishCoalesce(doc._version, () => ( 1n))})`
-      ),
-      ","
-    );
-    return _dumbo.SQL`
-      INSERT INTO ${_dumbo.SQL.identifier(collectionName)} (_id, data, _version) VALUES ${values}
+	},
+	insertMany: (documents) => {
+		const values = _event_driven_io_dumbo.SQL.merge(documents.map((doc) => _event_driven_io_dumbo.SQL`(${doc._id}, ${serializer.serialize(doc)}, ${doc._version ?? 1n})`), ",");
+		return _event_driven_io_dumbo.SQL`
+      INSERT INTO ${_event_driven_io_dumbo.SQL.identifier(collectionName)} (_id, data, _version) VALUES ${values}
       ON CONFLICT(_id) DO NOTHING
       RETURNING _id;`;
-  },
-  updateOne: (filter, update, options) => {
-    const expectedVersion = _chunk4BL6YWLWcjs.expectedVersionValue.call(void 0, _optionalChain([options, 'optionalAccess', _ => _.expectedVersion]));
-    const expectedVersionUpdate = expectedVersion != null ? _dumbo.SQL`AND ${_dumbo.SQL.identifier(collectionName)}._version = ${expectedVersion}` : _dumbo.SQL``;
-    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`
+	},
+	insertOrReplace: (documents) => {
+		const col = _event_driven_io_dumbo.SQL.identifier(collectionName);
+		return _event_driven_io_dumbo.SQL`
+      INSERT INTO ${col} (_id, data, _version)
+      VALUES ${_event_driven_io_dumbo.SQL.merge(documents.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb || jsonb_build_object('_id', ${d._id}::text) || jsonb_build_object('_version', '1'::text), 1::bigint)`), ",")}
+      ON CONFLICT(_id) DO UPDATE SET
+        data = EXCLUDED.data
+          || jsonb_build_object('_id', ${col}._id)
+          || jsonb_build_object('_version', (${col}._version + 1)::text),
+        _version = ${col}._version + 1
+      RETURNING _id, _version AS version;`;
+	},
+	updateOne: (filter, update, options) => {
+		const expectedVersionUpdate = versionCheckClause(collectionName, options?.expectedVersion);
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		const updateQuery = (0, _event_driven_io_dumbo.isSQL)(update) ? update : buildUpdateQuery(update, serializer);
+		return _event_driven_io_dumbo.SQL`
       WITH existing AS (
         SELECT _id, _version as current_version
-        FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}
+        FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}
         LIMIT 1
       ),
       updated AS (
-        UPDATE ${_dumbo.SQL.identifier(collectionName)} 
+        UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} 
         SET 
-          data = ${updateQuery} || jsonb_build_object('_id', ${_dumbo.SQL.identifier(collectionName)}._id) || jsonb_build_object('_version', (_version + 1)::text),
+          data = ${updateQuery} || jsonb_build_object('_id', ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id) || jsonb_build_object('_version', (_version + 1)::text),
           _version = _version + 1
         FROM existing 
-        WHERE ${_dumbo.SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
-        RETURNING ${_dumbo.SQL.identifier(collectionName)}._id, ${_dumbo.SQL.identifier(collectionName)}._version
+        WHERE ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
+        RETURNING ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id, ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._version
       )
       SELECT 
         existing._id,
@@ -213,25 +194,24 @@ var postgresSQLBuilder = (collectionName) => ({
       FROM existing
       LEFT JOIN updated 
       ON existing._id = updated._id;`;
-  },
-  replaceOne: (filter, document, options) => {
-    const expectedVersion = _chunk4BL6YWLWcjs.expectedVersionValue.call(void 0, _optionalChain([options, 'optionalAccess', _2 => _2.expectedVersion]));
-    const expectedVersionUpdate = expectedVersion != null ? _dumbo.SQL`AND ${_dumbo.SQL.identifier(collectionName)}._version = ${expectedVersion}` : _dumbo.SQL``;
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
-    return _dumbo.SQL`
+	},
+	replaceOne: (filter, document, options) => {
+		const expectedVersionUpdate = versionCheckClause(collectionName, options?.expectedVersion);
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		return _event_driven_io_dumbo.SQL`
       WITH existing AS (
         SELECT _id, _version as current_version
-        FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}
+        FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}
         LIMIT 1
       ),
       updated AS (
-        UPDATE ${_dumbo.SQL.identifier(collectionName)}        
+        UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)}        
         SET 
-          data = ${_dumbo.JSONSerializer.serialize(document)} || jsonb_build_object('_id', ${_dumbo.SQL.identifier(collectionName)}._id) || jsonb_build_object('_version', (_version + 1)::text),
+          data = ${serializer.serialize(document)} || jsonb_build_object('_id', ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id) || jsonb_build_object('_version', (_version + 1)::text),
           _version = _version + 1
         FROM existing 
-        WHERE ${_dumbo.SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
-        RETURNING ${_dumbo.SQL.identifier(collectionName)}._id, ${_dumbo.SQL.identifier(collectionName)}._version
+        WHERE ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
+        RETURNING ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id, ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._version
       )
       SELECT 
         existing._id,
@@ -241,32 +221,31 @@ var postgresSQLBuilder = (collectionName) => ({
       FROM existing
       LEFT JOIN updated 
       ON existing._id = updated._id;`;
-  },
-  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`
-      UPDATE ${_dumbo.SQL.identifier(collectionName)} 
+	},
+	updateMany: (filter, update) => {
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		const updateQuery = (0, _event_driven_io_dumbo.isSQL)(update) ? update : buildUpdateQuery(update, serializer);
+		return _event_driven_io_dumbo.SQL`
+      UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} 
       SET 
         data = ${updateQuery} || jsonb_build_object('_version', (_version + 1)::text),
         _version = _version + 1
       ${where(filterQuery)};`;
-  },
-  deleteOne: (filter, options) => {
-    const expectedVersion = _chunk4BL6YWLWcjs.expectedVersionValue.call(void 0, _optionalChain([options, 'optionalAccess', _3 => _3.expectedVersion]));
-    const expectedVersionUpdate = expectedVersion != null ? _dumbo.SQL`AND ${_dumbo.SQL.identifier(collectionName)}._version = ${expectedVersion}` : _dumbo.SQL``;
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
-    return _dumbo.SQL`
+	},
+	deleteOne: (filter, options) => {
+		const expectedVersionUpdate = versionCheckClause(collectionName, options?.expectedVersion);
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		return _event_driven_io_dumbo.SQL`
       WITH existing AS (
         SELECT _id
-        FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}
+        FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}
         LIMIT 1
       ),
       deleted AS (
-        DELETE FROM ${_dumbo.SQL.identifier(collectionName)}
+        DELETE FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)}
         USING existing
-        WHERE ${_dumbo.SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
-        RETURNING ${_dumbo.SQL.identifier(collectionName)}._id
+        WHERE ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
+        RETURNING ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._id
       )
       SELECT 
         existing._id,
@@ -275,88 +254,140 @@ var postgresSQLBuilder = (collectionName) => ({
       FROM existing
       LEFT JOIN deleted 
       ON existing._id = deleted._id;`;
-  },
-  deleteMany: (filter) => {
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
-    return _dumbo.SQL`DELETE FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}`;
-  },
-  findOne: (filter) => {
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
-    return _dumbo.SQL`SELECT data FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)} LIMIT 1;`;
-  },
-  find: (filter, options) => {
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter);
-    const query = [];
-    query.push(_dumbo.SQL`SELECT data FROM ${_dumbo.SQL.identifier(collectionName)}`);
-    query.push(where(filterQuery));
-    if (_optionalChain([options, 'optionalAccess', _4 => _4.limit])) {
-      query.push(_dumbo.SQL`LIMIT ${options.limit}`);
-    }
-    if (_optionalChain([options, 'optionalAccess', _5 => _5.skip])) {
-      query.push(_dumbo.SQL`OFFSET ${options.skip}`);
-    }
-    return _dumbo.SQL.merge([...query, _dumbo.SQL`;`]);
-  },
-  countDocuments: (filter) => {
-    const filterQuery = _dumbo.SQL.check.isSQL(filter) ? filter : constructFilterQuery(filter);
-    return _dumbo.SQL`SELECT COUNT(1) as count FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)};`;
-  },
-  rename: (newName) => _dumbo.SQL`ALTER TABLE ${_dumbo.SQL.identifier(collectionName)} RENAME TO ${_dumbo.SQL.identifier(newName)};`,
-  drop: (targetName = collectionName) => _dumbo.SQL`DROP TABLE IF EXISTS ${_dumbo.SQL.identifier(targetName)}`
+	},
+	deleteMany: (filter) => {
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		return _event_driven_io_dumbo.SQL`DELETE FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}`;
+	},
+	replaceMany: (documents) => {
+		if (documents.some((d) => "_version" in d && d._version !== void 0)) return _event_driven_io_dumbo.SQL`
+        WITH replacements(_id, data, expected_version) AS (
+          VALUES ${_event_driven_io_dumbo.SQL.merge(documents.map((d) => {
+			const expectedVersion = d._version;
+			return expectedVersion !== void 0 ? _event_driven_io_dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb, ${expectedVersion}::bigint)` : _event_driven_io_dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb, NULL::bigint)`;
+		}), ",")}
+        )
+        UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
+        SET
+          data = r.data
+            || jsonb_build_object('_id', t._id)
+            || jsonb_build_object('_version', (t._version + 1)::text),
+          _version = t._version + 1
+        FROM replacements r
+        WHERE t._id = r._id AND (r.expected_version IS NULL OR t._version = r.expected_version)
+        RETURNING t._id, t._version AS version;`;
+		return _event_driven_io_dumbo.SQL`
+      WITH replacements(_id, data) AS (
+        VALUES ${_event_driven_io_dumbo.SQL.merge(documents.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb)`), ",")}
+      )
+      UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
+      SET
+        data = r.data
+          || jsonb_build_object('_id', t._id)
+          || jsonb_build_object('_version', (t._version + 1)::text),
+        _version = t._version + 1
+      FROM replacements r
+      WHERE t._id = r._id
+      RETURNING t._id, t._version AS version;`;
+	},
+	deleteManyByIds: (ids) => {
+		if (ids.some((d) => d._version !== void 0)) return _event_driven_io_dumbo.SQL`
+        WITH targets(_id, expected_version) AS (
+          VALUES ${_event_driven_io_dumbo.SQL.merge(ids.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text, ${d._version ?? 0n}::bigint)`), ",")}
+        ),
+        deleted AS (
+          DELETE FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
+          USING targets r
+          WHERE t._id = r._id AND t._version = r.expected_version
+          RETURNING t._id
+        )
+        SELECT r._id,
+          CASE WHEN d._id IS NOT NULL THEN 1 ELSE 0 END as deleted
+        FROM targets r
+        LEFT JOIN deleted d ON r._id = d._id;`;
+		return _event_driven_io_dumbo.SQL`
+      WITH targets(_id) AS (
+        VALUES ${_event_driven_io_dumbo.SQL.merge(ids.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text)`), ",")}
+      ),
+      deleted AS (
+        DELETE FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
+        USING targets r
+        WHERE t._id = r._id
+        RETURNING t._id
+      )
+      SELECT r._id,
+        CASE WHEN d._id IS NOT NULL THEN 1 ELSE 0 END as deleted
+      FROM targets r
+      LEFT JOIN deleted d ON r._id = d._id;`;
+	},
+	findOne: (filter) => {
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		return _event_driven_io_dumbo.SQL`SELECT data, _id, _version FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)} LIMIT 1;`;
+	},
+	find: (filter, options) => {
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		const query = [];
+		query.push(_event_driven_io_dumbo.SQL`SELECT data, _id, _version FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)}`);
+		query.push(where(filterQuery));
+		if (options?.sort && Object.keys(options.sort).length > 0) {
+			const clauses = Object.entries(options.sort).map(([field, dir]) => {
+				const isMetadata = field === "_id" || field === "_version";
+				const isNested = !isMetadata && field.includes(".");
+				const accessor = isMetadata ? _event_driven_io_dumbo.SQL`${_event_driven_io_dumbo.SQL.plain(field)}` : isNested ? _event_driven_io_dumbo.SQL`data #> '${_event_driven_io_dumbo.SQL.plain(`{${field.split(".").join(",")}}`)}'` : _event_driven_io_dumbo.SQL`data -> '${_event_driven_io_dumbo.SQL.plain(field)}'`;
+				return dir === 1 ? _event_driven_io_dumbo.SQL`${accessor} ASC NULLS FIRST` : _event_driven_io_dumbo.SQL`${accessor} DESC NULLS LAST`;
+			});
+			query.push(_event_driven_io_dumbo.SQL`ORDER BY ${_event_driven_io_dumbo.SQL.merge(clauses, ",")}`);
+		}
+		if (options?.limit) query.push(_event_driven_io_dumbo.SQL`LIMIT ${options.limit}`);
+		if (options?.skip) query.push(_event_driven_io_dumbo.SQL`OFFSET ${options.skip}`);
+		return _event_driven_io_dumbo.SQL.merge([...query, _event_driven_io_dumbo.SQL`;`]);
+	},
+	countDocuments: (filter) => {
+		const filterQuery = _event_driven_io_dumbo.SQL.check.isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
+		return _event_driven_io_dumbo.SQL`SELECT COUNT(1) as count FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)};`;
+	},
+	rename: (newName) => _event_driven_io_dumbo.SQL`ALTER TABLE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} RENAME TO ${_event_driven_io_dumbo.SQL.identifier(newName)};`,
+	drop: (targetName = collectionName) => _event_driven_io_dumbo.SQL`DROP TABLE IF EXISTS ${_event_driven_io_dumbo.SQL.identifier(targetName)}`
 });
-var where = (filterQuery) => _dumbo.SQL.check.isEmpty(filterQuery) ? _dumbo.SQL.EMPTY : _dumbo.SQL.merge([_dumbo.SQL`WHERE `, filterQuery]);
-
-// src/storage/postgresql/pg/index.ts
-
-
-
-
-
-var _pg = require('@event-driven-io/dumbo/pg');
-require('pg');
-var pgDatabaseDriver = {
-  driverType: _pg.NodePostgresDriverType,
-  databaseFactory: (options) => {
-    const databaseName = _nullishCoalesce(options.databaseName, () => ( _pg.getDatabaseNameOrDefault.call(void 0, options.connectionString)));
-    return _chunk4BL6YWLWcjs.PongoDatabase.call(void 0, {
-      ...options,
-      pool: _dumbo.dumbo.call(void 0, {
-        connectionString: options.connectionString,
-        driver: _pg.pgDatabaseDriver,
-        ...options.connectionOptions
-      }),
-      schemaComponent: _chunk4BL6YWLWcjs.PongoDatabaseSchemaComponent.call(void 0, {
-        driverType: _pg.NodePostgresDriverType,
-        collectionFactory: (schema) => _chunk4BL6YWLWcjs.PongoCollectionSchemaComponent.call(void 0, {
-          driverType: _pg.NodePostgresDriverType,
-          definition: schema,
-          migrationsOrSchemaComponents: {
-            migrations: pongoCollectionPostgreSQLMigrations(schema.name)
-          },
-          sqlBuilder: postgresSQLBuilder(schema.name)
-        }),
-        definition: _nullishCoalesce(_optionalChain([options, 'access', _6 => _6.schema, 'optionalAccess', _7 => _7.definition]), () => ( _chunk4BL6YWLWcjs.pongoSchema.db(databaseName, {})))
-      }),
-      databaseName
-    });
-  },
-  getDatabaseNameOrDefault: (options) => {
-    return _nullishCoalesce(options.databaseName, () => ( _pg.getDatabaseNameOrDefault.call(void 0, options.connectionString)));
-  },
-  defaultConnectionString: "postgresql://localhost:5432/postgres"
+const where = (filterQuery) => _event_driven_io_dumbo.SQL.check.isEmpty(filterQuery) ? _event_driven_io_dumbo.SQL.EMPTY : _event_driven_io_dumbo.SQL.merge([_event_driven_io_dumbo.SQL`WHERE `, filterQuery]);
+
+//#endregion
+//#region src/storage/postgresql/pg/index.ts
+const pgPongoDriver = {
+	driverType: _event_driven_io_dumbo_pg.PgDriverType,
+	databaseFactory: (options) => {
+		const databaseName = options.databaseName ?? _event_driven_io_dumbo_pg.postgreSQLMetadata.parseDatabaseName(options.connectionString) ?? _event_driven_io_dumbo_pg.postgreSQLMetadata.defaultDatabaseName;
+		return require_core.PongoDatabase({
+			...options,
+			pool: (0, _event_driven_io_dumbo.dumbo)({
+				connectionString: options.connectionString,
+				driver: _event_driven_io_dumbo_pg.pgDumboDriver,
+				...options.connectionOptions,
+				serialization: { serializer: options.serializer }
+			}),
+			schemaComponent: require_core.PongoDatabaseSchemaComponent({
+				driverType: _event_driven_io_dumbo_pg.PgDriverType,
+				collectionFactory: (schema) => require_core.PongoCollectionSchemaComponent({
+					driverType: _event_driven_io_dumbo_pg.PgDriverType,
+					definition: schema,
+					migrationsOrSchemaComponents: { migrations: pongoCollectionPostgreSQLMigrations(schema.name) },
+					sqlBuilder: postgresSQLBuilder(schema.name, options.serialization?.serializer ?? _event_driven_io_dumbo.JSONSerializer)
+				}),
+				definition: options.schema?.definition ?? require_core.pongoSchema.db(databaseName, {})
+			}),
+			databaseName
+		});
+	}
 };
-var usePgDatabaseDriver = () => {
-  _chunk4BL6YWLWcjs.pongoDatabaseDriverRegistry.register(
-    _pg.NodePostgresDriverType,
-    pgDatabaseDriver
-  );
+const usePgPongoDriver = () => {
+	require_core.pongoDriverRegistry.register(_event_driven_io_dumbo_pg.PgDriverType, pgPongoDriver);
 };
-usePgDatabaseDriver();
-
-
-
-
-
-
-exports.databaseDriver = pgDatabaseDriver; exports.pgDriver = pgDatabaseDriver; exports.pongoCollectionPostgreSQLMigrations = pongoCollectionPostgreSQLMigrations; exports.postgresSQLBuilder = postgresSQLBuilder; exports.usePgDatabaseDriver = usePgDatabaseDriver;
+usePgPongoDriver();
+
+//#endregion
+exports.pgDriver = pgPongoDriver;
+exports.pongoDriver = pgPongoDriver;
+exports.pongoCollectionPostgreSQLMigrations = pongoCollectionPostgreSQLMigrations;
+exports.postgresSQLBuilder = postgresSQLBuilder;
+exports.usePgPongoDriver = usePgPongoDriver;
 //# sourceMappingURL=pg.cjs.map