@geekmidas/cache 0.0.1

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@geekmidas/cache",
+  "version": "0.0.1",
+  "description": "Type-safe email client with SMTP support and React templates",
+  "private": false,
+  "type": "module",
+  "exports": {
+    "./*": {
+      "import": "./dist/*.mjs",
+      "require": "./dist/*.cjs",
+      "types": "./src/*.ts"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "peerDependencies": {
+    "@upstash/redis": "~1.35.1"
+  }
+}

package/src/__tests__/cache.spec.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest';
+import type { Cache } from '../cache';
+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>();
+
+      expect(typeof cache.get).toBe('function');
+      expect(typeof cache.set).toBe('function');
+      expect(typeof cache.delete).toBe('function');
+    });
+
+    it('UpstashCache should implement Cache interface', () => {
+      const cache = new UpstashCache('http://localhost:8079', 'example_token');
+
+      expect(typeof cache.get).toBe('function');
+      expect(typeof cache.set).toBe('function');
+      expect(typeof cache.delete).toBe('function');
+    });
+  });
+
+  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;
+
+      // These should compile without errors
+      const getResult: Promise<any> = cache.get('test');
+      expect(getResult).toBeInstanceOf(Promise);
+    });
+
+    it('should have correct set method signature', () => {
+      const cache = new InMemoryCache() as TestCache;
+
+      // These should compile without errors
+      const setResult: Promise<void> = cache.set('test', 'value');
+      expect(setResult).toBeInstanceOf(Promise);
+    });
+
+    it('should have correct delete method signature', () => {
+      const cache = new InMemoryCache() as TestCache;
+
+      // These should compile without errors
+      const deleteResult: Promise<void> = cache.delete('test');
+      expect(deleteResult).toBeInstanceOf(Promise);
+    });
+  });
+
+  describe('generic type support', () => {
+    it('should support string types', async () => {
+      const cache: Cache<string> = new InMemoryCache<string>();
+
+      await cache.set('key', 'value');
+      const result = await cache.get('key');
+
+      expect(typeof result === 'string' || result === undefined).toBe(true);
+    });
+
+    it('should support number types', async () => {
+      const cache: Cache<number> = new InMemoryCache<number>();
+
+      await cache.set('key', 42);
+      const result = await cache.get('key');
+
+      expect(typeof result === 'number' || result === undefined).toBe(true);
+    });
+
+    it('should support object types', async () => {
+      interface User {
+        id: number;
+        name: string;
+      }
+
+      const cache: Cache<User> = new InMemoryCache<User>();
+      const user: User = { id: 1, name: 'John' };
+
+      await cache.set('user', user);
+      const result = await cache.get('user');
+
+      expect(
+        result === undefined ||
+          (typeof result === 'object' && 'id' in result && 'name' in result),
+      ).toBe(true);
+    });
+
+    it('should support union types', async () => {
+      type CacheValue = string | number | boolean;
+      const cache: Cache<CacheValue> = new InMemoryCache<CacheValue>();
+
+      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');
+
+      expect(stringResult).toBe('text');
+      expect(numberResult).toBe(42);
+      expect(booleanResult).toBe(true);
+    });
+  });
+});

package/src/__tests__/integration.spec.ts

