@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/auth/src/SessionManager.ts

@@ -1,92 +0,0 @@
-export interface SessionManagerOptions {
-  channelName: string
-  enabled: boolean
-  onTick: () => void
-  isRefreshDue: () => boolean
-  onRemoteMessage: (data: unknown) => void
-  tickMs?: number
-}
-
-/**
- * Primitive de cycle de vie de session (timers + BroadcastChannel + visibilité).
- * Aucune logique métier auth : `AuthService` fournit les callbacks et pilote `setActive`.
- * Sûr en Node/SSR/RN — tous les globals sont gardés (`typeof … !== 'undefined'`).
- */
-export class SessionManager {
-  private readonly opts: SessionManagerOptions & { tickMs: number }
-  private _interval: ReturnType<typeof setInterval> | null = null
-  private _channel: BroadcastChannel | null = null
-  private _active = false
-  private _visHandler: (() => void) | null = null
-
-  constructor(opts: SessionManagerOptions) {
-    this.opts = { tickMs: 30_000, ...opts }
-  }
-
-  get isActive(): boolean {
-    return this._active
-  }
-
-  start(): void {
-    if (!this.opts.enabled) return
-    if (typeof BroadcastChannel !== 'undefined' && !this._channel) {
-      this._channel = new BroadcastChannel(this.opts.channelName)
-      this._channel.onmessage = (e: MessageEvent) => this.opts.onRemoteMessage(e.data)
-    }
-    if (typeof document !== 'undefined' && !this._visHandler) {
-      this._visHandler = () => {
-        if (document.hidden) {
-          this._stopInterval()
-        } else if (this._active) {
-          this._startInterval()
-          if (this.opts.isRefreshDue()) this.opts.onTick()
-        }
-      }
-      document.addEventListener('visibilitychange', this._visHandler)
-    }
-  }
-
-  setActive(active: boolean): void {
-    this._active = active
-    if (!this.opts.enabled) return
-    const hidden = typeof document !== 'undefined' && document.hidden
-    if (active && !hidden) this._startInterval()
-    else this._stopInterval()
-  }
-
-  broadcast(data: unknown): void {
-    this._channel?.postMessage(data)
-  }
-
-  stop(): void {
-    this._stopInterval()
-    this._active = false
-    if (this._channel) {
-      try {
-        this._channel.close()
-      } catch {
-        /* ignore */
-      }
-      this._channel = null
-    }
-    if (this._visHandler && typeof document !== 'undefined') {
-      document.removeEventListener('visibilitychange', this._visHandler)
-      this._visHandler = null
-    }
-  }
-
-  private _startInterval(): void {
-    if (this._interval) return
-    this._interval = setInterval(() => {
-      if (this.opts.isRefreshDue()) this.opts.onTick()
-    }, this.opts.tickMs)
-    ;(this._interval as { unref?: () => void }).unref?.()
-  }
-
-  private _stopInterval(): void {
-    if (this._interval) {
-      clearInterval(this._interval)
-      this._interval = null
-    }
-  }
-}

package/packages/auth/src/index.ts

@@ -1,17 +0,0 @@
-export { AuthService, isMfaChallenge } from './AuthService'
-export { AuthAdminService } from './AuthAdminService'
-export { SessionManager } from './SessionManager'
-export type { SessionManagerOptions } from './SessionManager'
-export type {
-  VerifyOtpParams,
-  EmailOtpType,
-  MobileOtpType,
-  VerifySignupOtpParams,
-  VerifyMagiclinkOtpParams,
-  VerifyEmailOtpParams,
-  VerifySmsOtpParams,
-  VerifyEmailChangeOtpParams,
-  VerifyRecoveryOtpParams,
-  VerifyInviteOtpParams,
-  VerifyPhoneChangeOtpParams,
-} from './types'

package/packages/auth/src/jwks.ts

