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

package/dist/cli.js

@@ -1,12 +1,569 @@
 #!/usr/bin/env node
-import { _ as toDbSchemaMetadata, j as objectEntries, o as pongoClient, p as pongoSchema, u as pongoDriverRegistry } from "./core-BHdOCUrr.js";
-import { JSONSerializer, LogLevel, LogStyle, SQL, color, combineMigrations, dumbo, parseConnectionString, prettyJson, runSQLMigrations } from "@event-driven-io/dumbo";
 import { Command } from "commander";
 import fs from "node:fs";
+import { LRUCache } from "lru-cache";
+import { JSONSerializer, LogLevel, LogStyle, SQL, color, combineMigrations, dumbo, getDatabaseMetadata, parseConnectionString, prettyJson, runSQLMigrations } from "@event-driven-io/dumbo";
+import "uuid";
 import { checkConnection } from "@event-driven-io/dumbo/pg";
 import Table from "cli-table3";
 import repl from "node:repl";
 
+//#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/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/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];
+	} });
+};
+const toDbSchemaMetadata = (schema) => ({
+	name: schema.name,
+	collections: objectEntries(schema.collections).map((c) => ({ name: c[1].name }))
+});
+
+//#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/commandLine/configFile.ts
 const formatTypeName = (input) => {
 	if (input.length === 0) return input;
@@ -197,7 +754,7 @@ const prettifyLogs = (logLevel) => {
 const startRepl = async (options) => {
 	setLogLevel(process.env.DUMBO_LOG_LEVEL ?? options.logging.logLevel);
 	setLogStyle(process.env.DUMBO_LOG_STYLE ?? options.logging.logStyle);
-	console.log(color.green("Starting Pongo Shell (version: 0.17.0-beta.41)"));
+	console.log(color.green("Starting Pongo Shell (version: 0.17.0-beta.43)"));
 	if (options.logging.printOptions) {
 		console.log(color.green("With Options:"));
 		console.log(prettyJson(options));