@cubist-labs/cubesigner-sdk-browser-storage 0.4.21-0

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import type { SessionData, SessionManager, SessionMetadata } from "@cubist-labs/cubesigner-sdk";
+import { EventEmitter } from "@cubist-labs/cubesigner-sdk";
+type BrowserStorageEvents = {
+    logout(): void;
+    login(): void;
+};
+/**
+ * A manager that persists into browser storage and uses weblocks to safely perform refreshes
+ */
+export declare class BrowserStorageManager extends EventEmitter<BrowserStorageEvents> implements SessionManager {
+    #private;
+    /**
+     *
+     * @param {string} key The storage key to use
+     * @param {Storage} [storage] The storage object to use (defaults to localStorage)
+     */
+    constructor(key: string, storage?: Storage);
+    /**
+     * Loads the metadata for a session from storage
+     * @return {SessionMetadata} The session metadata
+     */
+    metadata(): Promise<SessionMetadata>;
+    /**
+     * Loads the current access token from storage
+     * @return {string} The access token
+     */
+    token(): Promise<string>;
+    /**
+     * Directly set the session (updating all consumers of the session storage)
+     * @param {SessionData} [session] The new session
+     */
+    setSession(session?: SessionData): Promise<any>;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BrowserStorageManager_instances, _BrowserStorageManager_key, _BrowserStorageManager_storage, _BrowserStorageManager_lock, _BrowserStorageManager_emitIfNecessary, _BrowserStorageManager_loadSession;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserStorageManager = void 0;
+const cubesigner_sdk_1 = require("@cubist-labs/cubesigner-sdk");
+const locks_1 = require("./locks");
+/**
+ * A manager that persists into browser storage and uses weblocks to safely perform refreshes
+ */
+class BrowserStorageManager extends cubesigner_sdk_1.EventEmitter {
+    /**
+     *
+     * @param {string} key The storage key to use
+     * @param {Storage} [storage] The storage object to use (defaults to localStorage)
+     */
+    constructor(key, storage = globalThis.localStorage) {
+        super();
+        _BrowserStorageManager_instances.add(this);
+        /** The storage key for the session data */
+        _BrowserStorageManager_key.set(this, void 0);
+        _BrowserStorageManager_storage.set(this, void 0);
+        _BrowserStorageManager_lock.set(this, void 0);
+        __classPrivateFieldSet(this, _BrowserStorageManager_key, key, "f");
+        __classPrivateFieldSet(this, _BrowserStorageManager_storage, storage, "f");
+        (__classPrivateFieldSet(this, _BrowserStorageManager_lock, `CS_SDK_STORAGE_LOCK_${key}`, "f")),
+            // Set up listeners to emit events when users log in or log out
+            window.addEventListener("storage", (ev) => {
+                // We only care about events on our storage object, using our key
+                if (ev.storageArea !== storage || ev.key !== key)
+                    return;
+                __classPrivateFieldGet(this, _BrowserStorageManager_instances, "m", _BrowserStorageManager_emitIfNecessary).call(this, ev.oldValue, ev.newValue);
+            });
+    }
+    /**
+     * Loads the metadata for a session from storage
+     * @return {SessionMetadata} The session metadata
+     */
+    async metadata() {
+        const sess = __classPrivateFieldGet(this, _BrowserStorageManager_instances, "m", _BrowserStorageManager_loadSession).call(this);
+        if (!sess) {
+            throw new cubesigner_sdk_1.NoSessionFoundError();
+        }
+        return (0, cubesigner_sdk_1.metadata)(sess);
+    }
+    /**
+     * Loads the current access token from storage
+     * @return {string} The access token
+     */
+    async token() {
+        const sess = await (0, locks_1.readTestAndSet)(__classPrivateFieldGet(this, _BrowserStorageManager_lock, "f"), {
+            read: () => __classPrivateFieldGet(this, _BrowserStorageManager_instances, "m", _BrowserStorageManager_loadSession).call(this),
+            test: (v) => v !== undefined && (0, cubesigner_sdk_1.isStale)(v),
+            set: async (oldSession) => {
+                if ((0, cubesigner_sdk_1.isRefreshable)(oldSession)) {
+                    try {
+                        const newSession = await (0, cubesigner_sdk_1.refresh)(oldSession);
+                        __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").setItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"), JSON.stringify(newSession));
+                        console.log("Successfully refreshed");
+                    }
+                    catch (e) {
+                        if (e instanceof cubesigner_sdk_1.ErrResponse && e.status === 403) {
+                            __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").removeItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"));
+                        }
+                    }
+                }
+                else {
+                    // If the session is not refreshable, we should remove it
+                    __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").removeItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"));
+                }
+                // Notify that the session has changed
+                __classPrivateFieldGet(this, _BrowserStorageManager_instances, "m", _BrowserStorageManager_emitIfNecessary).call(this, "", __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").getItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f")));
+            },
+        });
+        if (!sess) {
+            throw new cubesigner_sdk_1.NoSessionFoundError();
+        }
+        return sess.token;
+    }
+    /**
+     * Directly set the session (updating all consumers of the session storage)
+     * @param {SessionData} [session] The new session
+     */
+    async setSession(session) {
+        return await navigator.locks.request(__classPrivateFieldGet(this, _BrowserStorageManager_lock, "f"), {
+            mode: "exclusive",
+        }, async () => {
+            const oldValue = __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").getItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"));
+            const newValue = session ? JSON.stringify(session) : null;
+            // Unlike during refresh, we don't pre-empt the read locks
+            // because this operation is synchronous
+            if (newValue) {
+                __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").setItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"), newValue);
+            }
+            else {
+                __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").removeItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"));
+            }
+            // Storage events don't fire if the store occurred on the same page,
+            // so we have to manually invoke our emit logic
+            __classPrivateFieldGet(this, _BrowserStorageManager_instances, "m", _BrowserStorageManager_emitIfNecessary).call(this, oldValue, newValue);
+        });
+    }
+}
+exports.BrowserStorageManager = BrowserStorageManager;
+_BrowserStorageManager_key = new WeakMap(), _BrowserStorageManager_storage = new WeakMap(), _BrowserStorageManager_lock = new WeakMap(), _BrowserStorageManager_instances = new WeakSet(), _BrowserStorageManager_emitIfNecessary = function _BrowserStorageManager_emitIfNecessary(oldValue, newValue) {
+    if (newValue === null && oldValue !== null) {
+        this.emit("logout");
+    }
+    // There is now a session when there didn't used to be.
+    else if (oldValue === null && newValue !== null) {
+        this.emit("login");
+    }
+}, _BrowserStorageManager_loadSession = function _BrowserStorageManager_loadSession() {
+    const stored = __classPrivateFieldGet(this, _BrowserStorageManager_storage, "f").getItem(__classPrivateFieldGet(this, _BrowserStorageManager_key, "f"));
+    if (stored === null) {
+        return;
+    }
+    return JSON.parse(stored);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SessionData, SessionManager, SessionMetadata } from \"@cubist-labs/cubesigner-sdk\";\nimport {\n  EventEmitter,\n  NoSessionFoundError,\n  isStale,\n  isRefreshable,\n  metadata,\n  refresh,\n  ErrResponse,\n} from \"@cubist-labs/cubesigner-sdk\";\nimport { readTestAndSet } from \"./locks\";\n\ntype BrowserStorageEvents = {\n  logout(): void;\n  login(): void;\n};\n\n/**\n * A manager that persists into browser storage and uses weblocks to safely perform refreshes\n */\nexport class BrowserStorageManager\n  extends EventEmitter<BrowserStorageEvents>\n  implements SessionManager\n{\n  /** The storage key for the session data */\n  #key: string;\n  #storage: Storage;\n  #lock: string;\n\n  /**\n   *\n   * @param {string} key The storage key to use\n   * @param {Storage} [storage] The storage object to use (defaults to localStorage)\n   */\n  constructor(key: string, storage: Storage = globalThis.localStorage) {\n    super();\n    this.#key = key;\n    this.#storage = storage;\n    (this.#lock = `CS_SDK_STORAGE_LOCK_${key}`),\n      // Set up listeners to emit events when users log in or log out\n      window.addEventListener(\"storage\", (ev) => {\n        // We only care about events on our storage object, using our key\n        if (ev.storageArea !== storage || ev.key !== key) return;\n        this.#emitIfNecessary(ev.oldValue, ev.newValue);\n      });\n  }\n\n  /**\n   * Emits a `login` or `logout` event if necessary\n   * @param {null | string} oldValue The previously stored value\n   * @param {null | string} newValue The newly stored value\n   */\n  #emitIfNecessary(oldValue: null | string, newValue: string | null) {\n    if (newValue === null && oldValue !== null) {\n      this.emit(\"logout\");\n    }\n\n    // There is now a session when there didn't used to be.\n    else if (oldValue === null && newValue !== null) {\n      this.emit(\"login\");\n    }\n  }\n\n  /**\n   * Loads a session from the configured storage at the configured key\n   * @return {SessionData | undefined} The stored data or undefined if not present\n   */\n  #loadSession(): SessionData | undefined {\n    const stored = this.#storage.getItem(this.#key);\n    if (stored === null) {\n      return;\n    }\n\n    return JSON.parse(stored);\n  }\n\n  /**\n   * Loads the metadata for a session from storage\n   * @return {SessionMetadata} The session metadata\n   */\n  async metadata(): Promise<SessionMetadata> {\n    const sess = this.#loadSession();\n    if (!sess) {\n      throw new NoSessionFoundError();\n    }\n    return metadata(sess);\n  }\n\n  /**\n   * Loads the current access token from storage\n   * @return {string} The access token\n   */\n  async token(): Promise<string> {\n    const sess = await readTestAndSet<SessionData | undefined>(this.#lock, {\n      read: () => this.#loadSession(),\n      test: (v) => v !== undefined && isStale(v),\n      set: async (oldSession: SessionData) => {\n        if (isRefreshable(oldSession)) {\n          try {\n            const newSession = await refresh(oldSession);\n            this.#storage.setItem(this.#key, JSON.stringify(newSession));\n            console.log(\"Successfully refreshed\");\n          } catch (e) {\n            if (e instanceof ErrResponse && e.status === 403) {\n              this.#storage.removeItem(this.#key);\n            }\n          }\n        } else {\n          // If the session is not refreshable, we should remove it\n          this.#storage.removeItem(this.#key);\n        }\n\n        // Notify that the session has changed\n        this.#emitIfNecessary(\"\", this.#storage.getItem(this.#key));\n      },\n    });\n    if (!sess) {\n      throw new NoSessionFoundError();\n    }\n    return sess.token;\n  }\n\n  /**\n   * Directly set the session (updating all consumers of the session storage)\n   * @param {SessionData} [session] The new session\n   */\n  async setSession(session?: SessionData) {\n    return await navigator.locks.request(\n      this.#lock,\n      {\n        mode: \"exclusive\",\n      },\n      async () => {\n        const oldValue = this.#storage.getItem(this.#key);\n        const newValue = session ? JSON.stringify(session) : null;\n\n        // Unlike during refresh, we don't pre-empt the read locks\n        // because this operation is synchronous\n        if (newValue) {\n          this.#storage.setItem(this.#key, newValue);\n        } else {\n          this.#storage.removeItem(this.#key);\n        }\n\n        // Storage events don't fire if the store occurred on the same page,\n        // so we have to manually invoke our emit logic\n        this.#emitIfNecessary(oldValue, newValue);\n      },\n    );\n  }\n}\n"]}

