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

package/dist/core-D_iZiiYe.js

@@ -0,0 +1,1308 @@
+import { LRUCache } from "lru-cache";
+import { JSONSerializer, getDatabaseMetadata, mapColumnToBigint, mapColumnToJSON, runSQLMigrations, schemaComponent, single } from "@event-driven-io/dumbo";
+import { v7 } from "uuid";
+
+//#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/cache/transactions/pongoTransactionCache.ts
+const pongoTransactionCache = (options) => {
+	const innerCache = options?.cache ?? identityMapCache();
+	const operations = [];
+	return {
+		type: "pongo:cache:transaction-buffer",
+		get(key) {
+			return innerCache.get(key);
+		},
+		set(key, value, options) {
+			const { mainCache } = options;
+			innerCache.set(key, value);
+			operations.push({
+				type: "set",
+				key,
+				value,
+				mainCache
+			});
+		},
+		update(key, updater, options) {
+			const { mainCache } = options;
+			innerCache.update(key, updater);
+			operations.push({
+				type: "update",
+				key,
+				updater,
+				mainCache
+			});
+		},
+		delete(key, options) {
+			innerCache.delete(key);
+			operations.push({
+				type: "delete",
+				key,
+				mainCache: options.mainCache
+			});
+		},
+		getMany(keys) {
+			return innerCache.getMany(keys);
+		},
+		setMany(entries, options) {
+			innerCache.setMany(entries);
+			operations.push({
+				type: "setMany",
+				entries,
+				mainCache: options.mainCache
+			});
+		},
+		updateMany(keys, updater, options) {
+			const { mainCache } = options;
+			innerCache.updateMany(keys, updater);
+			operations.push({
+				type: "updateMany",
+				keys,
+				updater,
+				mainCache
+			});
+		},
+		deleteMany(keys, options) {
+			innerCache.deleteMany(keys);
+			operations.push({
+				type: "deleteMany",
+				keys,
+				mainCache: options.mainCache
+			});
+		},
+		clear() {
+			innerCache.clear();
+			operations.length = 0;
+		},
+		async commit() {
+			for (const op of operations) switch (op.type) {
+				case "set":
+					await op.mainCache.set(op.key, op.value);
+					break;
+				case "setMany":
+					await op.mainCache.setMany(op.entries);
+					break;
+				case "update":
+					await op.mainCache.update(op.key, op.updater);
+					break;
+				case "updateMany":
+					await op.mainCache.updateMany(op.keys, op.updater);
+					break;
+				case "delete":
+					await op.mainCache.delete(op.key);
+					break;
+				case "deleteMany":
+					await op.mainCache.deleteMany(op.keys);
+					break;
+			}
+			innerCache.clear();
+			operations.length = 0;
+		}
+	};
+};
+
+//#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 ? filter : 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, handler, options) => {
+		const results = (await handleDocuments(deps.storage, normalizeInput(input), handler, options)).map(({ change, result: outcome }) => toHandleResult(deps, change, outcome));
+		return Array.isArray(input) ? results : results[0];
+	};
+	return fn;
+}
+async function handleDocuments(storage, inputs, handler, 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
+	}, handler), { parallel }), operationOptions);
+}
+async function handleDocument(item, handler) {
+	const { _id: id, existing, expectedVersion } = item;
+	if (hasVersionMismatch(existing, expectedVersion)) return {
+		type: "noop",
+		existing,
+		versionMismatch: true
+	};
+	return toDocumentChange(id, existing, await handler(existing ? { ...existing } : null, id));
+}
+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 rowToDoc = (row) => upcast({
+		...row.data,
+		_version: row._version
+	});
+	const findOneFromDb = async (filter, options) => {
+		const row = (await query(SqlFor.findOne(filter), options)).rows[0];
+		return row ? rowToDoc(row) : 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(rowToDoc);
+			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 !== null ? upcast({ ...cached }) : null;
+			return dbDocsById.get(id) ?? null;
+		});
+	};
+	const findManyByIds = async (ids, options) => {
+		return (await fetchByIds(ids, options)).filter((doc) => doc !== null);
+	};
+	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 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 downcasted = downcast(document);
+			const successful = ((await command(SqlFor.insertOne({
+				...downcasted,
+				_id,
+				_version
+			}), options)).rowCount ?? 0) > 0;
+			if (successful && !options?.skipCache) await cacheSet({
+				...document,
+				_id,
+				_version
+			}, options);
+			return operationResult({
+				successful,
+				insertedId: successful ? _id : null,
+				nextExpectedVersion: _version
+			}, {
+				operationName: "insertOne",
+				collectionName,
+				serializer,
+				errors
+			});
+		},
+		insertMany: async (documents, options) => {
+			await ensureCollectionCreated(options);
+			const documentsWithMetadata = documents.map((doc) => doc._id && doc._version ? doc : {
+				...doc,
+				_id: doc._id ?? v7(),
+				_version: doc._version ?? 1n
+			});
+			const rows = documentsWithMetadata.map((d) => ({
+				...downcast(d),
+				_id: d._id,
+				_version: d._version
+			}));
+			const result = await command(SqlFor.insertMany(rows), options);
+			if (!options?.skipCache) {
+				const insertedIdSet = new Set(result.rows.map((d) => d._id));
+				await cacheSetMany(documentsWithMetadata.filter((d) => insertedIdSet.has(d._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),
+				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 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),
+				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({
+					...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 ? upcast({ ...cached }) : null;
+				const doc = await findOneFromDb(filter, options);
+				if (doc) await cacheSet(doc, options);
+				else await cacheDelete(id, options);
+				return doc;
+			}
+			return findOneFromDb(filter ?? {}, options);
+		},
+		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 downcasted = documents.map((d) => downcast(d));
+			const result = await command(SqlFor.replaceMany(downcasted), 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 = documents.filter((d) => modifiedIds.includes(d._id)).map((doc) => doc._version ? doc : {
+					...doc,
+					_version: versions.get(doc._id) ?? 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,
+				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(rowToDoc);
+		},
+		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/database/pongoDatabaseCache.ts
+const PongoDatabaseCache = ({ driver, typedSchema }) => {
+	const dbClients = /* @__PURE__ */ new Map();
+	const getDatabaseDefinition = (dbName) => Object.values(typedSchema?.dbs ?? {}).find((d) => d.name === dbName);
+	return {
+		getOrCreate: (createOptions) => {
+			const metadata = getDatabaseMetadata(driver.driverType);
+			const dbName = createOptions.databaseName ?? metadata?.parseDatabaseName?.("connectionString" in createOptions ? createOptions.connectionString : void 0) ?? "db:default";
+			const existing = dbClients.get(dbName);
+			if (existing) return existing;
+			const definition = getDatabaseDefinition(createOptions.databaseName);
+			const newDb = driver.databaseFactory({
+				...createOptions,
+				databaseName: dbName,
+				schema: {
+					...createOptions.schema,
+					...definition ? { definition } : {}
+				}
+			});
+			dbClients.set(dbName, newDb);
+			return newDb;
+		},
+		all: () => Array.from(dbClients.values()),
+		forAll: (func) => {
+			return Promise.all(Array.from(dbClients.values()).map((v) => v).map(func));
+		}
+	};
+};
+
+//#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 ObjectId = (value) => value ?? v7();
+const DOCUMENT_EXISTS = "DOCUMENT_EXISTS";
+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 expectedVersion = (version) => {
+	return version ? BigInt(version) : NO_CONCURRENCY_CHECK;
+};
+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];
+	} });
+};
+const proxyClientWithSchema = (client, schema) => {
+	if (!schema) return client;
+	const dbNames = Object.keys(schema.dbs);
+	return new Proxy(client, { get(target, prop) {
+		if (dbNames.includes(prop)) return client.db(schema.dbs[prop]?.name);
+		return target[prop];
+	} });
+};
+const toDbSchemaMetadata = (schema) => ({
+	name: schema.name,
+	collections: objectEntries(schema.collections).map((c) => ({ name: c[1].name }))
+});
+const toClientSchemaMetadata = (schema) => {
+	const databases = objectEntries(schema.dbs).map((e) => toDbSchemaMetadata(e[1]));
+	return {
+		databases,
+		database: (name) => databases.find((db) => db.name === name)
+	};
+};
+
+//#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/pongoTransaction.ts
+const pongoTransaction = (options) => {
+	let isCommitted = false;
+	let isRolledBack = false;
+	let databaseName = null;
+	let transaction = null;
+	const cache = pongoTransactionCache();
+	return {
+		cache,
+		enlistDatabase: async (db) => {
+			if (transaction && databaseName !== db.databaseName) throw new Error("There's already other database assigned to transaction");
+			if (transaction && databaseName === db.databaseName) return transaction;
+			databaseName = db.databaseName;
+			transaction = db.transaction();
+			await transaction.begin();
+			return transaction;
+		},
+		commit: async () => {
+			if (isCommitted) return;
+			if (isRolledBack) throw new Error("Transaction is not active!");
+			isCommitted = true;
+			if (transaction) {
+				await transaction.commit();
+				transaction = null;
+			}
+			await cache.commit();
+		},
+		rollback: async (error) => {
+			if (isCommitted) throw new Error("Cannot rollback commited transaction!");
+			if (isRolledBack) return;
+			isRolledBack = true;
+			if (transaction) {
+				await transaction.rollback(error);
+				transaction = null;
+			}
+			cache.clear();
+		},
+		databaseName,
+		isStarting: false,
+		isCommitted,
+		get isActive() {
+			return !isCommitted && !isRolledBack;
+		},
+		get sqlExecutor() {
+			if (transaction === null) throw new Error("No database transaction was started");
+			return transaction.execute;
+		},
+		options
+	};
+};
+
+//#endregion
+//#region src/core/pongoSession.ts
+const isActive = (transaction) => transaction?.isActive === true;
+function assertInActiveTransaction(transaction) {
+	if (!isActive(transaction)) throw new Error("No active transaction exists!");
+}
+function assertNotInActiveTransaction(transaction) {
+	if (isActive(transaction)) throw new Error("Active transaction already exists!");
+}
+const pongoSession = (options) => {
+	const explicit = options?.explicit === true;
+	const defaultTransactionOptions = options?.defaultTransactionOptions ?? { get snapshotEnabled() {
+		return false;
+	} };
+	let transaction = null;
+	let hasEnded = false;
+	const startTransaction = (options) => {
+		assertNotInActiveTransaction(transaction);
+		transaction = pongoTransaction(options ?? defaultTransactionOptions);
+	};
+	const commitTransaction = async () => {
+		assertInActiveTransaction(transaction);
+		await transaction.commit();
+	};
+	const abortTransaction = async () => {
+		assertInActiveTransaction(transaction);
+		await transaction.rollback();
+	};
+	const endSession = async () => {
+		if (hasEnded) return;
+		hasEnded = true;
+		if (isActive(transaction)) await transaction.rollback();
+	};
+	const session = {
+		get hasEnded() {
+			return hasEnded;
+		},
+		explicit,
+		defaultTransactionOptions: defaultTransactionOptions ?? { get snapshotEnabled() {
+			return false;
+		} },
+		get transaction() {
+			return transaction;
+		},
+		get snapshotEnabled() {
+			return defaultTransactionOptions.snapshotEnabled;
+		},
+		endSession,
+		incrementTransactionNumber: () => {},
+		inTransaction: () => isActive(transaction),
+		startTransaction,
+		commitTransaction,
+		abortTransaction,
+		withTransaction: async (fn, options) => {
+			startTransaction(options);
+			try {
+				const result = await fn(session);
+				await commitTransaction();
+				return result;
+			} catch (error) {
+				await abortTransaction();
+				throw error;
+			}
+		}
+	};
+	return session;
+};
+
+//#endregion
+//#region src/core/pongoClient.ts
+const pongoClient = (options) => {
+	const { driver, schema, errors, cache: cacheOptions, serialization, ...connectionOptions } = options;
+	const dbClients = PongoDatabaseCache({
+		driver,
+		typedSchema: schema?.definition
+	});
+	const serializer = JSONSerializer.from(options);
+	const cache = cacheOptions === "disabled" || cacheOptions === void 0 ? "disabled" : pongoCache(cacheOptions);
+	const pongoClient = {
+		driverType: driver.driverType,
+		connect: async () => {
+			await dbClients.forAll((db) => db.connect());
+			return pongoClient;
+		},
+		close: async () => {
+			await dbClients.forAll((db) => db.close());
+		},
+		db: (dbName, options) => {
+			return dbClients.getOrCreate({
+				...connectionOptions,
+				databaseName: dbName,
+				serializer,
+				errors,
+				cache: options?.cache ?? cache,
+				serialization
+			});
+		},
+		startSession: pongoSession,
+		withSession: async (callback) => {
+			const session = pongoSession();
+			try {
+				return await callback(session);
+			} finally {
+				await session.endSession();
+			}
+		}
+	};
+	return proxyClientWithSchema(pongoClient, schema?.definition);
+};
+
+//#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
+export { objectEntries as A, getIdsFromIdOnlyFilter as B, expectedVersionValue as C, PongoError as D, ConcurrencyError as E, isOperator as F, lruCache as G, pongoTransactionCache as H, PongoCollectionSchemaComponent as I, identityMapCache as K, pongoCollection as L, OperatorMap as M, QueryOperators as N, isNumber as O, hasOperators as P, transactionExecutorOrDefault as R, expectedVersion as S, operationResult as T, pongoCache as U, idFromFilter as V, noopCacheProvider as W, toDbSchemaMetadata as _, isEquatable as a, NO_CONCURRENCY_CHECK as b, pongoTransaction as c, PongoDatabase as d, PongoDatabaseSchemaComponent as f, toClientSchemaMetadata as g, proxyPongoDbWithSchema as h, deepEquals as i, PongoDatabaseCache as j, isString as k, PongoDriverRegistry as l, proxyClientWithSchema as m, mapParallel as n, pongoClient as o, pongoSchema as p, pongoCacheWrapper as q, mapSequential as r, pongoSession as s, mapAsync as t, pongoDriverRegistry as u, DOCUMENT_DOES_NOT_EXIST as v, isGeneralExpectedDocumentVersion as w, ObjectId as x, DOCUMENT_EXISTS as y, DocumentCommandHandler as z };
+//# sourceMappingURL=core-D_iZiiYe.js.map