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

package/dist/pg.js

@@ -1,150 +1,86 @@
-import {
-  OperatorMap,
-  PongoCollectionSchemaComponent,
-  PongoDatabase,
-  PongoDatabaseSchemaComponent,
-  QueryOperators,
-  expectedVersionValue,
-  hasOperators,
-  objectEntries,
-  pongoDriverRegistry,
-  pongoSchema
-} from "./chunk-U4NNEXNH.js";
+import { A as objectEntries, C as expectedVersionValue, I as PongoCollectionSchemaComponent, M as OperatorMap, N as QueryOperators, P as hasOperators, d as PongoDatabase, f as PongoDatabaseSchemaComponent, p as pongoSchema, u as pongoDriverRegistry } from "./core-D_iZiiYe.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, 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 { SQL } from "@event-driven-io/dumbo";
-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 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} = ANY (${value})`;
-    }
-    case "$nin": {
-      const jsonPath = `{${path.split(".").join(",")}}`;
-      return SQL`data #>> ${jsonPath} != 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": {
-      const nestedPath = serializer.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)} = ANY (${value})`;
-    case "$nin":
-      return SQL`${SQL.plain(fieldName)} != ALL (${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, serializer) => SQL2.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 = !hasOperators(value);
-  return SQL2.merge(
-    objectEntries(value).map(
-      ([nestedKey, val]) => isEquality ? handleOperator(
-        `${key}.${nestedKey}`,
-        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) => 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 = !hasOperators(value);
+	return SQL.merge(objectEntries(value).map(([nestedKey, val]) => isEquality ? handleOperator(`${key}.${nestedKey}`, 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
-import { SQL as SQL3 } from "@event-driven-io/dumbo";
-var 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;
-    }
-  },
-  SQL3`data`
-);
-var buildSetQuery = (set, currentUpdateQuery, serializer) => SQL3`${currentUpdateQuery} || ${serializer.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, serializer) => {
-  for (const [key, value] of Object.entries(push)) {
-    const serializedValue = serializer.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 createCollection = (collectionName) => SQL`
+    CREATE TABLE IF NOT EXISTS ${SQL.identifier(collectionName)} (
       _id           TEXT           PRIMARY KEY, 
       data          JSONB          NOT NULL, 
       metadata      JSONB          NOT NULL     DEFAULT '{}',
@@ -154,52 +90,43 @@ 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, serializer) => ({
-  createCollection: () => createCollection(collectionName),
-  insertOne: (document) => {
-    const serialized = serializer.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}, ${serializer.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, serializer);
-    const updateQuery = isSQL(update) ? update : buildUpdateQuery(update, serializer);
-    return SQL4`
+	},
+	updateOne: (filter, update, options) => {
+		const expectedVersion = expectedVersionValue(options?.expectedVersion);
+		const expectedVersionUpdate = expectedVersion != null ? SQL`AND ${SQL.identifier(collectionName)}._version = ${expectedVersion}` : SQL``;
+		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,
@@ -209,25 +136,25 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       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, serializer);
-    return SQL4`
+	},
+	replaceOne: (filter, document, options) => {
+		const expectedVersion = expectedVersionValue(options?.expectedVersion);
+		const expectedVersionUpdate = expectedVersion != null ? SQL`AND ${SQL.identifier(collectionName)}._version = ${expectedVersion}` : SQL``;
+		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 = ${serializer.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,
@@ -237,32 +164,32 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       FROM existing
       LEFT JOIN updated 
       ON existing._id = updated._id;`;
-  },
-  updateMany: (filter, update) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
-    const updateQuery = isSQL(update) ? update : buildUpdateQuery(update, serializer);
-    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, serializer);
-    return SQL4`
+	},
+	deleteOne: (filter, options) => {
+		const expectedVersion = expectedVersionValue(options?.expectedVersion);
+		const expectedVersionUpdate = expectedVersion != null ? SQL`AND ${SQL.identifier(collectionName)}._version = ${expectedVersion}` : SQL``;
+		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,
@@ -271,27 +198,17 @@ var postgresSQLBuilder = (collectionName, serializer) => ({
       FROM existing
       LEFT JOIN deleted 
       ON existing._id = deleted._id;`;
-  },
-  deleteMany: (filter) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
-    return SQL4`DELETE FROM ${SQL4.identifier(collectionName)} ${where(filterQuery)}`;
-  },
-  replaceMany: (documents) => {
-    const hasVersions = documents.some(
-      (d) => "_version" in d && d._version !== void 0
-    );
-    if (hasVersions) {
-      const values2 = SQL4.merge(
-        documents.map(
-          (d) => SQL4`(${d._id}::text, ${serializer.serialize(d)}::jsonb, ${d._version ?? 0n}::bigint)`
-        ),
-        ","
-      );
-      return SQL4`
+	},
+	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 ${values2}
+          VALUES ${SQL.merge(documents.map((d) => SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb, ${d._version ?? 0n}::bigint)`), ",")}
         )
-        UPDATE ${SQL4.identifier(collectionName)} t
+        UPDATE ${SQL.identifier(collectionName)} t
         SET
           data = r.data
             || jsonb_build_object('_id', t._id)
@@ -300,18 +217,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 = SQL4.merge(
-      documents.map(
-        (d) => SQL4`(${d._id}::text, ${serializer.serialize(d)}::jsonb)`
-      ),
-      ","
-    );
-    return SQL4`
+		return SQL`
       WITH replacements(_id, data) AS (
-        VALUES ${values}
+        VALUES ${SQL.merge(documents.map((d) => SQL`(${d._id}::text, ${serializer.serialize(d)}::jsonb)`), ",")}
       )
-      UPDATE ${SQL4.identifier(collectionName)} t
+      UPDATE ${SQL.identifier(collectionName)} t
       SET
         data = r.data
           || jsonb_build_object('_id', t._id)
@@ -320,20 +230,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 = SQL4.merge(
-        ids.map((d) => SQL4`(${d._id}::text, ${d._version ?? 0n}::bigint)`),
-        ","
-      );
-      return SQL4`
+	},
+	deleteManyByIds: (ids) => {
+		if (ids.some((d) => d._version !== void 0)) return SQL`
         WITH targets(_id, expected_version) AS (
-          VALUES ${values2}
+          VALUES ${SQL.merge(ids.map((d) => SQL`(${d._id}::text, ${d._version ?? 0n}::bigint)`), ",")}
         ),
         deleted AS (
-          DELETE FROM ${SQL4.identifier(collectionName)} t
+          DELETE FROM ${SQL.identifier(collectionName)} t
           USING targets r
           WHERE t._id = r._id AND t._version = r.expected_version
           RETURNING t._id
@@ -342,17 +246,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 = SQL4.merge(
-      ids.map((d) => SQL4`(${d._id}::text)`),
-      ","
-    );
-    return SQL4`
+		return SQL`
       WITH targets(_id) AS (
-        VALUES ${values}
+        VALUES ${SQL.merge(ids.map((d) => SQL`(${d._id}::text)`), ",")}
       ),
       deleted AS (
-        DELETE FROM ${SQL4.identifier(collectionName)} t
+        DELETE FROM ${SQL.identifier(collectionName)} t
         USING targets r
         WHERE t._id = r._id
         RETURNING t._id
@@ -361,82 +260,71 @@ 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 = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
-    return SQL4`SELECT data, _version FROM ${SQL4.identifier(collectionName)} ${where(filterQuery)} LIMIT 1;`;
-  },
-  find: (filter, options) => {
-    const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
-    const query = [];
-    query.push(
-      SQL4`SELECT data, _version 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, serializer);
-    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)}`
+	},
+	findOne: (filter) => {
+		const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
+		return SQL`SELECT data, _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, _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, JSONSerializer } from "@event-driven-io/dumbo";
-import {
-  pgDumboDriver as dumboDriver,
-  PgDriverType,
-  postgreSQLMetadata
-} from "@event-driven-io/dumbo/pg";
-var pgPongoDriver = {
-  driverType: PgDriverType,
-  databaseFactory: (options) => {
-    const databaseName = options.databaseName ?? postgreSQLMetadata.parseDatabaseName(options.connectionString) ?? postgreSQLMetadata.defaultDatabaseName;
-    return PongoDatabase({
-      ...options,
-      pool: dumbo({
-        connectionString: options.connectionString,
-        driver: dumboDriver,
-        ...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
-    });
-  }
+//#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 usePgPongoDriver = () => {
-  pongoDriverRegistry.register(PgDriverType, pgPongoDriver);
+const usePgPongoDriver = () => {
+	pongoDriverRegistry.register(PgDriverType, pgPongoDriver);
 };
 usePgPongoDriver();
-export {
-  pgPongoDriver as pgDriver,
-  pongoCollectionPostgreSQLMigrations,
-  pgPongoDriver as pongoDriver,
-  postgresSQLBuilder,
-  usePgPongoDriver
-};
+
+//#endregion
+export { pgPongoDriver as pgDriver, pgPongoDriver as pongoDriver, pongoCollectionPostgreSQLMigrations, postgresSQLBuilder, usePgPongoDriver };
 //# sourceMappingURL=pg.js.map