@geekmidas/cache 0.0.4 → 0.0.5

package/dist/__tests__/upstash.spec.mjs

@@ -1,5 +1,5 @@
-import { UpstashCache } from "../upstash-CTY-M8vR.mjs";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, globalExpect, it } from "../vi.bdSIJ99Y-DffpE2Zw.mjs";
+import { UpstashCache } from "../upstash-_05vyc5o.mjs";
 
 //#region src/__tests__/upstash.spec.ts
 describe("UpstashCache", () => {
@@ -24,7 +24,7 @@ describe("UpstashCache", () => {
 		it("should return undefined for non-existent key", async () => {
 			const key = getTestKey("non-existent");
 			const result = await cache.get(key);
-			expect(result).toBeUndefined();
+			globalExpect(result).toBeUndefined();
 		});
 		it("should parse and return JSON value", async () => {
 			const key = getTestKey("object");
@@ -34,28 +34,28 @@ describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			expect(result).toEqual(testValue);
+			globalExpect(result).toEqual(testValue);
 		});
 		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);
-			expect(result).toBe(testValue);
+			globalExpect(result).toBe(testValue);
 		});
 		it("should handle number values", async () => {
 			const key = getTestKey("number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			expect(result).toBe(testValue);
+			globalExpect(result).toBe(testValue);
 		});
 		it("should handle boolean values", async () => {
 			const key = getTestKey("boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			expect(result).toBe(testValue);
+			globalExpect(result).toBe(testValue);
 		});
 		it("should handle array values", async () => {
 			const key = getTestKey("array");
@@ -67,13 +67,13 @@ describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			expect(result).toEqual(testArray);
+			globalExpect(result).toEqual(testArray);
 		});
 		it("should handle null values as undefined", async () => {
 			const key = getTestKey("null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			expect(result).toBeUndefined();
+			globalExpect(result).toBeUndefined();
 		});
 	});
 	describe("set", () => {
@@ -85,28 +85,28 @@ describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			expect(result).toEqual(testValue);
+			globalExpect(result).toEqual(testValue);
 		});
 		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);
-			expect(result).toBe(testValue);
+			globalExpect(result).toBe(testValue);
 		});
 		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);
-			expect(result).toBe(testValue);
+			globalExpect(result).toBe(testValue);
 		});
 		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);
-			expect(result).toBe(testValue);
+			globalExpect(result).toBe(testValue);
 		});
 		it("should store and retrieve array values", async () => {
 			const key = getTestKey("set-array");
@@ -117,20 +117,20 @@ describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			expect(result).toEqual(testArray);
+			globalExpect(result).toEqual(testArray);
 		});
 		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);
-			expect(result).toBeUndefined();
+			globalExpect(result).toBeUndefined();
 		});
 		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);
-			expect(result).toBe("updated");
+			globalExpect(result).toBe("updated");
 		});
 	});
 	describe("delete", () => {
@@ -139,11 +139,11 @@ describe("UpstashCache", () => {
 			await cache.set(key, "value-to-delete");
 			await cache.delete(key);
 			const result = await cache.get(key);
-			expect(result).toBeUndefined();
+			globalExpect(result).toBeUndefined();
 		});
 		it("should handle deletion of non-existent key", async () => {
 			const key = getTestKey("non-existent-delete");
-			await expect(cache.delete(key)).resolves.not.toThrow();
+			await globalExpect(cache.delete(key)).resolves.not.toThrow();
 		});
 		it("should only delete specified key", async () => {
 			const key1 = getTestKey("delete-key1");
@@ -151,8 +151,8 @@ describe("UpstashCache", () => {
 			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");
+			globalExpect(await cache.get(key1)).toBeUndefined();
+			globalExpect(await cache.get(key2)).toBe("value2");
 		});
 	});
 	describe("integration scenarios", () => {
@@ -168,7 +168,7 @@ describe("UpstashCache", () => {
 			};
 			await cache.set(key, testData);
 			const result = await cache.get(key);
-			expect(result).toEqual(testData);
+			globalExpect(result).toEqual(testData);
 		});
 		it("should handle complex nested objects", async () => {
 			const key = getTestKey("complex");
@@ -178,7 +178,7 @@ describe("UpstashCache", () => {
 			} } } };
 			await cache.set(key, complexObject);
 			const result = await cache.get(key);
-			expect(result).toEqual(complexObject);
+			globalExpect(result).toEqual(complexObject);
 		});
 		it("should handle concurrent operations", async () => {
 			const keys = [
@@ -193,7 +193,7 @@ describe("UpstashCache", () => {
 			];
 			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);
+			globalExpect(results).toEqual(values);
 		});
 	});
 });

