@event-driven-io/pongo 0.17.0-beta.42 → 0.17.0-beta.44

package/dist/shim.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_core = require('./core-C9SB3XMx.cjs');
-const require_cli = require('./cli.cjs');
 let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
+let lru_cache = require("lru-cache");
+require("uuid");
 
 //#region src/mongo/findCursor.ts
 var FindCursor = class {
@@ -33,6 +33,554 @@ var FindCursor = class {
 	}
 };
 
+//#endregion
+//#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 lru_cache.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/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 = (0, _event_driven_io_dumbo.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/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 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];
+	} });
+};
+
+//#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$1 = 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 = _event_driven_io_dumbo.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/mongo/mongoCollection.ts
 const toCollectionOperationOptions = (options) => options?.session ? { session: options.session } : void 0;
@@ -260,13 +808,13 @@ var MongoClient = class {
 	pongoClient;
 	constructor(connectionStringOrOptions, options) {
 		if (typeof connectionStringOrOptions !== "string") {
-			this.pongoClient = require_core.pongoClient(connectionStringOrOptions);
+			this.pongoClient = pongoClient(connectionStringOrOptions);
 			return;
 		}
 		const { databaseType, driverName } = (0, _event_driven_io_dumbo.parseConnectionString)(connectionStringOrOptions);
 		const driver = options?.driver ?? pongoDriverRegistry.tryGet((0, _event_driven_io_dumbo.toDatabaseDriverType)(databaseType, driverName));
 		if (driver === null) throw new Error(`No database driver registered for ${databaseType} with name ${driverName}`);
-		this.pongoClient = require_core.pongoClient({
+		this.pongoClient = pongoClient({
 			...options ?? {},
 			connectionString: connectionStringOrOptions,
 			driver
@@ -283,11 +831,11 @@ var MongoClient = class {
 		return new Db(this.pongoClient.db(dbName));
 	}
 	startSession(_options) {
-		return require_core.pongoSession();
+		return pongoSession();
 	}
 	async withSession(optionsOrExecutor, executor) {
 		const callback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor;
-		const session = require_core.pongoSession();
+		const session = pongoSession();
 		try {
 			return await callback(session);
 		} finally {