package/dist/locks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Used as an argument to {@link readTestAndSet}.
+ * Defines the behavior to perform during the locking strategy
+ */
+export type ReadTestAndSet<T> = {
+    /** How to read the data */
+    read(): T;
+    /** If true, perform set, if false, return v */
+    test(v: T): boolean;
+    /** Persist the value */
+    set(prev: T): Promise<void>;
+};
+/**
+ * A locking primitive for contentious reads and writes.
+ *
+ * Guarantees:
+ *  1. Set is only called when test(read()) returns true
+ *  2. Only 1 set() call is active at a time
+ *  3. read() never occurs while set() is running
+ *
+ * @param {string} lock The name of the lock to use
+ * @param {ReadTestAndSet} spec The set of read, test, and set functions to use
+ * @return {Promise<T>} The current value
+ */
+export declare function readTestAndSet<T>(lock: string, { read, test, set }: ReadTestAndSet<T>): Promise<T>;

package/dist/locks.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTestAndSet = void 0;
+/**
+ * A locking primitive for contentious reads and writes.
+ *
+ * Guarantees:
+ *  1. Set is only called when test(read()) returns true
+ *  2. Only 1 set() call is active at a time
+ *  3. read() never occurs while set() is running
+ *
+ * @param {string} lock The name of the lock to use
+ * @param {ReadTestAndSet} spec The set of read, test, and set functions to use
+ * @return {Promise<T>} The current value
+ */
+async function readTestAndSet(lock, { read, test, set }) {
+    const value = await navigator.locks.request(lock, { mode: "shared" }, async () => read());
+    if (test(value)) {
+        return navigator.locks.request(lock, { mode: "exclusive" }, async () => {
+            const prev = read();
+            if (test(prev)) {
+                await set(prev);
+                return read();
+            }
+            return prev;
+        });
+    }
+    return value;
+}
+exports.readTestAndSet = readTestAndSet;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@cubist-labs/cubesigner-sdk-browser-storage",
+  "version": "0.4.21-0",
+  "description": "Browser-based storage for CubeSigner SDK sessions",
+  "license": "MIT OR Apache-2.0",
+  "author": "Cubist, Inc.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "tsconfig.json",
+    "src/**",
+    "dist/**",
+    "../../NOTICE",
+    "../../LICENSE-APACHE",
+    "../../LICENSE-MIT"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepack": "tsc",
+    "test:playwright": "playwright test",
+    "test:build": "esbuild test/site/testscript.ts --bundle --format=esm --outfile='test/site/testscript.js' --external:crypto",
+    "test:server": "http-server ./test/site -c-1"
+  },
+  "peerDependencies": {
+    "@cubist-labs/cubesigner-sdk": "^0.4.21-0"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "devDependencies": {
+    "@cubist-labs/cubesigner-sdk": "^0.4.21-0",
+    "@cubist-labs/cubesigner-sdk-fs-storage": "^0.4.21-0",
+    "@playwright/test": "^1.42.1",
+    "esbuild": "^0.20.1",
+    "http-server": "^14.1.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,151 @@
+import type { SessionData, SessionManager, SessionMetadata } from "@cubist-labs/cubesigner-sdk";
+import {
+  EventEmitter,
+  NoSessionFoundError,
+  isStale,
+  isRefreshable,
+  metadata,
+  refresh,
+  ErrResponse,
+} from "@cubist-labs/cubesigner-sdk";
+import { readTestAndSet } from "./locks";
+
+type BrowserStorageEvents = {
+  logout(): void;
+  login(): void;
+};
+
+/**
+ * A manager that persists into browser storage and uses weblocks to safely perform refreshes
+ */
+export class BrowserStorageManager
+  extends EventEmitter<BrowserStorageEvents>
+  implements SessionManager
+{
+  /** The storage key for the session data */
+  #key: string;
+  #storage: Storage;
+  #lock: string;
+
+  /**
+   *
+   * @param {string} key The storage key to use
+   * @param {Storage} [storage] The storage object to use (defaults to localStorage)
+   */
+  constructor(key: string, storage: Storage = globalThis.localStorage) {
+    super();
+    this.#key = key;
+    this.#storage = storage;
+    (this.#lock = `CS_SDK_STORAGE_LOCK_${key}`),
+      // Set up listeners to emit events when users log in or log out
+      window.addEventListener("storage", (ev) => {
+        // We only care about events on our storage object, using our key
+        if (ev.storageArea !== storage || ev.key !== key) return;
+        this.#emitIfNecessary(ev.oldValue, ev.newValue);
+      });
+  }
+
+  /**
+   * Emits a `login` or `logout` event if necessary
+   * @param {null | string} oldValue The previously stored value
+   * @param {null | string} newValue The newly stored value
+   */
+  #emitIfNecessary(oldValue: null | string, newValue: string | null) {
+    if (newValue === null && oldValue !== null) {
+      this.emit("logout");
+    }
+
+    // There is now a session when there didn't used to be.
+    else if (oldValue === null && newValue !== null) {
+      this.emit("login");
+    }
+  }
+
+  /**
+   * Loads a session from the configured storage at the configured key
+   * @return {SessionData | undefined} The stored data or undefined if not present
+   */
+  #loadSession(): SessionData | undefined {
+    const stored = this.#storage.getItem(this.#key);
+    if (stored === null) {
+      return;
+    }
+
+    return JSON.parse(stored);
+  }
+
+  /**
+   * Loads the metadata for a session from storage
+   * @return {SessionMetadata} The session metadata
+   */
+  async metadata(): Promise<SessionMetadata> {
+    const sess = this.#loadSession();
+    if (!sess) {
+      throw new NoSessionFoundError();
+    }
+    return metadata(sess);
+  }
+
+  /**
+   * Loads the current access token from storage
+   * @return {string} The access token
+   */
+  async token(): Promise<string> {
+    const sess = await readTestAndSet<SessionData | undefined>(this.#lock, {
+      read: () => this.#loadSession(),
+      test: (v) => v !== undefined && isStale(v),
+      set: async (oldSession: SessionData) => {
+        if (isRefreshable(oldSession)) {
+          try {
+            const newSession = await refresh(oldSession);
+            this.#storage.setItem(this.#key, JSON.stringify(newSession));
+            console.log("Successfully refreshed");
+          } catch (e) {
+            if (e instanceof ErrResponse && e.status === 403) {
+              this.#storage.removeItem(this.#key);
+            }
+          }
+        } else {
+          // If the session is not refreshable, we should remove it
+          this.#storage.removeItem(this.#key);
+        }
+
+        // Notify that the session has changed
+        this.#emitIfNecessary("", this.#storage.getItem(this.#key));
+      },
+    });
+    if (!sess) {
+      throw new NoSessionFoundError();
+    }
+    return sess.token;
+  }
+
+  /**
+   * Directly set the session (updating all consumers of the session storage)
+   * @param {SessionData} [session] The new session
+   */
+  async setSession(session?: SessionData) {
+    return await navigator.locks.request(
+      this.#lock,
+      {
+        mode: "exclusive",
+      },
+      async () => {
+        const oldValue = this.#storage.getItem(this.#key);
+        const newValue = session ? JSON.stringify(session) : null;
+
+        // Unlike during refresh, we don't pre-empt the read locks
+        // because this operation is synchronous
+        if (newValue) {
+          this.#storage.setItem(this.#key, newValue);
+        } else {
+          this.#storage.removeItem(this.#key);
+        }
+
+        // Storage events don't fire if the store occurred on the same page,
+        // so we have to manually invoke our emit logic
+        this.#emitIfNecessary(oldValue, newValue);
+      },
+    );
+  }
+}

