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

package/dist/pg.cjs

@@ -1,150 +1,88 @@
-"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; }
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-CwxxuUAn.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");
 
-
-
-
-
-
-
-
-
-
-var _chunkEQ3T4XHTcjs = require('./chunk-EQ3T4XHT.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, 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 _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(_chunkEQ3T4XHTcjs.OperatorMap[operator])} ${value}`;
-    }
-    case "$in": {
-      const jsonPath = `{${path.split(".").join(",")}}`;
-      return _dumbo.SQL`data #>> ${jsonPath} = ANY (${value})`;
-    }
-    case "$nin": {
-      const jsonPath = `{${path.split(".").join(",")}}`;
-      return _dumbo.SQL`data #>> ${jsonPath} != ALL (${value})`;
-    }
-    case "$elemMatch": {
-      const subQuery = _chunkEQ3T4XHTcjs.objectEntries.call(void 0, value).map(
-        ([subKey, subValue]) => `@."${subKey}" == ${serializer.serialize(subValue)}`
-      ).join(" && ");
-      return _dumbo.SQL`jsonb_path_exists(data, '$.${_dumbo.SQL.plain(path)}[*] ? (${_dumbo.SQL.plain(subQuery)})')`;
-    }
-    case "$all": {
-      const nestedPath = serializer.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}`);
-  }
+//#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(_chunkEQ3T4XHTcjs.OperatorMap[operator])} ${value}`;
-    case "$in":
-      return _dumbo.SQL`${_dumbo.SQL.plain(fieldName)} = ANY (${value})`;
-    case "$nin":
-      return _dumbo.SQL`${_dumbo.SQL.plain(fieldName)} != ALL (${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);
+const 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, serializer) => _dumbo.SQL.merge(
-  Object.entries(filter).map(
-    ([key, value]) => isRecord(value) ? constructComplexFilterQuery(key, value, serializer) : handleOperator(key, "$eq", value, serializer)
-  ),
-  ` ${AND} `
-);
-var constructComplexFilterQuery = (key, value, serializer) => {
-  const isEquality = !_chunkEQ3T4XHTcjs.hasOperators.call(void 0, value);
-  return _dumbo.SQL.merge(
-    _chunkEQ3T4XHTcjs.objectEntries.call(void 0, value).map(
-      ([nestedKey, val]) => isEquality ? handleOperator(
-        `${key}.${nestedKey}`,
-        _chunkEQ3T4XHTcjs.QueryOperators.$eq,
-        val,
-        serializer
-      ) : handleOperator(key, nestedKey, val, serializer)
-    ),
-    ` ${AND} `
-  );
+//#endregion
+//#region src/storage/postgresql/core/sqlBuilder/filter/index.ts
+const AND = "AND";
+const constructFilterQuery = (filter, serializer) => _event_driven_io_dumbo.SQL.merge(Object.entries(filter).map(([key, value]) => isRecord(value) ? constructComplexFilterQuery(key, value, serializer) : handleOperator(key, "$eq", value, serializer)), ` ${AND} `);
+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} `);
 };
