@geekmidas/cache 0.0.6 → 0.1.0

package/src/__benchmarks__/memory.bench.ts

@@ -0,0 +1,51 @@
+import { bench, describe } from 'vitest';
+import { InMemoryCache } from '../memory';
+
+describe('InMemoryCache', () => {
+  const cache = new InMemoryCache<string>();
+
+  bench('set with TTL', async () => {
+    await cache.set('key', 'value', 3600);
+  });
+
+  bench('get (cache hit)', async () => {
+    await cache.set('hit-key', 'value', 3600);
+    await cache.get('hit-key');
+  });
+
+  bench('get (cache miss)', async () => {
+    await cache.get('nonexistent-key');
+  });
+
+  bench('delete', async () => {
+    await cache.set('delete-key', 'value', 3600);
+    await cache.delete('delete-key');
+  });
+
+  bench('set + get cycle', async () => {
+    const key = `cycle-${Math.random()}`;
+    await cache.set(key, 'value', 3600);
+    await cache.get(key);
+  });
+});
+
+describe('InMemoryCache - Large Scale', () => {
+  bench('1000 sequential sets', async () => {
+    const cache = new InMemoryCache<string>();
+    for (let i = 0; i < 1000; i++) {
+      await cache.set(`key-${i}`, `value-${i}`, 3600);
+    }
+  });
+
+  bench('1000 sequential gets', async () => {
+    const cache = new InMemoryCache<string>();
+    // Pre-populate
+    for (let i = 0; i < 1000; i++) {
+      await cache.set(`key-${i}`, `value-${i}`, 3600);
+    }
+    // Benchmark gets
+    for (let i = 0; i < 1000; i++) {
+      await cache.get(`key-${i}`);
+    }
+  });
+});

package/src/__tests__/cache.spec.ts

@@ -1,12 +1,12 @@
 import { describe, expect, it } from 'vitest';
