@smartmemory/sdk-js 1.4.100 → 1.4.120

package/dist/react.js

@@ -1,40 +1,40 @@
-import h, { createContext as d, useRef as S, useState as p, useEffect as C, useCallback as c, useContext as g } from "react";
-import { l as y } from "./core-McKeQ81o.js";
-const m = d(null), f = d(null);
+import h, { createContext as d, useRef as I, useState as S, useEffect as C, useCallback as c, useContext as g } from "react";
+import { l as y } from "./core-DUg_hHl8.js";
+const f = d(null), m = d(null);
 function b({ children: e, ...r }) {
-  const n = S(null);
+  const n = I(null);
   n.current || (n.current = new y(r));
-  const t = n.current, [o, u] = p({
+  const t = n.current, [o, u] = S({
     isAuthenticated: t.auth.isAuthenticated(),
     user: t.auth.getCurrentUser(),
     token: t.auth.getCurrentToken(),
     tenantId: t.auth.getTenantId(),
-    workspaceId: t.auth.tokenManager.getTeamId(),
+    workspaceId: t.auth.tokenManager.getWorkspaceId(),
     loading: !1,
     error: null
   });
-  C(() => t.auth.addListener((i) => {
-    u((I) => ({
-      ...I,
-      isAuthenticated: i.isAuthenticated,
-      user: i.user,
-      token: i.token,
-      tenantId: i.tenantId,
-      workspaceId: i.workspaceId
+  C(() => t.auth.addListener((s) => {
+    u((p) => ({
+      ...p,
+      isAuthenticated: s.isAuthenticated,
+      user: s.user,
+      token: s.token,
+      tenantId: s.tenantId,
+      workspaceId: s.workspaceId
     }));
   }), [t]);
   const a = c(async () => {
     await t.auth.logout();
-  }, [t]), w = c((s) => t.auth.hasRole(s), [t]), A = c((s) => t.auth.getLoginUrl(s), [t]), k = {
+  }, [t]), w = c((i) => t.auth.hasRole(i), [t]), A = c((i) => t.auth.getLoginUrl(i), [t]), k = {
     ...o,
     logout: a,
     hasRole: w,
     getLoginUrl: A
   };
-  return /* @__PURE__ */ h.createElement(m.Provider, { value: k }, /* @__PURE__ */ h.createElement(f.Provider, { value: t }, e));
+  return /* @__PURE__ */ h.createElement(f.Provider, { value: k }, /* @__PURE__ */ h.createElement(m.Provider, { value: t }, e));
 }
 function l() {
-  const e = g(m);
+  const e = g(f);
   if (!e)
     throw new Error("useAuth must be used within a SmartMemoryProvider");
   return e;
@@ -48,7 +48,7 @@ function R() {
   return { login: e, logout: r, hasRole: n, getLoginUrl: t };
 }
 function U() {
-  const e = g(f);
+  const e = g(m);
   if (!e)
     throw new Error("useSmartMemory must be used within a SmartMemoryProvider");
   return e;
@@ -68,9 +68,9 @@ function E({ children: e, fallback: r = null, redirectToLogin: n = !1 }) {
   return e;
 }
 export {
-  m as AuthContext,
+  f as AuthContext,
   E as AuthWrapper,
-  f as ClientContext,
+  m as ClientContext,
   b as SmartMemoryProvider,
   l as useAuth,
   R as useAuthActions,

package/dist/recovery-JyUr2KHh.js

@@ -0,0 +1,34 @@
+async function A(e, n, { source: o, signal: t, retry: i = !0 } = {}) {
+  var c, f, p, d, w, l;
+  const s = () => new Headers(e.getAuthHeaders()).get("X-Workspace-Id"), h = s(), u = new Headers(e.getAuthHeaders()).get("Authorization"), a = () => {
+    if (s() !== h) throw new DOMException("Workspace changed during request", "AbortError");
+  };
+  try {
+    let r = await n(!1);
+    if (r.status === 401 && i) {
+      if (console.warn("[session] Unauthorized; refreshing and retrying once"), (c = e.connection) == null || c.report(o, "Refreshing session"), a(), t != null && t.aborted) throw new DOMException("Request aborted", "AbortError");
+      if (new Headers(e.getAuthHeaders()).get("Authorization") === u && await e.refreshToken(), a(), t != null && t.aborted) throw new DOMException("Request aborted", "AbortError");
+      r = await n(!0);
+    }
+    return r.status === 401 ? (console.warn("[session] Authentication required after recovery"), (f = e.clearLocalAuth) == null || f.call(e)) : r.status === 429 || r.status >= 500 ? (console.warn(`[session] Service unavailable: HTTP ${r.status}`), (p = e.connection) == null || p.report(o, `HTTP ${r.status}`)) : (d = e.connection) == null || d.report(o, null), r;
+  } catch (r) {
+    throw r.name === "AbortError" && ((w = e.connection) == null || w.report(o, null)), r.name !== "AbortError" && r.recoverable !== !1 && (console.warn("[session] Connection interrupted", r), (l = e.connection) == null || l.report(o, r.message)), r;
+  }
+}
+function b(e) {
+  return new URL(
+    e instanceof Request ? e.url : String(e),
+    typeof location < "u" ? location.href : "http://localhost"
+  );
+}
+function E(e, n, o = []) {
+  return [e.apiBaseUrl || "/", ...o].some((t) => {
+    const i = b(t), s = i.pathname.replace(/\/$/, "");
+    return n.origin === i.origin && (!s || n.pathname === s || n.pathname.startsWith(`${s}/`));
+  });
+}
+export {
+  A as f,
+  E as i,
+  b as r
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/sdk-js",
-  "version": "1.4.100",
+  "version": "1.4.120",
   "description": "Unified JavaScript SDK for SmartMemory API — auth + API client for all frontends",
   "type": "module",
   "main": "dist/index.js",
@@ -23,16 +23,24 @@
       "default": "./dist/react/analytics.js"
     },
     "./fetch": {
+      "types": "./types/fetch.d.ts",
       "development": "./src/fetch/index.js",
       "default": "./dist/fetch.js"
     },
     "./progress": {
+      "types": "./types/progress.d.ts",
       "development": "./src/progress.ts",
       "default": "./dist/progress.js"
+    },
+    "./connection": {
+      "types": "./types/connection.d.ts",
+      "development": "./src/connection/index.js",
+      "default": "./dist/connection.js"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "scripts": {
     "build": "vite build",

package/types/connection.d.ts

@@ -0,0 +1,30 @@
+export type ConnectionState = 'connected' | 'reconnecting' | 'signed_out';
+export interface ConnectionSnapshot {
+  readonly status: ConnectionState;
+  readonly reason: string | null;
+}
+export declare class ConnectionStatus {
+  readonly snapshot: ConnectionSnapshot;
+  subscribe(listener: (snapshot: ConnectionSnapshot) => void): () => void;
+  report(source: string | symbol, reason: string | null): void;
+  signedOut(): void;
+  authenticated(): void;
+}
+/** Structural type for client.connection / client.auth.connection. */
+export interface RecoveryClient {
+  connection: ConnectionStatus;
+  auth: RecoveryAuth;
+}
+export interface RecoveryAuth {
+  apiBaseUrl: string;
+  connection: ConnectionStatus;
+  getAuthHeaders(extra?: HeadersInit): Record<string, string>;
+  getRequestOptions(extra?: RequestInit): RequestInit;
+  refreshToken(): Promise<string | null>;
+  clearLocalAuth(): void;
+}
+export declare class SessionRefreshError extends Error {
+  constructor(message: string, status?: number, recoverable?: boolean);
+  status: number;
+  recoverable: boolean;
+}

package/types/fetch.d.ts

@@ -0,0 +1,12 @@
+import type { RecoveryAuth } from './connection.js';
+export type { RecoveryAuth, RecoveryClient, ConnectionSnapshot, ConnectionState } from './connection.js';
+export interface AuthFetchOptions {
+  fetchFn?: typeof fetch;
+  apiBases?: string[];
+}
+export interface InterceptorOptions extends AuthFetchOptions {
+  urlPatterns?: string[];
+}
+export declare function createAuthFetch(authCore: RecoveryAuth, options?: AuthFetchOptions): typeof fetch;
+/** Returns an injectable fetch; does not mutate global fetch or return an uninstaller. */
+export declare function installInterceptor(authCore: RecoveryAuth, options?: InterceptorOptions): typeof fetch;

package/types/progress.d.ts

@@ -0,0 +1,48 @@
+export interface ProgressEvent {
+  run_id: string;
+  scope: string;
+  seq: number;
+  ts: number;
+  kind: string;
+  status: 'started' | 'progress' | 'ok' | 'warn' | 'error' | 'skipped';
+  payload: Record<string, unknown>;
+  /** Optional — pipeline stage name when applicable */
+  stage?: string | null;
+}
+
+export interface ProgressAuth {
+  getAuthHeaders(): Record<string, string>;
+  getRequestOptions(options?: RequestInit): RequestInit;
+  refreshToken(): Promise<unknown>;
+  clearLocalAuth(): void;
+  connection?: ProgressConnection;
+}
+export interface ProgressConnection {
+  report(source: string | symbol, reason: string | null): void;
+}
+export interface SubscribeProgressOptions {
+  baseUrl?: string;
+  /** Static credentials remain supported. Prefer auth for session recovery. */
+  token?: string;
+  apiKey?: string;
+  workspaceId?: string;
+  auth?: ProgressAuth;
+  /** Synchronous live headers, read on every connection; overrides static headers. */
+  getHeaders?: () => Record<string, string>;
+  connection?: ProgressConnection;
+  fetchFn?: typeof fetch;
+  runId?: string;
+  fromSeq?: number;
+  since?: string;
+  useCookieAuth?: boolean;
+  /** Default true. Set false for deliberate finite replay; EOF invokes onComplete. */
+  reconnect?: boolean;
+  onComplete?: () => void;
+  onEvent: (event: ProgressEvent) => void;
+  /** Terminal errors only; transient interruption invokes onReconnect. */
+  onError: (err: unknown) => void;
+  onReconnect?: () => void;
+}
+export interface ProgressSubscription { close(): void; }
+
+export declare function subscribeProgress(options: SubscribeProgressOptions): ProgressSubscription;