@smileid/usesmileid 12.0.2 → 12.1.1

package/src/data/util/retry_util.ts

@@ -1,81 +0,0 @@
-import { isAxiosError } from "axios";
-import {
-  RetryStrategy,
-  type RetryConfig,
-} from "../../core/models/network_config";
-
-/**
- * Retry helper. Retries `block` until success or `maxAttempts`
- * exhausted, with delays driven by the configured strategy. Only
- * network-class failures are retried — application errors (4xx other
- * than 408 / 429) bubble out immediately.
- *
- * Concrete scenario: a 401 (token expired) bubbles through here so
- * the auth interceptor can invalidate its cache. A 503 (server busy)
- * is retried up to `maxAttempts` times with exponential backoff.
- */
-export async function withRetry<T>(
-  config: RetryConfig,
-  block: (attempt: number) => Promise<T>,
-): Promise<T> {
-  // Without this the loop below never runs and rejects with `undefined`.
-  if (config.strategy === RetryStrategy.none || config.maxAttempts <= 1) {
-    return block(0);
-  }
-
-  let lastError: unknown;
-  for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
-    try {
-      // `attempt` is the number of retries that preceded this try (0 first).
-      return await block(attempt);
-    } catch (error) {
-      lastError = error;
-      if (!isRetryable(error) || attempt === config.maxAttempts - 1) {
-        throw error;
-      }
-      const delayMs = computeDelayMs(config, attempt);
-      await sleep(delayMs);
-    }
-  }
-  // Unreachable — the loop either returns or throws — but TS needs
-  // an explicit terminal statement here.
-  throw lastError;
-}
-
-/**
- * Network-class failure check. Returns `true` for axios errors that
- * indicate transient transport problems (timeout, 5xx, 408, 429) and
- * `false` for application errors the caller must handle (400, 401,
- * 403, …) or for non-axios errors (programming bugs).
- */
-export function isRetryable(error: unknown): boolean {
-  if (!isAxiosError(error)) return false;
-  // No response yet → transport failure (timeout, DNS, connection
-  // reset). Retry.
-  if (!error.response) return true;
-  const code = error.response.status;
-  return code >= 500 || code === 408 || code === 429;
-}
-
-/**
- * Compute the delay (in milliseconds) before the next retry attempt.
- * `attempt` is 0-indexed (0 = first retry, after the initial call
- * failed). Config delays are in seconds; the return value is converted
- * to ms so it can drive `setTimeout` directly.
- */
-export function computeDelayMs(config: RetryConfig, attempt: number): number {
-  if (config.strategy === "none") return 0;
-  if (config.strategy === "fixed") return config.fixedDelay * 1000;
-
-  const maxDelayMs = config.maxDelay * 1000;
-  const baseMs =
-    config.initialDelay * 1000 * Math.pow(config.multiplier, attempt);
-  const cappedMs = Math.min(baseMs, maxDelayMs);
-  const jitterFactor = (Math.random() * 2 - 1) * config.jitter;
-  const withJitterMs = cappedMs * (1 + jitterFactor);
-  return Math.max(0, Math.min(maxDelayMs, Math.round(withJitterMs)));
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/data/util/use_smile_id_token_decoder.ts

@@ -1,207 +0,0 @@
-import { ZodError } from "zod";
-
-import { type SdkConfig, sdkConfigSchema } from "../model/sdk_config";
-import { type TokenPayload, parseTokenPayload } from "../model/token_payload";
-
-// `atob` is a global available in React Native's Hermes runtime and in
-// modern browsers. The `lib: ["ES2022"]` tsconfig omits DOM types, so the
-// declaration must be explicit. The function exists at runtime; the
-// declaration is a type-only hint.
-declare function atob(data: string): string;
-
-/**
- * Result of decoding a Smile ID JWT auth token.
- *
- * A non-`undefined` `DecodedToken` means the token was structurally
- * valid (three base64url segments, decodable JSON object payload).
- * `sdkConfig` may still be `undefined` within a valid token when the
- * `sdk_config` claim was absent, had an unexpected type, or failed
- * schema validation — all those cases degrade gracefully to `undefined`
- * rather than rejecting the token.
- */
-export type DecodedToken = {
-  readonly sdkConfig?: SdkConfig;
-  /**
-   * Canonical `partner_id` from the top-level JWT claim (server-padded form,
-   * e.g. `"002"`), which can differ from the partner-supplied config string
-   * (`"2"`). The Smile EXIF tagger keys its HMAC/AES derivation on this so the
-   * stamped value matches the partner_id the backend validates against.
-   * `undefined` when the claim is absent.
-   */
-  readonly partnerId?: string;
-  /**
-   * Token-bound user-detail presence flags and consent subfields from the
-   * top-level `payload` claim (a sibling of `sdk_config`). `undefined` when
-   * the claim is absent or not an object — legacy tokens keep today's strict
-   * validation. Same graceful degradation as `sdk_config`: a malformed claim
-   * never rejects the token.
-   */
-  readonly tokenPayload?: TokenPayload;
-};
-
-/**
- * Decode a Smile ID JWT auth token and extract the `sdk_config` and
- * `payload` claims.
- *
- * The JWT signature is intentionally NOT verified — the server validates
- * authenticity; the SDK only reads capture settings and token-bound
- * user-detail/consent presence from the payload.
- *
- * Return semantics:
- *   - Structurally invalid token (not exactly three `.`-delimited
- *     segments, non-base64url payload, non-object JSON) → `undefined`.
- *   - Valid token with no `sdk_config` claim, a non-object claim, or a
- *     claim that fails Zod parsing → non-`undefined` `DecodedToken`
- *     with `sdkConfig` unset. The `payload` claim degrades the same
- *     way into `tokenPayload`.
- *   - Valid token with a parseable `sdk_config` → non-`undefined`
- *     `DecodedToken` with `sdkConfig` set.
- *
- * This function never throws — all failure paths return a value.
- */
-export function decodeSmileIDToken(token: string): DecodedToken | undefined {
-  const payloadObject = parseJwtPayloadObject(token);
-  if (payloadObject === undefined) return undefined;
-
-  // Canonical partner_id — a TOP-LEVEL claim (server-padded form, e.g. "002"), a sibling of
-  // `sdk_config`. The EXIF tagger keys on this so the stamped value matches the backend. Spread
-  // in only when present so `exactOptionalPropertyTypes` isn't violated by an explicit undefined.
-  const rawPartnerId = payloadObject["partner_id"];
-  const partnerIdField =
-    typeof rawPartnerId === "string" ? { partnerId: rawPartnerId } : {};
-
-  // Token-bound user details & consent — a TOP-LEVEL `payload` claim, another
-  // sibling of `sdk_config`. Absent/malformed degrades to unset, never rejects.
-  const tokenPayload = parseTokenPayload(payloadObject["payload"]);
-  const tokenPayloadField = tokenPayload !== undefined ? { tokenPayload } : {};
-
-  const rawClaim = payloadObject["sdk_config"];
-
-  if (rawClaim === undefined || rawClaim === null) {
-    // No claim present — defaults apply throughout the flow.
-    return { ...partnerIdField, ...tokenPayloadField };
-  }
-
-  if (typeof rawClaim !== "object" || Array.isArray(rawClaim)) {
-    // Claim exists but is not an object — treat as absent.
-    return { ...partnerIdField, ...tokenPayloadField };
-  }
-
-  const parseResult = sdkConfigSchema.safeParse(rawClaim);
-  if (!parseResult.success) {
-    // Zod rejected the claim shape — degrade to defaults.
-    if (!(parseResult.error instanceof ZodError)) {
-      // Unreachable in practice (safeParse always gives ZodError on
-      // failure), but degrade gracefully to preserve the never-throws
-      // contract rather than surfacing an unexpected error type.
-      return { ...partnerIdField, ...tokenPayloadField };
-    }
-    return { ...partnerIdField, ...tokenPayloadField };
-  }
-
-  return {
-    sdkConfig: parseResult.data,
-    ...partnerIdField,
-    ...tokenPayloadField,
-  };
-}
-
-/**
- * Extract the server-driven security policy bit-code from the token's **top-level** `policy` claim
- * (a sibling of `sdk_config`, not nested inside it — mirroring the backend and the v11
- * `/v1/auth_smile` response).
- *
- * Internal-only: deliberately NOT re-exported from the package entrypoint (`src/index.ts`), so the
- * policy never widens the partner-facing API. It rides here — alongside the decoder — rather than
- * on the exported {@link DecodedToken} for the same reason. See `SecurityPolicy` and
- * `docs/Policy.md`.
- *
- * Returns `undefined` when the token is unparseable or carries no numeric top-level `policy`. The
- * caller treats `undefined` as fail-secure (every behaviour active), so this never throws.
- */
-export function decodeSecurityPolicyBitCode(token: string): number | undefined {
-  const payloadObject = parseJwtPayloadObject(token);
-  if (payloadObject === undefined) return undefined;
-
-  const policy = payloadObject["policy"];
-  return typeof policy === "number" ? policy : undefined;
-}
-
-/**
- * Parse the JWT payload (middle segment) into a JSON object, or `undefined` when the token is
- * structurally invalid (not exactly three `.`-delimited segments, non-base64url payload, or a
- * non-object JSON payload). Shared by {@link decodeSmileIDToken} and
- * {@link decodeSecurityPolicyBitCode} so both read the payload the same way.
- */
-function parseJwtPayloadObject(
-  token: string,
-): Record<string, unknown> | undefined {
-  const segments = token.split(".");
-  if (segments.length !== 3) return undefined;
-
-  // Decode the payload (middle segment). JWTs omit base64 padding; add
-  // it back before decoding. Replace the URL-safe alphabet (-_) with the
-  // standard alphabet (+/) that `atob` / `Buffer.from` expects.
-  const payloadSegment = segments[1];
-  if (!payloadSegment) return undefined;
-
-  let payloadJson: string;
-  try {
-    payloadJson = decodeBase64Url(payloadSegment);
-  } catch {
-    // Non-base64 data in the payload segment — structurally invalid token.
-    return undefined;
-  }
-
-  let payload: unknown;
-  try {
-    payload = JSON.parse(payloadJson);
-  } catch {
-    // Non-JSON payload — structurally invalid token.
-    return undefined;
-  }
-
-  if (
-    typeof payload !== "object" ||
-    payload === null ||
-    Array.isArray(payload)
-  ) {
-    // JWT payload must be a JSON object per RFC 7519 §3.
-    return undefined;
-  }
-
-  return payload as Record<string, unknown>;
-}
-
-/**
- * Decode a base64url string (no padding) to a UTF-8 string.
- *
- * JWTs use base64url encoding (RFC 4648 §5) which replaces `+` with
- * `-` and `/` with `_`, and omits `=` padding. This helper restores the
- * standard alphabet and adds padding before decoding.
- *
- * Throws `DOMException` / `TypeError` when the input is not valid
- * base64; callers wrap it in a try/catch.
- */
-function decodeBase64Url(input: string): string {
-  // Restore standard base64 alphabet.
-  const standard = input.replace(/-/g, "+").replace(/_/g, "/");
-  // Add `=` padding to reach a multiple of 4.
-  const remainder = standard.length % 4;
-  const padded =
-    remainder === 0 ? standard : standard + "=".repeat(4 - remainder);
-
-  // `atob` is available in React Native's Hermes runtime and in all
-  // modern browsers. It decodes to a binary string; decode UTF-8 via
-  // `decodeURIComponent` + percent-encoding to handle non-ASCII claims.
-  const binaryString = atob(padded);
-  return decodeURIComponent(
-    binaryString
-      .split("")
-      .map(
-        (char: string) =>
-          "%" + char.charCodeAt(0).toString(16).padStart(2, "0"),
-      )
-      .join(""),
-  );
-}