@@ -0,0 +1,273 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { Cache } from '../cache';
+import { InMemoryCache } from '../memory';
+
+describe('Cache Integration Tests', () => {
+  let memoryCache: Cache<any>;
+
+  beforeEach(() => {
+    memoryCache = new InMemoryCache();
+  });
+
+  describe('cross-cache behavior consistency', () => {
+    const testCases = [
+      { name: 'InMemoryCache', cache: () => new InMemoryCache() },
+    ];
+
+    testCases.forEach(({ name, cache }) => {
+      describe(name, () => {
+        let cacheInstance: Cache<any>;
+
+        beforeEach(() => {
+          cacheInstance = cache();
+        });
+
+        it('should handle basic CRUD operations', async () => {
+          // Create
+          await cacheInstance.set('user:1', { id: 1, name: 'John' });
+
+          // Read
+          const user = await cacheInstance.get('user:1');
+          expect(user).toEqual({ id: 1, name: 'John' });
+
+          // Update
+          await cacheInstance.set('user:1', { id: 1, name: 'Jane' });
+          const updatedUser = await cacheInstance.get('user:1');
+          expect(updatedUser).toEqual({ id: 1, name: 'Jane' });
+
+          // Delete
+          await cacheInstance.delete('user:1');
+          const deletedUser = await cacheInstance.get('user:1');
+          expect(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'),
+          ]);
+
+          expect(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,
+          };
+
+          // Store all data types
+          await Promise.all(
+            Object.entries(testData).map(([key, value]) =>
+              cacheInstance.set(key, value),
+            ),
+          );
+
+          // Retrieve and verify
+          const results = await Promise.all(
+            Object.keys(testData).map((key) => cacheInstance.get(key)),
+          );
+
+          expect(results[0]).toBe('hello');
+          expect(results[1]).toBe(42);
+          expect(results[2]).toBe(true);
+          expect(results[3]).toEqual({ nested: true });
+          expect(results[4]).toEqual([1, 2, 3]);
+          expect(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');
+
+          expect(await cacheInstance.get('user:1')).toBeUndefined();
+          expect(await cacheInstance.get('user:2')).toBe('User Two');
+          expect(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<any>();
+      const targetCache = new InMemoryCache<any>();
+
+      // Populate source cache
+      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);
+      }
+
+      // Simulate migration by reading from source and writing to target
+      const migrationKeys = Object.keys(testData);
+      for (const key of migrationKeys) {
+        const value = await sourceCache.get(key);
+        if (value !== undefined) {
+          await targetCache.set(key, value);
+        }
+      }
+
+      // Verify migration
+      for (const [key, expectedValue] of Object.entries(testData)) {
+        const migratedValue = await targetCache.get(key);
+        expect(migratedValue).toEqual(expectedValue);
+      }
+    });
+  });
+
+  describe('cache abstraction patterns', () => {
+    it('should support cache factory pattern', async () => {
+      const createCache = <T>(type: 'memory'): Cache<T> => {
+        switch (type) {
+          case 'memory':
+            return new InMemoryCache<T>();
+          default:
+            throw new Error(`Unknown cache type: ${type}`);
+        }
+      };
+
+      const userCache = createCache<{ id: number; name: string }>('memory');
+      const sessionCache = createCache<string>('memory');
+
+      await userCache.set('user:1', { id: 1, name: 'John' });
+      await sessionCache.set('session:abc', 'active');
+
+      expect(await userCache.get('user:1')).toEqual({ id: 1, name: 'John' });
+      expect(await sessionCache.get('session:abc')).toBe('active');
+    });
+
+    it('should support cache wrapper pattern', async () => {
+      class LoggingCache<T> implements Cache<T> {
+        private logs: string[] = [];
+
+        constructor(private underlying: Cache<T>) {}
+
+        async get(key: string): Promise<T | undefined> {
+          this.logs.push(`GET ${key}`);
+          return this.underlying.get(key);
+        }
+
+        async set(key: string, value: T): Promise<void> {
+          this.logs.push(`SET ${key}`);
+          return this.underlying.set(key, value);
+        }
+
+        async delete(key: string): Promise<void> {
+          this.logs.push(`DELETE ${key}`);
+          return this.underlying.delete(key);
+        }
+
+        getLogs(): string[] {
+          return [...this.logs];
+        }
+      }
+
+      const baseCache = new InMemoryCache<string>();
+      const loggingCache = new LoggingCache(baseCache);
+
+      await loggingCache.set('test', 'value');
+      await loggingCache.get('test');
+      await loggingCache.delete('test');
+
+      const logs = loggingCache.getLogs();
+      expect(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<number>();
+      const operationCount = 1000;
+
+      // Bulk insert
+      const insertPromises = Array.from({ length: operationCount }, (_, i) =>
+        cache.set(`key:${i}`, i),
+      );
+      await Promise.all(insertPromises);
+
+      // Bulk read
+      const readPromises = Array.from({ length: operationCount }, (_, i) =>
+        cache.get(`key:${i}`),
+      );
+      const results = await Promise.all(readPromises);
+
+      // Verify all values
+      for (let i = 0; i < operationCount; i++) {
+        expect(results[i]).toBe(i);
+      }
+
+      // Bulk delete
+      const deletePromises = Array.from({ length: operationCount }, (_, i) =>
+        cache.delete(`key:${i}`),
+      );
+      await Promise.all(deletePromises);
+
+      // Verify deletion
+      const postDeleteRead = await cache.get('key:0');
+      expect(postDeleteRead).toBeUndefined();
+    });
+
+    it('should handle large objects efficiently', async () => {
+      const cache = new InMemoryCache<any>();
+
+      const largeObject = {
+        id: 1,
+        data: Array.from({ length: 1000 }, (_, 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();
+
+      expect(result).toEqual(largeObject);
+      expect(endTime - startTime).toBeLessThan(100); // Should complete within 100ms
+    });
+  });
+
+  describe('error scenarios', () => {
+    it('should handle operations after errors gracefully', async () => {
+      const cache = new InMemoryCache<string>();
+
+      // Successful operations
+      await cache.set('valid-key', 'valid-value');
+      expect(await cache.get('valid-key')).toBe('valid-value');
+
+      // Operations should continue working normally
+      await cache.set('another-key', 'another-value');
+      expect(await cache.get('another-key')).toBe('another-value');
+
+      await cache.delete('valid-key');
+      expect(await cache.get('valid-key')).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/memory.spec.ts

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { InMemoryCache } from '../memory';
+
+describe('InMemoryCache', () => {
+  let cache: InMemoryCache<any>;
+
+  beforeEach(() => {
+    cache = new InMemoryCache();
+  });
+
+  describe('get', () => {
+    it('should return undefined for non-existent key', async () => {
+      const result = await cache.get('non-existent');
+      expect(result).toBeUndefined();
+    });
+
+    it('should return value for existing key', async () => {
+      await cache.set('test-key', 'test-value');
+      const result = await cache.get('test-key');
+      expect(result).toBe('test-value');
+    });
+
+    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);
+
+      expect(await cache.get('object')).toEqual(objectValue);
+      expect(await cache.get('array')).toEqual(arrayValue);
+      expect(await cache.get('number')).toBe(numberValue);
+      expect(await cache.get('boolean')).toBe(booleanValue);
+    });
+  });
+
+  describe('set', () => {
+    it('should store string value', async () => {
+      await cache.set('string-key', 'string-value');
+      const result = await cache.get('string-key');
+      expect(result).toBe('string-value');
+    });
+
+    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');
+      expect(result).toEqual(value);
+    });
+
+    it('should overwrite existing value', async () => {
+      await cache.set('key', 'initial-value');
+      await cache.set('key', 'updated-value');
+      const result = await cache.get('key');
+      expect(result).toBe('updated-value');
+    });
+
+    it('should handle null values', async () => {
+      await cache.set('null-key', null);
+      const result = await cache.get('null-key');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('delete', () => {
+    it('should remove existing key', async () => {
+      await cache.set('to-delete', 'value');
+      await cache.delete('to-delete');
+      const result = await cache.get('to-delete');
+      expect(result).toBeUndefined();
+    });
+
+    it('should not throw error for non-existent key', async () => {
+      await expect(cache.delete('non-existent')).resolves.not.toThrow();
+    });
+
+    it('should only delete specified key', async () => {
+      await cache.set('key1', 'value1');
+      await cache.set('key2', 'value2');
+      await cache.delete('key1');
+
+      expect(await cache.get('key1')).toBeUndefined();
+      expect(await cache.get('key2')).toBe('value2');
+    });
+  });
+
+  describe('multiple operations', () => {
+    it('should handle multiple keys independently', async () => {
+      await cache.set('key1', 'value1');
+      await cache.set('key2', 'value2');
+      await cache.set('key3', 'value3');
+
+      expect(await cache.get('key1')).toBe('value1');
+      expect(await cache.get('key2')).toBe('value2');
+      expect(await cache.get('key3')).toBe('value3');
+    });
+
+    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');
+      expect(original.count).toBe(5); // Reference equality in memory
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty string as key', async () => {
+      await cache.set('', 'empty-key-value');
+      const result = await cache.get('');
+      expect(result).toBe('empty-key-value');
+    });
+
+    it('should handle special characters in keys', async () => {
+      const specialKey = 'key!@#$%^&*()_+{}|:"<>?[]\\;\',./?`~';
+      await cache.set(specialKey, 'special-value');
+      const result = await cache.get(specialKey);
+      expect(result).toBe('special-value');
+    });
+
+    it('should handle undefined values', async () => {
+      await cache.set('undefined-key', undefined);
+      const result = await cache.get('undefined-key');
+      expect(result).toBeUndefined();
+    });
+  });
+});