@hedystia/db 2.0.5 → 2.0.7

package/dist/cache/index.mjs

@@ -0,0 +1,12 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
+import "./memory-store.mjs";
+import { init_manager } from "./manager.mjs";
+//#region src/cache/index.ts
+var init_cache = __esmMin((() => {
+	init_manager();
+}));
+//#endregion
+init_cache();
+export { init_cache };
+
+//# sourceMappingURL=index.mjs.map

package/dist/cache/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/cache/index.ts"],"sourcesContent":["export { CacheManager } from \"./manager\";\nexport { MemoryStore } from \"./memory-store\";\n"],"mappings":";;;;;eAAyC"}

package/dist/cache/manager.mjs

@@ -1,163 +1,166 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
 import { DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_MAX_TTL, DEFAULT_CACHE_TTL, init_constants } from "../constants.mjs";
 import { stableStringify } from "../utils/stable-stringify.mjs";
 import { init_utils } from "../utils/index.mjs";
-import { MemoryStore } from "./memory-store.mjs";
+import { MemoryStore, init_memory_store } from "./memory-store.mjs";
 //#region src/cache/manager.ts
-init_constants();
-init_utils();
-/**
-* Cache manager that wraps query execution with caching behavior
-*/
-var CacheManager = class {
-	store;
-	baseTtl;
-	maxTtl;
-	enabled;
-	constructor(config) {
-		if (typeof config === "boolean") {
-			this.enabled = config;
-			this.baseTtl = DEFAULT_CACHE_TTL;
-			this.maxTtl = DEFAULT_CACHE_MAX_TTL;
-			this.store = new MemoryStore(DEFAULT_CACHE_MAX_ENTRIES);
-		} else if (config) {
-			this.enabled = config.enabled;
-			this.baseTtl = config.ttl ?? 6e4;
-			this.maxTtl = config.maxTtl ?? 3e5;
-			this.store = new MemoryStore(config.maxEntries ?? 1e4);
-		} else {
-			this.enabled = false;
-			this.baseTtl = DEFAULT_CACHE_TTL;
-			this.maxTtl = DEFAULT_CACHE_MAX_TTL;
-			this.store = new MemoryStore();
+var CacheManager;
+var init_manager = __esmMin((() => {
+	init_constants();
+	init_utils();
+	init_memory_store();
+	CacheManager = class {
+		store;
+		baseTtl;
+		maxTtl;
+		enabled;
+		constructor(config) {
+			if (typeof config === "boolean") {
+				this.enabled = config;
+				this.baseTtl = DEFAULT_CACHE_TTL;
+				this.maxTtl = DEFAULT_CACHE_MAX_TTL;
+				this.store = new MemoryStore(DEFAULT_CACHE_MAX_ENTRIES);
+			} else if (config) {
+				this.enabled = config.enabled;
+				this.baseTtl = config.ttl ?? 6e4;
+				this.maxTtl = config.maxTtl ?? 3e5;
+				this.store = new MemoryStore(config.maxEntries ?? 1e4);
+			} else {
+				this.enabled = false;
+				this.baseTtl = DEFAULT_CACHE_TTL;
+				this.maxTtl = DEFAULT_CACHE_MAX_TTL;
+				this.store = new MemoryStore();
+			}
 		}
-	}
-	/**
-	* Get a cached query result or execute the query and cache the result
-	* @param {string} table - Table name
-	* @param {string} method - Method name (find, findFirst, etc.)
-	* @param {unknown} options - Query options
-	* @param {() => Promise<T>} executor - Function that executes the query
-	* @returns {Promise<T>} The query result
-	*/
-	async getOrSet(table, method, options, executor) {
-		if (!this.enabled) return executor();
-		const key = this.buildKey(table, method, options);
-		const cached = this.store.get(key);
-		if (cached !== void 0) {
-			this.store.extendTtl(key, this.baseTtl, this.maxTtl);
-			return cached;
+		/**
+		* Get a cached query result or execute the query and cache the result
+		* @param {string} table - Table name
+		* @param {string} method - Method name (find, findFirst, etc.)
+		* @param {unknown} options - Query options
+		* @param {() => Promise<T>} executor - Function that executes the query
+		* @returns {Promise<T>} The query result
+		*/
+		async getOrSet(table, method, options, executor) {
+			if (!this.enabled) return executor();
+			const key = this.buildKey(table, method, options);
+			const cached = this.store.get(key);
+			if (cached !== void 0) {
+				this.store.extendTtl(key, this.baseTtl, this.maxTtl);
+				return cached;
+			}
+			const result = await executor();
+			this.store.set(key, result, this.baseTtl);
+			return result;
 		}
-		const result = await executor();
-		this.store.set(key, result, this.baseTtl);
-		return result;
-	}
-	/**
-	* Set an entity in the cache by primary key
-	* @param {string} table - Table name
-	* @param {string | number} id - Primary key value
-	* @param {unknown} data - Entity data
-	*/
-	setEntity(table, id, data) {
-		if (!this.enabled) return;
-		const key = `entity:${table}:${id}`;
-		this.store.set(key, data, this.baseTtl);
-	}
-	/**
-	* Get a cached entity by primary key
-	* @param {string} table - Table name
-	* @param {string | number} id - Primary key value
-	* @returns {unknown | undefined} Cached entity or undefined
-	*/
-	getEntity(table, id) {
-		if (!this.enabled) return;
-		const key = `entity:${table}:${id}`;
-		const result = this.store.get(key);
-		if (result !== void 0) this.store.extendTtl(key, this.baseTtl, this.maxTtl);
-		return result;
-	}
-	/**
-	* Invalidate all cache entries for a table
-	* @param {string} table - Table name
-	*/
-	invalidateTable(table) {
-		if (!this.enabled) return;
-		this.store.invalidateByPrefix(`query:${table}:`);
-		this.store.invalidateByPrefix(`entity:${table}:`);
-	}
-	/**
-	* Invalidate a specific entity cache entry
-	* @param {string} table - Table name
-	* @param {string | number} id - Primary key value
-	*/
-	invalidateEntity(table, id) {
-		if (!this.enabled) return;
-		this.store.delete(`entity:${table}:${id}`);
-		this.store.invalidateByPrefix(`query:${table}:`);
-	}
-	/**
-	* Update an entity in cache if it exists
-	* @param {string} table - Table name
-	* @param {string | number} id - Primary key value
-	* @param {Record<string, unknown>} data - Updated data
-	*/
-	updateEntity(table, id, data) {
-		if (!this.enabled) return;
-		const key = `entity:${table}:${id}`;
-		const existing = this.store.get(key);
-		if (existing && typeof existing === "object") this.store.set(key, {
-			...existing,
-			...data
-		}, this.baseTtl);
-		this.store.invalidateByPrefix(`query:${table}:`);
-	}
-	/**
-	* Clear the entire cache
-	*/
-	clear() {
-		this.store.clear();
-	}
-	/**
-	* Get the number of cached entries
-	* @returns {number} Cache size
-	*/
-	get size() {
-		return this.store.size;
-	}
-	/**
-	* Check if caching is enabled
-	* @returns {boolean} Whether caching is enabled
-	*/
-	get isEnabled() {
-		return this.enabled;
-	}
-	/**
-	* Get a cached query result or execute the query with per-table cache config override
-	* @param {string} table - Table name
-	* @param {string} method - Method name (find, findFirst, etc.)
-	* @param {unknown} options - Query options
-	* @param {() => Promise<T>} executor - Function that executes the query
-	* @param {{ enabled: boolean; ttl?: number; maxTtl?: number }} [tableConfig] - Per-table cache config
-	* @returns {Promise<T>} The query result
-	*/
-	async getOrSetWithTableConfig(table, method, options, executor, tableConfig) {
-		if (!(tableConfig ? tableConfig.enabled : this.enabled)) return executor();
-		const effectiveTtl = tableConfig?.ttl ?? this.baseTtl;
-		const effectiveMaxTtl = tableConfig?.maxTtl ?? this.maxTtl;
-		const key = this.buildKey(table, method, options);
-		const cached = this.store.get(key);
-		if (cached !== void 0) {
-			this.store.extendTtl(key, effectiveTtl, effectiveMaxTtl);
-			return cached;
+		/**
+		* Set an entity in the cache by primary key
+		* @param {string} table - Table name
+		* @param {string | number} id - Primary key value
+		* @param {unknown} data - Entity data
+		*/
+		setEntity(table, id, data) {
+			if (!this.enabled) return;
+			const key = `entity:${table}:${id}`;
+			this.store.set(key, data, this.baseTtl);
 		}
-		const result = await executor();
-		this.store.set(key, result, effectiveTtl);
-		return result;
-	}
-	buildKey(table, method, options) {
-		return `query:${table}:${method}:${stableStringify(options)}`;
-	}
-};
+		/**
+		* Get a cached entity by primary key
+		* @param {string} table - Table name
+		* @param {string | number} id - Primary key value
+		* @returns {unknown | undefined} Cached entity or undefined
+		*/
+		getEntity(table, id) {
+			if (!this.enabled) return;
+			const key = `entity:${table}:${id}`;
+			const result = this.store.get(key);
+			if (result !== void 0) this.store.extendTtl(key, this.baseTtl, this.maxTtl);
+			return result;
+		}
+		/**
+		* Invalidate all cache entries for a table
+		* @param {string} table - Table name
+		*/
+		invalidateTable(table) {
+			if (!this.enabled) return;
+			this.store.invalidateByPrefix(`query:${table}:`);
+			this.store.invalidateByPrefix(`entity:${table}:`);
+		}
+		/**
+		* Invalidate a specific entity cache entry
+		* @param {string} table - Table name
+		* @param {string | number} id - Primary key value
+		*/
+		invalidateEntity(table, id) {
+			if (!this.enabled) return;
+			this.store.delete(`entity:${table}:${id}`);
+			this.store.invalidateByPrefix(`query:${table}:`);
+		}
+		/**
+		* Update an entity in cache if it exists
+		* @param {string} table - Table name
+		* @param {string | number} id - Primary key value
+		* @param {Record<string, unknown>} data - Updated data
+		*/
+		updateEntity(table, id, data) {
+			if (!this.enabled) return;
+			const key = `entity:${table}:${id}`;
+			const existing = this.store.get(key);
+			if (existing && typeof existing === "object") this.store.set(key, {
+				...existing,
+				...data
+			}, this.baseTtl);
+			this.store.invalidateByPrefix(`query:${table}:`);
+		}
+		/**
+		* Clear the entire cache
+		*/
+		clear() {
+			this.store.clear();
+		}
+		/**
+		* Get the number of cached entries
+		* @returns {number} Cache size
+		*/
+		get size() {
+			return this.store.size;
+		}
+		/**
+		* Check if caching is enabled
+		* @returns {boolean} Whether caching is enabled
+		*/
+		get isEnabled() {
+			return this.enabled;
+		}
+		/**
+		* Get a cached query result or execute the query with per-table cache config override
+		* @param {string} table - Table name
+		* @param {string} method - Method name (find, findFirst, etc.)
+		* @param {unknown} options - Query options
+		* @param {() => Promise<T>} executor - Function that executes the query
+		* @param {{ enabled: boolean; ttl?: number; maxTtl?: number }} [tableConfig] - Per-table cache config
+		* @returns {Promise<T>} The query result
+		*/
+		async getOrSetWithTableConfig(table, method, options, executor, tableConfig) {
+			if (!(tableConfig ? tableConfig.enabled : this.enabled)) return executor();
+			const effectiveTtl = tableConfig?.ttl ?? this.baseTtl;
+			const effectiveMaxTtl = tableConfig?.maxTtl ?? this.maxTtl;
+			const key = this.buildKey(table, method, options);
+			const cached = this.store.get(key);
+			if (cached !== void 0) {
+				this.store.extendTtl(key, effectiveTtl, effectiveMaxTtl);
+				return cached;
+			}
+			const result = await executor();
+			this.store.set(key, result, effectiveTtl);
+			return result;
+		}
+		buildKey(table, method, options) {
+			return `query:${table}:${method}:${stableStringify(options)}`;
+		}
+	};
+}));
 //#endregion
-export { CacheManager };
+init_manager();
+export { CacheManager, init_manager };
 
 //# sourceMappingURL=manager.mjs.map

package/dist/cache/manager.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"manager.mjs","names":[],"sources":["../../src/cache/manager.ts"],"sourcesContent":["import { DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_MAX_TTL, DEFAULT_CACHE_TTL } from \"../constants\";\nimport type { CacheConfig } from \"../types\";\nimport { stableStringify } from \"../utils\";\nimport { MemoryStore } from \"./memory-store\";\n\n/**\n * Cache manager that wraps query execution with caching behavior\n */\nexport class CacheManager {\n  private store: MemoryStore;\n  private baseTtl: number;\n  private maxTtl: number;\n  private enabled: boolean;\n\n  constructor(config?: boolean | CacheConfig) {\n    if (typeof config === \"boolean\") {\n      this.enabled = config;\n      this.baseTtl = DEFAULT_CACHE_TTL;\n      this.maxTtl = DEFAULT_CACHE_MAX_TTL;\n      this.store = new MemoryStore(DEFAULT_CACHE_MAX_ENTRIES);\n    } else if (config) {\n      this.enabled = config.enabled;\n      this.baseTtl = config.ttl ?? DEFAULT_CACHE_TTL;\n      this.maxTtl = config.maxTtl ?? DEFAULT_CACHE_MAX_TTL;\n      this.store = new MemoryStore(config.maxEntries ?? DEFAULT_CACHE_MAX_ENTRIES);\n    } else {\n      this.enabled = false;\n      this.baseTtl = DEFAULT_CACHE_TTL;\n      this.maxTtl = DEFAULT_CACHE_MAX_TTL;\n      this.store = new MemoryStore();\n    }\n  }\n\n  /**\n   * Get a cached query result or execute the query and cache the result\n   * @param {string} table - Table name\n   * @param {string} method - Method name (find, findFirst, etc.)\n   * @param {unknown} options - Query options\n   * @param {() => Promise<T>} executor - Function that executes the query\n   * @returns {Promise<T>} The query result\n   */\n  async getOrSet<T>(\n    table: string,\n    method: string,\n    options: unknown,\n    executor: () => Promise<T>,\n  ): Promise<T> {\n    if (!this.enabled) {\n      return executor();\n    }\n\n    const key = this.buildKey(table, method, options);\n    const cached = this.store.get(key);\n    if (cached !== undefined) {\n      this.store.extendTtl(key, this.baseTtl, this.maxTtl);\n      return cached as T;\n    }\n\n    const result = await executor();\n    this.store.set(key, result, this.baseTtl);\n    return result;\n  }\n\n  /**\n   * Set an entity in the cache by primary key\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   * @param {unknown} data - Entity data\n   */\n  setEntity(table: string, id: string | number, data: unknown): void {\n    if (!this.enabled) {\n      return;\n    }\n    const key = `entity:${table}:${id}`;\n    this.store.set(key, data, this.baseTtl);\n  }\n\n  /**\n   * Get a cached entity by primary key\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   * @returns {unknown | undefined} Cached entity or undefined\n   */\n  getEntity(table: string, id: string | number): unknown | undefined {\n    if (!this.enabled) {\n      return undefined;\n    }\n    const key = `entity:${table}:${id}`;\n    const result = this.store.get(key);\n    if (result !== undefined) {\n      this.store.extendTtl(key, this.baseTtl, this.maxTtl);\n    }\n    return result;\n  }\n\n  /**\n   * Invalidate all cache entries for a table\n   * @param {string} table - Table name\n   */\n  invalidateTable(table: string): void {\n    if (!this.enabled) {\n      return;\n    }\n    this.store.invalidateByPrefix(`query:${table}:`);\n    this.store.invalidateByPrefix(`entity:${table}:`);\n  }\n\n  /**\n   * Invalidate a specific entity cache entry\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   */\n  invalidateEntity(table: string, id: string | number): void {\n    if (!this.enabled) {\n      return;\n    }\n    this.store.delete(`entity:${table}:${id}`);\n    this.store.invalidateByPrefix(`query:${table}:`);\n  }\n\n  /**\n   * Update an entity in cache if it exists\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   * @param {Record<string, unknown>} data - Updated data\n   */\n  updateEntity(table: string, id: string | number, data: Record<string, unknown>): void {\n    if (!this.enabled) {\n      return;\n    }\n    const key = `entity:${table}:${id}`;\n    const existing = this.store.get(key);\n    if (existing && typeof existing === \"object\") {\n      this.store.set(key, { ...existing, ...data }, this.baseTtl);\n    }\n    this.store.invalidateByPrefix(`query:${table}:`);\n  }\n\n  /**\n   * Clear the entire cache\n   */\n  clear(): void {\n    this.store.clear();\n  }\n\n  /**\n   * Get the number of cached entries\n   * @returns {number} Cache size\n   */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /**\n   * Check if caching is enabled\n   * @returns {boolean} Whether caching is enabled\n   */\n  get isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  /**\n   * Get a cached query result or execute the query with per-table cache config override\n   * @param {string} table - Table name\n   * @param {string} method - Method name (find, findFirst, etc.)\n   * @param {unknown} options - Query options\n   * @param {() => Promise<T>} executor - Function that executes the query\n   * @param {{ enabled: boolean; ttl?: number; maxTtl?: number }} [tableConfig] - Per-table cache config\n   * @returns {Promise<T>} The query result\n   */\n  async getOrSetWithTableConfig<T>(\n    table: string,\n    method: string,\n    options: unknown,\n    executor: () => Promise<T>,\n    tableConfig?: { enabled: boolean; ttl?: number; maxTtl?: number },\n  ): Promise<T> {\n    const effectiveEnabled = tableConfig ? tableConfig.enabled : this.enabled;\n    if (!effectiveEnabled) {\n      return executor();\n    }\n\n    const effectiveTtl = tableConfig?.ttl ?? this.baseTtl;\n    const effectiveMaxTtl = tableConfig?.maxTtl ?? this.maxTtl;\n    const key = this.buildKey(table, method, options);\n    const cached = this.store.get(key);\n    if (cached !== undefined) {\n      this.store.extendTtl(key, effectiveTtl, effectiveMaxTtl);\n      return cached as T;\n    }\n\n    const result = await executor();\n    this.store.set(key, result, effectiveTtl);\n    return result;\n  }\n\n  private buildKey(table: string, method: string, options: unknown): string {\n    return `query:${table}:${method}:${stableStringify(options)}`;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"manager.mjs","names":[],"sources":["../../src/cache/manager.ts"],"sourcesContent":["import { DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_MAX_TTL, DEFAULT_CACHE_TTL } from \"../constants\";\nimport type { CacheConfig } from \"../types\";\nimport { stableStringify } from \"../utils\";\nimport { MemoryStore } from \"./memory-store\";\n\n/**\n * Cache manager that wraps query execution with caching behavior\n */\nexport class CacheManager {\n  private store: MemoryStore;\n  private baseTtl: number;\n  private maxTtl: number;\n  private enabled: boolean;\n\n  constructor(config?: boolean | CacheConfig) {\n    if (typeof config === \"boolean\") {\n      this.enabled = config;\n      this.baseTtl = DEFAULT_CACHE_TTL;\n      this.maxTtl = DEFAULT_CACHE_MAX_TTL;\n      this.store = new MemoryStore(DEFAULT_CACHE_MAX_ENTRIES);\n    } else if (config) {\n      this.enabled = config.enabled;\n      this.baseTtl = config.ttl ?? DEFAULT_CACHE_TTL;\n      this.maxTtl = config.maxTtl ?? DEFAULT_CACHE_MAX_TTL;\n      this.store = new MemoryStore(config.maxEntries ?? DEFAULT_CACHE_MAX_ENTRIES);\n    } else {\n      this.enabled = false;\n      this.baseTtl = DEFAULT_CACHE_TTL;\n      this.maxTtl = DEFAULT_CACHE_MAX_TTL;\n      this.store = new MemoryStore();\n    }\n  }\n\n  /**\n   * Get a cached query result or execute the query and cache the result\n   * @param {string} table - Table name\n   * @param {string} method - Method name (find, findFirst, etc.)\n   * @param {unknown} options - Query options\n   * @param {() => Promise<T>} executor - Function that executes the query\n   * @returns {Promise<T>} The query result\n   */\n  async getOrSet<T>(\n    table: string,\n    method: string,\n    options: unknown,\n    executor: () => Promise<T>,\n  ): Promise<T> {\n    if (!this.enabled) {\n      return executor();\n    }\n\n    const key = this.buildKey(table, method, options);\n    const cached = this.store.get(key);\n    if (cached !== undefined) {\n      this.store.extendTtl(key, this.baseTtl, this.maxTtl);\n      return cached as T;\n    }\n\n    const result = await executor();\n    this.store.set(key, result, this.baseTtl);\n    return result;\n  }\n\n  /**\n   * Set an entity in the cache by primary key\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   * @param {unknown} data - Entity data\n   */\n  setEntity(table: string, id: string | number, data: unknown): void {\n    if (!this.enabled) {\n      return;\n    }\n    const key = `entity:${table}:${id}`;\n    this.store.set(key, data, this.baseTtl);\n  }\n\n  /**\n   * Get a cached entity by primary key\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   * @returns {unknown | undefined} Cached entity or undefined\n   */\n  getEntity(table: string, id: string | number): unknown | undefined {\n    if (!this.enabled) {\n      return undefined;\n    }\n    const key = `entity:${table}:${id}`;\n    const result = this.store.get(key);\n    if (result !== undefined) {\n      this.store.extendTtl(key, this.baseTtl, this.maxTtl);\n    }\n    return result;\n  }\n\n  /**\n   * Invalidate all cache entries for a table\n   * @param {string} table - Table name\n   */\n  invalidateTable(table: string): void {\n    if (!this.enabled) {\n      return;\n    }\n    this.store.invalidateByPrefix(`query:${table}:`);\n    this.store.invalidateByPrefix(`entity:${table}:`);\n  }\n\n  /**\n   * Invalidate a specific entity cache entry\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   */\n  invalidateEntity(table: string, id: string | number): void {\n    if (!this.enabled) {\n      return;\n    }\n    this.store.delete(`entity:${table}:${id}`);\n    this.store.invalidateByPrefix(`query:${table}:`);\n  }\n\n  /**\n   * Update an entity in cache if it exists\n   * @param {string} table - Table name\n   * @param {string | number} id - Primary key value\n   * @param {Record<string, unknown>} data - Updated data\n   */\n  updateEntity(table: string, id: string | number, data: Record<string, unknown>): void {\n    if (!this.enabled) {\n      return;\n    }\n    const key = `entity:${table}:${id}`;\n    const existing = this.store.get(key);\n    if (existing && typeof existing === \"object\") {\n      this.store.set(key, { ...existing, ...data }, this.baseTtl);\n    }\n    this.store.invalidateByPrefix(`query:${table}:`);\n  }\n\n  /**\n   * Clear the entire cache\n   */\n  clear(): void {\n    this.store.clear();\n  }\n\n  /**\n   * Get the number of cached entries\n   * @returns {number} Cache size\n   */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /**\n   * Check if caching is enabled\n   * @returns {boolean} Whether caching is enabled\n   */\n  get isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  /**\n   * Get a cached query result or execute the query with per-table cache config override\n   * @param {string} table - Table name\n   * @param {string} method - Method name (find, findFirst, etc.)\n   * @param {unknown} options - Query options\n   * @param {() => Promise<T>} executor - Function that executes the query\n   * @param {{ enabled: boolean; ttl?: number; maxTtl?: number }} [tableConfig] - Per-table cache config\n   * @returns {Promise<T>} The query result\n   */\n  async getOrSetWithTableConfig<T>(\n    table: string,\n    method: string,\n    options: unknown,\n    executor: () => Promise<T>,\n    tableConfig?: { enabled: boolean; ttl?: number; maxTtl?: number },\n  ): Promise<T> {\n    const effectiveEnabled = tableConfig ? tableConfig.enabled : this.enabled;\n    if (!effectiveEnabled) {\n      return executor();\n    }\n\n    const effectiveTtl = tableConfig?.ttl ?? this.baseTtl;\n    const effectiveMaxTtl = tableConfig?.maxTtl ?? this.maxTtl;\n    const key = this.buildKey(table, method, options);\n    const cached = this.store.get(key);\n    if (cached !== undefined) {\n      this.store.extendTtl(key, effectiveTtl, effectiveMaxTtl);\n      return cached as T;\n    }\n\n    const result = await executor();\n    this.store.set(key, result, effectiveTtl);\n    return result;\n  }\n\n  private buildKey(table: string, method: string, options: unknown): string {\n    return `query:${table}:${method}:${stableStringify(options)}`;\n  }\n}\n"],"mappings":"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"}

package/dist/cache/memory-store.mjs

@@ -1,122 +1,124 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
 //#region src/cache/memory-store.ts
-/**
-* In-memory cache store with TTL and hit-count tracking
-*/
-var MemoryStore = class {
-	store = /* @__PURE__ */ new Map();
-	maxEntries;
-	constructor(maxEntries = 1e4) {
-		this.maxEntries = maxEntries;
-	}
-	/**
-	* Get a value from cache
-	* @param {string} key - Cache key
-	* @returns {unknown | undefined} Cached value or undefined
-	*/
-	get(key) {
-		const entry = this.store.get(key);
-		if (!entry) return;
-		if (Date.now() > entry.expiresAt) {
-			this.store.delete(key);
-			return;
-		}
-		entry.hitCount++;
-		entry.lastAccess = Date.now();
-		return entry.value;
-	}
-	/**
-	* Set a value in cache with TTL
-	* @param {string} key - Cache key
-	* @param {unknown} value - Value to cache
-	* @param {number} ttl - Time to live in milliseconds
-	*/
-	set(key, value, ttl) {
-		if (this.store.size >= this.maxEntries) this.evict();
-		this.store.set(key, {
-			value,
-			expiresAt: Date.now() + ttl,
-			hitCount: 1,
-			lastAccess: Date.now()
-		});
-	}
-	/**
-	* Check if a key exists in cache and is not expired
-	* @param {string} key - Cache key
-	* @returns {boolean} Whether the key exists
-	*/
-	has(key) {
-		const entry = this.store.get(key);
-		if (!entry) return false;
-		if (Date.now() > entry.expiresAt) {
-			this.store.delete(key);
-			return false;
+var MemoryStore;
+var init_memory_store = __esmMin((() => {
+	MemoryStore = class {
+		store = /* @__PURE__ */ new Map();
+		maxEntries;
+		constructor(maxEntries = 1e4) {
+			this.maxEntries = maxEntries;
 		}
-		return true;
-	}
-	/**
-	* Delete a key from cache
-	* @param {string} key - Cache key
-	*/
-	delete(key) {
-		this.store.delete(key);
-	}
-	/**
-	* Invalidate all cache entries matching a prefix
-	* @param {string} prefix - Key prefix
-	*/
-	invalidateByPrefix(prefix) {
-		for (const key of this.store.keys()) if (key.startsWith(prefix)) this.store.delete(key);
-	}
-	/**
-	* Clear all cached entries
-	*/
-	clear() {
-		this.store.clear();
-	}
-	/**
-	* Get the number of cached entries
-	* @returns {number} Number of entries
-	*/
-	get size() {
-		return this.store.size;
-	}
-	/**
-	* Get hit count for a cache key
-	* @param {string} key - Cache key
-	* @returns {number} Number of hits
-	*/
-	getHitCount(key) {
-		return this.store.get(key)?.hitCount ?? 0;
-	}
-	/**
-	* Extend the TTL of a cache entry based on hit count
-	* @param {string} key - Cache key
-	* @param {number} baseTtl - Base TTL in milliseconds
-	* @param {number} maxTtl - Maximum TTL in milliseconds
-	*/
-	extendTtl(key, baseTtl, maxTtl) {
-		const entry = this.store.get(key);
-		if (!entry) return;
-		const adaptiveTtl = Math.min(maxTtl, baseTtl * (1 + Math.log2(entry.hitCount + 1)));
-		entry.expiresAt = Date.now() + adaptiveTtl;
-	}
-	evict() {
-		let oldestKey = null;
-		let oldestAccess = Number.POSITIVE_INFINITY;
-		for (const [key, entry] of this.store) {
+		/**
+		* Get a value from cache
+		* @param {string} key - Cache key
+		* @returns {unknown | undefined} Cached value or undefined
+		*/
+		get(key) {
+			const entry = this.store.get(key);
+			if (!entry) return;
 			if (Date.now() > entry.expiresAt) {
 				this.store.delete(key);
 				return;
 			}
-			if (entry.lastAccess < oldestAccess) {
-				oldestAccess = entry.lastAccess;
-				oldestKey = key;
+			entry.hitCount++;
+			entry.lastAccess = Date.now();
+			return entry.value;
+		}
+		/**
+		* Set a value in cache with TTL
+		* @param {string} key - Cache key
+		* @param {unknown} value - Value to cache
+		* @param {number} ttl - Time to live in milliseconds
+		*/
+		set(key, value, ttl) {
+			if (this.store.size >= this.maxEntries) this.evict();
+			this.store.set(key, {
+				value,
+				expiresAt: Date.now() + ttl,
+				hitCount: 1,
+				lastAccess: Date.now()
+			});
+		}
+		/**
+		* Check if a key exists in cache and is not expired
+		* @param {string} key - Cache key
+		* @returns {boolean} Whether the key exists
+		*/
+		has(key) {
+			const entry = this.store.get(key);
+			if (!entry) return false;
+			if (Date.now() > entry.expiresAt) {
+				this.store.delete(key);
+				return false;
+			}
+			return true;
+		}
+		/**
+		* Delete a key from cache
+		* @param {string} key - Cache key
+		*/
+		delete(key) {
+			this.store.delete(key);
+		}
+		/**
+		* Invalidate all cache entries matching a prefix
+		* @param {string} prefix - Key prefix
+		*/
+		invalidateByPrefix(prefix) {
+			for (const key of this.store.keys()) if (key.startsWith(prefix)) this.store.delete(key);
+		}
+		/**
+		* Clear all cached entries
+		*/
+		clear() {
+			this.store.clear();
+		}
+		/**
+		* Get the number of cached entries
+		* @returns {number} Number of entries
+		*/
+		get size() {
+			return this.store.size;
+		}
+		/**
+		* Get hit count for a cache key
+		* @param {string} key - Cache key
+		* @returns {number} Number of hits
+		*/
+		getHitCount(key) {
+			return this.store.get(key)?.hitCount ?? 0;
+		}
+		/**
+		* Extend the TTL of a cache entry based on hit count
+		* @param {string} key - Cache key
+		* @param {number} baseTtl - Base TTL in milliseconds
+		* @param {number} maxTtl - Maximum TTL in milliseconds
+		*/
+		extendTtl(key, baseTtl, maxTtl) {
+			const entry = this.store.get(key);
+			if (!entry) return;
+			const adaptiveTtl = Math.min(maxTtl, baseTtl * (1 + Math.log2(entry.hitCount + 1)));
+			entry.expiresAt = Date.now() + adaptiveTtl;
+		}
+		evict() {
+			let oldestKey = null;
+			let oldestAccess = Number.POSITIVE_INFINITY;
+			for (const [key, entry] of this.store) {
+				if (Date.now() > entry.expiresAt) {
+					this.store.delete(key);
+					return;
+				}
+				if (entry.lastAccess < oldestAccess) {
+					oldestAccess = entry.lastAccess;
+					oldestKey = key;
+				}
 			}
+			if (oldestKey) this.store.delete(oldestKey);
 		}
-		if (oldestKey) this.store.delete(oldestKey);
-	}
-};
+	};
+}));
 //#endregion
-export { MemoryStore };
+init_memory_store();
+export { MemoryStore, init_memory_store };
 
 //# sourceMappingURL=memory-store.mjs.map

package/dist/cache/memory-store.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory-store.mjs","names":[],"sources":["../../src/cache/memory-store.ts"],"sourcesContent":["interface CacheEntry {\n  value: unknown;\n  expiresAt: number;\n  hitCount: number;\n  lastAccess: number;\n}\n\n/**\n * In-memory cache store with TTL and hit-count tracking\n */\nexport class MemoryStore {\n  private store = new Map<string, CacheEntry>();\n  private maxEntries: number;\n\n  constructor(maxEntries = 10_000) {\n    this.maxEntries = maxEntries;\n  }\n\n  /**\n   * Get a value from cache\n   * @param {string} key - Cache key\n   * @returns {unknown | undefined} Cached value or undefined\n   */\n  get(key: string): unknown | undefined {\n    const entry = this.store.get(key);\n    if (!entry) {\n      return undefined;\n    }\n    if (Date.now() > entry.expiresAt) {\n      this.store.delete(key);\n      return undefined;\n    }\n    entry.hitCount++;\n    entry.lastAccess = Date.now();\n    return entry.value;\n  }\n\n  /**\n   * Set a value in cache with TTL\n   * @param {string} key - Cache key\n   * @param {unknown} value - Value to cache\n   * @param {number} ttl - Time to live in milliseconds\n   */\n  set(key: string, value: unknown, ttl: number): void {\n    if (this.store.size >= this.maxEntries) {\n      this.evict();\n    }\n    this.store.set(key, {\n      value,\n      expiresAt: Date.now() + ttl,\n      hitCount: 1,\n      lastAccess: Date.now(),\n    });\n  }\n\n  /**\n   * Check if a key exists in cache and is not expired\n   * @param {string} key - Cache key\n   * @returns {boolean} Whether the key exists\n   */\n  has(key: string): boolean {\n    const entry = this.store.get(key);\n    if (!entry) {\n      return false;\n    }\n    if (Date.now() > entry.expiresAt) {\n      this.store.delete(key);\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * Delete a key from cache\n   * @param {string} key - Cache key\n   */\n  delete(key: string): void {\n    this.store.delete(key);\n  }\n\n  /**\n   * Invalidate all cache entries matching a prefix\n   * @param {string} prefix - Key prefix\n   */\n  invalidateByPrefix(prefix: string): void {\n    for (const key of this.store.keys()) {\n      if (key.startsWith(prefix)) {\n        this.store.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Clear all cached entries\n   */\n  clear(): void {\n    this.store.clear();\n  }\n\n  /**\n   * Get the number of cached entries\n   * @returns {number} Number of entries\n   */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /**\n   * Get hit count for a cache key\n   * @param {string} key - Cache key\n   * @returns {number} Number of hits\n   */\n  getHitCount(key: string): number {\n    return this.store.get(key)?.hitCount ?? 0;\n  }\n\n  /**\n   * Extend the TTL of a cache entry based on hit count\n   * @param {string} key - Cache key\n   * @param {number} baseTtl - Base TTL in milliseconds\n   * @param {number} maxTtl - Maximum TTL in milliseconds\n   */\n  extendTtl(key: string, baseTtl: number, maxTtl: number): void {\n    const entry = this.store.get(key);\n    if (!entry) {\n      return;\n    }\n    const adaptiveTtl = Math.min(maxTtl, baseTtl * (1 + Math.log2(entry.hitCount + 1)));\n    entry.expiresAt = Date.now() + adaptiveTtl;\n  }\n\n  private evict(): void {\n    let oldestKey: string | null = null;\n    let oldestAccess = Number.POSITIVE_INFINITY;\n    for (const [key, entry] of this.store) {\n      if (Date.now() > entry.expiresAt) {\n        this.store.delete(key);\n        return;\n      }\n      if (entry.lastAccess < oldestAccess) {\n        oldestAccess = entry.lastAccess;\n        oldestKey = key;\n      }\n    }\n    if (oldestKey) {\n      this.store.delete(oldestKey);\n    }\n  }\n}\n"],"mappings":";;;;AAUA,IAAa,cAAb,MAAyB;CACvB,wBAAgB,IAAI,KAAyB;CAC7C;CAEA,YAAY,aAAa,KAAQ;AAC/B,OAAK,aAAa;;;;;;;CAQpB,IAAI,KAAkC;EACpC,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,CAAC,MACH;AAEF,MAAI,KAAK,KAAK,GAAG,MAAM,WAAW;AAChC,QAAK,MAAM,OAAO,IAAI;AACtB;;AAEF,QAAM;AACN,QAAM,aAAa,KAAK,KAAK;AAC7B,SAAO,MAAM;;;;;;;;CASf,IAAI,KAAa,OAAgB,KAAmB;AAClD,MAAI,KAAK,MAAM,QAAQ,KAAK,WAC1B,MAAK,OAAO;AAEd,OAAK,MAAM,IAAI,KAAK;GAClB;GACA,WAAW,KAAK,KAAK,GAAG;GACxB,UAAU;GACV,YAAY,KAAK,KAAK;GACvB,CAAC;;;;;;;CAQJ,IAAI,KAAsB;EACxB,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,CAAC,MACH,QAAO;AAET,MAAI,KAAK,KAAK,GAAG,MAAM,WAAW;AAChC,QAAK,MAAM,OAAO,IAAI;AACtB,UAAO;;AAET,SAAO;;;;;;CAOT,OAAO,KAAmB;AACxB,OAAK,MAAM,OAAO,IAAI;;;;;;CAOxB,mBAAmB,QAAsB;AACvC,OAAK,MAAM,OAAO,KAAK,MAAM,MAAM,CACjC,KAAI,IAAI,WAAW,OAAO,CACxB,MAAK,MAAM,OAAO,IAAI;;;;;CAQ5B,QAAc;AACZ,OAAK,MAAM,OAAO;;;;;;CAOpB,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;;;;;;CAQpB,YAAY,KAAqB;AAC/B,SAAO,KAAK,MAAM,IAAI,IAAI,EAAE,YAAY;;;;;;;;CAS1C,UAAU,KAAa,SAAiB,QAAsB;EAC5D,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,CAAC,MACH;EAEF,MAAM,cAAc,KAAK,IAAI,QAAQ,WAAW,IAAI,KAAK,KAAK,MAAM,WAAW,EAAE,EAAE;AACnF,QAAM,YAAY,KAAK,KAAK,GAAG;;CAGjC,QAAsB;EACpB,IAAI,YAA2B;EAC/B,IAAI,eAAe,OAAO;AAC1B,OAAK,MAAM,CAAC,KAAK,UAAU,KAAK,OAAO;AACrC,OAAI,KAAK,KAAK,GAAG,MAAM,WAAW;AAChC,SAAK,MAAM,OAAO,IAAI;AACtB;;AAEF,OAAI,MAAM,aAAa,cAAc;AACnC,mBAAe,MAAM;AACrB,gBAAY;;;AAGhB,MAAI,UACF,MAAK,MAAM,OAAO,UAAU"}
+{"version":3,"file":"memory-store.mjs","names":[],"sources":["../../src/cache/memory-store.ts"],"sourcesContent":["interface CacheEntry {\n  value: unknown;\n  expiresAt: number;\n  hitCount: number;\n  lastAccess: number;\n}\n\n/**\n * In-memory cache store with TTL and hit-count tracking\n */\nexport class MemoryStore {\n  private store = new Map<string, CacheEntry>();\n  private maxEntries: number;\n\n  constructor(maxEntries = 10_000) {\n    this.maxEntries = maxEntries;\n  }\n\n  /**\n   * Get a value from cache\n   * @param {string} key - Cache key\n   * @returns {unknown | undefined} Cached value or undefined\n   */\n  get(key: string): unknown | undefined {\n    const entry = this.store.get(key);\n    if (!entry) {\n      return undefined;\n    }\n    if (Date.now() > entry.expiresAt) {\n      this.store.delete(key);\n      return undefined;\n    }\n    entry.hitCount++;\n    entry.lastAccess = Date.now();\n    return entry.value;\n  }\n\n  /**\n   * Set a value in cache with TTL\n   * @param {string} key - Cache key\n   * @param {unknown} value - Value to cache\n   * @param {number} ttl - Time to live in milliseconds\n   */\n  set(key: string, value: unknown, ttl: number): void {\n    if (this.store.size >= this.maxEntries) {\n      this.evict();\n    }\n    this.store.set(key, {\n      value,\n      expiresAt: Date.now() + ttl,\n      hitCount: 1,\n      lastAccess: Date.now(),\n    });\n  }\n\n  /**\n   * Check if a key exists in cache and is not expired\n   * @param {string} key - Cache key\n   * @returns {boolean} Whether the key exists\n   */\n  has(key: string): boolean {\n    const entry = this.store.get(key);\n    if (!entry) {\n      return false;\n    }\n    if (Date.now() > entry.expiresAt) {\n      this.store.delete(key);\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * Delete a key from cache\n   * @param {string} key - Cache key\n   */\n  delete(key: string): void {\n    this.store.delete(key);\n  }\n\n  /**\n   * Invalidate all cache entries matching a prefix\n   * @param {string} prefix - Key prefix\n   */\n  invalidateByPrefix(prefix: string): void {\n    for (const key of this.store.keys()) {\n      if (key.startsWith(prefix)) {\n        this.store.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Clear all cached entries\n   */\n  clear(): void {\n    this.store.clear();\n  }\n\n  /**\n   * Get the number of cached entries\n   * @returns {number} Number of entries\n   */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /**\n   * Get hit count for a cache key\n   * @param {string} key - Cache key\n   * @returns {number} Number of hits\n   */\n  getHitCount(key: string): number {\n    return this.store.get(key)?.hitCount ?? 0;\n  }\n\n  /**\n   * Extend the TTL of a cache entry based on hit count\n   * @param {string} key - Cache key\n   * @param {number} baseTtl - Base TTL in milliseconds\n   * @param {number} maxTtl - Maximum TTL in milliseconds\n   */\n  extendTtl(key: string, baseTtl: number, maxTtl: number): void {\n    const entry = this.store.get(key);\n    if (!entry) {\n      return;\n    }\n    const adaptiveTtl = Math.min(maxTtl, baseTtl * (1 + Math.log2(entry.hitCount + 1)));\n    entry.expiresAt = Date.now() + adaptiveTtl;\n  }\n\n  private evict(): void {\n    let oldestKey: string | null = null;\n    let oldestAccess = Number.POSITIVE_INFINITY;\n    for (const [key, entry] of this.store) {\n      if (Date.now() > entry.expiresAt) {\n        this.store.delete(key);\n        return;\n      }\n      if (entry.lastAccess < oldestAccess) {\n        oldestAccess = entry.lastAccess;\n        oldestKey = key;\n      }\n    }\n    if (oldestKey) {\n      this.store.delete(oldestKey);\n    }\n  }\n}\n"],"mappings":";;;;AAUa,eAAb,MAAyB;EACvB,wBAAgB,IAAI,KAAyB;EAC7C;EAEA,YAAY,aAAa,KAAQ;AAC/B,QAAK,aAAa;;;;;;;EAQpB,IAAI,KAAkC;GACpC,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,OAAI,CAAC,MACH;AAEF,OAAI,KAAK,KAAK,GAAG,MAAM,WAAW;AAChC,SAAK,MAAM,OAAO,IAAI;AACtB;;AAEF,SAAM;AACN,SAAM,aAAa,KAAK,KAAK;AAC7B,UAAO,MAAM;;;;;;;;EASf,IAAI,KAAa,OAAgB,KAAmB;AAClD,OAAI,KAAK,MAAM,QAAQ,KAAK,WAC1B,MAAK,OAAO;AAEd,QAAK,MAAM,IAAI,KAAK;IAClB;IACA,WAAW,KAAK,KAAK,GAAG;IACxB,UAAU;IACV,YAAY,KAAK,KAAK;IACvB,CAAC;;;;;;;EAQJ,IAAI,KAAsB;GACxB,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,OAAI,CAAC,MACH,QAAO;AAET,OAAI,KAAK,KAAK,GAAG,MAAM,WAAW;AAChC,SAAK,MAAM,OAAO,IAAI;AACtB,WAAO;;AAET,UAAO;;;;;;EAOT,OAAO,KAAmB;AACxB,QAAK,MAAM,OAAO,IAAI;;;;;;EAOxB,mBAAmB,QAAsB;AACvC,QAAK,MAAM,OAAO,KAAK,MAAM,MAAM,CACjC,KAAI,IAAI,WAAW,OAAO,CACxB,MAAK,MAAM,OAAO,IAAI;;;;;EAQ5B,QAAc;AACZ,QAAK,MAAM,OAAO;;;;;;EAOpB,IAAI,OAAe;AACjB,UAAO,KAAK,MAAM;;;;;;;EAQpB,YAAY,KAAqB;AAC/B,UAAO,KAAK,MAAM,IAAI,IAAI,EAAE,YAAY;;;;;;;;EAS1C,UAAU,KAAa,SAAiB,QAAsB;GAC5D,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,OAAI,CAAC,MACH;GAEF,MAAM,cAAc,KAAK,IAAI,QAAQ,WAAW,IAAI,KAAK,KAAK,MAAM,WAAW,EAAE,EAAE;AACnF,SAAM,YAAY,KAAK,KAAK,GAAG;;EAGjC,QAAsB;GACpB,IAAI,YAA2B;GAC/B,IAAI,eAAe,OAAO;AAC1B,QAAK,MAAM,CAAC,KAAK,UAAU,KAAK,OAAO;AACrC,QAAI,KAAK,KAAK,GAAG,MAAM,WAAW;AAChC,UAAK,MAAM,OAAO,IAAI;AACtB;;AAEF,QAAI,MAAM,aAAa,cAAc;AACnC,oBAAe,MAAM;AACrB,iBAAY;;;AAGhB,OAAI,UACF,MAAK,MAAM,OAAO,UAAU"}