@event-driven-io/pongo 0.17.0-beta.41 → 0.17.0-beta.43

package/dist/pg.js

@@ -1,29 +1,1146 @@
-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 { JSONParam, JSONSerializer, SQL, dumbo, isSQL, mapColumnToBigint, mapColumnToJSON, runSQLMigrations, schemaComponent, single, sqlMigration } from "@event-driven-io/dumbo";
+import { PostgreSQLJSON } from "@event-driven-io/dumbo/postgresql";
+import { LRUCache } from "lru-cache";
+import { v7 } from "uuid";
 import { PgDriverType, pgDumboDriver, postgreSQLMetadata } from "@event-driven-io/dumbo/pg";
 
+//#region src/core/cache/pongoCacheWrapper.ts
+const pongoCacheWrapper = (options) => {
+	const { provider, hooks } = options;
+	const onError = (error, operation) => {
+		hooks?.onError?.(error, operation);
+	};
+	let isClosed = false;
+	return {
+		cacheType: provider.cacheType,
+		async get(key) {
+			try {
+				const result = await provider.get(key);
+				if (result !== void 0) hooks?.onHit?.(key);
+				else hooks?.onMiss?.(key);
+				return result;
+			} catch (error) {
+				onError(error, "get");
+				hooks?.onMiss?.(key);
+				return;
+			}
+		},
+		async getMany(keys) {
+			try {
+				return await provider.getMany(keys);
+			} catch (error) {
+				onError(error, "getMany");
+				return [];
+			}
+		},
+		async set(key, value) {
+			try {
+				await provider.set(key, value);
+			} catch (error) {
+				onError(error, "set");
+			}
+		},
+		async setMany(entries) {
+			try {
+				await provider.setMany(entries);
+			} catch (error) {
+				onError(error, "setMany");
+			}
+		},
+		async update(key, updater) {
+			try {
+				await provider.update(key, updater);
+			} catch (error) {
+				onError(error, "update");
+			}
+		},
+		async updateMany(keys, updater) {
+			try {
+				await provider.updateMany(keys, updater);
+			} catch (error) {
+				onError(error, "updateMany");
+			}
+		},
+		async delete(key) {
+			try {
+				await provider.delete(key);
+				hooks?.onEvict?.(key);
+			} catch (error) {
+				onError(error, "delete");
+			}
+		},
+		async deleteMany(keys) {
+			try {
+				await provider.deleteMany(keys);
+				for (const key of keys) hooks?.onEvict?.(key);
+			} catch (error) {
+				onError(error, "deleteMany");
+			}
+		},
+		clear() {
+			return provider.clear();
+		},
+		close() {
+			if (isClosed) return;
+			isClosed = true;
+			return provider.close();
+		}
+	};
+};
+
+//#endregion
+//#region src/core/cache/providers/identityMapCache.ts
+const identityMapCache = () => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		cacheType: "pongo:cache:identity-map",
+		get: (key) => Promise.resolve(store.has(key) ? store.get(key) : void 0),
+		getMany: (keys) => keys.map((k) => store.has(k) ? store.get(k) : void 0),
+		set: (key, value) => {
+			store.set(key, value);
+		},
+		setMany: (entries) => {
+			for (const { key, value } of entries) store.set(key, value);
+		},
+		update: (key, _updater) => {
+			store.delete(key);
+		},
+		updateMany: (keys, _updater) => {
+			for (const key of keys) store.delete(key);
+		},
+		delete: (key) => {
+			store.delete(key);
+		},
+		deleteMany: (keys) => {
+			for (const key of keys) store.delete(key);
+		},
+		clear: () => {
+			store.clear();
+		},
+		close: () => {
+			store.clear();
+		}
+	};
+};
+
+//#endregion
+//#region src/core/cache/providers/lruCache.ts
+const defaultLRUCacheOptions = { max: 1e3 };
+const lruCache = (options) => {
+	const cache = new LRUCache({
+		...defaultLRUCacheOptions,
+		...options
+	});
+	return {
+		cacheType: "pongo:cache:lru",
+		get: (key) => {
+			const entry = cache.get(key);
+			if (entry === void 0) return void 0;
+			return entry.doc;
+		},
+		getMany: (keys) => keys.map((k) => {
+			const entry = cache.get(k);
+			if (entry === void 0) return void 0;
+			return entry.doc;
+		}),
+		set: (key, value) => {
+			cache.set(key, { doc: value });
+		},
+		setMany: (entries) => {
+			for (const { key, value } of entries) cache.set(key, { doc: value });
+		},
+		update: (key, _updater) => {
+			cache.delete(key);
+		},
+		updateMany(keys, _updater) {
+			for (const key of keys) cache.delete(key);
+		},
+		delete: (key) => {
+			cache.delete(key);
+		},
+		deleteMany: (keys) => {
+			for (const key of keys) cache.delete(key);
+		},
+		clear: () => {
+			cache.clear();
+		},
+		close: () => {
+			cache.clear();
+		}
+	};
+};
+
+//#endregion
+//#region src/core/cache/providers/noopCache.ts
+const noopCacheProvider = {
+	cacheType: "pongo:cache:no-op",
+	get: () => void 0,
+	set: () => {},
+	update: () => {},
+	delete: () => {},
+	getMany: (keys) => keys.map(() => void 0),
+	setMany: () => {},
+	updateMany: () => {},
+	deleteMany: () => {},
+	clear: () => {},
+	close: () => {}
+};
+
+//#endregion
+//#region src/core/cache/pongoCache.ts
+const DEFAULT_CONFIG = { type: "in-memory" };
+const pongoCache = (options) => {
+	if (options === void 0 || options === "disabled") return noopCacheProvider;
+	if ("cacheType" in options) return options;
+	const config = options ?? DEFAULT_CONFIG;
+	if (config.type === "identity-map") return identityMapCache();
+	return pongoCacheWrapper({ provider: lruCache(config) });
+};
+
+//#endregion
+//#region src/core/collection/filters/filters.ts
+const asPlainObjectWithSingleKey = (filter, key) => filter && typeof filter === "object" && !Array.isArray(filter) && Object.keys(filter).length === 1 && key in filter ? { [key]: filter[key] } : void 0;
+const idFromFilter = (filter) => {
+	const idFilter = asPlainObjectWithSingleKey(filter, "_id");
+	return typeof idFilter?.["_id"] === "string" ? idFilter["_id"] : void 0;
+};
+const getIdsFromIdOnlyFilter = (filter) => {
+	const idFilter = asPlainObjectWithSingleKey(filter, "_id");
+	if (!idFilter) return void 0;
+	const idValue = idFilter["_id"];
+	if (typeof idValue === "string") return [idValue];
+	const $in = idValue && typeof idValue === "object" && "$in" in idValue ? idValue["$in"] : void 0;
+	return Array.isArray($in) && $in.every((i) => typeof i === "string") ? $in : void 0;
+};
+
+//#endregion
+//#region src/core/collection/handle.ts
+function DocumentCommandHandler(deps) {
+	const fn = async (input, handle, options) => {
+		const results = (await handleDocuments(deps.storage, normalizeInput(input), handle, options)).map(({ change, result: outcome }) => toHandleResult(deps, change, outcome));
+		return Array.isArray(input) ? results : results[0];
+	};
+	return fn;
+}
+async function handleDocuments(storage, inputs, handle, options) {
+	if (inputs.length === 0) return [];
+	const { parallel, ...operationOptions } = options ?? {};
+	await storage.ensureCollectionCreated(operationOptions);
+	const docs = await storage.fetchByIds(inputs.map((i) => i._id), operationOptions);
+	return await executeStorageChanges(storage, await mapAsync(inputs, (item, i) => handleDocument({
+		...item,
+		existing: docs[i] ?? null
+	}, handle), { parallel }), operationOptions);
+}
+async function handleDocument(item, handle) {
+	const { _id: id, existing, expectedVersion } = item;
+	if (hasVersionMismatch(existing, expectedVersion)) return {
+		type: "noop",
+		existing,
+		versionMismatch: true
+	};
+	const handlers = Array.isArray(handle) ? handle : [handle];
+	let result = existing ? { ...existing } : null;
+	for (const handler of handlers) result = await handler(result, id);
+	return toDocumentChange(id, existing, result);
+}
+async function executeStorageChanges(storage, changes, operationOptions) {
+	const toInsert = changes.flatMap((c) => c.type === "insert" ? [c.doc] : []);
+	const toReplace = changes.flatMap((c) => {
+		if (c.type !== "replace") return [];
+		const { _version: _, ...cleanResult } = c.result;
+		return [c._version !== void 0 ? {
+			...cleanResult,
+			_version: c._version
+		} : cleanResult];
+	});
+	const toDelete = changes.flatMap((c) => c.type === "delete" ? [c._version !== void 0 ? {
+		_id: c.docId,
+		_version: c._version
+	} : { _id: c.docId }] : []);
+	const insertedIds = toInsert.length > 0 ? new Set((await storage.insertMany(toInsert, operationOptions)).insertedIds) : /* @__PURE__ */ new Set();
+	const replaceResult = toReplace.length > 0 ? await storage.replaceMany(toReplace, operationOptions) : null;
+	const deletedIds = toDelete.length > 0 ? (await storage.deleteManyByIds(toDelete, operationOptions)).deletedIds : /* @__PURE__ */ new Set();
+	const toDocumentHandlerResult = (change) => {
+		if (change.type === "noop") return { succeeded: !change.versionMismatch };
+		if (change.type === "insert") return {
+			succeeded: insertedIds.has(change.doc._id),
+			newVersion: 1n
+		};
+		if (change.type === "delete") return { succeeded: deletedIds.has(change.docId) };
+		const id = change.result._id;
+		return {
+			succeeded: replaceResult?.modifiedIds.includes(id) ?? false,
+			newVersion: replaceResult?.nextExpectedVersions.get(id) ?? 0n
+		};
+	};
+	return changes.map((change) => ({
+		change,
+		result: toDocumentHandlerResult(change)
+	}));
+}
+function normalizeInput(input) {
+	if (typeof input === "string") return [{ _id: input }];
+	if (!Array.isArray(input)) return [input];
+	return input.map((item) => typeof item === "string" ? { _id: item } : item);
+}
+function hasVersionMismatch(existing, version) {
+	const expected = expectedVersionValue(version);
+	return existing == null && version === "DOCUMENT_EXISTS" || existing == null && expected != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expected !== null && existing._version !== expected;
+}
+function toDocumentChange(docId, existing, result) {
+	if (deepEquals(existing, result)) return {
+		type: "noop",
+		existing
+	};
+	if (!existing && result) return {
+		type: "insert",
+		doc: {
+			...result,
+			_id: docId
+		}
+	};
+	if (existing && !result) return {
+		type: "delete",
+		docId,
+		_version: existing._version
+	};
+	return {
+		type: "replace",
+		existing,
+		result: {
+			...result,
+			_id: docId
+		},
+		_version: existing._version
+	};
+}
+function toHandleResult(deps, change, { succeeded, newVersion }) {
+	const opMeta = {
+		operationName: "handle",
+		collectionName: deps.collectionName,
+		serializer: deps.serializer,
+		errors: deps.errors
+	};
+	const toResult = (op, document) => ({
+		...operationResult(op, opMeta),
+		document
+	});
+	if (change.type === "noop") return toResult({ successful: succeeded }, change.existing);
+	if (change.type === "insert") return toResult({
+		successful: succeeded,
+		insertedId: succeeded ? change.doc._id : null,
+		nextExpectedVersion: 1n
+	}, succeeded ? {
+		...change.doc,
+		_version: 1n
+	} : null);
+	if (change.type === "delete") return toResult({
+		successful: succeeded,
+		deletedCount: succeeded ? 1 : 0,
+		matchedCount: 1
+	}, null);
+	return toResult({
+		successful: succeeded,
+		modifiedCount: succeeded ? 1 : 0,
+		matchedCount: 1,
+		nextExpectedVersion: newVersion ?? 0n
+	}, succeeded ? {
+		...change.result,
+		_version: newVersion
+	} : change.existing);
+}
+
+//#endregion
+//#region src/core/collection/pongoCollection.ts
+const enlistIntoTransactionIfActive = async (db, options) => {
+	const transaction = options?.session?.transaction;
+	if (!transaction || !transaction.isActive) return null;
+	return await transaction.enlistDatabase(db);
+};
+const transactionExecutorOrDefault = async (db, options, defaultSqlExecutor) => {
+	return (await enlistIntoTransactionIfActive(db, options))?.execute ?? defaultSqlExecutor;
+};
+const pongoCollection = ({ db, collectionName, pool, schemaComponent, schema, errors, serializer, cache: cacheOptions }) => {
+	const SqlFor = schemaComponent.sqlBuilder;
+	const sqlExecutor = pool.execute;
+	const cache = pongoCache(cacheOptions);
+	const columnMapping = { mapping: {
+		...mapColumnToJSON("data", serializer),
+		...mapColumnToBigint("_version")
+	} };
+	const command = async (sql, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).command(sql, columnMapping);
+	const query = async (sql, options) => (await transactionExecutorOrDefault(db, options, sqlExecutor)).query(sql, columnMapping);
+	let shouldMigrate = schema?.autoMigration !== "None";
+	const createCollection = (options) => {
+		shouldMigrate = false;
+		if (options?.session) return command(SqlFor.createCollection(), options);
+		else return command(SqlFor.createCollection());
+	};
+	const ensureCollectionCreated = (options) => {
+		if (!shouldMigrate) return Promise.resolve();
+		return createCollection(options);
+	};
+	const upcast = schema?.versioning?.upcast ?? ((doc) => doc);
+	const downcast = schema?.versioning?.downcast ?? ((doc) => doc);
+	const toStored = (document) => ({
+		...downcast(document),
+		_id: document._id,
+		_version: document._version
+	});
+	const fromStored = (stored) => ({
+		...upcast(stored),
+		_id: stored._id,
+		_version: stored._version
+	});
+	const findOneStoredFromDb = async (filter, options) => {
+		const row = (await query(SqlFor.findOne(filter), options)).rows[0];
+		return row ? {
+			...row.data,
+			_id: row._id,
+			_version: row._version
+		} : null;
+	};
+	const cacheKey = (id) => `${db.databaseName}:${collectionName}:${id}`;
+	const txCacheFor = (options) => options?.session?.transaction?.cache ?? null;
+	const resolveFromCache = async (key, options) => {
+		const txCache = txCacheFor(options);
+		if (txCache) {
+			const cached = await txCache.get(key);
+			if (cached !== void 0) return cached;
+		}
+		return cache.get(key);
+	};
+	const findManyFromCache = async (keys, options) => {
+		const txCache = txCacheFor(options);
+		if (!txCache) return cache.getMany(keys);
+		const txResults = await txCache.getMany(keys);
+		const mainResults = await cache.getMany(keys);
+		return keys.map((_, i) => txResults[i] !== void 0 ? txResults[i] : mainResults[i]);
+	};
+	const fetchByIds = async (ids, options) => {
+		const cachedResults = await findManyFromCache(ids.map(cacheKey), options);
+		const missIds = ids.filter((_, i) => cachedResults[i] === void 0);
+		let dbDocsById = /* @__PURE__ */ new Map();
+		if (missIds.length > 0) {
+			const dbDocs = (await query(SqlFor.find({ _id: { $in: missIds } }, options))).rows.map((row) => ({
+				...row.data,
+				_id: row._id,
+				_version: row._version
+			}));
+			dbDocsById = new Map(dbDocs.map((d) => [d._id, d]));
+			const leftovers = missIds.map((id) => [id, dbDocsById.get(id) ?? null]);
+			await cacheSetMany(leftovers.map((d) => d[1]).filter((d) => d !== null), options);
+			await cacheDeleteMany(leftovers.filter(([, doc]) => doc === null).map(([id]) => id), options);
+		}
+		return ids.map((id, i) => {
+			const cached = cachedResults[i];
+			if (cached !== void 0) return cached;
+			return dbDocsById.get(id) ?? null;
+		});
+	};
+	const findManyByIds = async (ids, options) => {
+		return (await fetchByIds(ids, options)).filter((doc) => doc !== null).map(fromStored);
+	};
+	const cacheSet = (value, options) => {
+		const key = cacheKey(value._id);
+		const txCache = txCacheFor(options);
+		if (txCache) return txCache.set(key, value, { mainCache: cache });
+		return cache.set(key, value);
+	};
+	const cacheSetMany = (documents, options) => {
+		const txCache = txCacheFor(options);
+		const entries = documents.map((d) => ({
+			key: cacheKey(d._id),
+			value: d
+		}));
+		if (txCache) return txCache.setMany(entries, { mainCache: cache });
+		return cache.setMany(entries);
+	};
+	const cacheDelete = (id, options) => {
+		const txCache = txCacheFor(options);
+		const key = cacheKey(id);
+		if (txCache) return txCache.delete(key, { mainCache: cache });
+		return cache.delete(key);
+	};
+	const cacheDeleteMany = (ids, options) => {
+		const txCache = txCacheFor(options);
+		const keys = ids.map(cacheKey);
+		if (txCache) return txCache.deleteMany(keys, { mainCache: cache });
+		return cache.deleteMany(keys);
+	};
+	const deleteManyByIds = async (ids, options) => {
+		await ensureCollectionCreated(options);
+		const result = await command(SqlFor.deleteManyByIds(ids), options);
+		const deletedIds = new Set(result.rows.filter((row) => (row.deleted ?? 1) > 0).map((row) => row._id));
+		if (!options?.skipCache) await cacheDeleteMany([...deletedIds], options);
+		return operationResult({
+			successful: deletedIds.size > 0,
+			deletedCount: deletedIds.size,
+			matchedCount: ids.length,
+			deletedIds
+		}, {
+			operationName: "deleteManyByIds",
+			collectionName,
+			serializer,
+			errors
+		});
+	};
+	const executeUpsert = async (storedRows, options) => {
+		const result = await command(SqlFor.insertOrReplace(storedRows), options);
+		const writtenIds = result.rows.map((r) => r._id);
+		const versions = new Map(result.rows.map((r) => [r._id, BigInt(r.version ?? 1n)]));
+		if (!options?.skipCache) {
+			const writtenSet = new Set(writtenIds);
+			const cacheEntries = storedRows.filter((r) => writtenSet.has(r._id)).map((r) => ({
+				...r,
+				_version: versions.get(r._id) ?? 1n
+			}));
+			if (cacheEntries.length > 0) await cacheSetMany(cacheEntries, options);
+		}
+		return {
+			writtenIds,
+			versions
+		};
+	};
+	const collection = {
+		dbName: db.databaseName,
+		collectionName,
+		createCollection: async (options) => {
+			await createCollection(options);
+		},
+		insertOne: async (document, options) => {
+			await ensureCollectionCreated(options);
+			const _id = document._id ?? v7();
+			const _version = document._version ?? 1n;
+			const stored = toStored({
+				...document,
+				_id,
+				_version
+			});
+			if (options?.upsert) {
+				const { writtenIds, versions } = await executeUpsert([stored], options);
+				const successful = writtenIds.length > 0;
+				const nextExpectedVersion = versions.get(_id) ?? _version;
+				return operationResult({
+					successful,
+					insertedId: successful ? _id : null,
+					nextExpectedVersion
+				}, {
+					operationName: "insertOne",
+					collectionName,
+					serializer,
+					errors
+				});
+			}
+			const successful = ((await command(SqlFor.insertOne(stored), options)).rowCount ?? 0) > 0;
+			if (successful && !options?.skipCache) await cacheSet(stored, options);
+			return operationResult({
+				successful,
+				insertedId: successful ? _id : null,
+				nextExpectedVersion: _version
+			}, {
+				operationName: "insertOne",
+				collectionName,
+				serializer,
+				errors
+			});
+		},
+		insertMany: async (documents, options) => {
+			await ensureCollectionCreated(options);
+			const rows = documents.map((doc) => doc._id && doc._version ? doc : {
+				...doc,
+				_id: doc._id ?? v7(),
+				_version: doc._version ?? 1n
+			}).map((d) => toStored(d));
+			if (options?.upsert) {
+				const { writtenIds } = await executeUpsert(rows, options);
+				return operationResult({
+					successful: writtenIds.length === rows.length,
+					insertedCount: writtenIds.length,
+					insertedIds: writtenIds
+				}, {
+					operationName: "insertMany",
+					collectionName,
+					serializer,
+					errors
+				});
+			}
+			const result = await command(SqlFor.insertMany(rows), options);
+			if (!options?.skipCache) {
+				const insertedIdSet = new Set(result.rows.map((d) => d._id));
+				await cacheSetMany(rows.filter((r) => insertedIdSet.has(r._id)), options);
+			}
+			return operationResult({
+				successful: result.rowCount === rows.length,
+				insertedCount: result.rowCount ?? 0,
+				insertedIds: result.rows.map((d) => d._id)
+			}, {
+				operationName: "insertMany",
+				collectionName,
+				serializer,
+				errors
+			});
+		},
+		updateOne: async (filter, update, options) => {
+			await ensureCollectionCreated(options);
+			const result = await command(SqlFor.updateOne(filter, update, options), options);
+			const opResult = operationResult({
+				successful: result.rows.length > 0 && result.rows[0].modified === result.rows[0].matched,
+				modifiedCount: Number(result.rows[0]?.modified ?? 0),
+				matchedCount: Number(result.rows[0]?.matched ?? 0),
+				upsertedId: null,
+				upsertedCount: 0,
+				nextExpectedVersion: BigInt(result.rows[0]?.version ?? 0n)
+			}, {
+				operationName: "updateOne",
+				collectionName,
+				serializer,
+				errors
+			});
+			if (opResult.successful && !options?.skipCache) {
+				const id = idFromFilter(filter);
+				if (id) await cacheDelete(id, options);
+			}
+			return opResult;
+		},
+		replaceOne: async (filter, document, options) => {
+			await ensureCollectionCreated(options);
+			const noConcurrencyCheck = options?.expectedVersion === void 0 || options.expectedVersion === "NO_CONCURRENCY_CHECK";
+			if (options?.upsert && noConcurrencyCheck) {
+				const _id = idFromFilter(filter) ?? v7();
+				const { writtenIds, versions } = await executeUpsert([toStored({
+					...document,
+					_id,
+					_version: 1n
+				})], options);
+				const written = writtenIds.length > 0;
+				const nextExpectedVersion = versions.get(_id) ?? 1n;
+				const inserted = written && nextExpectedVersion === 1n;
+				return operationResult({
+					successful: written,
+					modifiedCount: written && !inserted ? 1 : 0,
+					matchedCount: written && !inserted ? 1 : 0,
+					upsertedId: inserted ? _id : null,
+					upsertedCount: inserted ? 1 : 0,
+					nextExpectedVersion
+				}, {
+					operationName: "replaceOne",
+					collectionName,
+					serializer,
+					errors
+				});
+			}
+			const downcasted = downcast(document);
+			const result = await command(SqlFor.replaceOne(filter, downcasted, options), options);
+			const opResult = operationResult({
+				successful: result.rows.length > 0 && result.rows[0].modified > 0,
+				modifiedCount: Number(result.rows[0]?.modified ?? 0),
+				matchedCount: Number(result.rows[0]?.matched ?? 0),
+				upsertedId: null,
+				upsertedCount: 0,
+				nextExpectedVersion: BigInt(result.rows[0]?.version ?? 0n)
+			}, {
+				operationName: "replaceOne",
+				collectionName,
+				serializer,
+				errors
+			});
+			if (opResult.successful && !options?.skipCache) {
+				const _id = idFromFilter(filter);
+				if (_id) await cacheSet(toStored({
+					...document,
+					_id,
+					_version: opResult.nextExpectedVersion
+				}), options);
+			}
+			return opResult;
+		},
+		updateMany: async (filter, update, options) => {
+			await ensureCollectionCreated(options);
+			const result = await command(SqlFor.updateMany(filter, update), options);
+			return operationResult({
+				successful: true,
+				modifiedCount: result.rowCount ?? 0,
+				matchedCount: result.rowCount ?? 0
+			}, {
+				operationName: "updateMany",
+				collectionName,
+				serializer,
+				errors
+			});
+		},
+		deleteOne: async (filter, options) => {
+			await ensureCollectionCreated(options);
+			const result = await command(SqlFor.deleteOne(filter ?? {}, options), options);
+			const opResult = operationResult({
+				successful: result.rows.length > 0 && result.rows[0].deleted > 0,
+				deletedCount: Number(result.rows[0]?.deleted ?? 0),
+				matchedCount: Number(result.rows[0]?.matched ?? 0)
+			}, {
+				operationName: "deleteOne",
+				collectionName,
+				serializer,
+				errors
+			});
+			if (opResult.successful && !options?.skipCache && filter) {
+				const id = idFromFilter(filter);
+				if (id) await cacheDelete(id, options);
+			}
+			return opResult;
+		},
+		deleteMany: async (filter, options) => {
+			const ids = filter ? getIdsFromIdOnlyFilter(filter) : null;
+			if (ids) return deleteManyByIds(ids.map((id) => ({ _id: id })), options);
+			await ensureCollectionCreated(options);
+			const result = await command(SqlFor.deleteMany(filter ?? {}), options);
+			return operationResult({
+				successful: (result.rowCount ?? 0) > 0,
+				deletedCount: result.rowCount ?? 0,
+				matchedCount: result.rowCount ?? 0
+			}, {
+				operationName: "deleteMany",
+				collectionName,
+				serializer,
+				errors
+			});
+		},
+		findOne: async (filter, options) => {
+			await ensureCollectionCreated(options);
+			const id = filter && !options?.skipCache ? idFromFilter(filter) : null;
+			if (id) {
+				const cached = await resolveFromCache(cacheKey(id), options);
+				if (cached !== void 0) return cached !== null ? fromStored(cached) : null;
+				const stored = await findOneStoredFromDb(filter, options);
+				if (stored) await cacheSet(stored, options);
+				else await cacheDelete(id, options);
+				return stored ? fromStored(stored) : null;
+			}
+			const stored = await findOneStoredFromDb(filter ?? {}, options);
+			return stored ? fromStored(stored) : null;
+		},
+		findOneAndDelete: async (filter, options) => {
+			await ensureCollectionCreated(options);
+			const existingDoc = await collection.findOne(filter, options);
+			if (existingDoc === null) return null;
+			await collection.deleteOne(filter, options);
+			return existingDoc;
+		},
+		findOneAndReplace: async (filter, replacement, options) => {
+			await ensureCollectionCreated(options);
+			const existingDoc = await collection.findOne(filter, options);
+			if (existingDoc === null) return null;
+			await collection.replaceOne(filter, replacement, options);
+			return existingDoc;
+		},
+		findOneAndUpdate: async (filter, update, options) => {
+			await ensureCollectionCreated(options);
+			const existingDoc = await collection.findOne(filter, options);
+			if (existingDoc === null) return null;
+			await collection.updateOne(filter, update, options);
+			return existingDoc;
+		},
+		replaceMany: async (documents, options) => {
+			await ensureCollectionCreated(options);
+			const rows = documents.map((d) => toStored(d));
+			if (options?.upsert) {
+				const versioned = documents.map((d) => "_version" in d && d._version !== void 0);
+				const hasVersions = versioned.some((v) => v);
+				const allVersioned = versioned.every((v) => v);
+				if (hasVersions && !allVersioned) throw new Error("replaceMany with upsert cannot mix documents with and without _version in a single batch");
+				if (!hasVersions) {
+					const { writtenIds, versions } = await executeUpsert(rows, options);
+					const conflictIds = documents.map((d) => d._id).filter((id) => !writtenIds.includes(id));
+					return operationResult({
+						successful: conflictIds.length === 0,
+						modifiedCount: writtenIds.length,
+						matchedCount: documents.length,
+						modifiedIds: [...writtenIds],
+						conflictIds: [...conflictIds],
+						nextExpectedVersions: versions
+					}, {
+						operationName: "replaceMany",
+						collectionName,
+						serializer,
+						errors
+					});
+				}
+			}
+			const result = await command(SqlFor.replaceMany(rows), options);
+			const modifiedIds = result.rows.map((row) => row._id);
+			const conflictIds = documents.map((d) => d._id).filter((id) => !modifiedIds.includes(id));
+			const versions = new Map(result.rows.map((row) => [row._id, BigInt(row.version ?? 1n)]));
+			if (!options?.skipCache) {
+				const cacheEntries = rows.filter((r) => modifiedIds.includes(r._id)).map((r) => ({
+					...r,
+					_version: versions.get(r._id) ?? r._version ?? 1n
+				}));
+				if (cacheEntries.length > 0) await cacheSetMany(cacheEntries, options);
+				if (conflictIds.length > 0) await cacheDeleteMany([...conflictIds], options);
+			}
+			return operationResult({
+				successful: modifiedIds.length > 0 && conflictIds.length === 0,
+				modifiedCount: modifiedIds.length,
+				matchedCount: documents.length,
+				modifiedIds: [...modifiedIds],
+				conflictIds: [...conflictIds],
+				nextExpectedVersions: versions
+			}, {
+				operationName: "replaceMany",
+				collectionName,
+				serializer,
+				errors
+			});
+		},
+		handle: DocumentCommandHandler({
+			collectionName,
+			serializer,
+			errors,
+			storage: {
+				ensureCollectionCreated,
+				fetchByIds: (ids, options) => fetchByIds(ids, options).then((rows) => rows.map((stored) => stored ? fromStored(stored) : null)),
+				insertMany: (docs, options) => collection.insertMany(docs, options),
+				replaceMany: (docs, options) => collection.replaceMany(docs, options),
+				deleteManyByIds
+			}
+		}),
+		find: async (filter, options) => {
+			await ensureCollectionCreated(options);
+			if (!options?.skipCache && filter) {
+				const ids = getIdsFromIdOnlyFilter(filter);
+				if (ids && ids.length > 0) return findManyByIds(ids, options);
+			}
+			return (await query(SqlFor.find(filter ?? {}, options))).rows.map((row) => fromStored({
+				...row.data,
+				_id: row._id,
+				_version: row._version
+			}));
+		},
+		countDocuments: async (filter, options) => {
+			await ensureCollectionCreated(options);
+			const { count } = await single(query(SqlFor.countDocuments(filter ?? {})));
+			return count;
+		},
+		drop: async (options) => {
+			await ensureCollectionCreated(options);
+			return ((await command(SqlFor.drop()))?.rowCount ?? 0) > 0;
+		},
+		rename: async (newName, options) => {
+			await ensureCollectionCreated(options);
+			await command(SqlFor.rename(newName));
+			collectionName = newName;
+			return collection;
+		},
+		close: () => cache.close(),
+		sql: {
+			async query(sql, options) {
+				await ensureCollectionCreated(options);
+				return (await query(sql, options)).rows;
+			},
+			async command(sql, options) {
+				await ensureCollectionCreated(options);
+				return command(sql, options);
+			}
+		},
+		schema: {
+			component: schemaComponent,
+			migrate: (options) => runSQLMigrations(pool, schemaComponent.migrations, options)
+		}
+	};
+	return collection;
+};
+
+//#endregion
+//#region src/core/collection/pongoCollectionSchemaComponent.ts
+const PongoCollectionSchemaComponent = ({ definition, migrationsOrSchemaComponents, sqlBuilder }) => ({
+	...schemaComponent(`sc:pongo:collection:${definition.name}`, migrationsOrSchemaComponents),
+	sqlBuilder,
+	definition,
+	collectionName: definition.name
+});
+
+//#endregion
+//#region src/core/collection/query.ts
+const QueryOperators = {
+	$eq: "$eq",
+	$gt: "$gt",
+	$gte: "$gte",
+	$lt: "$lt",
+	$lte: "$lte",
+	$ne: "$ne",
+	$in: "$in",
+	$nin: "$nin",
+	$elemMatch: "$elemMatch",
+	$all: "$all",
+	$size: "$size"
+};
+const OperatorMap = {
+	$gt: ">",
+	$gte: ">=",
+	$lt: "<",
+	$lte: "<=",
+	$ne: "!="
+};
+const isOperator = (key) => key.startsWith("$");
+const hasOperators = (value) => Object.keys(value).some(isOperator);
+
+//#endregion
+//#region src/core/typing/entries.ts
+const objectEntries = (obj) => Object.entries(obj).map(([key, value]) => [key, value]);
+
+//#endregion
+//#region src/core/errors/index.ts
+const isNumber = (val) => typeof val === "number" && val === val;
+const isString = (val) => typeof val === "string";
+var PongoError = class PongoError extends Error {
+	errorCode;
+	constructor(options) {
+		const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+		const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Pongo processing`;
+		super(message);
+		this.errorCode = errorCode;
+		Object.setPrototypeOf(this, PongoError.prototype);
+	}
+};
+var ConcurrencyError = class ConcurrencyError extends PongoError {
+	constructor(message) {
+		super({
+			errorCode: 412,
+			message: message ?? `Expected document state does not match current one!`
+		});
+		Object.setPrototypeOf(this, ConcurrencyError.prototype);
+	}
+};
+
+//#endregion
+//#region src/core/typing/operations.ts
+const DOCUMENT_DOES_NOT_EXIST = "DOCUMENT_DOES_NOT_EXIST";
+const NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+const isGeneralExpectedDocumentVersion = (version) => version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
+const expectedVersionValue = (version) => version === void 0 || isGeneralExpectedDocumentVersion(version) ? null : version;
+const expectedVersionPredicate = (version) => {
+	if (version === void 0) return { operator: "none" };
+	if (isGeneralExpectedDocumentVersion(version)) return version === "DOCUMENT_DOES_NOT_EXIST" ? {
+		operator: "=",
+		value: 0n
+	} : { operator: "none" };
+	return {
+		operator: "=",
+		value: version
+	};
+};
+const operationResult = (result, options) => {
+	const operationResult = {
+		...result,
+		acknowledged: true,
+		successful: result.successful,
+		assertSuccessful: (errorMessage) => {
+			const { successful } = result;
+			const { operationName, collectionName } = options;
+			if (!successful) throw new ConcurrencyError(errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${options.serializer.serialize(result)}!`);
+		}
+	};
+	if (options.errors?.throwOnOperationFailures) operationResult.assertSuccessful();
+	return operationResult;
+};
+
+//#endregion
+//#region src/core/schema/index.ts
+const pongoCollectionSchema = (name) => ({ name });
+pongoCollectionSchema.from = (collectionNames) => collectionNames.reduce((acc, collectionName) => (acc[collectionName] = pongoSchema.collection(collectionName), acc), {});
+function pongoDbSchema(nameOrCollections, collections) {
+	if (collections === void 0) {
+		if (typeof nameOrCollections === "string") throw new Error("You need to provide colleciton definition");
+		return { collections: nameOrCollections };
+	}
+	return nameOrCollections && typeof nameOrCollections === "string" ? {
+		name: nameOrCollections,
+		collections
+	} : { collections };
+}
+pongoDbSchema.from = (databaseName, collectionNames) => databaseName ? pongoDbSchema(databaseName, pongoCollectionSchema.from(collectionNames)) : pongoDbSchema(pongoCollectionSchema.from(collectionNames));
+const pongoClientSchema = (dbs) => ({ dbs });
+const pongoSchema = {
+	client: pongoClientSchema,
+	db: pongoDbSchema,
+	collection: pongoCollectionSchema
+};
+const proxyPongoDbWithSchema = (pongoDb, dbSchema, collections) => {
+	const collectionNames = Object.keys(dbSchema.collections);
+	for (const collectionName of collectionNames) collections.set(collectionName, pongoDb.collection(collectionName));
+	return new Proxy(pongoDb, { get(target, prop) {
+		return collections.get(prop) ?? target[prop];
+	} });
+};
+
+//#endregion
+//#region src/core/database/pongoDatabaseSchemaComponent.ts
+const PongoDatabaseSchemaComponent = ({ definition, collectionFactory }) => {
+	const collections = Object.values(definition.collections).map(collectionFactory) ?? [];
+	return {
+		...schemaComponent(`sc:dumbo:database:${definition.name}`, { components: collections }),
+		definition,
+		collections,
+		collection: (schema) => {
+			const existing = collections.find((c) => c.collectionName === schema.name);
+			if (existing) return existing;
+			const newCollection = collectionFactory(pongoSchema.collection(schema.name));
+			collections.push(newCollection);
+			definition.collections[schema.name] = schema;
+			return newCollection;
+		}
+	};
+};
+
+//#endregion
+//#region src/core/database/pongoDb.ts
+const PongoDatabase = (options) => {
+	const { databaseName, schemaComponent, pool, cache: cacheOptions, serializer } = options;
+	const cache = cacheOptions === "disabled" || cacheOptions === void 0 ? "disabled" : pongoCache(cacheOptions);
+	const collections = /* @__PURE__ */ new Map();
+	const command = async (sql, options) => (await transactionExecutorOrDefault(db, options, pool.execute)).command(sql, options);
+	const query = async (sql, options) => (await transactionExecutorOrDefault(db, options, pool.execute)).query(sql, options);
+	const db = {
+		driverType: pool.driverType,
+		databaseName,
+		connect: () => Promise.resolve(),
+		close: async () => {
+			await Promise.allSettled([
+				pool.close(),
+				cache !== "disabled" ? cache.close() : Promise.resolve(),
+				...collections.values().map((collection) => collection.close())
+			]);
+		},
+		collections: () => [...collections.values()],
+		collection: (collectionName, collectionOptions) => collections.get(collectionName) ?? pongoCollection({
+			collectionName,
+			db,
+			pool,
+			schemaComponent: schemaComponent.collection(pongoSchema.collection(collectionName)),
+			schema: {
+				...options.schema,
+				...collectionOptions?.schema
+			},
+			serializer,
+			errors: {
+				...options.errors,
+				...collectionOptions?.errors
+			},
+			cache: collectionOptions?.cache !== void 0 ? collectionOptions.cache : cache
+		}),
+		transaction: () => pool.transaction(),
+		withTransaction: (handle) => pool.withTransaction(handle),
+		schema: {
+			component: schemaComponent,
+			migrate: (options) => runSQLMigrations(pool, schemaComponent.migrations, options)
+		},
+		sql: {
+			async query(sql, options) {
+				return (await query(sql, options)).rows;
+			},
+			async command(sql, options) {
+				return command(sql, options);
+			}
+		}
+	};
+	const dbSchema = options?.schema?.definition;
+	if (dbSchema) return proxyPongoDbWithSchema(db, dbSchema, collections);
+	return db;
+};
+
+//#endregion
+//#region src/core/drivers/databaseDriver.ts
+const PongoDriverRegistry = () => {
+	const drivers = /* @__PURE__ */ new Map();
+	const register = (driverType, driver) => {
+		const entry = drivers.get(driverType);
+		if (entry && (typeof entry !== "function" || typeof driver === "function")) return;
+		drivers.set(driverType, driver);
+	};
+	const tryResolve = async (driverType) => {
+		const entry = drivers.get(driverType);
+		if (!entry) return null;
+		if (typeof entry !== "function") return entry;
+		const driver = await entry();
+		register(driverType, driver);
+		return driver;
+	};
+	const tryGet = (driverType) => {
+		const entry = drivers.get(driverType);
+		return entry && typeof entry !== "function" ? entry : null;
+	};
+	const has = (driverType) => drivers.has(driverType);
+	return {
+		register,
+		tryResolve,
+		tryGet,
+		has,
+		get databaseDriverTypes() {
+			return Array.from(drivers.keys());
+		}
+	};
+};
+const pongoDriverRegistry = globalThis.pongoDriverRegistry = globalThis.pongoDriverRegistry ?? PongoDriverRegistry();
+
+//#endregion
+//#region src/core/utils/deepEquals.ts
+const deepEquals = (left, right) => {
+	if (isEquatable(left)) return left.equals(right);
+	if (Array.isArray(left)) return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return left === right;
+	if (Array.isArray(right)) return false;
+	const keys1 = Object.keys(left);
+	const keys2 = Object.keys(right);
+	if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key))) return false;
+	for (const key in left) {
+		if (left[key] instanceof Function && right[key] instanceof Function) continue;
+		if (!deepEquals(left[key], right[key])) return false;
+	}
+	return true;
+};
+const isEquatable = (left) => {
+	return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+
+//#endregion
+//#region src/core/utils/mapAsync.ts
+async function mapSequential(items, fn) {
+	const results = [];
+	for (let i = 0; i < items.length; i++) results.push(await fn(items[i], i));
+	return results;
+}
+const mapParallel = (items, fn) => Promise.all(items.map(fn));
+const mapAsync = (items, fn, options = { parallel: false }) => options?.parallel ? mapParallel(items, fn) : mapSequential(items, fn);
+
+//#endregion
 //#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)})'))`;
+			const field = PostgreSQLJSON.field(SQL`data`, path);
+			return SQL`(${field} = ${JSONParam.value(value, serializer)}::jsonb OR ${field} @> ${JSONParam.arrayContaining(value, serializer)}::jsonb)`;
 		}
 		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 "$ne": return SQL`${PostgreSQLJSON.textField(SQL`data`, path)} ${SQL.plain(OperatorMap[operator])} ${value}`;
