@mosano-product-framework/sdk 0.2.0

package/dist/chunk-7WAV52EO.js

@@ -0,0 +1,621 @@
+import { tryDecodeAccessToken, tokenLifetimeSeconds, isExpired, DeadSessionError, MPFAuthError } from './chunk-AJWM5MDZ.js';
+
+// src/auth/tenant-selection.ts
+var DEFAULT_SELECTION_KEY = "mpf.tenant_selection";
+function readPersisted(storage, key) {
+  if (!storage) {
+    return null;
+  }
+  try {
+    const raw = storage.getItem(key);
+    if (!raw) {
+      return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.tenant !== "string" || parsed.tenant === "") {
+      return null;
+    }
+    return {
+      tenant: parsed.tenant,
+      ...typeof parsed.role === "string" && parsed.role !== "" ? { role: parsed.role } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function createTenantSelection(initialOrOptions) {
+  const isOptions = initialOrOptions !== void 0 && !("tenant" in initialOrOptions);
+  const options = isOptions ? initialOrOptions : { ...initialOrOptions ? { initial: initialOrOptions } : {} };
+  const storage = options.storage;
+  const storageKey = options.storageKey ?? DEFAULT_SELECTION_KEY;
+  const initial = options.initial ?? readPersisted(storage, storageKey) ?? void 0;
+  let current = {
+    tenant: initial?.tenant ?? null,
+    ...initial?.role !== void 0 ? { role: initial.role } : {}
+  };
+  function persist() {
+    if (!storage) {
+      return;
+    }
+    try {
+      if (current.tenant === null) {
+        storage.removeItem(storageKey);
+      } else {
+        storage.setItem(storageKey, JSON.stringify(current));
+      }
+    } catch {
+    }
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  function emit() {
+    for (const listener of [...listeners]) {
+      listener(current);
+    }
+  }
+  return {
+    get() {
+      return current;
+    },
+    set(tenant, role) {
+      if (current.tenant === tenant && current.role === role) {
+        return;
+      }
+      current = { tenant, ...role !== void 0 ? { role } : {} };
+      persist();
+      emit();
+    },
+    clear() {
+      if (current.tenant === null && current.role === void 0) {
+        return;
+      }
+      current = { tenant: null };
+      persist();
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/auth/storage.ts
+function createMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => map.get(key) ?? null,
+    setItem: (key, value) => {
+      map.set(key, value);
+    },
+    removeItem: (key) => {
+      map.delete(key);
+    }
+  };
+}
+function createSessionStorage() {
+  if (typeof window === "undefined") {
+    return createMemoryStorage();
+  }
+  try {
+    const probe = "__mpf_probe__";
+    window.sessionStorage.setItem(probe, probe);
+    window.sessionStorage.removeItem(probe);
+    return window.sessionStorage;
+  } catch {
+    return createMemoryStorage();
+  }
+}
+function createDefaultStorage() {
+  if (typeof window === "undefined") {
+    return createMemoryStorage();
+  }
+  try {
+    const probe = "__mpf_probe__";
+    window.localStorage.setItem(probe, probe);
+    window.localStorage.removeItem(probe);
+    return window.localStorage;
+  } catch {
+    return createMemoryStorage();
+  }
+}
+
+// src/auth/cross-tab.ts
+function defaultLocks() {
+  if (typeof navigator === "undefined") {
+    return null;
+  }
+  const locks = navigator.locks;
+  return locks ?? null;
+}
+function defaultChannel(name) {
+  if (typeof BroadcastChannel === "undefined") {
+    return null;
+  }
+  try {
+    return new BroadcastChannel(name);
+  } catch {
+    return null;
+  }
+}
+function timeoutSignal(ms) {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(new Error(`Lock wait timed out after ${ms}ms`)), ms);
+  return controller.signal;
+}
+function applyJitter(baseMs, jitterMs, random = Math.random) {
+  if (jitterMs <= 0) {
+    return Math.max(0, baseMs);
+  }
+  const offset = (random() * 2 - 1) * jitterMs;
+  return Math.max(0, baseMs + offset);
+}
+function createCrossTabCoordinator(options = {}) {
+  const {
+    lockName = "mpf.refresh",
+    channelName = "mpf.auth",
+    lockTimeoutMs = 5e3,
+    loadPolyfill = async () => null,
+    channelFactory = defaultChannel
+  } = options;
+  const browser = typeof window !== "undefined";
+  const injected = options.locks;
+  let locks = injected !== void 0 ? injected : browser ? defaultLocks() : null;
+  let mode = locks ? injected !== void 0 ? "native" : "native" : "none";
+  let polyfillPromise = null;
+  if (!locks && browser && injected === void 0) {
+    polyfillPromise = loadPolyfill().then((loaded) => {
+      if (loaded) {
+        locks = loaded;
+        mode = "polyfill";
+      }
+    }).catch(() => {
+    });
+  }
+  const channel = browser ? channelFactory(channelName) : null;
+  const listeners = /* @__PURE__ */ new Set();
+  const onMessage = (event) => {
+    const data = event.data;
+    if (!data || typeof data.accessToken !== "string" || typeof data.refreshToken !== "string") {
+      return;
+    }
+    const message = {
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken
+    };
+    for (const listener of [...listeners]) {
+      listener(message);
+    }
+  };
+  channel?.addEventListener("message", onMessage);
+  return {
+    get mode() {
+      return mode;
+    },
+    async withLock(fn) {
+      if (polyfillPromise) {
+        await polyfillPromise;
+        polyfillPromise = null;
+      }
+      if (!locks) {
+        return fn();
+      }
+      let result;
+      let ran = false;
+      try {
+        await locks.request(lockName, { signal: timeoutSignal(lockTimeoutMs) }, async () => {
+          result = await fn();
+          ran = true;
+        });
+      } catch (error) {
+        if (ran) {
+          throw error;
+        }
+        return fn();
+      }
+      return result;
+    },
+    publish(message) {
+      channel?.postMessage(message);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    close() {
+      listeners.clear();
+      channel?.removeEventListener("message", onMessage);
+      channel?.close();
+    }
+  };
+}
+
+// src/auth/session-manager.ts
+var REFRESH_TOKEN_SUPERSEDED = "REFRESH_TOKEN_SUPERSEDED";
+var DEFAULT_BUFFER_SECONDS = 120;
+var DEFAULT_MIN_RENEW_INTERVAL_MS = 5e3;
+var DEFAULT_JITTER_MS = 3e4;
+var SessionManager = class {
+  constructor(options) {
+    this.options = options;
+    this.storage = options.storage ?? createDefaultStorage();
+    this.storageKey = options.storageKey ?? "mpf.refresh_token";
+    this.bufferSeconds = options.bufferSeconds ?? DEFAULT_BUFFER_SECONDS;
+    this.minRenewIntervalMs = options.minRenewIntervalMs ?? DEFAULT_MIN_RENEW_INTERVAL_MS;
+    this.jitterMs = options.jitterMs ?? DEFAULT_JITTER_MS;
+    this.now = options.now ?? (() => Date.now());
+    this.random = options.random ?? Math.random;
+    this.crossTab = options.crossTab === null ? null : options.crossTab ?? createCrossTabCoordinator();
+    if (this.crossTab) {
+      this.unsubscribeBroadcast = this.crossTab.subscribe((message) => {
+        this.adopt(message, { rebroadcast: false });
+      });
+    }
+    this.refreshToken = this.storage.getItem(this.storageKey);
+    this.wakeListening = options.listenToWake ?? typeof window !== "undefined";
+    if (this.wakeListening && typeof window !== "undefined") {
+      window.addEventListener("visibilitychange", this.onWakeEvent);
+      window.addEventListener("online", this.onWakeEvent);
+    }
+  }
+  accessToken = null;
+  refreshToken = null;
+  /** In-flight renewal, for coalescing. */
+  inflight = null;
+  /**
+   * Gate that `getAccessToken()` awaits. Set by the wake path so that requests
+   * queued during a wake renewal block behind it instead of shipping a token
+   * that is already dead.
+   */
+  wakeGate = null;
+  timer = null;
+  lastRenewAt = 0;
+  destroyed = false;
+  /**
+   * Incremented on every `clear()`. A renewal captures it before its network
+   * call and refuses to adopt a result from a superseded generation, so signing
+   * out (or clearing) mid-renew cannot be undone by the renewal completing.
+   */
+  generation = 0;
+  storage;
+  storageKey;
+  bufferSeconds;
+  minRenewIntervalMs;
+  jitterMs;
+  now;
+  random;
+  crossTab;
+  unsubscribeBroadcast = null;
+  wakeListening;
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Adopt a freshly minted token pair (after sign-in, or after any flow that
+   * changes memberships).
+   */
+  setTokens(tokens) {
+    this.adopt(
+      { accessToken: tokens.access_token, refreshToken: tokens.refresh_token },
+      { rebroadcast: true }
+    );
+  }
+  /**
+   * A usable access token, renewing first if necessary.
+   *
+   * Returns `null` only when there is no session at all.
+   */
+  async getAccessToken() {
+    if (this.wakeGate) {
+      await this.wakeGate;
+    }
+    if (!this.accessToken) {
+      return this.refreshToken ? this.renew() : null;
+    }
+    if (this.isStale()) {
+      return this.renew();
+    }
+    return this.accessToken;
+  }
+  /** The current access token without renewing. */
+  peekAccessToken() {
+    return this.accessToken;
+  }
+  /** Decoded (UNVERIFIED — UX only) claims of the current access token. */
+  getClaims() {
+    return tryDecodeAccessToken(this.accessToken);
+  }
+  /**
+   * Renew the session. Coalesced: concurrent callers share one network call,
+   * which is mandatory because the refresh token is single-use.
+   */
+  async renew() {
+    if (this.inflight) {
+      return this.inflight;
+    }
+    this.inflight = this.renewGuarded().finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  /**
+   * Sign out: revoke the session server-side, then clear it locally.
+   *
+   * **Never throws, and always clears.** A user who clicked sign-out must end up
+   * signed out locally whatever the network did — a UI that refuses to log out
+   * is worse than a token that outlives its client, and the failed revoke leaves
+   * that token behind either way. The outcome is reported in the return value so
+   * an app can say "signed out, but we couldn't reach the server" rather than
+   * having to guess.
+   *
+   * Order is load-bearing: `revokeSession` is an *authenticated* endpoint, so
+   * the revoke must go out **before** the access token is cleared. Reversing it
+   * silently sends an unauthenticated request that cannot succeed.
+   *
+   * Idempotent: with no session, it is a no-op reporting `revoked: false`.
+   *
+   * This exists so consumers never need the raw refresh token. Reaching into
+   * storage for it — `localStorage.getItem('mpf.refresh_token')` — hardcodes the
+   * default key and breaks for anyone using a custom storage or key.
+   */
+  async signOut() {
+    const refreshToken = this.refreshToken;
+    const revoker = this.options.revoke;
+    let revoked = false;
+    let error;
+    if (refreshToken && revoker) {
+      try {
+        await revoker(refreshToken);
+        revoked = true;
+      } catch (caught) {
+        error = caught instanceof Error ? caught : new Error(String(caught));
+      }
+    }
+    this.clear();
+    return { revoked, ...error ? { error } : {} };
+  }
+  /**
+   * Forget the session locally. Stops timers and invalidates any in-flight
+   * renewal so it cannot resurrect the session after it resolves.
+   *
+   * Prefer {@link signOut} for a user-initiated sign-out: this leaves the
+   * refresh token valid server-side.
+   */
+  clear() {
+    this.generation += 1;
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.storage.removeItem(this.storageKey);
+    this.cancelTimer();
+    this.options.onTokensChanged?.(null);
+  }
+  /** Detach listeners and release the coordinator. */
+  destroy() {
+    this.destroyed = true;
+    this.cancelTimer();
+    this.unsubscribeBroadcast?.();
+    if (this.wakeListening && typeof window !== "undefined") {
+      window.removeEventListener("visibilitychange", this.onWakeEvent);
+      window.removeEventListener("online", this.onWakeEvent);
+    }
+    this.crossTab?.close();
+  }
+  /**
+   * The buffer actually in force for the current token.
+   *
+   * The configured buffer is clamped to just under half the token's lifetime:
+   * if the buffer were ≥ half the lifetime, a freshly minted token would be
+   * "stale" the instant it arrived and the manager would renew-loop, hammering
+   * `/sessions/renew` forever. A 60s-TTL token therefore gets a 29s buffer, not
+   * the configured 120s.
+   *
+   * Falls back to the configured value when the token carries no `iat` and the
+   * lifetime is unknowable.
+   */
+  effectiveBufferSeconds() {
+    const claims = this.getClaims();
+    if (!claims) {
+      return this.bufferSeconds;
+    }
+    const lifetime = tokenLifetimeSeconds(claims);
+    if (lifetime === void 0) {
+      return this.bufferSeconds;
+    }
+    const ceiling = Math.max(0, Math.floor(lifetime / 2) - 1);
+    return Math.min(this.bufferSeconds, ceiling);
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  isStale() {
+    const claims = this.getClaims();
+    if (!claims) {
+      return true;
+    }
+    return isExpired(claims, this.effectiveBufferSeconds(), this.now());
+  }
+  adopt(tokens, opts) {
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+    this.storage.setItem(this.storageKey, tokens.refreshToken);
+    this.scheduleProactiveRenew();
+    this.options.onTokensChanged?.({
+      access_token: tokens.accessToken,
+      refresh_token: tokens.refreshToken
+    });
+    if (opts.rebroadcast) {
+      this.crossTab?.publish(tokens);
+    }
+  }
+  async renewGuarded() {
+    if (!this.refreshToken) {
+      return this.die(new DeadSessionError("No refresh token available"));
+    }
+    const sinceLast = this.now() - this.lastRenewAt;
+    if (this.lastRenewAt !== 0 && sinceLast < this.minRenewIntervalMs && this.accessToken) {
+      return this.accessToken;
+    }
+    const startedWith = this.refreshToken;
+    const run = async () => {
+      const persisted = this.storage.getItem(this.storageKey);
+      if (persisted && persisted !== startedWith) {
+        this.refreshToken = persisted;
+        if (this.accessToken && !this.isStale()) {
+          return this.accessToken;
+        }
+      }
+      return this.networkRenew();
+    };
+    return this.crossTab ? this.crossTab.withLock(run) : run();
+  }
+  async networkRenew() {
+    const refreshToken = this.refreshToken;
+    if (!refreshToken) {
+      return this.die(new DeadSessionError("No refresh token available"));
+    }
+    this.lastRenewAt = this.now();
+    const generation = this.generation;
+    let pair;
+    try {
+      pair = await this.options.renew(refreshToken);
+    } catch (error) {
+      if (isSupersededError(error)) {
+        const adopted = await this.adoptAfterSuperseded();
+        if (adopted) {
+          return adopted;
+        }
+      }
+      return this.die(
+        new DeadSessionError(
+          "Session renewal failed",
+          error instanceof Error ? error : void 0
+        )
+      );
+    }
+    if (generation !== this.generation) {
+      return pair.access_token;
+    }
+    this.adopt(
+      { accessToken: pair.access_token, refreshToken: pair.refresh_token },
+      { rebroadcast: true }
+    );
+    return pair.access_token;
+  }
+  /**
+   * After a REFRESH_TOKEN_SUPERSEDED, take the winner's tokens.
+   *
+   * The winner's access token arrives over the broadcast channel; its refresh
+   * token is in storage. If neither is usable there is nothing to adopt and the
+   * caller declares the session dead.
+   */
+  async adoptAfterSuperseded() {
+    const persisted = this.storage.getItem(this.storageKey);
+    if (persisted) {
+      this.refreshToken = persisted;
+    }
+    if (this.accessToken && !this.isStale()) {
+      return this.accessToken;
+    }
+    return null;
+  }
+  die(error) {
+    this.clear();
+    this.options.onDeadSession?.(error);
+    throw error;
+  }
+  cancelTimer() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Schedule a renewal shortly before the token goes stale.
+   *
+   * Jittered so that N tabs computing the same deadline from the same token do
+   * not all wake on the same millisecond.
+   */
+  scheduleProactiveRenew() {
+    this.cancelTimer();
+    if (this.destroyed) {
+      return;
+    }
+    const claims = this.getClaims();
+    if (!claims) {
+      return;
+    }
+    const staleAtMs = (claims.exp - this.effectiveBufferSeconds()) * 1e3;
+    const base = Math.max(0, staleAtMs - this.now());
+    const delay = Math.max(
+      this.minRenewIntervalMs,
+      applyJitter(base, this.jitterMs, this.random)
+    );
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.renew().catch(() => {
+      });
+    }, delay);
+  }
+  onWakeEvent = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      return;
+    }
+    void this.handleWake();
+  };
+  /**
+   * Wake path — the real safety net.
+   *
+   * `setTimeout` does not fire in frozen or discarded tabs (Chrome tab
+   * freezing, iOS Safari), so a tab backgrounded for 20 minutes wakes holding a
+   * guaranteed-dead token with its timer never having run.
+   *
+   * Merely rescheduling here is wrong: the delay computes negative, becomes
+   * `setTimeout(0)`, and then races whatever the app fires on focus. Instead
+   * renew immediately and publish a gate that `getAccessToken()` awaits, so
+   * requests triggered by the same focus event queue behind the renewal rather
+   * than each eating a 401.
+   */
+  async handleWake() {
+    if (this.destroyed || !this.refreshToken) {
+      return;
+    }
+    if (this.accessToken && !this.isStale()) {
+      this.scheduleProactiveRenew();
+      return;
+    }
+    if (this.wakeGate) {
+      return;
+    }
+    let release;
+    this.wakeGate = new Promise((resolve) => {
+      release = resolve;
+    });
+    try {
+      await this.renew();
+    } catch {
+    } finally {
+      const gate = release;
+      this.wakeGate = null;
+      gate();
+    }
+  }
+};
+function isSupersededError(error) {
+  if (error instanceof MPFAuthError) {
+    return error.serverCode === REFRESH_TOKEN_SUPERSEDED;
+  }
+  if (error && typeof error === "object" && "code" in error) {
+    return error.code === REFRESH_TOKEN_SUPERSEDED;
+  }
+  return false;
+}
+function createSessionManager(options) {
+  return new SessionManager(options);
+}
+
+export { REFRESH_TOKEN_SUPERSEDED, SessionManager, applyJitter, createCrossTabCoordinator, createDefaultStorage, createMemoryStorage, createSessionManager, createSessionStorage, createTenantSelection, isSupersededError };
+//# sourceMappingURL=chunk-7WAV52EO.js.map
+//# sourceMappingURL=chunk-7WAV52EO.js.map