-var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 
-// src/storage/postgresql/core/sqlBuilder/update/index.ts
-
-var buildUpdateQuery = (update, serializer) => _chunkEQ3T4XHTcjs.objectEntries.call(void 0, 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;
-    }
-  },
-  _dumbo.SQL`data`
-);
-var buildSetQuery = (set, currentUpdateQuery, serializer) => _dumbo.SQL`${currentUpdateQuery} || ${serializer.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;
+//#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;
 };
-var buildPushQuery = (push, currentUpdateQuery, serializer) => {
-  for (const [key, value] of Object.entries(push)) {
-    const serializedValue = serializer.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 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 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 '{}',
@@ -154,52 +92,43 @@ 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, serializer) => ({
-  createCollection: () => createCollection(collectionName),
-  insertOne: (document) => {
-    const serialized = serializer.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}, ${serializer.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 = _chunkEQ3T4XHTcjs.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, serializer);
-    const updateQuery = _dumbo.isSQL.call(void 0, update) ? update : buildUpdateQuery(update, serializer);
-    return _dumbo.SQL`
+	},
+	updateOne: (filter, update, options) => {
+		const expectedVersion = require_core.expectedVersionValue(options?.expectedVersion);
+		const expectedVersionUpdate = expectedVersion != null ? _event_driven_io_dumbo.SQL`AND ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._version = ${expectedVersion}` : _event_driven_io_dumbo.SQL``;
+		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,
@@ -209,25 +138,25 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       FROM existing
       LEFT JOIN updated 
       ON existing._id = updated._id;`;
-  },
-  replaceOne: (filter, document, options) => {
-    const expectedVersion = _chunkEQ3T4XHTcjs.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, serializer);
-    return _dumbo.SQL`
+	},
+	replaceOne: (filter, document, options) => {
+		const expectedVersion = require_core.expectedVersionValue(options?.expectedVersion);
+		const expectedVersionUpdate = expectedVersion != null ? _event_driven_io_dumbo.SQL`AND ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._version = ${expectedVersion}` : _event_driven_io_dumbo.SQL``;
+		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 = ${serializer.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,
@@ -237,32 +166,32 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       FROM existing
       LEFT JOIN updated 
       ON existing._id = updated._id;`;
-  },
-  updateMany: (filter, update) => {
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter, serializer);
-    const updateQuery = _dumbo.isSQL.call(void 0, update) ? update : buildUpdateQuery(update, serializer);
-    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 = _chunkEQ3T4XHTcjs.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, serializer);
-    return _dumbo.SQL`
+	},
+	deleteOne: (filter, options) => {
+		const expectedVersion = require_core.expectedVersionValue(options?.expectedVersion);
+		const expectedVersionUpdate = expectedVersion != null ? _event_driven_io_dumbo.SQL`AND ${_event_driven_io_dumbo.SQL.identifier(collectionName)}._version = ${expectedVersion}` : _event_driven_io_dumbo.SQL``;
+		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,
@@ -271,27 +200,17 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       FROM existing
       LEFT JOIN deleted 
       ON existing._id = deleted._id;`;
-  },
-  deleteMany: (filter) => {
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter, serializer);
-    return _dumbo.SQL`DELETE FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)}`;
-  },
-  replaceMany: (documents) => {
-    const hasVersions = documents.some(
-      (d) => "_version" in d && d._version !== void 0
-    );
-    if (hasVersions) {
-      const values2 = _dumbo.SQL.merge(
-        documents.map(
-          (d) => _dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb, ${_nullishCoalesce(d._version, () => ( 0n))}::bigint)`
-        ),
-        ","
-      );
-      return _dumbo.SQL`
+	},
+	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 ${values2}
+          VALUES ${_event_driven_io_dumbo.SQL.merge(documents.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb, ${d._version ?? 0n}::bigint)`), ",")}
         )
-        UPDATE ${_dumbo.SQL.identifier(collectionName)} t
+        UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
         SET
           data = r.data
             || jsonb_build_object('_id', t._id)
@@ -300,18 +219,11 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
         FROM replacements r
         WHERE t._id = r._id AND t._version = r.expected_version
         RETURNING t._id, t._version AS version;`;
-    }
-    const values = _dumbo.SQL.merge(
-      documents.map(
-        (d) => _dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb)`
-      ),
-      ","
-    );
-    return _dumbo.SQL`
+		return _event_driven_io_dumbo.SQL`
       WITH replacements(_id, data) AS (
-        VALUES ${values}
+        VALUES ${_event_driven_io_dumbo.SQL.merge(documents.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb)`), ",")}
       )
-      UPDATE ${_dumbo.SQL.identifier(collectionName)} t
+      UPDATE ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
       SET
         data = r.data
           || jsonb_build_object('_id', t._id)
@@ -320,20 +232,14 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       FROM replacements r
       WHERE t._id = r._id
       RETURNING t._id, t._version AS version;`;
-  },
-  deleteManyByIds: (ids) => {
-    const hasVersions = ids.some((d) => d._version !== void 0);
-    if (hasVersions) {
-      const values2 = _dumbo.SQL.merge(
-        ids.map((d) => _dumbo.SQL`(${d._id}::text, ${_nullishCoalesce(d._version, () => ( 0n))}::bigint)`),
-        ","
-      );
-      return _dumbo.SQL`
+	},
+	deleteManyByIds: (ids) => {
+		if (ids.some((d) => d._version !== void 0)) return _event_driven_io_dumbo.SQL`
         WITH targets(_id, expected_version) AS (
-          VALUES ${values2}
+          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 ${_dumbo.SQL.identifier(collectionName)} t
+          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
@@ -342,17 +248,12 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
           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;`;
-    }
-    const values = _dumbo.SQL.merge(
-      ids.map((d) => _dumbo.SQL`(${d._id}::text)`),
-      ","
-    );
-    return _dumbo.SQL`
+		return _event_driven_io_dumbo.SQL`
       WITH targets(_id) AS (
-        VALUES ${values}
+        VALUES ${_event_driven_io_dumbo.SQL.merge(ids.map((d) => _event_driven_io_dumbo.SQL`(${d._id}::text)`), ",")}
       ),
       deleted AS (
-        DELETE FROM ${_dumbo.SQL.identifier(collectionName)} t
+        DELETE FROM ${_event_driven_io_dumbo.SQL.identifier(collectionName)} t
         USING targets r
         WHERE t._id = r._id
         RETURNING t._id
@@ -361,82 +262,75 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
         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 = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter, serializer);
-    return _dumbo.SQL`SELECT data, _version FROM ${_dumbo.SQL.identifier(collectionName)} ${where(filterQuery)} LIMIT 1;`;
-  },
-  find: (filter, options) => {
-    const filterQuery = _dumbo.isSQL.call(void 0, filter) ? filter : constructFilterQuery(filter, serializer);
-    const query = [];
-    query.push(
-      _dumbo.SQL`SELECT data, _version 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, serializer);
-    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)}`
+	},
+	findOne: (filter) => {
+		const filterQuery = (0, _event_driven_io_dumbo.isSQL)(filter) ? filter : constructFilterQuery(filter, serializer);
+		return _event_driven_io_dumbo.SQL`SELECT data, _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, _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
-
-
+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]);
 
