@geekmidas/cache 0.0.1

package/dist/__tests__/cache.spec.cjs

@@ -0,0 +1,76 @@
+const require_memory = require('../memory-n6Iosq6J.cjs');
+const require_upstash = require('../upstash-s7dedvpn.cjs');
+const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+
+//#region src/__tests__/cache.spec.ts
+require_vi_DgezovHB.describe("Cache Interface", () => {
+	require_vi_DgezovHB.describe("interface compliance", () => {
+		require_vi_DgezovHB.it("InMemoryCache should implement Cache interface", () => {
+			const cache = new require_memory.InMemoryCache();
+			require_vi_DgezovHB.globalExpect(typeof cache.get).toBe("function");
+			require_vi_DgezovHB.globalExpect(typeof cache.set).toBe("function");
+			require_vi_DgezovHB.globalExpect(typeof cache.delete).toBe("function");
+		});
+		require_vi_DgezovHB.it("UpstashCache should implement Cache interface", () => {
+			const cache = new require_upstash.UpstashCache("http://localhost:8079", "example_token");
+			require_vi_DgezovHB.globalExpect(typeof cache.get).toBe("function");
+			require_vi_DgezovHB.globalExpect(typeof cache.set).toBe("function");
+			require_vi_DgezovHB.globalExpect(typeof cache.delete).toBe("function");
+		});
+	});
+	require_vi_DgezovHB.describe("method signatures", () => {
+		require_vi_DgezovHB.it("should have correct get method signature", () => {
+			const cache = new require_memory.InMemoryCache();
+			const getResult = cache.get("test");
+			require_vi_DgezovHB.globalExpect(getResult).toBeInstanceOf(Promise);
+		});
+		require_vi_DgezovHB.it("should have correct set method signature", () => {
+			const cache = new require_memory.InMemoryCache();
+			const setResult = cache.set("test", "value");
+			require_vi_DgezovHB.globalExpect(setResult).toBeInstanceOf(Promise);
+		});
+		require_vi_DgezovHB.it("should have correct delete method signature", () => {
+			const cache = new require_memory.InMemoryCache();
+			const deleteResult = cache.delete("test");
+			require_vi_DgezovHB.globalExpect(deleteResult).toBeInstanceOf(Promise);
+		});
+	});
+	require_vi_DgezovHB.describe("generic type support", () => {
+		require_vi_DgezovHB.it("should support string types", async () => {
+			const cache = new require_memory.InMemoryCache();
+			await cache.set("key", "value");
+			const result = await cache.get("key");
+			require_vi_DgezovHB.globalExpect(typeof result === "string" || result === void 0).toBe(true);
+		});
+		require_vi_DgezovHB.it("should support number types", async () => {
+			const cache = new require_memory.InMemoryCache();
+			await cache.set("key", 42);
+			const result = await cache.get("key");
+			require_vi_DgezovHB.globalExpect(typeof result === "number" || result === void 0).toBe(true);
+		});
+		require_vi_DgezovHB.it("should support object types", async () => {
+			const cache = new require_memory.InMemoryCache();
+			const user = {
+				id: 1,
+				name: "John"
+			};
+			await cache.set("user", user);
+			const result = await cache.get("user");
+			require_vi_DgezovHB.globalExpect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
+		});
+		require_vi_DgezovHB.it("should support union types", async () => {
+			const cache = new require_memory.InMemoryCache();
+			await cache.set("string", "text");
+			await cache.set("number", 42);
+			await cache.set("boolean", true);
+			const stringResult = await cache.get("string");
+			const numberResult = await cache.get("number");
+			const booleanResult = await cache.get("boolean");
+			require_vi_DgezovHB.globalExpect(stringResult).toBe("text");
+			require_vi_DgezovHB.globalExpect(numberResult).toBe(42);
+			require_vi_DgezovHB.globalExpect(booleanResult).toBe(true);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/cache.spec.mjs

@@ -0,0 +1,76 @@
+import { describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
+import { InMemoryCache } from "../memory-YteQXj7m.mjs";
+import { UpstashCache } from "../upstash-Cpe9W0-L.mjs";
+
+//#region src/__tests__/cache.spec.ts
+describe("Cache Interface", () => {
+	describe("interface compliance", () => {
+		it("InMemoryCache should implement Cache interface", () => {
+			const cache = new InMemoryCache();
+			globalExpect(typeof cache.get).toBe("function");
+			globalExpect(typeof cache.set).toBe("function");
+			globalExpect(typeof cache.delete).toBe("function");
+		});
+		it("UpstashCache should implement Cache interface", () => {
+			const cache = new UpstashCache("http://localhost:8079", "example_token");
+			globalExpect(typeof cache.get).toBe("function");
+			globalExpect(typeof cache.set).toBe("function");
+			globalExpect(typeof cache.delete).toBe("function");
+		});
+	});
+	describe("method signatures", () => {
+		it("should have correct get method signature", () => {
+			const cache = new InMemoryCache();
+			const getResult = cache.get("test");
+			globalExpect(getResult).toBeInstanceOf(Promise);
+		});
+		it("should have correct set method signature", () => {
+			const cache = new InMemoryCache();
+			const setResult = cache.set("test", "value");
+			globalExpect(setResult).toBeInstanceOf(Promise);
+		});
+		it("should have correct delete method signature", () => {
+			const cache = new InMemoryCache();
+			const deleteResult = cache.delete("test");
+			globalExpect(deleteResult).toBeInstanceOf(Promise);
+		});
+	});
+	describe("generic type support", () => {
+		it("should support string types", async () => {
+			const cache = new InMemoryCache();
+			await cache.set("key", "value");
+			const result = await cache.get("key");
+			globalExpect(typeof result === "string" || result === void 0).toBe(true);
+		});
+		it("should support number types", async () => {
+			const cache = new InMemoryCache();
+			await cache.set("key", 42);
+			const result = await cache.get("key");
+			globalExpect(typeof result === "number" || result === void 0).toBe(true);
+		});
+		it("should support object types", async () => {
+			const cache = new InMemoryCache();
+			const user = {
+				id: 1,
+				name: "John"
+			};
+			await cache.set("user", user);
+			const result = await cache.get("user");
+			globalExpect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
+		});
+		it("should support union types", async () => {
+			const cache = new InMemoryCache();
+			await cache.set("string", "text");
+			await cache.set("number", 42);
+			await cache.set("boolean", true);
+			const stringResult = await cache.get("string");
+			const numberResult = await cache.get("number");
+			const booleanResult = await cache.get("boolean");
+			globalExpect(stringResult).toBe("text");
+			globalExpect(numberResult).toBe(42);
+			globalExpect(booleanResult).toBe(true);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/integration.spec.cjs

@@ -0,0 +1,234 @@
+const require_memory = require('../memory-n6Iosq6J.cjs');
+const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+
+//#region src/__tests__/integration.spec.ts
+require_vi_DgezovHB.describe("Cache Integration Tests", () => {
+	let memoryCache;
+	require_vi_DgezovHB.beforeEach(() => {
+		memoryCache = new require_memory.InMemoryCache();
+	});
+	require_vi_DgezovHB.describe("cross-cache behavior consistency", () => {
+		const testCases = [{
+			name: "InMemoryCache",
+			cache: () => new require_memory.InMemoryCache()
+		}];
+		testCases.forEach(({ name, cache }) => {
+			require_vi_DgezovHB.describe(name, () => {
+				let cacheInstance;
+				require_vi_DgezovHB.beforeEach(() => {
+					cacheInstance = cache();
+				});
+				require_vi_DgezovHB.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_DgezovHB.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_DgezovHB.globalExpect(updatedUser).toEqual({
+						id: 1,
+						name: "Jane"
+					});
+					await cacheInstance.delete("user:1");
+					const deletedUser = await cacheInstance.get("user:1");
+					require_vi_DgezovHB.globalExpect(deletedUser).toBeUndefined();
+				});
+				require_vi_DgezovHB.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_DgezovHB.globalExpect(results).toEqual([
+						"value1",
+						"value2",
+						"value3"
+					]);
+				});
+				require_vi_DgezovHB.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_DgezovHB.globalExpect(results[0]).toBe("hello");
+					require_vi_DgezovHB.globalExpect(results[1]).toBe(42);
+					require_vi_DgezovHB.globalExpect(results[2]).toBe(true);
+					require_vi_DgezovHB.globalExpect(results[3]).toEqual({ nested: true });
+					require_vi_DgezovHB.globalExpect(results[4]).toEqual([
+						1,
+						2,
+						3
+					]);
+					require_vi_DgezovHB.globalExpect(results[5]).toBeNull();
+				});
+				require_vi_DgezovHB.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_DgezovHB.globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
+					require_vi_DgezovHB.globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
+					require_vi_DgezovHB.globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
+				});
+			});
+		});
+	});
+	require_vi_DgezovHB.describe("cache migration scenarios", () => {
+		require_vi_DgezovHB.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_DgezovHB.globalExpect(migratedValue).toEqual(expectedValue);
+			}
+		});
+	});
+	require_vi_DgezovHB.describe("cache abstraction patterns", () => {
+		require_vi_DgezovHB.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_DgezovHB.globalExpect(await userCache.get("user:1")).toEqual({
+				id: 1,
+				name: "John"
+			});
+			require_vi_DgezovHB.globalExpect(await sessionCache.get("session:abc")).toBe("active");
+		});
+		require_vi_DgezovHB.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_DgezovHB.globalExpect(logs).toEqual([
+				"SET test",
+				"GET test",
+				"DELETE test"
+			]);
+		});
+	});
+	require_vi_DgezovHB.describe("performance and stress tests", () => {
+		require_vi_DgezovHB.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_DgezovHB.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_DgezovHB.globalExpect(postDeleteRead).toBeUndefined();
+		});
+		require_vi_DgezovHB.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_DgezovHB.globalExpect(result).toEqual(largeObject);
+			require_vi_DgezovHB.globalExpect(endTime - startTime).toBeLessThan(100);
+		});
+	});
+	require_vi_DgezovHB.describe("error scenarios", () => {
+		require_vi_DgezovHB.it("should handle operations after errors gracefully", async () => {
+			const cache = new require_memory.InMemoryCache();
+			await cache.set("valid-key", "valid-value");
+			require_vi_DgezovHB.globalExpect(await cache.get("valid-key")).toBe("valid-value");
+			await cache.set("another-key", "another-value");
+			require_vi_DgezovHB.globalExpect(await cache.get("another-key")).toBe("another-value");
+			await cache.delete("valid-key");
+			require_vi_DgezovHB.globalExpect(await cache.get("valid-key")).toBeUndefined();
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/integration.spec.mjs

@@ -0,0 +1,234 @@
+import { beforeEach, describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
+import { InMemoryCache } from "../memory-YteQXj7m.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