@llmops/core 0.1.3 → 0.1.5-beta.1

package/dist/index.cjs

@@ -1,6 +1,10 @@
 const require_db = require('./db-C9-M-kdS.cjs');
 let __llmops_gateway = require("@llmops/gateway");
 __llmops_gateway = require_db.__toESM(__llmops_gateway);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_db.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_db.__toESM(node_path);
 let __better_auth_utils_random = require("@better-auth/utils/random");
 let node_crypto = require("node:crypto");
 
@@ -465,6 +469,491 @@ function validateLLMOpsConfig(config) {
 	return result.data;
 }
 
+//#endregion
+//#region src/cache/types.ts
+/** Time constants in milliseconds for convenience */
+const MS = {
+	"1_MINUTE": 60 * 1e3,
+	"5_MINUTES": 300 * 1e3,
+	"10_MINUTES": 600 * 1e3,
+	"30_MINUTES": 1800 * 1e3,
+	"1_HOUR": 3600 * 1e3,
+	"6_HOURS": 360 * 60 * 1e3,
+	"12_HOURS": 720 * 60 * 1e3,
+	"1_DAY": 1440 * 60 * 1e3,
+	"7_DAYS": 10080 * 60 * 1e3,
+	"30_DAYS": 720 * 60 * 60 * 1e3
+};
+
+//#endregion
+//#region src/cache/backends/memory.ts
+var MemoryCacheBackend = class {
+	cache = /* @__PURE__ */ new Map();
+	stats = {
+		hits: 0,
+		misses: 0,
+		sets: 0,
+		deletes: 0,
+		size: 0,
+		expired: 0
+	};
+	cleanupInterval;
+	maxSize;
+	constructor(maxSize = 1e4, cleanupIntervalMs = 6e4) {
+		this.maxSize = maxSize;
+		this.startCleanup(cleanupIntervalMs);
+	}
+	startCleanup(intervalMs) {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanup();
+		}, intervalMs);
+	}
+	getFullKey(key, namespace) {
+		return namespace ? `${namespace}:${key}` : key;
+	}
+	isExpired(entry) {
+		return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+	}
+	evictIfNeeded() {
+		if (this.cache.size >= this.maxSize) {
+			const entries = Array.from(this.cache.entries());
+			entries.sort((a, b) => a[1].createdAt - b[1].createdAt);
+			const toRemove = Math.floor(this.maxSize * .1);
+			for (let i = 0; i < toRemove && i < entries.length; i++) this.cache.delete(entries[i][0]);
+		}
+	}
+	async get(key, namespace) {
+		const fullKey = this.getFullKey(key, namespace);
+		const entry = this.cache.get(fullKey);
+		if (!entry) {
+			this.stats.misses++;
+			return null;
+		}
+		if (this.isExpired(entry)) {
+			this.cache.delete(fullKey);
+			this.stats.expired++;
+			this.stats.misses++;
+			return null;
+		}
+		this.stats.hits++;
+		return entry;
+	}
+	async set(key, value, options = {}) {
+		const fullKey = this.getFullKey(key, options.namespace);
+		const now = Date.now();
+		const entry = {
+			value,
+			createdAt: now,
+			expiresAt: options.ttl ? now + options.ttl : void 0,
+			metadata: options.metadata
+		};
+		this.evictIfNeeded();
+		this.cache.set(fullKey, entry);
+		this.stats.sets++;
+		this.stats.size = this.cache.size;
+	}
+	async delete(key, namespace) {
+		const fullKey = this.getFullKey(key, namespace);
+		const deleted = this.cache.delete(fullKey);
+		if (deleted) {
+			this.stats.deletes++;
+			this.stats.size = this.cache.size;
+		}
+		return deleted;
+	}
+	async clear(namespace) {
+		if (namespace) {
+			const prefix = `${namespace}:`;
+			const keysToDelete = Array.from(this.cache.keys()).filter((key) => key.startsWith(prefix));
+			for (const key of keysToDelete) this.cache.delete(key);
+			this.stats.deletes += keysToDelete.length;
+		} else {
+			this.stats.deletes += this.cache.size;
+			this.cache.clear();
+		}
+		this.stats.size = this.cache.size;
+	}
+	async has(key, namespace) {
+		const fullKey = this.getFullKey(key, namespace);
+		const entry = this.cache.get(fullKey);
+		if (!entry) return false;
+		if (this.isExpired(entry)) {
+			this.cache.delete(fullKey);
+			this.stats.expired++;
+			return false;
+		}
+		return true;
+	}
+	async keys(namespace) {
+		const allKeys = Array.from(this.cache.keys());
+		if (namespace) {
+			const prefix = `${namespace}:`;
+			return allKeys.filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+		}
+		return allKeys;
+	}
+	async getStats(namespace) {
+		if (namespace) {
+			const prefix = `${namespace}:`;
+			const namespaceKeys = Array.from(this.cache.keys()).filter((key) => key.startsWith(prefix));
+			let expired = 0;
+			for (const key of namespaceKeys) {
+				const entry = this.cache.get(key);
+				if (entry && this.isExpired(entry)) expired++;
+			}
+			return {
+				...this.stats,
+				size: namespaceKeys.length,
+				expired
+			};
+		}
+		return { ...this.stats };
+	}
+	async cleanup() {
+		let expiredCount = 0;
+		for (const [key, entry] of this.cache.entries()) if (this.isExpired(entry)) {
+			this.cache.delete(key);
+			expiredCount++;
+		}
+		if (expiredCount > 0) {
+			this.stats.expired += expiredCount;
+			this.stats.size = this.cache.size;
+		}
+	}
+	async close() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+		this.cache.clear();
+	}
+};
+
+//#endregion
+//#region src/cache/backends/file.ts
+/**
+* @file src/cache/backends/file.ts
+* File-based cache backend implementation
+*/
+var FileCacheBackend = class {
+	cacheFile;
+	data = {};
+	saveTimer;
+	cleanupInterval;
+	loaded = false;
+	loadPromise;
+	stats = {
+		hits: 0,
+		misses: 0,
+		sets: 0,
+		deletes: 0,
+		size: 0,
+		expired: 0
+	};
+	saveInterval;
+	constructor(dataDir = "data", fileName = "cache.json", saveIntervalMs = 1e3, cleanupIntervalMs = 6e4) {
+		this.cacheFile = node_path.join(process.cwd(), dataDir, fileName);
+		this.saveInterval = saveIntervalMs;
+		this.loadPromise = this.loadCache();
+		this.loadPromise.then(() => {
+			this.startCleanup(cleanupIntervalMs);
+		});
+	}
+	/** Ensure cache is loaded before any operation */
+	async ensureLoaded() {
+		if (!this.loaded) await this.loadPromise;
+	}
+	async ensureDataDir() {
+		const dir = node_path.dirname(this.cacheFile);
+		try {
+			await node_fs_promises.mkdir(dir, { recursive: true });
+		} catch {}
+	}
+	async loadCache() {
+		try {
+			const content = await node_fs_promises.readFile(this.cacheFile, "utf-8");
+			this.data = JSON.parse(content);
+			this.updateStats();
+			this.loaded = true;
+		} catch {
+			this.data = {};
+			this.loaded = true;
+		}
+	}
+	async saveCache() {
+		try {
+			await this.ensureDataDir();
+			await node_fs_promises.writeFile(this.cacheFile, JSON.stringify(this.data, null, 2));
+		} catch {}
+	}
+	scheduleSave() {
+		if (this.saveTimer) clearTimeout(this.saveTimer);
+		this.saveTimer = setTimeout(() => {
+			this.saveCache();
+			this.saveTimer = void 0;
+		}, this.saveInterval);
+	}
+	startCleanup(intervalMs) {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanup();
+		}, intervalMs);
+	}
+	isExpired(entry) {
+		return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+	}
+	updateStats() {
+		let totalSize = 0;
+		let totalExpired = 0;
+		for (const namespace of Object.values(this.data)) for (const entry of Object.values(namespace)) {
+			totalSize++;
+			if (this.isExpired(entry)) totalExpired++;
+		}
+		this.stats.size = totalSize;
+		this.stats.expired = totalExpired;
+	}
+	getNamespaceData(namespace = "default") {
+		if (!this.data[namespace]) this.data[namespace] = {};
+		return this.data[namespace];
+	}
+	async get(key, namespace) {
+		await this.ensureLoaded();
+		const namespaceData = this.getNamespaceData(namespace);
+		const entry = namespaceData[key];
+		if (!entry) {
+			this.stats.misses++;
+			return null;
+		}
+		if (this.isExpired(entry)) {
+			delete namespaceData[key];
+			this.stats.expired++;
+			this.stats.misses++;
+			this.scheduleSave();
+			return null;
+		}
+		this.stats.hits++;
+		return entry;
+	}
+	async set(key, value, options = {}) {
+		await this.ensureLoaded();
+		const namespace = options.namespace || "default";
+		const namespaceData = this.getNamespaceData(namespace);
+		const now = Date.now();
+		namespaceData[key] = {
+			value,
+			createdAt: now,
+			expiresAt: options.ttl ? now + options.ttl : void 0,
+			metadata: options.metadata
+		};
+		this.stats.sets++;
+		this.updateStats();
+		this.scheduleSave();
+	}
+	async delete(key, namespace) {
+		const namespaceData = this.getNamespaceData(namespace);
+		const existed = key in namespaceData;
+		if (existed) {
+			delete namespaceData[key];
+			this.stats.deletes++;
+			this.updateStats();
+			this.scheduleSave();
+		}
+		return existed;
+	}
+	async clear(namespace) {
+		if (namespace) {
+			const namespaceData = this.getNamespaceData(namespace);
+			const count = Object.keys(namespaceData).length;
+			this.data[namespace] = {};
+			this.stats.deletes += count;
+		} else {
+			const totalCount = Object.values(this.data).reduce((sum, ns) => sum + Object.keys(ns).length, 0);
+			this.data = {};
+			this.stats.deletes += totalCount;
+		}
+		this.updateStats();
+		this.scheduleSave();
+	}
+	async has(key, namespace) {
+		const namespaceData = this.getNamespaceData(namespace);
+		const entry = namespaceData[key];
+		if (!entry) return false;
+		if (this.isExpired(entry)) {
+			delete namespaceData[key];
+			this.stats.expired++;
+			this.scheduleSave();
+			return false;
+		}
+		return true;
+	}
+	async keys(namespace) {
+		if (namespace) {
+			const namespaceData = this.getNamespaceData(namespace);
+			return Object.keys(namespaceData);
+		}
+		const allKeys = [];
+		for (const namespaceData of Object.values(this.data)) allKeys.push(...Object.keys(namespaceData));
+		return allKeys;
+	}
+	async getStats(namespace) {
+		if (namespace) {
+			const namespaceData = this.getNamespaceData(namespace);
+			const keys = Object.keys(namespaceData);
+			let expired = 0;
+			for (const key of keys) {
+				const entry = namespaceData[key];
+				if (this.isExpired(entry)) expired++;
+			}
+			return {
+				...this.stats,
+				size: keys.length,
+				expired
+			};
+		}
+		this.updateStats();
+		return { ...this.stats };
+	}
+	async cleanup() {
+		let expiredCount = 0;
+		let hasChanges = false;
+		for (const [, namespaceData] of Object.entries(this.data)) for (const [key, entry] of Object.entries(namespaceData)) if (this.isExpired(entry)) {
+			delete namespaceData[key];
+			expiredCount++;
+			hasChanges = true;
+		}
+		if (hasChanges) {
+			this.stats.expired += expiredCount;
+			this.updateStats();
+			this.scheduleSave();
+		}
+	}
+	/** Wait for the cache to be ready (file loaded) */
+	async waitForReady() {
+		await this.loadPromise;
+	}
+	async close() {
+		if (this.saveTimer) {
+			clearTimeout(this.saveTimer);
+			await this.saveCache();
+		}
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+	}
+};
+
+//#endregion
+//#region src/cache/service.ts
+/**
+* @file src/cache/service.ts
+* Unified cache service with pluggable backends
+*/
+var CacheService = class {
+	backend;
+	defaultTtl;
+	constructor(config) {
+		this.defaultTtl = config.defaultTtl;
+		this.backend = this.createBackend(config);
+	}
+	createBackend(config) {
+		switch (config.backend) {
+			case "memory": return new MemoryCacheBackend(config.maxSize, config.cleanupInterval);
+			case "file": return new FileCacheBackend(config.dataDir, config.fileName, config.saveInterval, config.cleanupInterval);
+			default: throw new Error(`Unsupported cache backend: ${config.backend}`);
+		}
+	}
+	/** Get a value from the cache */
+	async get(key, namespace) {
+		const entry = await this.backend.get(key, namespace);
+		return entry ? entry.value : null;
+	}
+	/** Get the full cache entry (with metadata) */
+	async getEntry(key, namespace) {
+		return this.backend.get(key, namespace);
+	}
+	/** Set a value in the cache */
+	async set(key, value, options = {}) {
+		const finalOptions = {
+			...options,
+			ttl: options.ttl ?? this.defaultTtl
+		};
+		await this.backend.set(key, value, finalOptions);
+	}
+	/** Set a value with TTL in seconds (convenience method) */
+	async setWithTtl(key, value, ttlSeconds, namespace) {
+		await this.set(key, value, {
+			ttl: ttlSeconds * 1e3,
+			namespace
+		});
+	}
+	/** Delete a value from the cache */
+	async delete(key, namespace) {
+		return this.backend.delete(key, namespace);
+	}
+	/** Check if a key exists in the cache */
+	async has(key, namespace) {
+		return this.backend.has(key, namespace);
+	}
+	/** Get all keys in a namespace */
+	async keys(namespace) {
+		return this.backend.keys(namespace);
+	}
+	/** Clear all entries in a namespace (or all entries if no namespace) */
+	async clear(namespace) {
+		await this.backend.clear(namespace);
+	}
+	/** Get cache statistics */
+	async getStats(namespace) {
+		return this.backend.getStats(namespace);
+	}
+	/** Manually trigger cleanup of expired entries */
+	async cleanup() {
+		await this.backend.cleanup();
+	}
+	/** Wait for the backend to be ready */
+	async waitForReady() {
+		if ("waitForReady" in this.backend) await this.backend.waitForReady();
+	}
+	/** Close the cache and cleanup resources */
+	async close() {
+		await this.backend.close();
+	}
+	/** Get or set pattern - get value, or compute and cache it if not found */
+	async getOrSet(key, factory, options = {}) {
+		const existing = await this.get(key, options.namespace);
+		if (existing !== null) return existing;
+		const value = await factory();
+		await this.set(key, value, options);
+		return value;
+	}
+	/** Increment a numeric value (simulated atomic operation) */
+	async increment(key, delta = 1, options = {}) {
+		const newValue = (await this.get(key, options.namespace) || 0) + delta;
+		await this.set(key, newValue, options);
+		return newValue;
+	}
+	/** Set multiple values at once */
+	async setMany(entries, defaultOptions = {}) {
+		const promises = entries.map(({ key, value, options }) => this.set(key, value, {
+			...defaultOptions,
+			...options
+		}));
+		await Promise.all(promises);
+	}
+	/** Get multiple values at once */
+	async getMany(keys, namespace) {
+		const promises = keys.map(async (key) => ({
+			key,
+			value: await this.get(key, namespace)
+		}));
+		return Promise.all(promises);
+	}
+	/** Get the underlying backend (for advanced use cases) */
+	getBackend() {
+		return this.backend;
+	}
+};
+
 //#endregion
 //#region src/utils/id.ts
 const generateId = (size) => {
@@ -1338,6 +1827,39 @@ const createVariantVersionsDataLayer = (db) => {
 	};
 };
 
