@geekmidas/cache 0.0.7 → 0.2.0

package/src/__tests__/upstash.spec.ts

@@ -2,246 +2,275 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { UpstashCache } from '../upstash';
 
 describe('UpstashCache', () => {
-  let cache: UpstashCache<any>;
-  const testKeyPrefix = `test:${Date.now()}:`;
-  let testKeys: string[] = [];
+	let cache: UpstashCache;
+	const testKeyPrefix = `test:${Date.now()}:`;
+	let testKeys: string[] = [];
 
-  beforeEach(() => {
-    cache = new UpstashCache('http://localhost:8079', 'example_token');
-    testKeys = [];
-  });
+	beforeEach(() => {
+		cache = new UpstashCache('http://localhost:8079', 'example_token');
+		testKeys = [];
+	});
 
-  afterEach(async () => {
-    // Clean up test keys
-    for (const key of testKeys) {
-      try {
-        await cache.delete(key);
-      } catch (error) {
-        // Ignore cleanup errors
-      }
-    }
-  });
+	afterEach(async () => {
+		// Clean up test keys
+		for (const key of testKeys) {
+			try {
+				await cache.delete(key);
+			} catch (_error) {
+				// Ignore cleanup errors
+			}
+		}
+	});
 
-  const getTestKey = (suffix: string): string => {
-    const key = `${testKeyPrefix}${suffix}`;
-    testKeys.push(key);
-    return key;
-  };
+	const getTestKey = (suffix: string): string => {
+		const key = `${testKeyPrefix}${suffix}`;
+		testKeys.push(key);
+		return key;
+	};
 
-  describe('get', () => {
-    it('should return undefined for non-existent key', async () => {
-      const key = getTestKey('non-existent');
-      const result = await cache.get(key);
+	describe('get', () => {
+		it('should return undefined for non-existent key', async () => {
+			const key = getTestKey('non-existent');
+			const result = await cache.get(key);
 
-      expect(result).toBeUndefined();
-    });
+			expect(result).toBeUndefined();
+		});
 
-    it('should parse and return JSON value', async () => {
-      const key = getTestKey('object');
-      const testValue = { id: 1, name: 'test' };
+		it('should parse and return JSON value', async () => {
+			const key = getTestKey('object');
+			const testValue = { id: 1, name: 'test' };
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toEqual(testValue);
-    });
+			expect(result).toEqual(testValue);
+		});
 
-    it('should handle string values', async () => {
-      const key = getTestKey('string');
-      const testValue = 'simple string';
+		it('should handle string values', async () => {
+			const key = getTestKey('string');
+			const testValue = 'simple string';
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toBe(testValue);
-    });
+			expect(result).toBe(testValue);
+		});
 
-    it('should handle number values', async () => {
-      const key = getTestKey('number');
-      const testValue = 42;
+		it('should handle number values', async () => {
+			const key = getTestKey('number');
+			const testValue = 42;
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toBe(testValue);
-    });
+			expect(result).toBe(testValue);
+		});
 
-    it('should handle boolean values', async () => {
-      const key = getTestKey('boolean');
-      const testValue = true;
+		it('should handle boolean values', async () => {
+			const key = getTestKey('boolean');
+			const testValue = true;
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toBe(testValue);
-    });
+			expect(result).toBe(testValue);
+		});
 
-    it('should handle array values', async () => {
-      const key = getTestKey('array');
-      const testArray = [1, 2, 3, 'test'];
+		it('should handle array values', async () => {
+			const key = getTestKey('array');
+			const testArray = [1, 2, 3, 'test'];
 
-      await cache.set(key, testArray);
-      const result = await cache.get(key);
+			await cache.set(key, testArray);
+			const result = await cache.get(key);
 
-      expect(result).toEqual(testArray);
-    });
+			expect(result).toEqual(testArray);
+		});
 
-    it('should handle null values as undefined', async () => {
-      const key = getTestKey('null');
+		it('should handle null values as undefined', async () => {
+			const key = getTestKey('null');
 
-      await cache.set(key, null);
-      const result = await cache.get(key);
+			await cache.set(key, null);
+			const result = await cache.get(key);
 
-      expect(result).toBeUndefined();
-    });
-  });
+			expect(result).toBeUndefined();
+		});
+	});
 
-  describe('set', () => {
-    it('should store and retrieve object value', async () => {
-      const key = getTestKey('set-object');
-      const testValue = { id: 1, name: 'test' };
+	describe('set', () => {
+		it('should store and retrieve object value', async () => {
+			const key = getTestKey('set-object');
+			const testValue = { id: 1, name: 'test' };
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toEqual(testValue);
-    });
+			expect(result).toEqual(testValue);
+		});
 
-    it('should store and retrieve string values', async () => {
-      const key = getTestKey('set-string');
-      const testValue = 'test string';
+		it('should store and retrieve string values', async () => {
+			const key = getTestKey('set-string');
+			const testValue = 'test string';
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toBe(testValue);
-    });
+			expect(result).toBe(testValue);
+		});
 
-    it('should store and retrieve number values', async () => {
-      const key = getTestKey('set-number');
-      const testValue = 42;
+		it('should store and retrieve number values', async () => {
+			const key = getTestKey('set-number');
+			const testValue = 42;
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toBe(testValue);
-    });
+			expect(result).toBe(testValue);
+		});
 
-    it('should store and retrieve boolean values', async () => {
-      const key = getTestKey('set-boolean');
-      const testValue = true;
+		it('should store and retrieve boolean values', async () => {
+			const key = getTestKey('set-boolean');
+			const testValue = true;
 
-      await cache.set(key, testValue);
-      const result = await cache.get(key);
+			await cache.set(key, testValue);
+			const result = await cache.get(key);
 
-      expect(result).toBe(testValue);
-    });
+			expect(result).toBe(testValue);
+		});
 
-    it('should store and retrieve array values', async () => {
-      const key = getTestKey('set-array');
-      const testArray = [1, 2, 3];
+		it('should store and retrieve array values', async () => {
+			const key = getTestKey('set-array');
+			const testArray = [1, 2, 3];
 
-      await cache.set(key, testArray);
-      const result = await cache.get(key);
+			await cache.set(key, testArray);
+			const result = await cache.get(key);
 
-      expect(result).toEqual(testArray);
-    });
+			expect(result).toEqual(testArray);
+		});
 
-    it('should not store and retrieve null values', async () => {
-      const key = getTestKey('set-null');
+		it('should not store and retrieve null values', async () => {
+			const key = getTestKey('set-null');
 
-      await cache.set(key, null);
-      const result = await cache.get(key);
+			await cache.set(key, null);
+			const result = await cache.get(key);
 
-      expect(result).toBeUndefined();
-    });
+			expect(result).toBeUndefined();
+		});
 
-    it('should overwrite existing values', async () => {
-      const key = getTestKey('overwrite');
+		it('should overwrite existing values', async () => {
+			const key = getTestKey('overwrite');
 
-      await cache.set(key, 'initial');
-      await cache.set(key, 'updated');
-      const result = await cache.get(key);
+			await cache.set(key, 'initial');
+			await cache.set(key, 'updated');
+			const result = await cache.get(key);
 
-      expect(result).toBe('updated');
-    });
-  });
+			expect(result).toBe('updated');
+		});
+	});
 
-  describe('delete', () => {
-    it('should delete existing key', async () => {
-      const key = getTestKey('delete-test');
+	describe('delete', () => {
+		it('should delete existing key', async () => {
+			const key = getTestKey('delete-test');
 
-      await cache.set(key, 'value-to-delete');
-      await cache.delete(key);
-      const result = await cache.get(key);
+			await cache.set(key, 'value-to-delete');
+			await cache.delete(key);
+			const result = await cache.get(key);
 
-      expect(result).toBeUndefined();
-    });
+			expect(result).toBeUndefined();
+		});
 
-    it('should handle deletion of non-existent key', async () => {
-      const key = getTestKey('non-existent-delete');
+		it('should handle deletion of non-existent key', async () => {
+			const key = getTestKey('non-existent-delete');
 
-      await expect(cache.delete(key)).resolves.not.toThrow();
-    });
+			await expect(cache.delete(key)).resolves.not.toThrow();
+		});
 
-    it('should only delete specified key', async () => {
-      const key1 = getTestKey('delete-key1');
-      const key2 = getTestKey('delete-key2');
+		it('should only delete specified key', async () => {
+			const key1 = getTestKey('delete-key1');
+			const key2 = getTestKey('delete-key2');
 
-      await cache.set(key1, 'value1');
-      await cache.set(key2, 'value2');
+			await cache.set(key1, 'value1');
+			await cache.set(key2, 'value2');
 
-      await cache.delete(key1);
+			await cache.delete(key1);
 
-      expect(await cache.get(key1)).toBeUndefined();
-      expect(await cache.get(key2)).toBe('value2');
-    });
-  });
+			expect(await cache.get(key1)).toBeUndefined();
+			expect(await cache.get(key2)).toBe('value2');
+		});
+	});
 
-  describe('integration scenarios', () => {
-    it('should handle round-trip operations', async () => {
-      const key = getTestKey('user-session');
-      const testData = {
-        user: { id: 1, name: 'John' },
-        preferences: ['dark-mode', 'notifications'],
-        count: 42,
-      };
+	describe('ttl', () => {
+		it('should return 0 for non-existent key', async () => {
+			const key = getTestKey('ttl-non-existent');
+			const result = await cache.ttl(key);
 
-      await cache.set(key, testData);
-      const result = await cache.get(key);
+			expect(result).toBe(0);
+		});
 
-      expect(result).toEqual(testData);
-    });
+		it('should return positive TTL for existing key with expiry', async () => {
+			const key = getTestKey('ttl-with-expiry');
 
-    it('should handle complex nested objects', async () => {
-      const key = getTestKey('complex');
-      const complexObject = {
-        level1: {
-          level2: {
-            level3: {
-              data: 'deep nested value',
-              array: [{ id: 1 }, { id: 2 }],
-            },
-          },
-        },
-      };
+			await cache.set(key, 'test-value', 3600);
+			const result = await cache.ttl(key);
 
-      await cache.set(key, complexObject);
-      const result = await cache.get(key);
+			expect(result).toBeGreaterThan(0);
+			expect(result).toBeLessThanOrEqual(3600);
+		});
 
-      expect(result).toEqual(complexObject);
-    });
+		it('should return TTL in seconds', async () => {
+			const key = getTestKey('ttl-seconds');
 
-    it('should handle concurrent operations', async () => {
-      const keys = ['concurrent1', 'concurrent2', 'concurrent3'].map((suffix) =>
-        getTestKey(suffix),
-      );
-      const values = ['value1', 'value2', 'value3'];
+			await cache.set(key, 'test-value', 60); // 60 seconds
+			const result = await cache.ttl(key);
 
-      await Promise.all(keys.map((key, i) => cache.set(key, values[i])));
-      const results = await Promise.all(keys.map((key) => cache.get(key)));
+			expect(result).toBeGreaterThan(0);
+			expect(result).toBeLessThanOrEqual(60);
+		});
+	});
 
-      expect(results).toEqual(values);
-    });
-  });
+	describe('integration scenarios', () => {
+		it('should handle round-trip operations', async () => {
+			const key = getTestKey('user-session');
+			const testData = {
+				user: { id: 1, name: 'John' },
+				preferences: ['dark-mode', 'notifications'],
+				count: 42,
+			};
+
+			await cache.set(key, testData);
+			const result = await cache.get(key);
+
+			expect(result).toEqual(testData);
+		});
+
+		it('should handle complex nested objects', async () => {
+			const key = getTestKey('complex');
+			const complexObject = {
+				level1: {
+					level2: {
+						level3: {
+							data: 'deep nested value',
+							array: [{ id: 1 }, { id: 2 }],
+						},
+					},
+				},
+			};
+
+			await cache.set(key, complexObject);
+			const result = await cache.get(key);
+
+			expect(result).toEqual(complexObject);
+		});
+
+		it('should handle concurrent operations', async () => {
+			const keys = ['concurrent1', 'concurrent2', 'concurrent3'].map((suffix) =>
+				getTestKey(suffix),
+			);
+			const values = ['value1', 'value2', 'value3'];
+
+			await Promise.all(keys.map((key, i) => cache.set(key, values[i])));
+			const results = await Promise.all(keys.map((key) => cache.get(key)));
+
+			expect(results).toEqual(values);
+		});
+	});
 });