+		case "$in": return SQL`${PostgreSQLJSON.textField(SQL`data`, path)} = ANY (${value})`;
+		case "$nin": return SQL`${PostgreSQLJSON.textField(SQL`data`, path)} != 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)})')`;
+			const field = PostgreSQLJSON.field(SQL`data`, path);
+			return SQL`EXISTS (
+        SELECT 1
+        FROM jsonb_array_elements(${SQL`CASE WHEN jsonb_typeof(${field}) = 'array' THEN ${field} ELSE '[]'::jsonb END`}) AS elem(value)
+        WHERE elem.value @> ${JSONParam.value(value, serializer)}::jsonb
+      )`;
 		}
-		case "$all": return SQL`data @> ${serializer.serialize(buildNestedObject(path, value))}::jsonb`;
-		case "$size": return SQL`jsonb_array_length(data #> ${`{${path.split(".").join(",")}}`}) = ${value}`;
+		case "$all": {
+			const serializedValue = JSONParam.value(value, serializer);
+			return SQL`${PostgreSQLJSON.field(SQL`data`, path)} @> ${serializedValue}::jsonb`;
+		}
+		case "$size": return SQL`jsonb_array_length(${PostgreSQLJSON.field(SQL`data`, path)}) = ${value}`;
 		default: throw new Error(`Unsupported operator: ${operator}`);
 	}
 };