package/src/locks.ts

@@ -0,0 +1,42 @@
+/**
+ * Used as an argument to {@link readTestAndSet}.
+ * Defines the behavior to perform during the locking strategy
+ */
+export type ReadTestAndSet<T> = {
+  /** How to read the data */
+  read(): T;
+  /** If true, perform set, if false, return v */
+  test(v: T): boolean;
+  /** Persist the value */
+  set(prev: T): Promise<void>;
+};
+
+/**
+ * A locking primitive for contentious reads and writes.
+ *
+ * Guarantees:
+ *  1. Set is only called when test(read()) returns true
+ *  2. Only 1 set() call is active at a time
+ *  3. read() never occurs while set() is running
+ *
+ * @param {string} lock The name of the lock to use
+ * @param {ReadTestAndSet} spec The set of read, test, and set functions to use
+ * @return {Promise<T>} The current value
+ */
+export async function readTestAndSet<T>(
+  lock: string,
+  { read, test, set }: ReadTestAndSet<T>,
+): Promise<T> {
+  const value = await navigator.locks.request(lock, { mode: "shared" }, async () => read());
+  if (test(value)) {
+    return navigator.locks.request(lock, { mode: "exclusive" }, async () => {
+      const prev = read();
+      if (test(prev)) {
+        await set(prev);
+        return read();
+      }
+      return prev;
+    });
+  }
+  return value;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "Node16",
+    "moduleResolution": "node16",
+    "outDir": "./dist"
+  },
+  "typedocOptions": {
+    "out": "./docs",
+    "entryPoints": ["src/index.ts"]
+  },
+  "exclude": ["node_modules", "dist"],
+  "include": ["src/**/*.ts"]
+}