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

package/dist/pg.js

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