package/src/expo.ts

@@ -2,50 +2,49 @@ 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> {
-  static getExpiryKey(key: string): string {
-    return `${key}:expiresAt`;
-  }
-
-  async ttl(key: string): Promise<number> {
-    const result = await SecureStore.getItemAsync(
-      ExpoSecureCache.getExpiryKey(key),
-    );
-    if (!result) {
-      return 0;
-    }
-
-    const secondsLeft = getExpirationInSeconds(result);
-
-    return Math.max(secondsLeft, 0);
-  }
-
-  // Implementation details
-  async get(key: string): Promise<T | undefined> {
-    const result = await SecureStore.getItemAsync(key);
-    if (!result) {
-      return undefined;
-    }
-
-    const expiresAt = await this.ttl(key);
-    if (expiresAt === 0) {
-      return undefined;
-    }
-
-    return JSON.parse(result) as T;
-  }
-
-  async set(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(
-      ExpoSecureCache.getExpiryKey(key),
-      expiresAt,
-    );
-  }
-
-  async delete(key: string): Promise<void> {
-    await SecureStore.deleteItemAsync(key);
-    await SecureStore.deleteItemAsync(ExpoSecureCache.getExpiryKey(key));
-  }
+export class ExpoSecureCache implements Cache {
+	static getExpiryKey(key: string): string {
+		return `${key}:expiresAt`;
+	}
+
+	async ttl(key: string): Promise<number> {
+		const result = await SecureStore.getItemAsync(
+			ExpoSecureCache.getExpiryKey(key),
+		);
+		if (!result) {
+			return 0;
+		}
+
+		const secondsLeft = getExpirationInSeconds(result);
+
+		return Math.max(secondsLeft, 0);
+	}
+
+	async get<T>(key: string): Promise<T | undefined> {
+		const result = await SecureStore.getItemAsync(key);
+		if (!result) {
+			return undefined;
+		}
+
+		const expiresAt = await this.ttl(key);
+		if (expiresAt === 0) {
+			return undefined;
+		}
+
+		return JSON.parse(result) as T;
+	}
+
+	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(
+			ExpoSecureCache.getExpiryKey(key),
+			expiresAt,
+		);
+	}
+
+	async delete(key: string): Promise<void> {
+		await SecureStore.deleteItemAsync(key);
+		await SecureStore.deleteItemAsync(ExpoSecureCache.getExpiryKey(key));
+	}
 }