-import type { Cache } from '../cache';
+import type { Cache } from '../';
 import { InMemoryCache } from '../memory';
 import { UpstashCache } from '../upstash';
 
 describe('Cache Interface', () => {
   describe('interface compliance', () => {
     it('InMemoryCache should implement Cache interface', () => {
-      const cache: Cache<string> = new InMemoryCache<string>();
+      const cache: Cache = new InMemoryCache();
 
       expect(typeof cache.get).toBe('function');
       expect(typeof cache.set).toBe('function');
@@ -14,7 +14,10 @@ describe('Cache Interface', () => {
     });
 
     it('UpstashCache should implement Cache interface', () => {
-      const cache = new UpstashCache('http://localhost:8079', 'example_token');
+      const cache: Cache = new UpstashCache(
+        'http://localhost:8079',
+        'example_token',
+      );
 
       expect(typeof cache.get).toBe('function');
       expect(typeof cache.set).toBe('function');
@@ -23,22 +26,16 @@ describe('Cache Interface', () => {
   });
 
   describe('method signatures', () => {
-    interface TestCache extends Cache<any> {
-      get(key: string): Promise<any>;
-      set(key: string, value: any): Promise<void>;
-      delete(key: string): Promise<void>;
-    }
-
     it('should have correct get method signature', () => {
-      const cache = new InMemoryCache() as TestCache;
+      const cache: Cache = new InMemoryCache();
 
       // These should compile without errors
-      const getResult: Promise<any> = cache.get('test');
+      const getResult: Promise<unknown> = cache.get('test');
       expect(getResult).toBeInstanceOf(Promise);
     });
 
     it('should have correct set method signature', () => {
-      const cache = new InMemoryCache() as TestCache;
+      const cache: Cache = new InMemoryCache();
 
       // These should compile without errors
       const setResult: Promise<void> = cache.set('test', 'value');
@@ -46,7 +43,7 @@ describe('Cache Interface', () => {
     });
 
     it('should have correct delete method signature', () => {
-      const cache = new InMemoryCache() as TestCache;
+      const cache: Cache = new InMemoryCache();
 
       // These should compile without errors
       const deleteResult: Promise<void> = cache.delete('test');
@@ -54,36 +51,36 @@ describe('Cache Interface', () => {
     });
   });
 
-  describe('generic type support', () => {
-    it('should support string types', async () => {
-      const cache: Cache<string> = new InMemoryCache<string>();
+  describe('function-level generic type support', () => {
+    it('should support string types with function-level generics', async () => {
+      const cache: Cache = new InMemoryCache();
 
-      await cache.set('key', 'value');
-      const result = await cache.get('key');
+      await cache.set<string>('key', 'value');
+      const result = await cache.get<string>('key');
 
       expect(typeof result === 'string' || result === undefined).toBe(true);
     });
 
-    it('should support number types', async () => {
-      const cache: Cache<number> = new InMemoryCache<number>();
+    it('should support number types with function-level generics', async () => {
+      const cache: Cache = new InMemoryCache();
 
-      await cache.set('key', 42);
-      const result = await cache.get('key');
+      await cache.set<number>('key', 42);
+      const result = await cache.get<number>('key');
 
       expect(typeof result === 'number' || result === undefined).toBe(true);
     });
 
-    it('should support object types', async () => {
+    it('should support object types with function-level generics', async () => {
       interface User {
         id: number;
         name: string;
       }
 
-      const cache: Cache<User> = new InMemoryCache<User>();
+      const cache: Cache = new InMemoryCache();
       const user: User = { id: 1, name: 'John' };
 
-      await cache.set('user', user);
-      const result = await cache.get('user');
+      await cache.set<User>('user', user);
+      const result = await cache.get<User>('user');
 
       expect(
         result === undefined ||
@@ -91,17 +88,16 @@ describe('Cache Interface', () => {
       ).toBe(true);
     });
 
-    it('should support union types', async () => {
-      type CacheValue = string | number | boolean;
-      const cache: Cache<CacheValue> = new InMemoryCache<CacheValue>();
+    it('should support mixed types in same cache instance', async () => {
+      const cache: Cache = new InMemoryCache();
 
-      await cache.set('string', 'text');
-      await cache.set('number', 42);
-      await cache.set('boolean', true);
+      await cache.set<string>('string', 'text');
+      await cache.set<number>('number', 42);
+      await cache.set<boolean>('boolean', true);
 
-      const stringResult = await cache.get('string');
-      const numberResult = await cache.get('number');
-      const booleanResult = await cache.get('boolean');
+      const stringResult = await cache.get<string>('string');
+      const numberResult = await cache.get<number>('number');
+      const booleanResult = await cache.get<boolean>('boolean');
 
       expect(stringResult).toBe('text');
       expect(numberResult).toBe(42);

package/src/__tests__/integration.spec.ts

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import type { Cache } from '../cache';
+import type { Cache } from '../';
 import { InMemoryCache } from '../memory';
 
 describe('Cache Integration Tests', () => {
-  let memoryCache: Cache<any>;
+  let memoryCache: Cache;
 
   beforeEach(() => {
     memoryCache = new InMemoryCache();
@@ -16,7 +16,7 @@ describe('Cache Integration Tests', () => {
 
     testCases.forEach(({ name, cache }) => {
       describe(name, () => {
-        let cacheInstance: Cache<any>;
+        let cacheInstance: Cache;
 
         beforeEach(() => {
           cacheInstance = cache();
@@ -106,8 +106,8 @@ describe('Cache Integration Tests', () => {
 
   describe('cache migration scenarios', () => {
     it('should support migrating data between cache implementations', async () => {
-      const sourceCache = new InMemoryCache<any>();
-      const targetCache = new InMemoryCache<any>();
+      const sourceCache = new InMemoryCache();
+      const targetCache = new InMemoryCache();
 
       // Populate source cache
       const testData = {
@@ -139,39 +139,44 @@ describe('Cache Integration Tests', () => {
 
   describe('cache abstraction patterns', () => {
     it('should support cache factory pattern', async () => {
-      const createCache = <T>(type: 'memory'): Cache<T> => {
+      const createCache = (type: 'memory'): Cache => {
         switch (type) {
           case 'memory':
-            return new InMemoryCache<T>();
+            return new InMemoryCache();
           default:
             throw new Error(`Unknown cache type: ${type}`);
         }
       };
 
-      const userCache = createCache<{ id: number; name: string }>('memory');
-      const sessionCache = createCache<string>('memory');
+      const userCache = createCache('memory');
+      const sessionCache = createCache('memory');
 
-      await userCache.set('user:1', { id: 1, name: 'John' });
-      await sessionCache.set('session:abc', 'active');
+      await userCache.set<{ id: number; name: string }>('user:1', {
+        id: 1,
+        name: 'John',
+      });
+      await sessionCache.set<string>('session:abc', 'active');
 
-      expect(await userCache.get('user:1')).toEqual({ id: 1, name: 'John' });
-      expect(await sessionCache.get('session:abc')).toBe('active');
+      expect(
+        await userCache.get<{ id: number; name: string }>('user:1'),
+      ).toEqual({ id: 1, name: 'John' });
+      expect(await sessionCache.get<string>('session:abc')).toBe('active');
     });
 
     it('should support cache wrapper pattern', async () => {
-      class LoggingCache<T> implements Cache<T> {
+      class LoggingCache implements Cache {
         private logs: string[] = [];
 
-        constructor(private underlying: Cache<T>) {}
+        constructor(private underlying: Cache) {}
 
-        async get(key: string): Promise<T | undefined> {
+        async get<T>(key: string): Promise<T | undefined> {
           this.logs.push(`GET ${key}`);
-          return this.underlying.get(key);
+          return this.underlying.get<T>(key);
         }
 
-        async set(key: string, value: T): Promise<void> {
+        async set<T>(key: string, value: T, ttl?: number): Promise<void> {
           this.logs.push(`SET ${key}`);
-          return this.underlying.set(key, value);
+          return this.underlying.set<T>(key, value, ttl);
         }
 
         async delete(key: string): Promise<void> {
@@ -179,12 +184,16 @@ describe('Cache Integration Tests', () => {
           return this.underlying.delete(key);
         }
 
+        async ttl(key: string): Promise<number> {
+          return this.underlying.ttl(key);
+        }
+
         getLogs(): string[] {
           return [...this.logs];
         }
       }
 
-      const baseCache = new InMemoryCache<string>();
+      const baseCache = new InMemoryCache();
       const loggingCache = new LoggingCache(baseCache);
 
       await loggingCache.set('test', 'value');
@@ -198,7 +207,7 @@ describe('Cache Integration Tests', () => {
 
   describe('performance and stress tests', () => {
     it('should handle large number of operations', async () => {
-      const cache = new InMemoryCache<number>();
+      const cache = new InMemoryCache();
       const operationCount = 1000;
 
       // Bulk insert
@@ -230,7 +239,7 @@ describe('Cache Integration Tests', () => {
     });
 
     it('should handle large objects efficiently', async () => {
-      const cache = new InMemoryCache<any>();
+      const cache = new InMemoryCache();
 
       const largeObject = {
         id: 1,
@@ -256,7 +265,7 @@ describe('Cache Integration Tests', () => {
 
   describe('error scenarios', () => {
     it('should handle operations after errors gracefully', async () => {
-      const cache = new InMemoryCache<string>();
+      const cache = new InMemoryCache();
 
       // Successful operations
       await cache.set('valid-key', 'valid-value');

package/src/__tests__/memory.spec.ts

@@ -2,7 +2,7 @@ import { beforeEach, describe, expect, it } from 'vitest';
 import { InMemoryCache } from '../memory';
 
 describe('InMemoryCache', () => {
-  let cache: InMemoryCache<any>;
+  let cache: InMemoryCache;
 
   beforeEach(() => {
     cache = new InMemoryCache();

package/src/__tests__/upstash.spec.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { UpstashCache } from '../upstash';
 
 describe('UpstashCache', () => {
-  let cache: UpstashCache<any>;
+  let cache: UpstashCache;
   const testKeyPrefix = `test:${Date.now()}:`;
   let testKeys: string[] = [];
 

package/src/expo.ts

@@ -2,7 +2,7 @@ import { addSeconds } from 'date-fns';
 import * as SecureStore from 'expo-secure-store';
 import { type Cache, getExpirationInSeconds } from './index';
 
-export class ExpoSecureCache<T> implements Cache<T> {
+export class ExpoSecureCache implements Cache {
   static getExpiryKey(key: string): string {
     return `${key}:expiresAt`;
   }
@@ -20,8 +20,7 @@ export class ExpoSecureCache<T> implements Cache<T> {
     return Math.max(secondsLeft, 0);
   }
 
-  // Implementation details
-  async get(key: string): Promise<T | undefined> {
+  async get<T>(key: string): Promise<T | undefined> {
     const result = await SecureStore.getItemAsync(key);
     if (!result) {
       return undefined;
@@ -35,7 +34,7 @@ export class ExpoSecureCache<T> implements Cache<T> {
     return JSON.parse(result) as T;
   }
 
-  async set(key: string, value: T, ttl: number = 600): Promise<void> {
+  async set<T>(key: string, value: T, ttl: number = 600): Promise<void> {
     const expiresAt = addSeconds(new Date(), ttl).toISOString();
     await SecureStore.setItemAsync(key, JSON.stringify(value));
     await SecureStore.setItemAsync(

package/src/index.ts

@@ -15,13 +15,14 @@ export const getExpirationInSeconds = (
   return Math.max(secondsLeft, 0);
 };
 
-export interface Cache<T> {
+export interface Cache {
   /**
    * Retrieves a value from the cache.
    *
    * @param key The key to retrieve the value for.
+   * @returns The cached value, or undefined if not found.
    */
-  get(key: string): Promise<T | undefined>;
+  get<T>(key: string): Promise<T | undefined>;
   /**
    * Sets a value in the cache.
    *
@@ -29,7 +30,7 @@ export interface Cache<T> {
    * @param value The value to cache.
    * @param ttl Optional time-to-live in seconds. If not provided, the value will not expire.
    */
-  set(key: string, value: T, ttl?: number): Promise<void>;
+  set<T>(key: string, value: T, ttl?: number): Promise<void>;
   /**
    * Deletes a value from the cache.
    *
@@ -41,7 +42,7 @@ export interface Cache<T> {
    * Retrieves the time-to-live (TTL) for a cached value.
    *
    * @param key The key to retrieve the TTL for.
-   * @returns The TTL in seconds, or undefined if the key does not exist.
+   * @returns The TTL in seconds, or 0 if the key does not exist.
    */
   ttl(key: string): Promise<number>;
 }

package/src/memory.ts

@@ -1,18 +1,18 @@
 import { addSeconds } from 'date-fns';
 import { type Cache, getExpirationInSeconds } from './';
 
-export class InMemoryCache<T> implements Cache<T> {
-  private store: Map<string, T> = 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> {
+  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> {
@@ -24,7 +24,7 @@ export class InMemoryCache<T> implements Cache<T> {
     return getExpirationInSeconds(expiration);
   }
 
-  async set(key: string, value: T, ttl: number = 600): Promise<void> {
+  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);
@@ -33,5 +33,6 @@ export class InMemoryCache<T> implements Cache<T> {
 
   async delete(key: string): Promise<void> {
     this.store.delete(key);
+    this.expirations.delete(key);
   }
 }

package/src/upstash.ts

@@ -1,7 +1,7 @@
 import { Redis } from '@upstash/redis';
 import type { Cache } from './';
 
-export class UpstashCache<T> implements Cache<T> {
+export class UpstashCache implements Cache {
   private client: Redis;
 
   constructor(url: string, token: string) {
@@ -21,17 +21,17 @@ export class UpstashCache<T> implements Cache<T> {
     return ttl; // Returns TTL in seconds
   }
 
-  async get(key: string): Promise<T | undefined> {
+  async get<T>(key: string): Promise<T | undefined> {
     const v = await this.client.get(key);
 
     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> {
+  async set<T>(key: string, value: T, ttl = 3600): Promise<void> {
     await this.client.set(key, value, { ex: ttl });
   }
 

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