@@ -1,337 +0,0 @@
-/**
- * Vérification JWT locale via JWKS (WebCrypto).
- *
- * Contrainte anti-alg-confusion (CRITIQUE) : la vérification locale n'accepte
- * QUE `alg ∈ {RS256, ES256}` (clés asymétriques). Tout autre `alg` (HS256, none,
- * ou JWKS sans clé correspondante) ne donne JAMAIS lieu à une vérification locale
- * avec un secret : l'appelant retombe sur `getUser()` (validation côté serveur).
- */
-
-interface CachedJwks {
-  keys: JsonWebKey[]
-  fetchedAt: number
-  maxAgeMs: number
-}
-
-/**
- * État de robustesse JWKS, aligné sur `jose` `createRemoteJWKSet` :
- *  - dédup in-flight des fetch concurrents (cf. `fetch.ts:31` single-flight refresh),
- *  - cooldown sur refetch forcé (kid inconnu), défaut 30s comme jose `cooldownDuration`,
- *  - negative-cache court sur échec de fetch (anti-tempête pendant une panne),
- *  - plafond `max-age` (pas de cache figé illimité).
- *
- * SEC-F4 : l'état est CLIENT-SCOPED via un `WeakMap<scope, JwksState>` (même pattern
- * que `fetch.ts` `inflightRefreshes: WeakMap<AuraClientLike, …>`), et non plus des
- * `Map` module-level process-global. Chaque `AuraClient` porte donc son propre cache
- * (comme une instance `jose.createRemoteJWKSet`, qui embarque son cache par instance) :
- *  - pas de fuite mémoire SSR multi-tenant (l'état est GC'd avec le client, WeakMap),
- *  - isolation stricte entre clients (deux clients distincts ne partagent RIEN),
- *  - le `scope` reste un `object` opaque → `jwks.ts` n'a AUCUNE dépendance vers `core`.
- */
-const MAX_AGE_CAP_MS = 86_400_000 // 24h — borne haute d'un `Cache-Control: max-age`.
-const FORCED_REFETCH_COOLDOWN_MS = 30_000 // aligné jose `cooldownDuration` (30s).
-const NEGATIVE_CACHE_TTL_MS = 10_000 // fenêtre anti-retry pendant une panne de fetch.
-const DEFAULT_MAX_AGE_MS = 600_000 // défaut quand aucun `Cache-Control: max-age`.
-
-/** État JWKS d'UN client (caches par baseUrl, cf. supra). */
-interface JwksState {
-  cache: Map<string, CachedJwks>
-  inflight: Map<string, Promise<JsonWebKey[]>>
-  lastFailedAt: Map<string, number>
-  lastForcedFetchAt: Map<string, number>
-}
-
-/**
- * État JWKS par client (identité d'objet). `WeakMap` → l'entrée est libérée avec le
- * client (pas de fuite mémoire, pas d'invalidation manuelle nécessaire).
- */
-const clientStates = new WeakMap<object, JwksState>()
-
-/** Récupère (ou crée paresseusement) l'état JWKS du `scope` (le client). */
-function stateFor(scope: object): JwksState {
-  let s = clientStates.get(scope)
-  if (!s) {
-    s = {
-      cache: new Map(),
-      inflight: new Map(),
-      lastFailedAt: new Map(),
-      lastForcedFetchAt: new Map(),
-    }
-    clientStates.set(scope, s)
-  }
-  return s
-}
-
-/**
- * @deprecated SEC-F4 : le cache JWKS est désormais CLIENT-SCOPED (`WeakMap` par client)
- * — plus aucun état process-global à vider. Conservé en NO-OP pour compatibilité des
- * appelants existants (chaque test/instance de client a déjà son cache isolé). À
- * retirer une fois les appels supprimés.
- */
-export function __resetJwksCache(): void {
-  // no-op : plus d'état global (voir stateFor / clientStates).
-}
-
-interface DecodedJwt {
-  header: { alg?: string; kid?: string; typ?: string; [k: string]: unknown }
-  payload: { exp?: number; nbf?: number; [k: string]: unknown }
-  signingInput: string
-  signature: Uint8Array
-}
-
-function b64urlToBytes(s: string): Uint8Array {
-  const b64 = s.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat((4 - (s.length % 4)) % 4)
-  const bin = atob(b64)
-  const out = new Uint8Array(bin.length)
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
-  return out
-}
-
-export function decodeJwt(jwt: string): DecodedJwt {
-  const [h, p, s] = jwt.split('.')
-  if (!h || !p || !s) throw new Error('malformed jwt')
-  const dec = new TextDecoder()
-  return {
-    header: JSON.parse(dec.decode(b64urlToBytes(h))),
-    payload: JSON.parse(dec.decode(b64urlToBytes(p))),
-    signingInput: `${h}.${p}`,
-    signature: b64urlToBytes(s),
-  }
-}
-
-function parseMaxAge(cc: string | null): number | null {
-  const m = cc?.match(/max-age=(\d+)/)
-  return m ? Number(m[1]) * 1000 : null
-}
-
-/**
- * Fetch réseau réel du JWKS, DÉDUPLIQUÉ par baseUrl (single-flight, même idée que
- * `refreshOnce` dans `fetch.ts`). En cas d'échec (réseau ou HTTP non-2xx), arme le
- * negative-cache et jette `jwks_fetch_failed`. En cas de succès, peuple le cache
- * (max-age plafonné) et purge le negative-cache.
- */
-function fetchJwksDeduped(
-  state: JwksState,
-  fetchFn: typeof globalThis.fetch,
-  baseUrl: string,
-): Promise<JsonWebKey[]> {
-  const existing = state.inflight.get(baseUrl)
-  if (existing) return existing
-  const p = (async () => {
-    try {
-      const res = await fetchFn(`${baseUrl}/.well-known/jwks.json`)
-      if (!res.ok) throw new Error('jwks_fetch_failed')
-      const body = (await res.json()) as { keys?: JsonWebKey[] }
-      const parsed = parseMaxAge(res.headers.get('Cache-Control')) ?? DEFAULT_MAX_AGE_MS
-      const maxAge = Math.min(parsed, MAX_AGE_CAP_MS) // cap : pas de cache figé illimité.
-      const keys = body.keys ?? []
-      state.cache.set(baseUrl, { keys, fetchedAt: Date.now(), maxAgeMs: maxAge })
-      state.lastFailedAt.delete(baseUrl)
-      return keys
-    } catch {
-      state.lastFailedAt.set(baseUrl, Date.now())
-      throw new Error('jwks_fetch_failed')
-    }
-  })().finally(() => state.inflight.delete(baseUrl))
-  state.inflight.set(baseUrl, p)
-  return p
-}
-
-/**
- * Chargement non forcé : cache-first (max-age plafonné), gardé par le negative-cache
- * (pas de re-fetch en boucle pendant une panne), déduplication des appels concurrents.
- */
-async function loadJwks(
-  state: JwksState,
-  fetchFn: typeof globalThis.fetch,
-  baseUrl: string,
-): Promise<JsonWebKey[]> {
-  const now = Date.now()
-  const c = state.cache.get(baseUrl)
-  if (c && now - c.fetchedAt < c.maxAgeMs) return c.keys
-  const failedAt = state.lastFailedAt.get(baseUrl)
-  if (failedAt !== undefined && now - failedAt < NEGATIVE_CACHE_TTL_MS) {
-    throw new Error('jwks_fetch_failed')
-  }
-  return fetchJwksDeduped(state, fetchFn, baseUrl)
-}
-
-/**
- * Refetch FORCÉ (kid inconnu → possible rotation). Borné par un cooldown : dans la
- * fenêtre `FORCED_REFETCH_COOLDOWN_MS`, on NE refetch PAS (retourne `null` → l'appelant
- * retombe sur `no_matching_key` sans réseau). Anti-amplification : un token à `kid`
- * aléatoire ne peut pas provoquer un fetch JWKS par appel.
- */
-async function forcedRefetchJwks(
-  state: JwksState,
-  fetchFn: typeof globalThis.fetch,
-  baseUrl: string,
-): Promise<JsonWebKey[] | null> {
-  const now = Date.now()
-  const last = state.lastForcedFetchAt.get(baseUrl)
-  if (last !== undefined && now - last < FORCED_REFETCH_COOLDOWN_MS) return null
-  state.lastForcedFetchAt.set(baseUrl, now)
-  const failedAt = state.lastFailedAt.get(baseUrl)
-  if (failedAt !== undefined && now - failedAt < NEGATIVE_CACHE_TTL_MS) {
-    throw new Error('jwks_fetch_failed')
-  }
-  return fetchJwksDeduped(state, fetchFn, baseUrl)
-}
-
-interface AlgParams {
-  importAlg: RsaHashedImportParams | EcKeyImportParams
-  verifyAlg: AlgorithmIdentifier | EcdsaParams
-}
-
-// alg → paramètres WebCrypto import/verify. `null` = pas de vérif locale (fallback).
-function algParams(alg: string | undefined): AlgParams | null {
-  if (alg === 'RS256') {
-    return {
-      importAlg: { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
-      verifyAlg: { name: 'RSASSA-PKCS1-v1_5' },
-    }
-  }
-  if (alg === 'ES256') {
-    return {
-      importAlg: { name: 'ECDSA', namedCurve: 'P-256' },
-      verifyAlg: { name: 'ECDSA', hash: 'SHA-256' },
-    }
-  }
-  return null // HS256 / none / autre → jamais de vérif locale avec un secret
-}
-
-export type VerifyResult =
-  | { ok: true; claims: Record<string, unknown>; header: { alg: string; kid?: string; typ?: string } }
-  | { ok: false; code: string }
-
-export async function verifyJwtLocal(
-  /**
-   * SEC-F4 : clé d'isolation du cache JWKS (identité d'objet). L'appelant passe son
-   * `client` (n'importe quel `object` opaque) → l'état JWKS est porté par ce client
-   * via `WeakMap` (jamais process-global). Garde `jwks.ts` sans dépendance vers `core`.
-   */
-  scope: object,
-  fetchFn: typeof globalThis.fetch,
-  baseUrl: string,
-  jwt: string,
-  opts: {
-    allowExpired?: boolean
-    /**
-     * Callback d'observabilité (LOT 3, finding I8), appelé à chaque échec de fetch
-     * JWKS (réseau ou HTTP non-2xx). Volontairement non typé sur `AuraObservabilityEvent`
-     * (core) — `jwks.ts` reste sans dépendance vers `@aurabase/core` ; c'est `AuthService`
-     * qui fournit ce callback en le reliant à `emitAuraEvent(client.onEvent, client.debug,
-     * {kind:'jwks-fetch-failed', baseUrl})`. Ne doit jamais throw (appelé au mieux-effort).
-     */
-    onEvent?: (baseUrl: string) => void
-  } = {},
-): Promise<VerifyResult> {
-  let d: DecodedJwt
-  try {
-    d = decodeJwt(jwt)
-  } catch {
-    return { ok: false, code: 'invalid_jwt' }
-  }
-
-  const params = algParams(d.header.alg)
-  if (!params) return { ok: false, code: 'unsupported_alg' } // → l'appelant fait le fallback getUser
-
-  const state = stateFor(scope)
-
-  // Le kty doit correspondre à l'alg (RS256→RSA, ES256→EC) — y compris sur le
-  // match par kid : deux clés peuvent partager un kid après rotation, on ne doit
-  // jamais sélectionner une clé EC pour un token RS256 (défense en profondeur).
-  const matchesAlg = (k: JsonWebKey): boolean =>
-    d.header.alg === 'RS256' ? k.kty === 'RSA' : k.kty === 'EC'
-  // Candidats à essayer, du bon `kty` :
-  //  - AVEC `kid` : on ne retient QUE les clés du kid demandé. Matcher une autre
-  //    clé « par kty seul » ferait échouer verify() → `signature_invalid` SANS
-  //    fallback (seul `no_matching_key` déclenche le fallback getUser) ; en rotation
-  //    (kid absent du JWKS), un token pourtant valide serait rejeté durement.
-  //  - SANS `kid` : on retient TOUTES les clés du bon `kty` et on tente verify sur
-  //    chacune (comme jose). En rotation multi-clés sans kid, la 2e clé peut être la
-  //    bonne → plus de faux `signature_invalid` en ne testant que la première.
-  const candidateKeys = (keys: JsonWebKey[]): JsonWebKey[] =>
-    d.header.kid
-      ? keys.filter((k) => (k as { kid?: string }).kid === d.header.kid && matchesAlg(k))
-      : keys.filter((k) => matchesAlg(k))
-
-  let keys: JsonWebKey[]
-  try {
-    keys = await loadJwks(state, fetchFn, baseUrl)
-  } catch {
-    try {
-      opts.onEvent?.(baseUrl)
-    } catch {
-      // le callback ne doit jamais throw
-    }
-    return { ok: false, code: 'jwks_fetch_failed' }
-  }
-  let candidates = candidateKeys(keys)
-
-  // Rotation de clés : si aucune clé ne matche le kid demandé, on force UN refetch
-  // (borné par cooldown). Le cooldown peut renvoyer `null` → pas de réseau, on
-  // retombe sur `no_matching_key` (→ fallback getUser côté appelant).
-  if (candidates.length === 0 && d.header.kid) {
-    let refetched: JsonWebKey[] | null
-    try {
-      refetched = await forcedRefetchJwks(state, fetchFn, baseUrl)
-    } catch {
-      try {
-        opts.onEvent?.(baseUrl)
-      } catch {
-        // le callback ne doit jamais throw
-      }
-      return { ok: false, code: 'jwks_fetch_failed' }
-    }
-    if (refetched) {
-      keys = refetched
-      candidates = candidateKeys(keys)
-    }
-  }
-  if (candidates.length === 0) return { ok: false, code: 'no_matching_key' }
-
-  // JWK issu du réseau : un JWK malformé (ou incompatible avec l'algo) fait *jeter*
-  // importKey/verify (DataError). On échoue fermé (signature_invalid) — jamais de
-  // rejet de promesse (contrat AuraResponse), jamais de fallback qui masquerait un
-  // JWKS corrompu. On tente chaque candidat ; le premier verify() vrai l'emporte.
-  const signingBytes = new TextEncoder().encode(d.signingInput)
-  let valid = false
-  for (const jwk of candidates) {
-    try {
-      const key = await crypto.subtle.importKey('jwk', jwk, params.importAlg, false, ['verify'])
-      if (
-        await crypto.subtle.verify(
-          params.verifyAlg,
-          key,
-          d.signature as unknown as BufferSource,
-          signingBytes,
-        )
-      ) {
-        valid = true
-        break
-      }
-    } catch {
-      // clé malformée / incompatible → on tente le candidat suivant.
-    }
-  }
-  if (!valid) return { ok: false, code: 'signature_invalid' }
-
-  const now = Math.floor(Date.now() / 1000)
-  if (!opts.allowExpired && typeof d.payload.exp === 'number' && d.payload.exp < now) {
-    return { ok: false, code: 'token_expired' }
-  }
-  if (typeof d.payload.nbf === 'number' && d.payload.nbf > now + 60) {
-    return { ok: false, code: 'token_not_yet_valid' }
-  }
-
-  return {
-    ok: true,
-    claims: d.payload,
-    header: {
-      alg: d.header.alg as string,
-      kid: d.header.kid,
-      typ: d.header.typ,
-    },
-  }
-}

package/packages/auth/src/pkce.ts

@@ -1,27 +0,0 @@
-// PKCE (RFC 7636) — génération du `code_verifier` et calcul du `code_challenge`
-// S256 pour le flux OAuth `signInWithOAuth(..., { flowType: 'pkce' })`.
-
-function b64url(bytes: Uint8Array): string {
-  let s = ''
-  for (const b of bytes) s += String.fromCharCode(b)
-  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-}
-
-/**
- * Génère un `code_verifier` aléatoire haute entropie (64 octets → ~86
- * caractères base64url), dans la plage [43, 128] imposée par RFC 7636.
- */
-export function generateCodeVerifier(): string {
-  const bytes = new Uint8Array(64)
-  crypto.getRandomValues(bytes)
-  return b64url(bytes)
-}
-
-/**
- * Calcule `code_challenge = base64url(SHA-256(verifier))` sans padding
- * (méthode `S256`), tel qu'attendu par le backend aura-auth (oauth.rs).
- */
-export async function codeChallengeS256(verifier: string): Promise<string> {
-  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier))
-  return b64url(new Uint8Array(digest))
-}

