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

package/dist/cli.cjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -27,17 +26,574 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_core = require('./core-C9SB3XMx.cjs');
-let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
 let commander = require("commander");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs, 1);
+let lru_cache = require("lru-cache");
+let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
+require("uuid");
 let _event_driven_io_dumbo_pg = require("@event-driven-io/dumbo/pg");
 let cli_table3 = require("cli-table3");
 cli_table3 = __toESM(cli_table3, 1);
 let node_repl = require("node:repl");
 node_repl = __toESM(node_repl, 1);
 
+//#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/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 = _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/commandLine/configFile.ts
 const formatTypeName = (input) => {
 	if (input.length === 0) return input;
@@ -91,11 +647,11 @@ const parseDefaultDbSchema = (imported) => {
 	if (!imported.default) return missingDefaultExport;
 	if (!imported.default.schema) return missingSchema;
 	if (!imported.default.schema.dbs) return missingDbs;
-	const defaultDb = require_core.objectEntries(imported.default.schema.dbs).map((db) => db[1]).find((db) => db.name === void 0);
+	const defaultDb = objectEntries(imported.default.schema.dbs).map((db) => db[1]).find((db) => db.name === void 0);
 	if (!defaultDb) return missingDefaultDb;
 	if (!defaultDb.collections) return missingCollections;
-	if (require_core.objectEntries(defaultDb.collections).map((col) => col[1]).length === 0) return missingCollections;
-	return require_core.toDbSchemaMetadata(defaultDb);
+	if (objectEntries(defaultDb.collections).map((col) => col[1]).length === 0) return missingCollections;
+	return toDbSchemaMetadata(defaultDb);
 };
 const configCommand = new commander.Command("config").description("Manage Pongo configuration");
 configCommand.command("sample").description("Generate or print sample configuration").option("--col, --collection <name>", "Specify the collection name", (value, previous) => {
@@ -172,13 +728,13 @@ migrateCommand.command("sql").description("Generate SQL for database migration")
 	console.log((0, _event_driven_io_dumbo.combineMigrations)(...migrations));
 });
 const getMigrations = ({ driverType, connectionString, databaseName, collectionNames }) => {
-	const driver = require_core.pongoDriverRegistry.tryGet(driverType);
+	const driver = pongoDriverRegistry.tryGet(driverType);
 	if (driver === null) {
 		console.error(`Error: No database driver found for driver type "${driverType}". Make sure the driver is registered and the connection string is correct.`);
 		process.exit(1);
 	}
 	const driverOptions = {
-		schema: { definition: require_core.pongoSchema.db.from(databaseName, collectionNames) },
+		schema: { definition: pongoSchema.db.from(databaseName, collectionNames) },
 		serializer: _event_driven_io_dumbo.JSONSerializer
 	};
 	const customOptions = {
@@ -228,7 +784,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(_event_driven_io_dumbo.color.green("Starting Pongo Shell (version: 0.17.0-beta.42)"));
+	console.log(_event_driven_io_dumbo.color.green("Starting Pongo Shell (version: 0.17.0-beta.44)"));
 	if (options.logging.printOptions) {
 		console.log(_event_driven_io_dumbo.color.green("With Options:"));
 		console.log((0, _event_driven_io_dumbo.prettyJson)(options));
@@ -237,7 +793,7 @@ const startRepl = async (options) => {
 	if (!(options.connectionString ?? process.env.DB_CONNECTION_STRING)) console.log(_event_driven_io_dumbo.color.yellow(`No connection string provided, using: 'postgresql://postgres:postgres@localhost:5432/postgres'`));
 	const { databaseType } = (0, _event_driven_io_dumbo.parseConnectionString)(connectionString);
 	const driverType = `${databaseType}:${options.databaseDriver}`;
-	const driver = require_core.pongoDriverRegistry.tryGet(driverType);
+	const driver = pongoDriverRegistry.tryGet(driverType);
 	if (driver === null) {
 		console.error(`Error: No database driver found for driver type "${driverType}". Make sure the driver is installed and the connection string is correct.`);
 		process.exit(1);
@@ -261,16 +817,16 @@ const startRepl = async (options) => {
 	let db;
 	if (options.schema.collections.length > 0) {
 		const collectionsSchema = {};
-		for (const collectionName of options.schema.collections) collectionsSchema[collectionName] = require_core.pongoSchema.collection(collectionName);
+		for (const collectionName of options.schema.collections) collectionsSchema[collectionName] = pongoSchema.collection(collectionName);
 		const driverOptions = {
 			driver,
 			schema: {
-				definition: require_core.pongoSchema.client({ database: require_core.pongoSchema.db(options.schema.database, collectionsSchema) }),
+				definition: pongoSchema.client({ database: pongoSchema.db(options.schema.database, collectionsSchema) }),
 				autoMigration: options.schema.autoMigration
 			}
 		};
 		const customOptions = { connectionString };
-		const typedClient = require_core.pongoClient({
+		const typedClient = pongoClient({
 			...driverOptions,
 			...customOptions
 		});
@@ -283,7 +839,7 @@ const startRepl = async (options) => {
 			schema: { autoMigration: options.schema.autoMigration }
 		};
 		const customOptions = { connectionString };
-		pongo = require_core.pongoClient({
+		pongo = pongoClient({
 			...driverOptions,
 			...customOptions
 		});
@@ -344,6 +900,5 @@ program.addCommand(shellCommand);
 program.parse(process.argv);
 
 //#endregion
-exports.__toESM = __toESM;
-exports.default = program;
+module.exports = program;
 //# sourceMappingURL=cli.cjs.map