+//#endregion
+//#region src/datalayer/workspaceSettings.ts
+const updateWorkspaceSettings = require_db.zod_default.object({ name: require_db.zod_default.string().nullable().optional() });
+const createWorkspaceSettingsDataLayer = (db) => {
+	return {
+		getWorkspaceSettings: async () => {
+			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
+			if (!settings) settings = await db.insertInto("workspace_settings").values({
+				id: (0, node_crypto.randomUUID)(),
+				name: null,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+			return settings;
+		},
+		updateWorkspaceSettings: async (params) => {
+			const value = await updateWorkspaceSettings.safeParseAsync(params);
+			if (!value.success) throw new LLMOpsError(`Invalid parameters: ${value.error.message}`);
+			let settings = await db.selectFrom("workspace_settings").selectAll().executeTakeFirst();
+			if (!settings) return db.insertInto("workspace_settings").values({
+				id: (0, node_crypto.randomUUID)(),
+				name: value.data.name ?? null,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).returningAll().executeTakeFirst();
+			return db.updateTable("workspace_settings").set({
+				name: value.data.name ?? null,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).where("id", "=", settings.id).returningAll().executeTakeFirst();
+		}
+	};
+};
+
 //#endregion
 //#region src/datalayer/index.ts
 const createDataLayer = async (db) => {
@@ -1348,11 +1870,16 @@ const createDataLayer = async (db) => {
 		...createEnvironmentSecretDataLayer(db),
 		...createTargetingRulesDataLayer(db),
 		...createVariantDataLayer(db),
-		...createVariantVersionsDataLayer(db)
+		...createVariantVersionsDataLayer(db),
+		...createWorkspaceSettingsDataLayer(db)
 	};
 };
 
 //#endregion
+exports.CacheService = CacheService;
+exports.FileCacheBackend = FileCacheBackend;
+exports.MS = MS;
+exports.MemoryCacheBackend = MemoryCacheBackend;
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
 exports.SupportedProviders = SupportedProviders;
 exports.chatCompletionCreateParamsBaseSchema = chatCompletionCreateParamsBaseSchema;