package/packages/auth/src/types.ts

@@ -1,89 +0,0 @@
-// ---------------------------------------------------------------------------
-// Types du package @aurabase/auth : façade `verifyOtp` (parité @supabase/auth-js).
-// ---------------------------------------------------------------------------
-
-/**
- * Types d'OTP « email » (parité `EmailOtpType` de supabase-js). Tous ne sont pas
- * exercables côté backend Aurabase : `invite` n'a aucun endpoint (→ `verifyOtp`
- * lève `otp_type_unsupported`). Conservé dans l'union pour la parité de surface.
- */
-export type EmailOtpType = 'signup' | 'invite' | 'magiclink' | 'recovery' | 'email_change' | 'email'
-
-/**
- * Types d'OTP « mobile » (parité `MobileOtpType` de supabase-js). `phone_change`
- * n'a aucun endpoint backend (→ `otp_type_unsupported`).
- */
-export type MobileOtpType = 'sms' | 'phone_change'
-
-export interface VerifySignupOtpParams {
-  type: 'signup'
-  /** Jeton reçu par email (lien de confirmation d'inscription). */
-  token: string
-}
-
-export interface VerifyMagiclinkOtpParams {
-  type: 'magiclink'
-  /** Jeton du magic link. */
-  token: string
-}
-
-export interface VerifyEmailOtpParams {
-  type: 'email'
-  email: string
-  /** Code OTP à 6 chiffres reçu par email (mappé sur `code` côté backend). */
-  token: string
-}
-
-export interface VerifySmsOtpParams {
-  type: 'sms'
-  phone: string
-  /** Code OTP reçu par SMS (mappé sur `code` côté backend). */
-  token: string
-}
-
-export interface VerifyEmailChangeOtpParams {
-  type: 'email_change'
-  /** Jeton de confirmation de changement d'email. */
-  token: string
-}
-
-export interface VerifyRecoveryOtpParams {
-  type: 'recovery'
-  /** Jeton de récupération reçu par email. */
-  token: string
-  /**
-   * Nouveau mot de passe. REQUIS : le backend `reset-password` fusionne
-   * consommation du token + changement de mot de passe (divergence documentée
-   * avec supabase-js qui renvoie une session puis attend un `updateUser`).
-   */
-  password: string
-}
-
-/** Type de surface (parité) sans endpoint backend → `otp_type_unsupported`. */
-export interface VerifyInviteOtpParams {
-  type: 'invite'
-  token: string
-}
-
-/** Type de surface (parité) sans endpoint backend → `otp_type_unsupported`. */
-export interface VerifyPhoneChangeOtpParams {
-  type: 'phone_change'
-  phone: string
-  token: string
-}
-
-/**
- * Union discriminée par `type` de la façade `verifyOtp` (parité surface
- * `@supabase/auth-js`). Chaque variante route vers l'endpoint historique
- * correspondant. `invite`/`phone_change` restent dans l'union pour la parité
- * mais lèvent `otp_type_unsupported` tant que le backend ne les expose pas.
- */
-export type VerifyOtpParams =
-  | VerifySignupOtpParams
-  | VerifyMagiclinkOtpParams
-  | VerifyEmailOtpParams
-  | VerifySmsOtpParams
-  | VerifyEmailChangeOtpParams
-  | VerifyRecoveryOtpParams
-  | VerifyInviteOtpParams
-  | VerifyPhoneChangeOtpParams