@geekmidas/cache 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cache",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Type-safe email client with SMTP support and React templates",
   "private": false,
   "type": "module",
@@ -19,15 +19,23 @@
       "types": "./dist/upstash.d.ts",
       "import": "./dist/upstash.mjs",
       "require": "./dist/upstash.cjs"
+    },
+    "./expo": {
+      "types": "./dist/expo.d.ts",
+      "import": "./dist/expo.mjs",
+      "require": "./dist/expo.cjs"
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "dependencies": {},
+  "dependencies": {
+    "date-fns": "~4.1.0"
+  },
   "devDependencies": {},
   "peerDependencies": {
-    "@upstash/redis": "~1.35.1"
+    "@upstash/redis": "~1.35.1",
+    "expo-secure-store": "^14.2.3"
   }
 }

package/src/expo.ts

@@ -0,0 +1,51 @@
+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));
+  }
+}

package/src/index.ts

@@ -1,3 +1,20 @@
+import { differenceInSeconds } from 'date-fns';
+
+export const getExpirationInSeconds = (
+  expiresAt: string | number | Date | undefined | null,
+): number => {
+  if (!expiresAt) {
+    return 0;
+  }
+
+  const expirationDate = new Date(expiresAt);
+  const now = new Date();
+
+  const secondsLeft = differenceInSeconds(expirationDate, now);
+
+  return Math.max(secondsLeft, 0);
+};
+
 export interface Cache<T> {
   /**
    * Retrieves a value from the cache.
@@ -19,4 +36,12 @@ export interface Cache<T> {
    * @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>;
 }

package/src/memory.ts

@@ -1,14 +1,34 @@
-import type { Cache } from './';
+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();
 
   async get(key: string): Promise<T | undefined> {
+    const expiration = await this.ttl(key);
+    if (!expiration) {
+      await this.delete(key);
+      return undefined;
+    }
+
     return this.store.get(key);
   }
 
-  async set(key: string, value: T): Promise<void> {
+  async ttl(key: string): Promise<number> {
+    const expiration = this.expirations.get(key);
+    if (!expiration) {
+      return 0;
+    }
+
+    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 delete(key: string): Promise<void> {

package/src/upstash.ts

@@ -11,6 +11,16 @@ export class UpstashCache<T> implements Cache<T> {
     });
   }
 
+  async ttl(key: string): Promise<number> {
+    const ttl = await this.client.ttl(key);
+
+    if (ttl === -2) {
+      return 0; // Key does not exist
+    }
+
+    return ttl; // Returns TTL in seconds
+  }
+
   async get(key: string): Promise<T | undefined> {
     const v = await this.client.get(key);
 

package/tsdown.config.ts

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

package/dist/memory-NQi0XmZ2.mjs

@@ -1,16 +0,0 @@
-//#region src/memory.ts
-var InMemoryCache = class {
-	store = /* @__PURE__ */ new Map();
-	async get(key) {
-		return this.store.get(key);
-	}
-	async set(key, value) {
-		this.store.set(key, value);
-	}
-	async delete(key) {
-		this.store.delete(key);
-	}
-};
-
-//#endregion
-export { InMemoryCache };

package/dist/memory-n6Iosq6J.cjs

@@ -1,22 +0,0 @@
-
-//#region src/memory.ts
-var InMemoryCache = class {
-	store = /* @__PURE__ */ new Map();
-	async get(key) {
-		return this.store.get(key);
-	}
-	async set(key, value) {
-		this.store.set(key, value);
-	}
-	async delete(key) {
-		this.store.delete(key);
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'InMemoryCache', {
-  enumerable: true,
-  get: function () {
-    return InMemoryCache;
-  }
-});