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

package/dist/sqlite3.js

@@ -1,8 +1,1460 @@
-import { L as PongoCollectionSchemaComponent, d as PongoDatabase, f as PongoDatabaseSchemaComponent, p as pongoSchema, u as pongoDriverRegistry } from "./core-BHdOCUrr.js";
-import { n as sqliteSQLBuilder, t as pongoCollectionSQLiteMigrations } from "./core-CH0SOCr3.js";
-import { JSONSerializer, dumbo } from "@event-driven-io/dumbo";
+import { JSONParam, JSONSerializer, SQL, dumbo, isSQL, mapColumnToBigint, mapColumnToJSON, runSQLMigrations, schemaComponent, single, sqlMigration } from "@event-driven-io/dumbo";
+import { SQLiteJSON } from "@event-driven-io/dumbo/sqlite";
+import { LRUCache } from "lru-cache";
+import { v7 } from "uuid";
 import { SQLite3DriverType, sqlite3DumboDriver } from "@event-driven-io/dumbo/sqlite3";
 
+//#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/sqlite/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 jsonPath = SQLiteJSON.path(path);
+			return SQL`(
+        json_extract(data, ${jsonPath}) = ${value}
+        OR (
+          json_type(data, ${jsonPath}) = 'array'
+          AND EXISTS(
+            SELECT 1 FROM json_each(data, ${jsonPath})
+            WHERE json_each.value = ${value}
+          )
+        )
+      )`;
+		}
+		case "$gt":
+		case "$gte":
+		case "$lt":
+		case "$lte":
+		case "$ne": return SQL`json_extract(data, ${SQLiteJSON.path(path)}) ${SQL.plain(OperatorMap[operator])} ${value}`;
+		case "$in": {
+			const jsonPath = SQLiteJSON.path(path);
+			const values = value;
+			return SQL`json_extract(data, ${jsonPath}) IN (${SQL.merge(values.map((v) => SQL`${v}`), ", ")})`;
+		}
+		case "$nin": {
+			const jsonPath = SQLiteJSON.path(path);
+			const values = value;
+			return SQL`json_extract(data, ${jsonPath}) NOT IN (${SQL.merge(values.map((v) => SQL`${v}`), ", ")})`;
+		}
+		case "$elemMatch": {
+			const subConditions = objectEntries(value).map(([subKey, subValue]) => SQL`json_extract(value, ${SQLiteJSON.path(subKey)}) = json(${JSONParam.value(subValue, serializer)})`);
+			return SQL`EXISTS(SELECT 1 FROM json_each(data, ${SQLiteJSON.path(path)}) WHERE ${SQL.merge(subConditions, " AND ")})`;
+		}
+		case "$all": {
+			const jsonPath = SQLiteJSON.path(path);
+			return SQL`(SELECT COUNT(*) FROM json_each(json(${JSONParam.value(value, serializer)})) WHERE json_each.value NOT IN (SELECT value FROM json_each(data, ${jsonPath}))) = 0`;
+		}
+		case "$size": return SQL`json_array_length(json_extract(data, ${SQLiteJSON.path(path)})) = ${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": {
+			const values = value;
+			const inClause = SQL.merge(values.map((v) => SQL`${v}`), ", ");
+			return SQL`${SQL.plain(fieldName)} IN (${inClause})`;
+		}
+		case "$nin": {
+			const values = value;
+			const inClause = SQL.merge(values.map((v) => SQL`${v}`), ", ");
+			return SQL`${SQL.plain(fieldName)} NOT IN (${inClause})`;
+		}
+		default: throw new Error(`Unsupported operator: ${operator}`);
+	}
+};
+
+//#endregion
+//#region src/storage/sqlite/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} `)})`;
+};
+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);
+
+//#endregion
+//#region src/storage/sqlite/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`json_patch(${currentUpdateQuery}, ${JSONParam.value(set, serializer)})`;
+const buildUnsetQuery = (unset, currentUpdateQuery) => {
+	const keys = Object.keys(unset);
+	let query = currentUpdateQuery;
+	for (const key of keys) query = SQL`json_remove(${query}, ${SQLiteJSON.path(key)})`;
+	return query;
+};
+const buildIncQuery = (inc, currentUpdateQuery) => {
+	for (const [key, value] of Object.entries(inc)) currentUpdateQuery = typeof value === "bigint" ? SQL`json_set(${currentUpdateQuery}, ${SQLiteJSON.path(key)}, CAST((COALESCE(json_extract(${currentUpdateQuery}, ${SQLiteJSON.path(key)}), 0) + ${value}) AS TEXT))` : SQL`json_set(${currentUpdateQuery}, ${SQLiteJSON.path(key)}, COALESCE(json_extract(${currentUpdateQuery}, ${SQLiteJSON.path(key)}), 0) + ${value})`;
+	return currentUpdateQuery;
+};
+const buildPushQuery = (push, currentUpdateQuery, serializer) => {
+	for (const [key, value] of Object.entries(push)) {
+		const serializedValue = JSONParam.value(value, serializer);
+		currentUpdateQuery = SQL`json_set(${currentUpdateQuery}, ${SQLiteJSON.path(key)}, CASE
+      WHEN json_type(json_extract(${currentUpdateQuery}, ${SQLiteJSON.path(key)})) = 'array'
+      THEN json_insert(json_extract(${currentUpdateQuery}, ${SQLiteJSON.path(key)}), '$[#]', json(${serializedValue}))
+      ELSE json(${JSONParam.arrayContaining(value, serializer)})
+    END)`;
+	}
+	return currentUpdateQuery;
+};
+
+//#endregion
+//#region src/storage/sqlite/core/sqlBuilder/index.ts
+const versionCheckClause = (expectedVersion) => {
+	const predicate = expectedVersionPredicate(expectedVersion);
+	return predicate.operator === "none" ? SQL.EMPTY : SQL`AND _version = ${predicate.value}`;
+};
+const createCollection = (collectionName) => SQL`
+    CREATE TABLE IF NOT EXISTS ${SQL.identifier(collectionName)} (
+      _id           TEXT           PRIMARY KEY,
+      data          JSON           NOT NULL,
+      metadata      JSON           NOT NULL     DEFAULT '{}',
+      _version      INTEGER        NOT NULL     DEFAULT 1,
+      _partition    TEXT           NOT NULL     DEFAULT 'png_global',
+      _archived     INTEGER        NOT NULL     DEFAULT 0,
+      _created      TEXT           NOT NULL     DEFAULT (datetime('now')),
+      _updated      TEXT           NOT NULL     DEFAULT (datetime('now'))
+  )`;
+const pongoCollectionSQLiteMigrations = (collectionName) => [sqlMigration(`pongoCollection:${collectionName}:001:createtable`, [createCollection(collectionName)])];
+const sqliteSQLBuilder = (collectionName, serializer) => ({
+	createCollection: () => createCollection(collectionName),
+	insertOne: (document) => {
+		const serialized = JSONParam.document(document, serializer);
+		const id = document._id;
+		const version = document._version ?? 1n;
+		return SQL`
+      INSERT OR IGNORE INTO ${SQL.identifier(collectionName)} (_id, data, _version)
+      VALUES (${id}, ${serialized}, ${version})
+      RETURNING _id;`;
+	},
+	insertMany: (documents) => {
+		const values = SQL.merge(documents.map((doc) => SQL`(${doc._id}, ${JSONParam.document(doc, serializer)}, ${doc._version ?? 1n})`), ",");
+		return SQL`
+      INSERT OR IGNORE INTO ${SQL.identifier(collectionName)} (_id, data, _version) VALUES ${values}
+      RETURNING _id;`;
+	},
+	insertOrReplace: (documents) => {
+		const col = SQL.identifier(collectionName);
+		return SQL`
+      INSERT INTO ${col} (_id, data, _version)
+      VALUES ${SQL.merge(documents.map((d) => SQL`(${d._id}, json_patch(${JSONParam.document(d, serializer)}, json_object('_id', ${d._id}, '_version', '1')), 1)`), ",")}
+      ON CONFLICT(_id) DO UPDATE SET
+        data = json_patch(excluded.data, json_object('_id', ${col}._id, '_version', cast(${col}._version + 1 as TEXT))),
+        _version = ${col}._version + 1
+      RETURNING _id, cast(_version as TEXT) as version;`;
+	},
+	updateOne: (filter, update, options) => {
+		const expectedVersionCheck = versionCheckClause(options?.expectedVersion);
+		const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
+		const updateQuery = isSQL(update) ? update : buildUpdateQuery(update, serializer);
+		return SQL`
+      UPDATE ${SQL.identifier(collectionName)}
+      SET
+        data = json_patch(${updateQuery}, json_object('_id', _id, '_version', cast(_version + 1 as TEXT))),
+        _version = _version + 1,
+        _updated = datetime('now')
+      WHERE _id = (
+        SELECT _id FROM ${SQL.identifier(collectionName)}
+        ${where(filterQuery)}
+        LIMIT 1
+      ) ${expectedVersionCheck}
+      RETURNING
+        _id,
+        cast(_version as TEXT) as version,
+        1 as matched,
+        1 as modified;`;
+	},
+	replaceOne: (filter, document, options) => {
+		const expectedVersionCheck = versionCheckClause(options?.expectedVersion);
+		const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
+		return SQL`
+      UPDATE ${SQL.identifier(collectionName)}
+      SET
+        data = json_patch(${JSONParam.document(document, serializer)}, json_object('_id', _id, '_version', cast(_version + 1 as TEXT))),
+        _version = _version + 1,
+        _updated = datetime('now')
+      WHERE _id = (
+        SELECT _id FROM ${SQL.identifier(collectionName)}
+        ${where(filterQuery)}
+        LIMIT 1
+      ) ${expectedVersionCheck}
+      RETURNING
+        _id,
+        cast(_version as TEXT) AS version,
+        1 AS matched,
+        1 AS modified;`;
+	},
+	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 = json_patch(${updateQuery}, json_object('_version', cast(_version + 1 as TEXT))),
+        _version = _version + 1,
+        _updated = datetime('now')
+      ${where(filterQuery)}
+      RETURNING _id;`;
+	},
+	deleteOne: (filter, options) => {
+		const expectedVersionCheck = versionCheckClause(options?.expectedVersion);
+		const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
+		return SQL`
+      DELETE FROM ${SQL.identifier(collectionName)}
+      WHERE _id = (
+        SELECT _id FROM ${SQL.identifier(collectionName)}
+        ${where(filterQuery)}
+        LIMIT 1
+      ) ${expectedVersionCheck}
+      RETURNING
+        _id,
+        1 AS matched,
+        1 AS deleted;`;
+	},
+	deleteMany: (filter) => {
+		const filterQuery = isSQL(filter) ? filter : constructFilterQuery(filter, serializer);
+		return SQL`DELETE FROM ${SQL.identifier(collectionName)} ${where(filterQuery)} RETURNING _id`;
+	},
+	replaceMany: (documents) => {
+		const col = SQL.identifier(collectionName);
+		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}, ${JSONParam.document(d, serializer)}, ${expectedVersion})` : SQL`(${d._id}, ${JSONParam.document(d, serializer)}, NULL)`;
+		}), ",")}
+        )
+        UPDATE ${col}
+        SET
+          data = json_patch(r.data, json_object('_id', ${col}._id, '_version', cast(${col}._version + 1 as TEXT))),
+          _version = ${col}._version + 1,
+          _updated = datetime('now')
+        FROM replacements r
+        WHERE ${col}._id = r._id AND (r.expected_version IS NULL OR ${col}._version = r.expected_version)
+        RETURNING ${col}._id, cast(${col}._version as TEXT) as version;`;
+		return SQL`
+      WITH replacements(_id, data) AS (
+        VALUES ${SQL.merge(documents.map((d) => SQL`(${d._id}, ${JSONParam.document(d, serializer)})`), ",")}
+      )
+      UPDATE ${col}
+      SET
+        data = json_patch(r.data, json_object('_id', ${col}._id, '_version', cast(${col}._version + 1 as TEXT))),
+        _version = ${col}._version + 1,
+        _updated = datetime('now')
+      FROM replacements r
+      WHERE ${col}._id = r._id
+      RETURNING ${col}._id, cast(${col}._version as TEXT) 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}, ${d._version ?? 0n})`), ",")}
+        )
+        DELETE FROM ${SQL.identifier(collectionName)}
+        WHERE _id IN (SELECT _id FROM targets)
+          AND _version = (SELECT expected_version FROM targets WHERE targets._id = ${SQL.identifier(collectionName)}._id)
+        RETURNING _id;`;
+		const idList = SQL.merge(ids.map((d) => SQL`${d._id}`), ",");
+		return SQL`
+      DELETE FROM ${SQL.identifier(collectionName)}
+      WHERE _id IN (${idList})
+      RETURNING _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 accessor = field === "_id" || field === "_version" ? SQL`${SQL.identifier(field)}` : SQL`json_extract(data, ${SQLiteJSON.path(field)})`;
+				return dir === 1 ? SQL`${accessor} ASC` : SQL`${accessor} DESC`;
+			});
+			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)}`
+});
+const where = (filterQuery) => SQL.check.isEmpty(filterQuery) ? SQL.EMPTY : SQL.merge([SQL`WHERE `, filterQuery]);
+
+//#endregion
 //#region src/storage/sqlite/sqlite3/index.ts
 const sqlite3PongoDriver = {
 	driverType: SQLite3DriverType,