shopstack 0.2.6 → 0.3.0

package/src/checkout-monitor.js

@@ -0,0 +1,126 @@
+// Notifications carry no checkout authority. The caller always reads the
+// authenticated canonical resource after this wait returns.
+export function checkoutMonitor(client, checkoutId, WebSocketImplementation) {
+  let attempted = false;
+  let socket;
+  let unavailable = typeof WebSocketImplementation !== "function";
+  let opened = false;
+  let latest = 0;
+  let delivered = 0;
+  let wake;
+  const close = () => {
+    unavailable = true;
+    const current = socket;
+    socket = undefined;
+    try {
+      current?.close();
+    } catch {
+      /* Already closed or never opened. */
+    }
+    wake?.();
+  };
+  const connect = async (remainingMs) => {
+    attempted = true;
+    try {
+      const subscription = await client.subscribeToCheckoutUpdates(checkoutId, {
+        signal: AbortSignal.timeout(Math.max(1, Math.min(5_000, remainingMs))),
+      });
+      const expected = new URL(
+        `${client.baseUrl}/checkout/${encodeURIComponent(checkoutId)}/updates`,
+      );
+      expected.protocol = expected.protocol === "https:" ? "wss:" : "ws:";
+      if (
+        subscription?.socket_url !== expected.href ||
+        subscription.protocol !== "shopstack.v1" ||
+        typeof subscription.token !== "string" ||
+        subscription.token.length > 4096 ||
+        !/^cus_v1\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/u.test(subscription.token) ||
+        !(Date.parse(subscription.expires_at) > Date.now())
+      ) {
+        unavailable = true;
+        return;
+      }
+      socket = new WebSocketImplementation(subscription.socket_url, [
+        subscription.protocol,
+        subscription.token,
+      ]);
+      latest = Number.isSafeInteger(subscription.presentation_revision)
+        ? subscription.presentation_revision
+        : 0;
+      socket.addEventListener("open", () => {
+        opened = true;
+      });
+      socket.addEventListener("close", close);
+      socket.addEventListener("error", close);
+      socket.addEventListener("message", (event) => {
+        if (typeof event.data !== "string" || event.data.length > 4096) return;
+        try {
+          const notification = JSON.parse(event.data);
+          if (
+            notification.type === "checkout_changed" &&
+            Number.isSafeInteger(notification.presentation_revision) &&
+            notification.presentation_revision > latest
+          ) {
+            latest = notification.presentation_revision;
+            wake?.();
+          }
+        } catch {
+          /* Malformed notifications cannot change checkout state. */
+        }
+      });
+    } catch (error) {
+      if (error?.status === 401 || error?.status === 403) throw error;
+      close();
+    }
+  };
+  return {
+    close,
+    async wait(after, remainingMs) {
+      const deadline = Date.now() + remainingMs;
+      if (!attempted && !unavailable) await connect(remainingMs);
+      const changed = () => latest > Math.max(after, delivered);
+      if (changed()) {
+        delivered = latest;
+        return;
+      }
+      if (!unavailable) {
+        await new Promise((resolve) => {
+          const finish = () => {
+            clearTimeout(timer);
+            wake = undefined;
+            resolve();
+          };
+          const timer = setTimeout(
+            () => {
+              if (!opened) close();
+              finish();
+            },
+            Math.max(
+              1,
+              Math.min(opened ? 25_000 : 5_000, deadline - Date.now()),
+            ),
+          );
+          wake = () => {
+            if (unavailable || changed()) finish();
+          };
+        });
+        if (!unavailable || changed()) {
+          delivered = latest;
+          return;
+        }
+      }
+      const remaining = deadline - Date.now();
+      if (remaining < 1_000) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, Math.max(0, remaining)),
+        );
+        return;
+      }
+      await client.waitForCheckoutUpdate(checkoutId, {
+        after,
+        wait: Math.min(25, Math.floor(remaining / 1_000)),
+        signal: AbortSignal.timeout(remaining),
+      });
+    },
+  };
+}