package/src/index.ts

@@ -1,47 +1,48 @@
 import { differenceInSeconds } from 'date-fns';
 
 export const getExpirationInSeconds = (
-  expiresAt: string | number | Date | undefined | null,
+	expiresAt: string | number | Date | undefined | null,
 ): number => {
-  if (!expiresAt) {
-    return 0;
-  }
+	if (!expiresAt) {
+		return 0;
+	}
 
-  const expirationDate = new Date(expiresAt);
-  const now = new Date();
+	const expirationDate = new Date(expiresAt);
+	const now = new Date();
 
-  const secondsLeft = differenceInSeconds(expirationDate, now);
+	const secondsLeft = differenceInSeconds(expirationDate, now);
 
-  return Math.max(secondsLeft, 0);
+	return Math.max(secondsLeft, 0);
 };
 
-export interface Cache<T> {
-  /**
-   * Retrieves a value from the cache.
-   *
-   * @param key The key to retrieve the value for.
-   */
-  get(key: string): Promise<T | undefined>;
-  /**
-   * Sets a value in the cache.
-   *
-   * @param key The key to set the value for.
-   * @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>;
-  /**
-   * Deletes a value from the cache.
-   *
-   * @param key The key to delete from the cache.
-   */
-  delete(key: string): Promise<void>;
+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<T>(key: string): Promise<T | undefined>;
+	/**
+	 * Sets a value in the cache.
+	 *
+	 * @param key The key to set the value for.
+	 * @param value The value to cache.
+	 * @param ttl Optional time-to-live in seconds. If not provided, the value will not expire.
+	 */
+	set<T>(key: string, value: T, ttl?: number): Promise<void>;
+	/**
+	 * Deletes a value from the cache.
+	 *
+	 * @param key The key to delete from the cache.
+	 */
+	delete(key: string): Promise<void>;
 
-  /**
-   * 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.
-   */
-  ttl(key: string): Promise<number>;
+	/**
+	 * 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 0 if the key does not exist.
+	 */
+	ttl(key: string): Promise<number>;
 }