@loomup/astro 0.1.10 → 0.1.12

package/dist/client.js

@@ -27,6 +27,9 @@ function resolveBrowserUrl(explicit) {
     throw new Error("@loomup/astro: createBrowserClient requires `url` or PUBLIC_LOOMUP_URL (set via the loomup() integration)");
 }
 let coordinatorSequence = 0;
+const SESSION_LOCK_DATABASE = "@loomup/astro:auth-locks";
+const SESSION_LOCK_STORE = "leases";
+const SESSION_LOCK_TTL_MS = 120_000;
 function delay(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
@@ -57,9 +60,9 @@ function browserLockManager() {
         return undefined;
     }
 }
-function browserStorage() {
+function browserIndexedDB() {
     try {
-        return globalThis.localStorage;
+        return globalThis.indexedDB;
     }
     catch {
         return undefined;
@@ -72,24 +75,86 @@ function leaseOwner() {
     coordinatorSequence += 1;
     return `${Date.now()}-${coordinatorSequence}`;
 }
-function readLease(storage, key) {
+function storedLease(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const lease = value;
+    if (typeof lease.owner !== "string" || typeof lease.expiresAt !== "number")
+        return null;
+    return { owner: lease.owner, expiresAt: lease.expiresAt };
+}
+function openLeaseDatabase(factory) {
+    return new Promise((resolve, reject) => {
+        const request = factory.open(SESSION_LOCK_DATABASE, 1);
+        request.onupgradeneeded = () => {
+            if (!request.result.objectStoreNames.contains(SESSION_LOCK_STORE)) {
+                request.result.createObjectStore(SESSION_LOCK_STORE);
+            }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error ?? new Error("could not open session lock database"));
+        request.onblocked = () => reject(new Error("session lock database is blocked"));
+    });
+}
+function mutateLease(database, key, decide) {
+    return new Promise((resolve, reject) => {
+        const transaction = database.transaction(SESSION_LOCK_STORE, "readwrite");
+        const store = transaction.objectStore(SESSION_LOCK_STORE);
+        const request = store.get(key);
+        let result = false;
+        request.onsuccess = () => {
+            const mutation = decide(storedLease(request.result));
+            result = mutation.result;
+            if (mutation.write === "put" && mutation.lease)
+                store.put(mutation.lease, key);
+            else if (mutation.write === "delete")
+                store.delete(key);
+        };
+        transaction.oncomplete = () => resolve(result);
+        transaction.onerror = () => reject(transaction.error ?? new Error("session lock transaction failed"));
+        transaction.onabort = () => reject(transaction.error ?? new Error("session lock transaction aborted"));
+    });
+}
+function acquireLease(database, key, owner) {
+    return mutateLease(database, key, (current) => {
+        if (current && current.expiresAt > Date.now()) {
+            return { result: false, write: "none" };
+        }
+        return {
+            result: true,
+            write: "put",
+            lease: { owner, expiresAt: Date.now() + SESSION_LOCK_TTL_MS },
+        };
+    });
+}
+function renewLease(database, key, owner) {
+    return mutateLease(database, key, (current) => current?.owner === owner
+        ? {
+            result: true,
+            write: "put",
+            lease: { owner, expiresAt: Date.now() + SESSION_LOCK_TTL_MS },
+        }
+        : { result: false, write: "none" });
+}
+function releaseLease(database, key, owner) {
+    return mutateLease(database, key, (current) => current?.owner === owner
+        ? { result: true, write: "delete" }
+        : { result: false, write: "none" });
+}
+async function withLease(name, operation) {
+    const factory = browserIndexedDB();
+    if (!factory) {
+        if (typeof window === "undefined")
+            return operation();
+        throw new LoomupError("browser storage cannot coordinate session refresh", "auth_lock_unavailable", 503);
+    }
+    let database;
     try {
-        const raw = storage.getItem(key);
-        if (!raw)
-            return null;
-        const value = JSON.parse(raw);
-        if (typeof value.owner !== "string" || typeof value.expiresAt !== "number")
-            return null;
-        return { owner: value.owner, expiresAt: value.expiresAt };
+        database = await openLeaseDatabase(factory);
     }
     catch {
-        return null;
+        throw new LoomupError("browser storage cannot coordinate session refresh", "auth_lock_unavailable", 503);
     }
-}
-async function withLease(name, operation) {
-    const storage = browserStorage();
-    if (!storage)
-        return operation();
     const key = `@loomup/astro:auth-lock:${name}`;
     const owner = leaseOwner();
     const deadline = Date.now() + 30_000;
@@ -98,32 +163,25 @@ async function withLease(name, operation) {
         : undefined;
     try {
         while (Date.now() < deadline) {
-            const current = readLease(storage, key);
-            if (!current || current.expiresAt <= Date.now()) {
+            if (await acquireLease(database, key, owner)) {
+                let heartbeatInFlight = null;
+                const heartbeat = setInterval(() => {
+                    if (heartbeatInFlight)
+                        return;
+                    heartbeatInFlight = renewLease(database, key, owner)
+                        .catch(() => false)
+                        .finally(() => { heartbeatInFlight = null; });
+                }, 5_000);
                 try {
-                    storage.setItem(key, JSON.stringify({ owner, expiresAt: Date.now() + 15_000 }));
-                }
-                catch {
-                    return operation();
+                    return await operation();
                 }
-                // localStorage has no compare-and-swap. A short settle and owner check
-                // ensures only the last contender enters the critical section.
-                await delay(20);
-                if (readLease(storage, key)?.owner === owner) {
-                    const heartbeat = setInterval(() => {
-                        if (readLease(storage, key)?.owner === owner) {
-                            storage.setItem(key, JSON.stringify({ owner, expiresAt: Date.now() + 15_000 }));
-                        }
-                    }, 5_000);
-                    try {
-                        return await operation();
-                    }
-                    finally {
-                        clearInterval(heartbeat);
-                        if (readLease(storage, key)?.owner === owner)
-                            storage.removeItem(key);
-                        channel?.postMessage("released");
-                    }
+                finally {
+                    clearInterval(heartbeat);
+                    const pendingHeartbeat = heartbeatInFlight;
+                    if (pendingHeartbeat)
+                        await pendingHeartbeat;
+                    await releaseLease(database, key, owner).catch(() => false);
+                    channel?.postMessage("released");
                 }
             }
             await delay(50);
@@ -132,6 +190,7 @@ async function withLease(name, operation) {
     }
     finally {
         channel?.close();
+        database.close();
     }
 }
 async function withBrowserSessionLock(name, operation) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomup/astro",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Astro integration and SSR helpers for Loomup Realtime",
   "type": "module",
   "main": "dist/index.js",
@@ -46,8 +46,9 @@
     }
   },
   "devDependencies": {
-    "typescript": "^5.7.0",
-    "@types/node": "^22.0.0"
+    "@types/node": "^22.0.0",
+    "fake-indexeddb": "^6.2.5",
+    "typescript": "^5.7.0"
   },
   "engines": {
     "node": ">=18"