new dual key strategy

Author: robin-drexler

src/index.mjs

@@ -4,39 +4,33 @@
  * @returns {Storage}
  */
 export function wrapStorage(originalStorage, { expiresInSeconds } = {}) {
-  const VERSION = "1";
+  const EXPIRY_PREFIX = "__exp_";
+  const EXPIRY_VERSION = "v1";
 
   /**
-   * @param {any} parsed
-   * @returns {boolean}
-   */
-  function isWrappedValue(parsed) {
-    return typeof parsed === "object" && parsed !== null && "__vr" in parsed;
-  }
-
-  /**
-   * @param {string} value
-   * @returns {object}
+   * @param {string} key
+   * @returns {string}
    */
-  function createWrappedItem(value) {
-    /** @type {{ v: string, __vr: string, ed?: number }} */
-    const item = { v: value, __vr: VERSION };
-    if (expiresInSeconds !== undefined) {
-      item.ed = Date.now() + expiresInSeconds * 1000;
-    }
-    return item;
+  function getExpiryKey(key) {
+    return EXPIRY_PREFIX + key;
   }
 
   /**
    * @param {string} key
-   * @param {string} value
-   * @returns {string}
    */
-  function autoWrapIfNeeded(key, value) {
-    if (expiresInSeconds !== undefined) {
-      originalStorage.setItem(key, JSON.stringify(createWrappedItem(value)));
+  function cleanupOrphanedExpiry(key) {
+    const cleanup = () => {
+      const expiryKey = getExpiryKey(key);
+      if (originalStorage.getItem(expiryKey) && !originalStorage.getItem(key)) {
+        originalStorage.removeItem(expiryKey);
+      }
+    };
+
+    if (typeof requestIdleCallback !== "undefined") {
+      requestIdleCallback(cleanup);
+    } else {
+      cleanup();
     }
-    return value;
   }
 
   return {
@@ -45,26 +39,54 @@ export function wrapStorage(originalStorage, { expiresInSeconds } = {}) {
      * @returns {string | null}
      */
     getItem(key) {
+      // Don't process expiry keys directly
+      if (key.startsWith(EXPIRY_PREFIX)) {
+        return originalStorage.getItem(key);
+      }
+
       const value = originalStorage.getItem(key);
-      if (!value) return value;
+      if (value === null) {
+        cleanupOrphanedExpiry(key);
+        return value;
+      }
 
-      try {
-        const parsed = JSON.parse(value);
+      const expiryKey = getExpiryKey(key);
+      const expiryData = originalStorage.getItem(expiryKey);
 
-        if (isWrappedValue(parsed)) {
-          if (parsed.ed && parsed.ed < Date.now()) {
-            originalStorage.removeItem(key);
-            return null;
-          }
-          return parsed.v;
-        }
+      // If no expiry data but we have expiration configured, auto-wrap it
+      if (!expiryData && expiresInSeconds !== undefined) {
+        const newExpiryTime = Date.now() + expiresInSeconds * 1000;
+        const expiryDataObj = JSON.stringify({
+          e: newExpiryTime,
+          v: EXPIRY_VERSION,
+        });
+        originalStorage.setItem(expiryKey, expiryDataObj);
+        return value;
+      }
+
+      // If no expiry data, return the value as-is
+      if (!expiryData) {
+        return value;
+      }
 
-        // Auto-wrap existing non-wrapped values
-        return autoWrapIfNeeded(key, value);
+      let expiryTime;
+      try {
+        const parsed = JSON.parse(expiryData);
+        expiryTime = parsed.e;
       } catch (e) {
-        // Handle non-JSON values
-        return autoWrapIfNeeded(key, value);
+        // Invalid expiry data, clean up and return value
+        originalStorage.removeItem(expiryKey);
+        return value;
       }
+
+      // Check if expired
+      if (Date.now() > expiryTime) {
+        originalStorage.removeItem(key);
+        originalStorage.removeItem(expiryKey);
+        return null;
+      }
+
+      return value;
     },
 
     /**
@@ -79,17 +101,21 @@ export function wrapStorage(originalStorage, { expiresInSeconds } = {}) {
       }
 
       const stringValue = String(value);
-      originalStorage.setItem(
-        key,
-        JSON.stringify(createWrappedItem(stringValue))
-      );
+      originalStorage.setItem(key, stringValue);
+
+      if (expiresInSeconds !== undefined) {
+        const expiryTime = Date.now() + expiresInSeconds * 1000;
+        const expiryData = JSON.stringify({ e: expiryTime, v: EXPIRY_VERSION });
+        originalStorage.setItem(getExpiryKey(key), expiryData);
+      }
     },
 
     /**
      * @param {string} key
      */
     removeItem(key) {
       originalStorage.removeItem(key);
+      originalStorage.removeItem(getExpiryKey(key));
     },
 
     /**
@@ -104,6 +130,44 @@ export function wrapStorage(originalStorage, { expiresInSeconds } = {}) {
       originalStorage.clear();
     },
 
+    cleanup() {
+      const keysToRemove = [];
+
+      for (let i = 0; i < originalStorage.length; i++) {
+        const key = originalStorage.key(i);
+
+        if (key?.startsWith(EXPIRY_PREFIX)) {
+          const dataKey = key.slice(EXPIRY_PREFIX.length);
+          const expiryData = originalStorage.getItem(key);
+
+          let expiryTime;
+          if (expiryData) {
+            try {
+              const parsed = JSON.parse(expiryData);
+              expiryTime = parsed.e;
+            } catch (e) {
+              expiryTime = 0; // Invalid data, will be cleaned up
+            }
+          } else {
+            expiryTime = 0; // No expiry data, will be cleaned up
+          }
+
+          // Remove if orphaned or expired
+          if (
+            !originalStorage.getItem(dataKey) ||
+            (expiryTime && Date.now() > expiryTime)
+          ) {
+            keysToRemove.push(key);
+            if (originalStorage.getItem(dataKey)) {
+              keysToRemove.push(dataKey);
+            }
+          }
+        }
+      }
+
+      keysToRemove.forEach((key) => originalStorage.removeItem(key));
+    },
+
     get length() {
       return originalStorage.length;
     },