-
-
-var _pg = require('@event-driven-io/dumbo/pg');
-var pgPongoDriver = {
-  driverType: _pg.PgDriverType,
-  databaseFactory: (options) => {
-    const databaseName = _nullishCoalesce(_nullishCoalesce(options.databaseName, () => ( _pg.postgreSQLMetadata.parseDatabaseName(options.connectionString))), () => ( _pg.postgreSQLMetadata.defaultDatabaseName));
-    return _chunkEQ3T4XHTcjs.PongoDatabase.call(void 0, {
-      ...options,
-      pool: _dumbo.dumbo.call(void 0, {
-        connectionString: options.connectionString,
-        driver: _pg.pgDumboDriver,
-        ...options.connectionOptions,
-        serialization: { serializer: options.serializer }
-      }),
-      schemaComponent: _chunkEQ3T4XHTcjs.PongoDatabaseSchemaComponent.call(void 0, {
-        driverType: _pg.PgDriverType,
-        collectionFactory: (schema) => _chunkEQ3T4XHTcjs.PongoCollectionSchemaComponent.call(void 0, {
-          driverType: _pg.PgDriverType,
-          definition: schema,
-          migrationsOrSchemaComponents: {
-            migrations: pongoCollectionPostgreSQLMigrations(schema.name)
-          },
-          sqlBuilder: postgresSQLBuilder(
-            schema.name,
-            _nullishCoalesce(_optionalChain([options, 'access', _6 => _6.serialization, 'optionalAccess', _7 => _7.serializer]), () => ( _dumbo.JSONSerializer))
-          )
-        }),
-        definition: _nullishCoalesce(_optionalChain([options, 'access', _8 => _8.schema, 'optionalAccess', _9 => _9.definition]), () => ( _chunkEQ3T4XHTcjs.pongoSchema.db(databaseName, {})))
-      }),
-      databaseName
-    });
-  }
+//#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 usePgPongoDriver = () => {
-  _chunkEQ3T4XHTcjs.pongoDriverRegistry.register(_pg.PgDriverType, pgPongoDriver);
+const usePgPongoDriver = () => {
+	require_core.pongoDriverRegistry.register(_event_driven_io_dumbo_pg.PgDriverType, pgPongoDriver);
 };
 usePgPongoDriver();
 
-
-
-
-
-
-exports.pgDriver = pgPongoDriver; exports.pongoCollectionPostgreSQLMigrations = pongoCollectionPostgreSQLMigrations; exports.pongoDriver = pgPongoDriver; exports.postgresSQLBuilder = postgresSQLBuilder; exports.usePgPongoDriver = usePgPongoDriver;
+//#endregion
+exports.pgDriver = pgPongoDriver;
+exports.pongoDriver = pgPongoDriver;
+exports.pongoCollectionPostgreSQLMigrations = pongoCollectionPostgreSQLMigrations;
+exports.postgresSQLBuilder = postgresSQLBuilder;
+exports.usePgPongoDriver = usePgPongoDriver;
 //# sourceMappingURL=pg.cjs.map