@geekmidas/cache 0.0.7 → 0.1.0

package/dist/__tests__/integration.spec.cjs

@@ -1,235 +0,0 @@
-require('../src-C7d6HaTp.cjs');
-const require_memory = require('../memory-Csy6J-Ak.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-B-qkABPq.cjs');
-
-//#region src/__tests__/integration.spec.ts
-require_vi_bdSIJ99Y.describe("Cache Integration Tests", () => {
-	let memoryCache;
-	require_vi_bdSIJ99Y.beforeEach(() => {
-		memoryCache = new require_memory.InMemoryCache();
-	});
-	require_vi_bdSIJ99Y.describe("cross-cache behavior consistency", () => {
-		const testCases = [{
-			name: "InMemoryCache",
-			cache: () => new require_memory.InMemoryCache()
-		}];
-		testCases.forEach(({ name, cache }) => {
-			require_vi_bdSIJ99Y.describe(name, () => {
-				let cacheInstance;
-				require_vi_bdSIJ99Y.beforeEach(() => {
-					cacheInstance = cache();
-				});
-				require_vi_bdSIJ99Y.it("should handle basic CRUD operations", async () => {
-					await cacheInstance.set("user:1", {
-						id: 1,
-						name: "John"
-					});
-					const user = await cacheInstance.get("user:1");
-					require_vi_bdSIJ99Y.globalExpect(user).toEqual({
-						id: 1,
-						name: "John"
-					});
-					await cacheInstance.set("user:1", {
-						id: 1,
-						name: "Jane"
-					});
-					const updatedUser = await cacheInstance.get("user:1");
-					require_vi_bdSIJ99Y.globalExpect(updatedUser).toEqual({
-						id: 1,
-						name: "Jane"
-					});
-					await cacheInstance.delete("user:1");
-					const deletedUser = await cacheInstance.get("user:1");
-					require_vi_bdSIJ99Y.globalExpect(deletedUser).toBeUndefined();
-				});
-				require_vi_bdSIJ99Y.it("should handle concurrent operations", async () => {
-					const operations = [
-						cacheInstance.set("key1", "value1"),
-						cacheInstance.set("key2", "value2"),
-						cacheInstance.set("key3", "value3")
-					];
-					await Promise.all(operations);
-					const results = await Promise.all([
-						cacheInstance.get("key1"),
-						cacheInstance.get("key2"),
-						cacheInstance.get("key3")
-					]);
-					require_vi_bdSIJ99Y.globalExpect(results).toEqual([
-						"value1",
-						"value2",
-						"value3"
-					]);
-				});
-				require_vi_bdSIJ99Y.it("should handle data type preservation", async () => {
-					const testData = {
-						string: "hello",
-						number: 42,
-						boolean: true,
-						object: { nested: true },
-						array: [
-							1,
-							2,
-							3
-						],
-						null: null
-					};
-					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
-					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					require_vi_bdSIJ99Y.globalExpect(results[0]).toBe("hello");
-					require_vi_bdSIJ99Y.globalExpect(results[1]).toBe(42);
-					require_vi_bdSIJ99Y.globalExpect(results[2]).toBe(true);
-					require_vi_bdSIJ99Y.globalExpect(results[3]).toEqual({ nested: true });
-					require_vi_bdSIJ99Y.globalExpect(results[4]).toEqual([
-						1,
-						2,
-						3
-					]);
-					require_vi_bdSIJ99Y.globalExpect(results[5]).toBeNull();
-				});
-				require_vi_bdSIJ99Y.it("should handle key isolation", async () => {
-					await cacheInstance.set("user:1", "User One");
-					await cacheInstance.set("user:2", "User Two");
-					await cacheInstance.set("session:1", "Session One");
-					await cacheInstance.delete("user:1");
-					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
-					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
-					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
-				});
-			});
-		});
-	});
-	require_vi_bdSIJ99Y.describe("cache migration scenarios", () => {
-		require_vi_bdSIJ99Y.it("should support migrating data between cache implementations", async () => {
-			const sourceCache = new require_memory.InMemoryCache();
-			const targetCache = new require_memory.InMemoryCache();
-			const testData = {
-				"user:1": {
-					id: 1,
-					name: "John"
-				},
-				"user:2": {
-					id: 2,
-					name: "Jane"
-				},
-				"config:app": {
-					theme: "dark",
-					notifications: true
-				}
-			};
-			for (const [key, value] of Object.entries(testData)) await sourceCache.set(key, value);
-			const migrationKeys = Object.keys(testData);
-			for (const key of migrationKeys) {
-				const value = await sourceCache.get(key);
-				if (value !== void 0) await targetCache.set(key, value);
-			}
-			for (const [key, expectedValue] of Object.entries(testData)) {
-				const migratedValue = await targetCache.get(key);
-				require_vi_bdSIJ99Y.globalExpect(migratedValue).toEqual(expectedValue);
-			}
-		});
-	});
-	require_vi_bdSIJ99Y.describe("cache abstraction patterns", () => {
-		require_vi_bdSIJ99Y.it("should support cache factory pattern", async () => {
-			const createCache = (type) => {
-				switch (type) {
-					case "memory": return new require_memory.InMemoryCache();
-					default: throw new Error(`Unknown cache type: ${type}`);
-				}
-			};
-			const userCache = createCache("memory");
-			const sessionCache = createCache("memory");
-			await userCache.set("user:1", {
-				id: 1,
-				name: "John"
-			});
-			await sessionCache.set("session:abc", "active");
-			require_vi_bdSIJ99Y.globalExpect(await userCache.get("user:1")).toEqual({
-				id: 1,
-				name: "John"
-			});
-			require_vi_bdSIJ99Y.globalExpect(await sessionCache.get("session:abc")).toBe("active");
-		});
-		require_vi_bdSIJ99Y.it("should support cache wrapper pattern", async () => {
-			class LoggingCache {
-				logs = [];
-				constructor(underlying) {
-					this.underlying = underlying;
-				}
-				async get(key) {
-					this.logs.push(`GET ${key}`);
-					return this.underlying.get(key);
-				}
-				async set(key, value) {
-					this.logs.push(`SET ${key}`);
-					return this.underlying.set(key, value);
-				}
-				async delete(key) {
-					this.logs.push(`DELETE ${key}`);
-					return this.underlying.delete(key);
-				}
-				getLogs() {
-					return [...this.logs];
-				}
-			}
-			const baseCache = new require_memory.InMemoryCache();
-			const loggingCache = new LoggingCache(baseCache);
-			await loggingCache.set("test", "value");
-			await loggingCache.get("test");
-			await loggingCache.delete("test");
-			const logs = loggingCache.getLogs();
-			require_vi_bdSIJ99Y.globalExpect(logs).toEqual([
-				"SET test",
-				"GET test",
-				"DELETE test"
-			]);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("performance and stress tests", () => {
-		require_vi_bdSIJ99Y.it("should handle large number of operations", async () => {
-			const cache = new require_memory.InMemoryCache();
-			const operationCount = 1e3;
-			const insertPromises = Array.from({ length: operationCount }, (_, i) => cache.set(`key:${i}`, i));
-			await Promise.all(insertPromises);
-			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
-			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) require_vi_bdSIJ99Y.globalExpect(results[i]).toBe(i);
-			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
-			await Promise.all(deletePromises);
-			const postDeleteRead = await cache.get("key:0");
-			require_vi_bdSIJ99Y.globalExpect(postDeleteRead).toBeUndefined();
-		});
-		require_vi_bdSIJ99Y.it("should handle large objects efficiently", async () => {
-			const cache = new require_memory.InMemoryCache();
-			const largeObject = {
-				id: 1,
-				data: Array.from({ length: 1e3 }, (_, i) => ({
-					index: i,
-					value: `value-${i}`,
-					metadata: {
-						timestamp: Date.now(),
-						random: Math.random()
-					}
-				}))
-			};
-			const startTime = Date.now();
-			await cache.set("large-object", largeObject);
-			const result = await cache.get("large-object");
-			const endTime = Date.now();
-			require_vi_bdSIJ99Y.globalExpect(result).toEqual(largeObject);
-			require_vi_bdSIJ99Y.globalExpect(endTime - startTime).toBeLessThan(100);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("error scenarios", () => {
-		require_vi_bdSIJ99Y.it("should handle operations after errors gracefully", async () => {
-			const cache = new require_memory.InMemoryCache();
-			await cache.set("valid-key", "valid-value");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("valid-key")).toBe("valid-value");
-			await cache.set("another-key", "another-value");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("another-key")).toBe("another-value");
-			await cache.delete("valid-key");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("valid-key")).toBeUndefined();
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/integration.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/integration.spec.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/integration.spec.mjs

@@ -1,235 +0,0 @@
-import { beforeEach, describe, globalExpect, it } from "../vi.bdSIJ99Y-CB5havZF.mjs";
-import "../src-DVpoP03o.mjs";
-import { InMemoryCache } from "../memory-QDTnSEX5.mjs";
-
-//#region src/__tests__/integration.spec.ts
-describe("Cache Integration Tests", () => {
-	let memoryCache;
-	beforeEach(() => {
-		memoryCache = new InMemoryCache();
-	});
-	describe("cross-cache behavior consistency", () => {
-		const testCases = [{
-			name: "InMemoryCache",
-			cache: () => new InMemoryCache()
-		}];
-		testCases.forEach(({ name, cache }) => {
-			describe(name, () => {
-				let cacheInstance;
-				beforeEach(() => {
-					cacheInstance = cache();
-				});
-				it("should handle basic CRUD operations", async () => {
-					await cacheInstance.set("user:1", {
-						id: 1,
-						name: "John"
-					});
-					const user = await cacheInstance.get("user:1");
-					globalExpect(user).toEqual({
-						id: 1,
-						name: "John"
-					});
-					await cacheInstance.set("user:1", {
-						id: 1,
-						name: "Jane"
-					});
-					const updatedUser = await cacheInstance.get("user:1");
-					globalExpect(updatedUser).toEqual({
-						id: 1,
-						name: "Jane"
-					});
-					await cacheInstance.delete("user:1");
-					const deletedUser = await cacheInstance.get("user:1");
-					globalExpect(deletedUser).toBeUndefined();
-				});
-				it("should handle concurrent operations", async () => {
-					const operations = [
-						cacheInstance.set("key1", "value1"),
-						cacheInstance.set("key2", "value2"),
-						cacheInstance.set("key3", "value3")
-					];
-					await Promise.all(operations);
-					const results = await Promise.all([
-						cacheInstance.get("key1"),
-						cacheInstance.get("key2"),
-						cacheInstance.get("key3")
-					]);
-					globalExpect(results).toEqual([
-						"value1",
-						"value2",
-						"value3"
-					]);
-				});
-				it("should handle data type preservation", async () => {
-					const testData = {
-						string: "hello",
-						number: 42,
-						boolean: true,
-						object: { nested: true },
-						array: [
-							1,
-							2,
-							3
-						],
-						null: null
-					};
-					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
-					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					globalExpect(results[0]).toBe("hello");
-					globalExpect(results[1]).toBe(42);
-					globalExpect(results[2]).toBe(true);
-					globalExpect(results[3]).toEqual({ nested: true });
-					globalExpect(results[4]).toEqual([
-						1,
-						2,
-						3
-					]);
-					globalExpect(results[5]).toBeNull();
-				});
-				it("should handle key isolation", async () => {
-					await cacheInstance.set("user:1", "User One");
-					await cacheInstance.set("user:2", "User Two");
-					await cacheInstance.set("session:1", "Session One");
-					await cacheInstance.delete("user:1");
-					globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
-					globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
-					globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
-				});
-			});
-		});
-	});
-	describe("cache migration scenarios", () => {
-		it("should support migrating data between cache implementations", async () => {
-			const sourceCache = new InMemoryCache();
-			const targetCache = new InMemoryCache();
-			const testData = {
-				"user:1": {
-					id: 1,
-					name: "John"
-				},
-				"user:2": {
-					id: 2,
-					name: "Jane"
-				},
-				"config:app": {
-					theme: "dark",
-					notifications: true
-				}
-			};
-			for (const [key, value] of Object.entries(testData)) await sourceCache.set(key, value);
-			const migrationKeys = Object.keys(testData);
-			for (const key of migrationKeys) {
-				const value = await sourceCache.get(key);
-				if (value !== void 0) await targetCache.set(key, value);
-			}
-			for (const [key, expectedValue] of Object.entries(testData)) {
-				const migratedValue = await targetCache.get(key);
-				globalExpect(migratedValue).toEqual(expectedValue);
-			}
-		});
-	});
-	describe("cache abstraction patterns", () => {
-		it("should support cache factory pattern", async () => {
-			const createCache = (type) => {
-				switch (type) {
-					case "memory": return new InMemoryCache();
-					default: throw new Error(`Unknown cache type: ${type}`);
-				}
-			};
-			const userCache = createCache("memory");
-			const sessionCache = createCache("memory");
-			await userCache.set("user:1", {
-				id: 1,
-				name: "John"
-			});
-			await sessionCache.set("session:abc", "active");
-			globalExpect(await userCache.get("user:1")).toEqual({
-				id: 1,
-				name: "John"
-			});
-			globalExpect(await sessionCache.get("session:abc")).toBe("active");
-		});
-		it("should support cache wrapper pattern", async () => {
-			class LoggingCache {
-				logs = [];
-				constructor(underlying) {
-					this.underlying = underlying;
-				}
-				async get(key) {
-					this.logs.push(`GET ${key}`);
-					return this.underlying.get(key);
-				}
-				async set(key, value) {
-					this.logs.push(`SET ${key}`);
-					return this.underlying.set(key, value);
-				}
-				async delete(key) {
-					this.logs.push(`DELETE ${key}`);
-					return this.underlying.delete(key);
-				}
-				getLogs() {
-					return [...this.logs];
-				}
-			}
-			const baseCache = new InMemoryCache();
-			const loggingCache = new LoggingCache(baseCache);
-			await loggingCache.set("test", "value");
-			await loggingCache.get("test");
-			await loggingCache.delete("test");
-			const logs = loggingCache.getLogs();
-			globalExpect(logs).toEqual([
-				"SET test",
-				"GET test",
-				"DELETE test"
-			]);
-		});
-	});
-	describe("performance and stress tests", () => {
-		it("should handle large number of operations", async () => {
-			const cache = new InMemoryCache();
-			const operationCount = 1e3;
-			const insertPromises = Array.from({ length: operationCount }, (_, i) => cache.set(`key:${i}`, i));
-			await Promise.all(insertPromises);
-			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
-			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) globalExpect(results[i]).toBe(i);
-			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
-			await Promise.all(deletePromises);
-			const postDeleteRead = await cache.get("key:0");
-			globalExpect(postDeleteRead).toBeUndefined();
-		});
-		it("should handle large objects efficiently", async () => {
-			const cache = new InMemoryCache();
-			const largeObject = {
-				id: 1,
-				data: Array.from({ length: 1e3 }, (_, i) => ({
-					index: i,
-					value: `value-${i}`,
-					metadata: {
-						timestamp: Date.now(),
-						random: Math.random()
-					}
-				}))
-			};
-			const startTime = Date.now();
-			await cache.set("large-object", largeObject);
-			const result = await cache.get("large-object");
-			const endTime = Date.now();
-			globalExpect(result).toEqual(largeObject);
-			globalExpect(endTime - startTime).toBeLessThan(100);
-		});
-	});
-	describe("error scenarios", () => {
-		it("should handle operations after errors gracefully", async () => {
-			const cache = new InMemoryCache();
-			await cache.set("valid-key", "valid-value");
-			globalExpect(await cache.get("valid-key")).toBe("valid-value");
-			await cache.set("another-key", "another-value");
-			globalExpect(await cache.get("another-key")).toBe("another-value");
-			await cache.delete("valid-key");
-			globalExpect(await cache.get("valid-key")).toBeUndefined();
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/memory.spec.cjs

@@ -1,126 +0,0 @@
-require('../src-C7d6HaTp.cjs');
-const require_memory = require('../memory-Csy6J-Ak.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-B-qkABPq.cjs');
-
-//#region src/__tests__/memory.spec.ts
-require_vi_bdSIJ99Y.describe("InMemoryCache", () => {
-	let cache;
-	require_vi_bdSIJ99Y.beforeEach(() => {
-		cache = new require_memory.InMemoryCache();
-	});
-	require_vi_bdSIJ99Y.describe("get", () => {
-		require_vi_bdSIJ99Y.it("should return undefined for non-existent key", async () => {
-			const result = await cache.get("non-existent");
-			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
-		});
-		require_vi_bdSIJ99Y.it("should return value for existing key", async () => {
-			await cache.set("test-key", "test-value");
-			const result = await cache.get("test-key");
-			require_vi_bdSIJ99Y.globalExpect(result).toBe("test-value");
-		});
-		require_vi_bdSIJ99Y.it("should handle different data types", async () => {
-			const objectValue = {
-				id: 1,
-				name: "test"
-			};
-			const arrayValue = [
-				1,
-				2,
-				3
-			];
-			const numberValue = 42;
-			const booleanValue = true;
-			await cache.set("object", objectValue);
-			await cache.set("array", arrayValue);
-			await cache.set("number", numberValue);
-			await cache.set("boolean", booleanValue);
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("object")).toEqual(objectValue);
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("array")).toEqual(arrayValue);
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("number")).toBe(numberValue);
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("boolean")).toBe(booleanValue);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("set", () => {
-		require_vi_bdSIJ99Y.it("should store string value", async () => {
-			await cache.set("string-key", "string-value");
-			const result = await cache.get("string-key");
-			require_vi_bdSIJ99Y.globalExpect(result).toBe("string-value");
-		});
-		require_vi_bdSIJ99Y.it("should store object value", async () => {
-			const value = {
-				id: 1,
-				data: "test"
-			};
-			await cache.set("object-key", value);
-			const result = await cache.get("object-key");
-			require_vi_bdSIJ99Y.globalExpect(result).toEqual(value);
-		});
-		require_vi_bdSIJ99Y.it("should overwrite existing value", async () => {
-			await cache.set("key", "initial-value");
-			await cache.set("key", "updated-value");
-			const result = await cache.get("key");
-			require_vi_bdSIJ99Y.globalExpect(result).toBe("updated-value");
-		});
-		require_vi_bdSIJ99Y.it("should handle null values", async () => {
-			await cache.set("null-key", null);
-			const result = await cache.get("null-key");
-			require_vi_bdSIJ99Y.globalExpect(result).toBeNull();
-		});
-	});
-	require_vi_bdSIJ99Y.describe("delete", () => {
-		require_vi_bdSIJ99Y.it("should remove existing key", async () => {
-			await cache.set("to-delete", "value");
-			await cache.delete("to-delete");
-			const result = await cache.get("to-delete");
-			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
-		});
-		require_vi_bdSIJ99Y.it("should not throw error for non-existent key", async () => {
-			await require_vi_bdSIJ99Y.globalExpect(cache.delete("non-existent")).resolves.not.toThrow();
-		});
-		require_vi_bdSIJ99Y.it("should only delete specified key", async () => {
-			await cache.set("key1", "value1");
-			await cache.set("key2", "value2");
-			await cache.delete("key1");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("key1")).toBeUndefined();
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("key2")).toBe("value2");
-		});
-	});
-	require_vi_bdSIJ99Y.describe("multiple operations", () => {
-		require_vi_bdSIJ99Y.it("should handle multiple keys independently", async () => {
-			await cache.set("key1", "value1");
-			await cache.set("key2", "value2");
-			await cache.set("key3", "value3");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("key1")).toBe("value1");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("key2")).toBe("value2");
-			require_vi_bdSIJ99Y.globalExpect(await cache.get("key3")).toBe("value3");
-		});
-		require_vi_bdSIJ99Y.it("should maintain data integrity across operations", async () => {
-			const data = { count: 0 };
-			await cache.set("counter", data);
-			const retrieved = await cache.get("counter");
-			retrieved.count = 5;
-			const original = await cache.get("counter");
-			require_vi_bdSIJ99Y.globalExpect(original.count).toBe(5);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("edge cases", () => {
-		require_vi_bdSIJ99Y.it("should handle empty string as key", async () => {
-			await cache.set("", "empty-key-value");
-			const result = await cache.get("");
-			require_vi_bdSIJ99Y.globalExpect(result).toBe("empty-key-value");
-		});
-		require_vi_bdSIJ99Y.it("should handle special characters in keys", async () => {
-			const specialKey = "key!@#$%^&*()_+{}|:\"<>?[]\\;',./?`~";
-			await cache.set(specialKey, "special-value");
-			const result = await cache.get(specialKey);
-			require_vi_bdSIJ99Y.globalExpect(result).toBe("special-value");
-		});
-		require_vi_bdSIJ99Y.it("should handle undefined values", async () => {
-			await cache.set("undefined-key", void 0);
-			const result = await cache.get("undefined-key");
-			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/memory.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/memory.spec.d.mts

@@ -1 +0,0 @@
-export { };