@aurabase/aurabase-js 0.3.1 → 0.4.0

package/packages/core/dist/index.js

@@ -1,673 +0,0 @@
-// src/AuraError.ts
-var AuraError = class _AuraError extends Error {
-  status;
-  code;
-  details;
-  /** Marqueur runtime pour `isAuraError` (détection cross-realm/cross-bundle). */
-  __isAuraError = true;
-  constructor(status, body) {
-    const message = body?.error?.message ?? body?.message ?? `HTTP ${status}`;
-    super(message);
-    this.name = "AuraError";
-    this.status = status;
-    this.code = body?.error?.code ?? `http_${status}`;
-    this.details = body;
-    Object.setPrototypeOf(this, _AuraError.prototype);
-  }
-  get isNotFound() {
-    return this.status === 404;
-  }
-  get isUnauthorized() {
-    return this.status === 401;
-  }
-  get isForbidden() {
-    return this.status === 403;
-  }
-  get isRateLimited() {
-    return this.status === 429;
-  }
-};
-function isAuraError(error) {
-  return error instanceof AuraError || typeof error === "object" && error !== null && error.__isAuraError === true;
-}
-
-// src/types.ts
-function redactUrl(u) {
-  const cut = u.search(/[?#]/);
-  return cut === -1 ? u : u.slice(0, cut);
-}
-function emitAuraEvent(onEvent, debug, event) {
-  const safe = "url" in event && typeof event.url === "string" ? { ...event, url: redactUrl(event.url) } : event;
-  if (debug && typeof console !== "undefined" && typeof console.debug === "function") {
-    try {
-      console.debug("[aurabase]", safe);
-    } catch {
-    }
-  }
-  if (!onEvent) return;
-  try {
-    onEvent(safe);
-  } catch {
-  }
-}
-
-// src/stores/BaseAuthStore.ts
-function decodeJwtPayload(token) {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3) return null;
-    let payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
-    while (payload.length % 4 !== 0) payload += "=";
-    const json = atob(payload);
-    return JSON.parse(json);
-  } catch {
-    return null;
-  }
-}
-function isTokenExpired(token, marginSec = 0) {
-  const payload = decodeJwtPayload(token);
-  if (!payload || typeof payload.exp !== "number") return true;
-  const nowSec = Math.floor(Date.now() / 1e3);
-  return payload.exp - marginSec <= nowSec;
-}
-var BaseAuthStore = class {
-  /**
-   * True si le store survit à un redirect pleine page (persistance disque, ex.
-   * localStorage). Le store de base est en mémoire → non persistant. Exploité par
-   * le flux PKCE : le `code_verifier` doit survivre au redirect OAuth.
-   */
-  persistent = false;
-  _token = null;
-  _refreshToken = null;
-  _user = null;
-  _listeners = /* @__PURE__ */ new Set();
-  _removalEpoch = 0;
-  /** Stockage générique clé/valeur (ex: PKCE `code_verifier`). En mémoire par défaut. */
-  _kv = /* @__PURE__ */ new Map();
-  /** Hook d'observabilité (LOT 3) — câblé par `AuraClient` via `setObservabilityHook`. */
-  _onEvent;
-  _debug = false;
-  // -- Getters ----------------------------------------------------------------
-  /** Compteur incrémenté à chaque `clear()` — sert au commit-guard anti-race du refresh. */
-  get removalEpoch() {
-    return this._removalEpoch;
-  }
-  get token() {
-    return this._token;
-  }
-  get refreshToken() {
-    return this._refreshToken;
-  }
-  get user() {
-    return this._user;
-  }
-  /** True if a non-expired access token is present. */
-  get isValid() {
-    return this._token !== null && !isTokenExpired(this._token);
-  }
-  // -- Mutators ---------------------------------------------------------------
-  save(token, refreshToken, user) {
-    this._token = token;
-    this._refreshToken = refreshToken;
-    this._user = user;
-    this._triggerChange();
-  }
-  clear() {
-    this._removalEpoch++;
-    this._token = null;
-    this._refreshToken = null;
-    this._user = null;
-    this._kv.clear();
-    this._triggerChange();
-  }
-  // -- Generic key/value storage ------------------------------------------------
-  // Utilisé par le flux PKCE (`code_verifier`) et tout autre besoin de stockage
-  // arbitraire lié à l'auth. Impl de base : en mémoire (ne survit pas à un
-  // redirect pleine page — voir `LocalAuthStore` pour la persistance).
-  setItem(key, value) {
-    this._kv.set(key, value);
-  }
-  getItem(key) {
-    return this._kv.get(key) ?? null;
-  }
-  removeItem(key) {
-    this._kv.delete(key);
-  }
-  // -- Observability (LOT 3) ----------------------------------------------------
-  /**
-   * Câble le hook d'observabilité (appelé par `AuraClient` à la construction).
-   * Permet à `LocalAuthStore` d'émettre `storage-blocked` quand `localStorage` est
-   * indisponible (navigation privée Safari, quota dépassé, storage désactivé…).
-   * Sans effet sur `BaseAuthStore` elle-même (en mémoire, jamais "bloquée").
-   */
-  setObservabilityHook(onEvent, debug) {
-    this._onEvent = onEvent;
-    this._debug = !!debug;
-  }
-  /** Émet `{kind:'storage-blocked', op}` — ne throw jamais (voir `emitAuraEvent`). */
-  _emitStorageBlocked(op) {
-    emitAuraEvent(this._onEvent, this._debug, { kind: "storage-blocked", op });
-  }
-  // -- Event emitter ----------------------------------------------------------
-  /**
-   * Register a callback that fires whenever the auth state changes.
-   * Returns an unsubscribe function.
-   */
-  onChange(callback) {
-    this._listeners.add(callback);
-    return () => {
-      this._listeners.delete(callback);
-    };
-  }
-  // -- Internal ---------------------------------------------------------------
-  _triggerChange() {
-    for (const cb of this._listeners) {
-      try {
-        cb(this._token, this._user);
-      } catch {
-      }
-    }
-  }
-};
-
-// src/retry.ts
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
-var RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
-var DEFAULT_MAX_RETRIES = 3;
-var BASE_MS = 500;
-var CAP_MS = 1e4;
-function isRetryableStatus(status) {
-  return RETRYABLE_STATUS.has(status);
-}
-function isRetryableMethod(method) {
-  return RETRYABLE_METHODS.has(method.toUpperCase());
-}
-function computeBackoff(attempt, rand = Math.random) {
-  const bound = Math.min(BASE_MS * 2 ** attempt, CAP_MS);
-  return Math.floor(rand() * bound);
-}
-function parseRetryAfter(header, now = Date.now()) {
-  if (header === null) return null;
-  const trimmed = header.trim();
-  if (/^\d+$/.test(trimmed)) return parseInt(trimmed, 10) * 1e3;
-  const dateMs = Date.parse(trimmed);
-  if (Number.isNaN(dateMs)) return null;
-  return Math.max(0, dateMs - now);
-}
-function abortableSleep(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve();
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function isAbortError(err) {
-  return typeof err === "object" && err !== null && err.name === "AbortError";
-}
-
-// src/serialize.ts
-function serializeBody(body) {
-  return JSON.stringify(
-    body,
-    (_key, value) => typeof value === "bigint" ? value.toString() : value
-  );
-}
-
-// src/fetch.ts
-var REFRESH_MARGIN_SEC = 30;
-var RETRY_AFTER_CAP_MS = 6e4;
-var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
-function unwrapEnvelope(body) {
-  if (body !== null && typeof body === "object" && "data" in body) {
-    return body.data;
-  }
-  return body;
-}
-var inflightRefreshes = /* @__PURE__ */ new WeakMap();
-async function doRefresh(client) {
-  const store = client.authStore;
-  const rt = store.refreshToken;
-  if (!rt) {
-    return {
-      data: null,
-      error: new AuraError(0, { error: { code: "no_session", message: "No refresh token available" } })
-    };
-  }
-  const epoch = store.removalEpoch;
-  let res;
-  try {
-    res = await client.fetchFn(`${client.baseUrl}/v1/auth/${client.projectId}/refresh`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: serializeBody({ refresh_token: rt })
-    });
-  } catch (err) {
-    return {
-      data: null,
-      error: new AuraError(0, {
-        error: { code: "network_error", message: err instanceof Error ? err.message : "Network request failed" }
-      })
-    };
-  }
-  if (!res.ok) {
-    let body2 = null;
-    try {
-      body2 = await res.json();
-    } catch {
-    }
-    if (res.status === 400 || res.status === 401 || res.status === 403) {
-      if (store.removalEpoch === epoch && store.refreshToken === rt) {
-        store.clear();
-      }
-    }
-    return { data: null, error: new AuraError(res.status, body2) };
-  }
-  let body;
-  try {
-    body = await res.json();
-  } catch {
-    return {
-      data: null,
-      error: new AuraError(0, { error: { code: "invalid_response", message: "Invalid refresh response (non-JSON body)" } })
-    };
-  }
-  const data = unwrapEnvelope(body);
-  if (data?.access_token && data?.refresh_token && data?.user) {
-    if (store.removalEpoch !== epoch || store.refreshToken !== rt) {
-      emitAuraEvent(client.onEvent, client.debug, {
-        kind: "refresh-discarded",
-        reason: "Session changed during refresh (concurrent signIn/signOut/rotation)"
-      });
-      return {
-        data: null,
-        error: new AuraError(409, { error: { code: "refresh_discarded", message: "Session changed during refresh" } })
-      };
-    }
-    store.save(data.access_token, data.refresh_token, data.user);
-    emitAuraEvent(client.onEvent, client.debug, { kind: "refresh-success" });
-    return { data, error: null };
-  }
-  return {
-    data: null,
-    error: new AuraError(0, { error: { code: "invalid_response", message: "Invalid refresh response" } })
-  };
-}
-function withRefreshLock(client, fn) {
-  const browser = typeof window !== "undefined";
-  const nav = globalThis.navigator;
-  const locks = nav?.locks;
-  if (!browser || !locks || typeof locks.request !== "function") {
-    return fn();
-  }
-  const request = locks.request;
-  const lockName = `aura-refresh-${client.projectId}`;
-  const timeoutMs = (client.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS) || DEFAULT_REQUEST_TIMEOUT_MS;
-  let timer;
-  const options = {};
-  if (typeof AbortController !== "undefined") {
-    const ctrl = new AbortController();
-    timer = setTimeout(() => ctrl.abort(), timeoutMs);
-    timer.unref?.();
-    options.signal = ctrl.signal;
-  }
-  const clearTimer = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-  };
-  try {
-    return Promise.resolve(
-      request(lockName, options, () => {
-        clearTimer();
-        return fn();
-      })
-    ).catch(() => {
-      clearTimer();
-      return fn();
-    });
-  } catch {
-    clearTimer();
-    return fn();
-  }
-}
-function refreshOnce(client) {
-  const existing = inflightRefreshes.get(client);
-  if (existing) return existing;
-  const p = withRefreshLock(client, () => doRefresh(client)).finally(
-    () => inflightRefreshes.delete(client)
-  );
-  inflightRefreshes.set(client, p);
-  return p;
-}
-async function maybeRefresh(client) {
-  const store = client.authStore;
-  if (!store.token || !store.refreshToken) return;
-  if (!isTokenExpired(store.token, REFRESH_MARGIN_SEC)) return;
-  await refreshOnce(client);
-}
-async function fetchWithAuth(url, init, client) {
-  if (!init.skipAuthRefresh) {
-    await maybeRefresh(client);
-  }
-  const method = (init.method ?? "GET").toUpperCase();
-  const retryEnabled = !init.skipRetry && (client.retryConfig?.enabled ?? true) && isRetryableMethod(method);
-  const maxRetries = client.retryConfig?.maxRetries ?? DEFAULT_MAX_RETRIES;
-  const store = client.authStore;
-  const isFormData = typeof FormData !== "undefined" && init.body instanceof FormData;
-  const timeoutMs = client.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-  const applyTimeout = timeoutMs > 0 && init.signal === void 0 && !isFormData;
-  let attempt = 0;
-  for (; ; ) {
-    const headers = { ...init.headers };
-    if (client.apiKey) {
-      headers["apikey"] = client.apiKey;
-    }
-    if (init.authToken) {
-      headers["Authorization"] = `Bearer ${init.authToken}`;
-    } else if (store.token) {
-      headers["Authorization"] = `Bearer ${store.token}`;
-    }
-    if (!isFormData && init.body !== void 0) {
-      headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
-    }
-    if (attempt > 0) {
-      headers["X-Retry-Count"] = String(attempt);
-    }
-    let timedOut = false;
-    let timeoutTimer;
-    let attemptSignal = init.signal;
-    if (applyTimeout) {
-      const ctrl = new AbortController();
-      timeoutTimer = setTimeout(() => {
-        timedOut = true;
-        ctrl.abort();
-      }, timeoutMs);
-      timeoutTimer.unref?.();
-      attemptSignal = ctrl.signal;
-    }
-    const clearTimeoutTimer = () => {
-      if (timeoutTimer) clearTimeout(timeoutTimer);
-    };
-    const requestInit = {
-      method,
-      headers,
-      signal: attemptSignal
-    };
-    if (init.body !== void 0) {
-      requestInit.body = isFormData ? init.body : serializeBody(init.body);
-    }
-    let res;
-    try {
-      res = await client.fetchFn(url, requestInit);
-    } catch (err) {
-      clearTimeoutTimer();
-      if (retryEnabled && attempt < maxRetries && !isAbortError(err)) {
-        const nextAttempt = attempt + 1;
-        emitAuraEvent(client.onEvent, client.debug, { kind: "retry", attempt: nextAttempt, url });
-        await abortableSleep(computeBackoff(attempt), init.signal);
-        attempt = nextAttempt;
-        continue;
-      }
-      if (timedOut) {
-        emitAuraEvent(client.onEvent, client.debug, { kind: "timeout", url });
-      }
-      return {
-        data: null,
-        error: new AuraError(0, {
-          error: timedOut ? { code: "timeout", message: `Request timed out after ${timeoutMs}ms` } : { code: "network_error", message: err instanceof Error ? err.message : "Network request failed" }
-        })
-      };
-    }
-    clearTimeoutTimer();
-    if (retryEnabled && attempt < maxRetries && isRetryableStatus(res.status)) {
-      const delay = Math.min(
-        parseRetryAfter(res.headers.get("Retry-After")) ?? computeBackoff(attempt),
-        RETRY_AFTER_CAP_MS
-      );
-      await res.body?.cancel().catch(() => {
-      });
-      const nextAttempt = attempt + 1;
-      emitAuraEvent(client.onEvent, client.debug, { kind: "retry", attempt: nextAttempt, status: res.status, url });
-      await abortableSleep(delay, init.signal);
-      attempt = nextAttempt;
-      continue;
-    }
-    if (res.status === 401 && !init.skipAuthRefresh && !init._retried && client.authStore.refreshToken) {
-      const refreshed = await refreshOnce(client);
-      if (refreshed.data) {
-        await res.body?.cancel().catch(() => {
-        });
-        return fetchWithAuth(url, { ...init, _retried: true }, client);
-      }
-    }
-    if (res.status === 204) {
-      return { data: null, error: null };
-    }
-    if (!res.ok) {
-      let body = null;
-      try {
-        body = await res.json();
-      } catch {
-      }
-      return { data: null, error: new AuraError(res.status, body) };
-    }
-    try {
-      const body = await res.json();
-      return {
-        data: unwrapEnvelope(body),
-        error: null,
-        meta: body !== null && typeof body === "object" && "meta" in body ? body.meta : void 0
-      };
-    } catch {
-      return { data: null, error: null };
-    }
-  }
-}
-
-// src/BaseService.ts
-var BaseService = class {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  /** Build a full URL for the given path. */
-  url(path) {
-    return `${this.client.baseUrl}${path}`;
-  }
-  /** Convenience HTTP helper that delegates to fetchWithAuth. */
-  request(method, path, body, options) {
-    const init = {
-      method,
-      body,
-      headers: options?.headers,
-      signal: options?.signal,
-      skipAuthRefresh: options?.skipAuthRefresh,
-      authToken: options?.authToken
-    };
-    return fetchWithAuth(this.url(path), init, this.client);
-  }
-};
-
-// src/stores/LocalAuthStore.ts
-var LocalAuthStore = class extends BaseAuthStore {
-  /** Persiste en localStorage → survit au redirect pleine page (cf. PKCE). */
-  persistent = true;
-  key;
-  constructor(key = "aurabase_auth") {
-    super();
-    this.key = key;
-    this._loadFromStorage();
-  }
-  // -- Overrides --------------------------------------------------------------
-  save(token, refreshToken, user) {
-    super.save(token, refreshToken, user);
-    this._persist();
-  }
-  clear() {
-    super.clear();
-    this._removeStorage();
-    this._removePkceVerifiers();
-  }
-  /**
-   * Supprime de localStorage tous les artefacts d'auth éphémères sur disque :
-   *  - `code_verifier` PKCE (`aura-<projectId>-pkce-code-verifier`),
-   *  - marqueur d'initiation OAuth implicit (`aura-<projectId>-oauth-implicit-initiated`,
-   *    SEC-F3). Un `signOut`/`clear()` ne doit laisser aucun résidu réutilisable (parité
-   * `@supabase/ssr` : ces artefacts sont éphémères). On itère les clés préfixées pour
-   * couvrir un store partagé entre plusieurs projets, sans dépendre du `projectId` courant.
-   */
-  _removePkceVerifiers() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      const toRemove = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const k = localStorage.key(i);
-        if (k && /^aura-.*-(pkce-code-verifier|oauth-implicit-initiated)$/.test(k)) toRemove.push(k);
-      }
-      for (const k of toRemove) localStorage.removeItem(k);
-    } catch {
-      this._emitStorageBlocked("removePkceVerifiers");
-    }
-  }
-  // -- Generic key/value storage (override : persistance localStorage) --------
-  // CRITIQUE pour le flux PKCE : le `code_verifier` doit survivre au redirect
-  // pleine page vers le provider OAuth et retour — un store purement mémoire
-  // ne survivrait pas à ce cycle de navigation.
-  setItem(key, value) {
-    super.setItem(key, value);
-    if (typeof localStorage === "undefined") return;
-    try {
-      localStorage.setItem(key, value);
-    } catch {
-      this._emitStorageBlocked("setItem");
-    }
-  }
-  getItem(key) {
-    if (typeof localStorage === "undefined") return super.getItem(key);
-    try {
-      const v = localStorage.getItem(key);
-      if (v !== null) return v;
-    } catch {
-      this._emitStorageBlocked("getItem");
-    }
-    return super.getItem(key);
-  }
-  removeItem(key) {
-    super.removeItem(key);
-    if (typeof localStorage === "undefined") return;
-    try {
-      localStorage.removeItem(key);
-    } catch {
-      this._emitStorageBlocked("removeItem");
-    }
-  }
-  // -- Cookie helpers (SSR) ---------------------------------------------------
-  /**
-   * Populate the store from a raw `Cookie` header string (server-side).
-   * Looks for the key matching `this.key`.
-   */
-  loadFromCookie(cookieString) {
-    const prefix = `${this.key}=`;
-    const entry = cookieString.split(";").map((c) => c.trim()).find((c) => c.startsWith(prefix));
-    if (!entry) return;
-    try {
-      const raw = decodeURIComponent(entry.slice(prefix.length));
-      const parsed = JSON.parse(raw);
-      if (parsed.token && parsed.refreshToken && parsed.user) {
-        super.save(parsed.token, parsed.refreshToken, parsed.user);
-      }
-    } catch {
-    }
-  }
-  /**
-   * Serialize current auth state into a `Set-Cookie` value.
-   */
-  exportToCookie(options = {}) {
-    const data = {
-      token: this.token,
-      refreshToken: this.refreshToken,
-      user: this.user
-    };
-    const encoded = encodeURIComponent(JSON.stringify(data));
-    const parts = [`${this.key}=${encoded}`];
-    if (options.path) parts.push(`Path=${options.path}`);
-    if (options.domain) parts.push(`Domain=${options.domain}`);
-    if (options.maxAge !== void 0) parts.push(`Max-Age=${options.maxAge}`);
-    if (options.secure) parts.push("Secure");
-    if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
-    if (options.httpOnly) parts.push("HttpOnly");
-    return parts.join("; ");
-  }
-  // -- Private ----------------------------------------------------------------
-  _loadFromStorage() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      const raw = localStorage.getItem(this.key);
-      if (!raw) return;
-      const parsed = JSON.parse(raw);
-      if (parsed.token && parsed.refreshToken && parsed.user) {
-        super.save(parsed.token, parsed.refreshToken, parsed.user);
-      }
-    } catch {
-      this._emitStorageBlocked("loadFromStorage");
-    }
-  }
-  _persist() {
-    if (typeof localStorage === "undefined") return;
-    const data = {
-      token: this.token,
-      refreshToken: this.refreshToken,
-      user: this.user
-    };
-    try {
-      localStorage.setItem(this.key, JSON.stringify(data));
-    } catch {
-      this._emitStorageBlocked("persist");
-    }
-  }
-  _removeStorage() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      localStorage.removeItem(this.key);
-    } catch {
-      this._emitStorageBlocked("removeStorage");
-    }
-  }
-};
-
-// src/cookie-utils.ts
-function parseCookieHeader(header) {
-  const result = {};
-  if (!header) return result;
-  for (const pair of header.split(";")) {
-    const idx = pair.indexOf("=");
-    if (idx === -1) continue;
-    const key = pair.slice(0, idx).trim();
-    const value = pair.slice(idx + 1).trim();
-    if (key) result[key] = decodeURIComponent(value);
-  }
-  return result;
-}
-function serializeCookieHeader(name, value, options = {}) {
-  const parts = [`${name}=${encodeURIComponent(value)}`];
-  if (options.path) parts.push(`Path=${options.path}`);
-  if (options.domain) parts.push(`Domain=${options.domain}`);
-  if (options.maxAge !== void 0) parts.push(`Max-Age=${options.maxAge}`);
-  if (options.secure) parts.push("Secure");
-  if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
-  if (options.httpOnly) parts.push("HttpOnly");
-  return parts.join("; ");
-}
-
-export { AuraError, BaseAuthStore, BaseService, DEFAULT_MAX_RETRIES, LocalAuthStore, RETRYABLE_METHODS, RETRYABLE_STATUS, abortableSleep, computeBackoff, emitAuraEvent, fetchWithAuth, isAbortError, isAuraError, isRetryableMethod, isRetryableStatus, isTokenExpired, parseCookieHeader, parseRetryAfter, refreshOnce, serializeBody, serializeCookieHeader };