package/dist/{chunk-CUT6urMc.cjs → chunk-DWy1uDak.cjs}

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -22,6 +25,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
+Object.defineProperty(exports, '__commonJS', {
+  enumerable: true,
+  get: function () {
+    return __commonJS;
+  }
+});
 Object.defineProperty(exports, '__toESM', {
   enumerable: true,
   get: function () {

package/dist/expo.cjs

@@ -0,0 +1,36 @@
+const require_chunk = require('./chunk-DWy1uDak.cjs');
+const date_fns = require_chunk.__toESM(require("date-fns"));
+const expo_secure_store = require_chunk.__toESM(require("expo-secure-store"));
+
+//#region src/expo.ts
+var ExpoSecureCache = class ExpoSecureCache {
+	static getExpiryKey(key) {
+		return `${key}:expiresAt`;
+	}
+	async getExpiration(key) {
+		const result = await expo_secure_store.getItemAsync(ExpoSecureCache.getExpiryKey(key));
+		if (!result) return 0;
+		const date = new Date(JSON.parse(result));
+		const secondsLeft = (0, date_fns.differenceInSeconds)(date, /* @__PURE__ */ new Date());
+		return Math.max(secondsLeft, 0);
+	}
+	async get(key) {
+		const result = await expo_secure_store.getItemAsync(key);
+		if (!result) return void 0;
+		const expiresAt = await this.getExpiration(key);
+		if (expiresAt === 0) return void 0;
+		return JSON.parse(result);
+	}
+	async set(key, value, ttl) {
+		const expiresAt = ttl ? Date.now() + ttl * 1e3 : 0;
+		await expo_secure_store.setItemAsync(key, JSON.stringify(value));
+		await expo_secure_store.setItemAsync(ExpoSecureCache.getExpiryKey(key), JSON.stringify(expiresAt));
+	}
+	async delete(key) {
+		await expo_secure_store.deleteItemAsync(key);
+		await expo_secure_store.deleteItemAsync(ExpoSecureCache.getExpiryKey(key));
+	}
+};
+
+//#endregion
+exports.ExpoSecureCache = ExpoSecureCache;

package/dist/expo.d.cts

@@ -0,0 +1,12 @@
+import { Cache } from "./index-q3xYn8_0.cjs";
+
+//#region src/expo.d.ts
+declare class ExpoSecureCache<T> implements Cache<T> {
+  static getExpiryKey(key: string): string;
+  private getExpiration;
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { ExpoSecureCache };

package/dist/expo.d.mts

@@ -0,0 +1,12 @@
+import { Cache } from "./index-CVen_7Cc.mjs";
+
+//#region src/expo.d.ts
+declare class ExpoSecureCache<T> implements Cache<T> {
+  static getExpiryKey(key: string): string;
+  private getExpiration;
+  get(key: string): Promise<T | undefined>;
+  set(key: string, value: T, ttl?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+//#endregion
+export { ExpoSecureCache };

package/dist/expo.mjs

@@ -0,0 +1,35 @@
+import { differenceInSeconds } from "date-fns";
+import * as SecureStore from "expo-secure-store";
+
+//#region src/expo.ts
+var ExpoSecureCache = class ExpoSecureCache {
+	static getExpiryKey(key) {
+		return `${key}:expiresAt`;
+	}
+	async getExpiration(key) {
+		const result = await SecureStore.getItemAsync(ExpoSecureCache.getExpiryKey(key));
+		if (!result) return 0;
+		const date = new Date(JSON.parse(result));
+		const secondsLeft = differenceInSeconds(date, /* @__PURE__ */ new Date());
+		return Math.max(secondsLeft, 0);
+	}
+	async get(key) {
+		const result = await SecureStore.getItemAsync(key);
+		if (!result) return void 0;
+		const expiresAt = await this.getExpiration(key);
+		if (expiresAt === 0) return void 0;
+		return JSON.parse(result);
+	}
+	async set(key, value, ttl) {
+		const expiresAt = ttl ? Date.now() + ttl * 1e3 : 0;
+		await SecureStore.setItemAsync(key, JSON.stringify(value));
+		await SecureStore.setItemAsync(ExpoSecureCache.getExpiryKey(key), JSON.stringify(expiresAt));
+	}
+	async delete(key) {
+		await SecureStore.deleteItemAsync(key);
+		await SecureStore.deleteItemAsync(ExpoSecureCache.getExpiryKey(key));
+	}
+};
+
+//#endregion
+export { ExpoSecureCache };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { Cache } from "./index-BPnJ3lrS.mjs";
+import { Cache } from "./index-CVen_7Cc.mjs";
 export { Cache };