@geekmidas/cache 0.0.7 → 0.2.0

package/src/memory.ts

@@ -1,37 +1,38 @@
 import { addSeconds } from 'date-fns';
 import { type Cache, getExpirationInSeconds } from './';
 
-export class InMemoryCache<T> implements Cache<T> {
-  private store: Map<string, T> = new Map();
-  private expirations: Map<string, Date> = new Map();
+export class InMemoryCache implements Cache {
+	private store: Map<string, unknown> = new Map();
+	private expirations: Map<string, Date> = new Map();
 
-  async get(key: string): Promise<T | undefined> {
-    const expiration = await this.ttl(key);
-    if (!expiration) {
-      await this.delete(key);
-      return undefined;
-    }
+	async get<T>(key: string): Promise<T | undefined> {
+		const expiration = await this.ttl(key);
+		if (!expiration) {
+			await this.delete(key);
+			return undefined;
+		}
 
-    return this.store.get(key);
-  }
+		return this.store.get(key) as T | undefined;
+	}
 
-  async ttl(key: string): Promise<number> {
-    const expiration = this.expirations.get(key);
-    if (!expiration) {
-      return 0;
-    }
+	async ttl(key: string): Promise<number> {
+		const expiration = this.expirations.get(key);
+		if (!expiration) {
+			return 0;
+		}
 
-    return getExpirationInSeconds(expiration);
-  }
+		return getExpirationInSeconds(expiration);
+	}
 
-  async set(key: string, value: T, ttl: number = 600): Promise<void> {
-    this.store.set(key, value);
-    const now = new Date();
-    const expiresAt = addSeconds(now, ttl);
-    this.expirations.set(key, expiresAt);
-  }
+	async set<T>(key: string, value: T, ttl: number = 600): Promise<void> {
+		this.store.set(key, value);
+		const now = new Date();
+		const expiresAt = addSeconds(now, ttl);
+		this.expirations.set(key, expiresAt);
+	}
 
-  async delete(key: string): Promise<void> {
-    this.store.delete(key);
-  }
+	async delete(key: string): Promise<void> {
+		this.store.delete(key);
+		this.expirations.delete(key);
+	}
 }

package/src/upstash.ts

@@ -1,41 +1,41 @@
 import { Redis } from '@upstash/redis';
 import type { Cache } from './';
 
-export class UpstashCache<T> implements Cache<T> {
-  private client: Redis;
+export class UpstashCache implements Cache {
+	private client: Redis;
 
-  constructor(url: string, token: string) {
-    this.client = new Redis({
-      url,
-      token,
-    });
-  }
+	constructor(url: string, token: string) {
+		this.client = new Redis({
+			url,
+			token,
+		});
+	}
 
-  async ttl(key: string): Promise<number> {
-    const ttl = await this.client.ttl(key);
+	async ttl(key: string): Promise<number> {
+		const ttl = await this.client.ttl(key);
 
-    if (ttl === -2) {
-      return 0; // Key does not exist
-    }
+		if (ttl === -2) {
+			return 0; // Key does not exist
+		}
 
-    return ttl; // Returns TTL in seconds
-  }
+		return ttl; // Returns TTL in seconds
+	}
 
-  async get(key: string): Promise<T | undefined> {
-    const v = await this.client.get(key);
+	async get<T>(key: string): Promise<T | undefined> {
+		const v = await this.client.get(key);
 
-    if (v === null) {
-      return undefined;
-    }
+		if (v === null) {
+			return undefined;
+		}
 
-    return v as T; // Assuming the value is stored as a string, you may need to parse it if it's JSON
-  }
+		return v as T;
+	}
 
-  async set(key: string, value: T, ttl = 3600): Promise<void> {
-    await this.client.set(key, value, { ex: ttl });
-  }
+	async set<T>(key: string, value: T, ttl = 3600): Promise<void> {
+		await this.client.set(key, value, { ex: ttl });
+	}
 
-  async delete(key: string): Promise<void> {
-    await this.client.del(key);
-  }
+	async delete(key: string): Promise<void> {
+		await this.client.del(key);
+	}
 }

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"]
+}

package/tsdown.config.ts

@@ -1,5 +1,5 @@
 import { defineConfig } from 'tsdown';
 
 export default defineConfig({
-  external: ['expo-secure-store', '@upstash/redis'],
+	external: ['expo-secure-store', '@upstash/redis'],
 });

package/dist/__tests__/cache.spec.cjs

@@ -1,77 +0,0 @@
-require('../src-C7d6HaTp.cjs');
-const require_memory = require('../memory-Csy6J-Ak.cjs');
-const require_upstash = require('../upstash-u8Hs4sZG.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-B-qkABPq.cjs');
-
-//#region src/__tests__/cache.spec.ts
-require_vi_bdSIJ99Y.describe("Cache Interface", () => {
-	require_vi_bdSIJ99Y.describe("interface compliance", () => {
-		require_vi_bdSIJ99Y.it("InMemoryCache should implement Cache interface", () => {
-			const cache = new require_memory.InMemoryCache();
-			require_vi_bdSIJ99Y.globalExpect(typeof cache.get).toBe("function");
-			require_vi_bdSIJ99Y.globalExpect(typeof cache.set).toBe("function");
-			require_vi_bdSIJ99Y.globalExpect(typeof cache.delete).toBe("function");
-		});
-		require_vi_bdSIJ99Y.it("UpstashCache should implement Cache interface", () => {
-			const cache = new require_upstash.UpstashCache("http://localhost:8079", "example_token");
-			require_vi_bdSIJ99Y.globalExpect(typeof cache.get).toBe("function");
-			require_vi_bdSIJ99Y.globalExpect(typeof cache.set).toBe("function");
-			require_vi_bdSIJ99Y.globalExpect(typeof cache.delete).toBe("function");
-		});
-	});
-	require_vi_bdSIJ99Y.describe("method signatures", () => {
-		require_vi_bdSIJ99Y.it("should have correct get method signature", () => {
-			const cache = new require_memory.InMemoryCache();
-			const getResult = cache.get("test");
-			require_vi_bdSIJ99Y.globalExpect(getResult).toBeInstanceOf(Promise);
-		});
-		require_vi_bdSIJ99Y.it("should have correct set method signature", () => {
-			const cache = new require_memory.InMemoryCache();
-			const setResult = cache.set("test", "value");
-			require_vi_bdSIJ99Y.globalExpect(setResult).toBeInstanceOf(Promise);
-		});
-		require_vi_bdSIJ99Y.it("should have correct delete method signature", () => {
-			const cache = new require_memory.InMemoryCache();
-			const deleteResult = cache.delete("test");
-			require_vi_bdSIJ99Y.globalExpect(deleteResult).toBeInstanceOf(Promise);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("generic type support", () => {
-		require_vi_bdSIJ99Y.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_bdSIJ99Y.globalExpect(typeof result === "string" || result === void 0).toBe(true);
-		});
-		require_vi_bdSIJ99Y.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_bdSIJ99Y.globalExpect(typeof result === "number" || result === void 0).toBe(true);
-		});
-		require_vi_bdSIJ99Y.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_bdSIJ99Y.globalExpect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
-		});
-		require_vi_bdSIJ99Y.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_bdSIJ99Y.globalExpect(stringResult).toBe("text");
-			require_vi_bdSIJ99Y.globalExpect(numberResult).toBe(42);
-			require_vi_bdSIJ99Y.globalExpect(booleanResult).toBe(true);
-		});
-	});
-});
-
-//#endregion

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

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

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

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

package/dist/__tests__/cache.spec.mjs

@@ -1,77 +0,0 @@
-import { describe, globalExpect, it } from "../vi.bdSIJ99Y-CB5havZF.mjs";
-import "../src-DVpoP03o.mjs";
-import { InMemoryCache } from "../memory-QDTnSEX5.mjs";
-import { UpstashCache } from "../upstash-CXy_duOa.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

@@ -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 { };