@@ -40,7 +1157,6 @@ const handleMetadataOperator = (fieldName, operator, value) => {
 		default: throw new Error(`Unsupported operator: ${operator}`);
 	}
 };
-const buildNestedObject = (path, value) => path.split(".").reverse().reduce((acc, key) => ({ [key]: acc }), value);
 
 //#endregion
 //#region src/storage/postgresql/core/sqlBuilder/filter/index.ts
@@ -103,16 +1219,20 @@ const buildUpdateQuery = (update, serializer) => objectEntries(update).reduce((c
 		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 buildSetQuery = (set, currentUpdateQuery, serializer) => SQL`${currentUpdateQuery} || ${JSONParam.value(set, serializer)}::jsonb`;
+const buildUnsetQuery = (unset, currentUpdateQuery) => {
+	let query = currentUpdateQuery;
+	for (const key of Object.keys(unset)) query = SQL`${query} - ${key}`;
+	return query;
+};
 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)`;
+	for (const [key, value] of Object.entries(inc)) currentUpdateQuery = typeof value === "bigint" ? SQL`jsonb_set(${currentUpdateQuery}, ${PostgreSQLJSON.path(key)}, to_jsonb((COALESCE((${PostgreSQLJSON.textField(SQL`data`, key)})::BIGINT, 0) + ${value})::TEXT), true)` : SQL`jsonb_set(${currentUpdateQuery}, ${PostgreSQLJSON.path(key)}, to_jsonb(COALESCE((${PostgreSQLJSON.textField(SQL`data`, key)})::NUMERIC, 0) + ${value}), true)`;
 	return currentUpdateQuery;
 };
 const buildPushQuery = (push, currentUpdateQuery, serializer) => {
 	for (const [key, value] of Object.entries(push)) {
-		const serializedValue = serializer.serialize([value]);
-		currentUpdateQuery = SQL`jsonb_set(${currentUpdateQuery}, '{${SQL.plain(key)}}', (coalesce(data->'${SQL.plain(key)}', '[]'::jsonb) || ${serializedValue}::jsonb), true)`;
+		const serializedValue = JSONParam.arrayContaining(value, serializer);
+		currentUpdateQuery = SQL`jsonb_set(${currentUpdateQuery}, ${PostgreSQLJSON.path(key)}, (coalesce(${PostgreSQLJSON.field(SQL`data`, key)}, '[]'::jsonb) || ${serializedValue}::jsonb), true)`;
 	}
 	return currentUpdateQuery;
 };
@@ -139,7 +1259,7 @@ const pongoCollectionPostgreSQLMigrations = (collectionName) => [sqlMigration(`p
 const postgresSQLBuilder = (collectionName, serializer) => ({
 	createCollection: () => createCollection(collectionName),
 	insertOne: (document) => {
-		const serialized = serializer.serialize(document);
+		const serialized = JSONParam.document(document, serializer);
 		const id = document._id;
 		const version = document._version ?? 1n;
 		return SQL`
@@ -147,7 +1267,7 @@ const postgresSQLBuilder = (collectionName, serializer) => ({
       VALUES (${id}, ${serialized}, ${version}) ON CONFLICT(_id) DO NOTHING;`;
 	},
 	insertMany: (documents) => {
-		const values = SQL.merge(documents.map((doc) => SQL`(${doc._id}, ${serializer.serialize(doc)}, ${doc._version ?? 1n})`), ",");
+		const values = SQL.merge(documents.map((doc) => SQL`(${doc._id}, ${JSONParam.document(doc, serializer)}, ${doc._version ?? 1n})`), ",");
 		return SQL`
       INSERT INTO ${SQL.identifier(collectionName)} (_id, data, _version) VALUES ${values}
       ON CONFLICT(_id) DO NOTHING
@@ -157,7 +1277,7 @@ const postgresSQLBuilder = (collectionName, serializer) => ({
 		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)`), ",")}
+      VALUES ${SQL.merge(documents.map((d) => SQL`(${d._id}::text, ${JSONParam.document(d, serializer)}::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)
@@ -205,7 +1325,7 @@ const postgresSQLBuilder = (collectionName, serializer) => ({
       updated AS (
         UPDATE ${SQL.identifier(collectionName)}        
         SET 
-          data = ${serializer.serialize(document)} || jsonb_build_object('_id', ${SQL.identifier(collectionName)}._id) || jsonb_build_object('_version', (_version + 1)::text),
+          data = ${JSONParam.document(document, serializer)} || jsonb_build_object('_id', ${SQL.identifier(collectionName)}._id) || jsonb_build_object('_version', (_version + 1)::text),
           _version = _version + 1
         FROM existing 
         WHERE ${SQL.identifier(collectionName)}._id = existing._id ${expectedVersionUpdate}
@@ -262,7 +1382,7 @@ const postgresSQLBuilder = (collectionName, serializer) => ({
         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)`;
+			return expectedVersion !== void 0 ? SQL`(${d._id}::text, ${JSONParam.document(d, serializer)}::jsonb, ${expectedVersion}::bigint)` : SQL`(${d._id}::text, ${JSONParam.document(d, serializer)}::jsonb, NULL::bigint)`;
 		}), ",")}
         )
         UPDATE ${SQL.identifier(collectionName)} t
@@ -276,7 +1396,7 @@ const postgresSQLBuilder = (collectionName, serializer) => ({
         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)`), ",")}
+        VALUES ${SQL.merge(documents.map((d) => SQL`(${d._id}::text, ${JSONParam.document(d, serializer)}::jsonb)`), ",")}
       )
       UPDATE ${SQL.identifier(collectionName)} t
       SET
@@ -329,9 +1449,7 @@ const postgresSQLBuilder = (collectionName, serializer) => ({
 		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)}'`;
+				const accessor = field === "_id" || field === "_version" ? SQL`${SQL.plain(field)}` : PostgreSQLJSON.field(SQL`data`, field);
 				return dir === 1 ? SQL`${accessor} ASC NULLS FIRST` : SQL`${accessor} DESC NULLS LAST`;
 			});
 			query.push(SQL`ORDER BY ${SQL.merge(clauses, ",")}`);