@smileid/usesmileid 12.0.1 → 12.1.0

package/src/data/api/interceptors/__tests__/smile_request_mac_interceptor.test.ts

@@ -1,156 +0,0 @@
-import { describe, expect, it, beforeEach } from "vitest";
-import axios, { AxiosHeaders, type InternalAxiosRequestConfig } from "axios";
-
-import { SmileIDCryptoManager } from "../../../security/smile_id_crypto_manager";
-import { SecurityPolicy } from "../../../security/security_policy";
-import {
-  SmileRequestMacInterceptor,
-  REQUEST_MAC_HEADER,
-  REQUEST_MAC_OPT_IN_KEY,
-  REQUEST_TIMESTAMP_HEADER,
-} from "../smile_request_mac_interceptor";
-
-/**
- * Pins down the MAC interceptor's wire shape:
- *   - Opt-out requests (`_useSmileIDRequestMac` unset) ship without the header.
- *   - Opt-in requests stamp `smileid-request-mac` with the Base64 HMAC that
- *     {@link SmileIDCryptoManager} produces over the canonical headers and body.
- *   - The timestamp stamped upstream is reused as-is; if it is missing the
- *     request is left unsigned rather than signed against an invented value.
- */
-describe("SmileRequestMacInterceptor", () => {
-  const TIMESTAMP = "1700000000000";
-  const cryptoManager = new SmileIDCryptoManager("test-signing-secret");
-
-  let client: ReturnType<typeof axios.create>;
-  let interceptor: SmileRequestMacInterceptor;
-
-  beforeEach(() => {
-    client = axios.create();
-    // undefined bit-code is fail-secure: payload signing is active, matching the pre-policy default.
-    interceptor = new SmileRequestMacInterceptor({
-      cryptoManager,
-      securityPolicy: SecurityPolicy.fromBitCode(undefined),
-    });
-    interceptor.attach(client);
-  });
-
-  async function run(
-    config: InternalAxiosRequestConfig,
-  ): Promise<InternalAxiosRequestConfig> {
-    const handlers = (
-      client.interceptors.request as unknown as {
-        handlers: {
-          fulfilled?: (cfg: InternalAxiosRequestConfig) => unknown;
-        }[];
-      }
-    ).handlers;
-    let current = config;
-    for (let i = handlers.length - 1; i >= 0; i--) {
-      const handler = handlers[i]?.fulfilled;
-      if (typeof handler === "function") {
-        current = (await handler(current)) as InternalAxiosRequestConfig;
-      }
-    }
-    return current;
-  }
-
-  function makeConfig(
-    overrides: Partial<InternalAxiosRequestConfig> = {},
-  ): InternalAxiosRequestConfig {
-    return {
-      headers: new AxiosHeaders(),
-      ...overrides,
-    } as InternalAxiosRequestConfig;
-  }
-
-  it("passes through when the opt-in flag is absent", async () => {
-    const result = await run(makeConfig({ data: '{"hello":"world"}' }));
-    expect(result.headers.get(REQUEST_MAC_HEADER)).toBeUndefined();
-  });
-
-  it("stamps the Base64 MAC when opted in and the timestamp is present", async () => {
-    const result = await run(
-      makeConfig({
-        data: '{"hello":"world"}',
-        headers: new AxiosHeaders({
-          "smileid-token": "test-token",
-          [REQUEST_TIMESTAMP_HEADER]: TIMESTAMP,
-        }),
-        [REQUEST_MAC_OPT_IN_KEY]: true,
-      } as Partial<InternalAxiosRequestConfig>),
-    );
-
-    // Recompute with the same manager so the test pins the wiring rather than a
-    // hard-coded digest.
-    const expected = await cryptoManager.sign(
-      TIMESTAMP,
-      { "smileid-token": "test-token", [REQUEST_TIMESTAMP_HEADER]: TIMESTAMP },
-      '{"hello":"world"}',
-    );
-    expect(result.headers.get(REQUEST_MAC_HEADER)).toBe(expected);
-  });
-
-  it("leaves the request unsigned when the timestamp is missing", async () => {
-    const result = await run(
-      makeConfig({
-        data: '{"hello":"world"}',
-        [REQUEST_MAC_OPT_IN_KEY]: true,
-      } as Partial<InternalAxiosRequestConfig>),
-    );
-    expect(result.headers.get(REQUEST_MAC_HEADER)).toBeUndefined();
-  });
-
-  /** Drive a one-interceptor client built with a specific policy. */
-  async function runWith(
-    policy: SecurityPolicy,
-    config: InternalAxiosRequestConfig,
-  ): Promise<InternalAxiosRequestConfig> {
-    const localClient = axios.create();
-    new SmileRequestMacInterceptor({
-      cryptoManager,
-      securityPolicy: policy,
-    }).attach(localClient);
-    const handlers = (
-      localClient.interceptors.request as unknown as {
-        handlers: {
-          fulfilled?: (cfg: InternalAxiosRequestConfig) => unknown;
-        }[];
-      }
-    ).handlers;
-    let current = config;
-    for (let i = handlers.length - 1; i >= 0; i--) {
-      const handler = handlers[i]?.fulfilled;
-      if (typeof handler === "function") {
-        current = (await handler(current)) as InternalAxiosRequestConfig;
-      }
-    }
-    return current;
-  }
-
-  it("leaves the request unsigned when the policy disables payload signing", async () => {
-    // bit-code 0: no bits set, so payload signing is off for this session.
-    const result = await runWith(
-      SecurityPolicy.fromBitCode(0),
-      makeConfig({
-        data: '{"hello":"world"}',
-        headers: new AxiosHeaders({ [REQUEST_TIMESTAMP_HEADER]: TIMESTAMP }),
-        [REQUEST_MAC_OPT_IN_KEY]: true,
-      } as Partial<InternalAxiosRequestConfig>),
-    );
-    expect(result.headers.get(REQUEST_MAC_HEADER)).toBeUndefined();
-  });
-
-  it("signs when the policy enables only payload signing", async () => {
-    // bit-code 1: bit 0 (payload signing) set; other behaviours off.
-    const result = await runWith(
-      SecurityPolicy.fromBitCode(1),
-      makeConfig({
-        data: '{"hello":"world"}',
-        headers: new AxiosHeaders({ [REQUEST_TIMESTAMP_HEADER]: TIMESTAMP }),
-        [REQUEST_MAC_OPT_IN_KEY]: true,
-      } as Partial<InternalAxiosRequestConfig>),
-    );
-    expect(result.headers.get(REQUEST_MAC_HEADER)).toBeDefined();
-  });
-});

package/src/data/api/interceptors/__tests__/token_refresh_interceptor.test.ts

@@ -1,173 +0,0 @@
-import axios, {
-  AxiosError,
-  AxiosHeaders,
-  type AxiosResponse,
-  type InternalAxiosRequestConfig,
-} from "axios";
-import { describe, expect, it, vi } from "vitest";
-
-import { TokenHolder } from "../../auth/token_holder";
-import { TokenRefreshInterceptor } from "../token_refresh_interceptor";
-
-/**
- * Build a `RequestOptions`-like object for re-issuing requests. axios's
- * `client.request(config)` reads `config.url`/`config.method` to dispatch.
- */
-function makeRequestConfig(): InternalAxiosRequestConfig {
-  return {
-    headers: new AxiosHeaders(),
-    url: "/v1/job",
-    method: "post",
-  } as InternalAxiosRequestConfig;
-}
-
-/**
- * Build a `401`-shaped `AxiosError` that the interceptor will receive on its
- * response error branch. Marked with `isAxiosError = true` so the interceptor's
- * narrow type-guard accepts it.
- */
-function build401(
-  config: InternalAxiosRequestConfig = makeRequestConfig(),
-): AxiosError {
-  const response = {
-    status: 401,
-    statusText: "Unauthorized",
-    headers: new AxiosHeaders(),
-    config,
-    data: {},
-  } as AxiosResponse;
-  const error = new AxiosError(
-    "401 Unauthorized",
-    "ERR_BAD_REQUEST",
-    config,
-    null,
-    response,
-  );
-  // AxiosError sets isAxiosError = true in the constructor; defensively
-  // ensure it for the type guard.
-  Object.assign(error, { isAxiosError: true });
-  return error;
-}
-
-describe("TokenRefreshInterceptor", () => {
-  it("passes through when callback is undefined", async () => {
-    const client = axios.create();
-    const holder = new TokenHolder("old");
-    const subject = new TokenRefreshInterceptor({
-      tokenHolder: holder,
-      onTokenExpired: undefined,
-    });
-    subject.attach(client);
-    const requestSpy = vi.spyOn(client, "request");
-
-    const error = build401();
-    await expect(
-      // Replay the response interceptor's error branch directly.
-      (
-        client.interceptors.response as unknown as {
-          handlers: { rejected?: (e: unknown) => Promise<unknown> }[];
-        }
-      ).handlers[0]!.rejected!(error),
-    ).rejects.toBe(error);
-    expect(requestSpy).not.toHaveBeenCalled();
-    expect(holder.current).toBe("old");
-  });
-
-  it("on 401 invokes callback, updates holder, retries once", async () => {
-    const client = axios.create();
-    const holder = new TokenHolder("old");
-    const subject = new TokenRefreshInterceptor({
-      tokenHolder: holder,
-      onTokenExpired: async (previous) => {
-        expect(previous).toBe("old");
-        return "new";
-      },
-    });
-    subject.attach(client);
-    const requestSpy = vi
-      .spyOn(client, "request")
-      .mockResolvedValue({ status: 200 } as AxiosResponse);
-
-    const error = build401();
-    const result = await (
-      client.interceptors.response as unknown as {
-        handlers: { rejected?: (e: unknown) => Promise<unknown> }[];
-      }
-    ).handlers[0]!.rejected!(error);
-
-    expect((result as AxiosResponse).status).toBe(200);
-    expect(requestSpy).toHaveBeenCalledTimes(1);
-    expect(holder.current).toBe("new");
-  });
-
-  it("surfaces original 401 when callback throws", async () => {
-    const client = axios.create();
-    const holder = new TokenHolder("old");
-    const subject = new TokenRefreshInterceptor({
-      tokenHolder: holder,
-      onTokenExpired: async () => {
-        throw new Error("partner refresh broke");
-      },
-    });
-    subject.attach(client);
-    const requestSpy = vi.spyOn(client, "request");
-
-    const error = build401();
-    await expect(
-      (
-        client.interceptors.response as unknown as {
-          handlers: { rejected?: (e: unknown) => Promise<unknown> }[];
-        }
-      ).handlers[0]!.rejected!(error),
-    ).rejects.toBe(error);
-    expect(requestSpy).not.toHaveBeenCalled();
-    expect(holder.current).toBe("old");
-  });
-
-  it("surfaces original 401 when callback returns identical token", async () => {
-    const client = axios.create();
-    const holder = new TokenHolder("old");
-    const subject = new TokenRefreshInterceptor({
-      tokenHolder: holder,
-      onTokenExpired: async (previous) => previous,
-    });
-    subject.attach(client);
-    const requestSpy = vi.spyOn(client, "request");
-
-    const error = build401();
-    await expect(
-      (
-        client.interceptors.response as unknown as {
-          handlers: { rejected?: (e: unknown) => Promise<unknown> }[];
-        }
-      ).handlers[0]!.rejected!(error),
-    ).rejects.toBe(error);
-    expect(requestSpy).not.toHaveBeenCalled();
-  });
-
-  it("does not loop on a second 401 — retry marker stops the chain", async () => {
-    const client = axios.create();
-    const holder = new TokenHolder("old");
-    const subject = new TokenRefreshInterceptor({
-      tokenHolder: holder,
-      onTokenExpired: async () => "new",
-    });
-    subject.attach(client);
-    // Simulate a request that already went through one refresh.
-    const config = makeRequestConfig() as InternalAxiosRequestConfig & {
-      __smileid_token_refresh_retried?: boolean;
-    };
-    config.__smileid_token_refresh_retried = true;
-    const requestSpy = vi.spyOn(client, "request");
-
-    const error = build401(config);
-    await expect(
-      (
-        client.interceptors.response as unknown as {
-          handlers: { rejected?: (e: unknown) => Promise<unknown> }[];
-        }
-      ).handlers[0]!.rejected!(error),
-    ).rejects.toBe(error);
-    expect(requestSpy).not.toHaveBeenCalled();
-  });
-});

package/src/data/api/interceptors/gzip_interceptor.ts

@@ -1,31 +0,0 @@
-import type { AxiosInstance } from "axios";
-import type { Interceptor } from "../../../core/models/network_config";
-
-/**
- * Interceptor that stamps `Accept-Encoding: gzip` on every outbound
- * request so the server is invited to gzip its response. This is the
- * same hint-only strategy iOS's `GzipRequestInterceptor` uses.
- *
- * Why hint-only on RN:
- * - axios in React Native does not natively compress outbound bodies.
- * - The SDK avoids pulling in a JS gzip dependency (`pako` etc.)
- *   because every additional bundle byte ships to every partner app.
- * - Stamping `Content-Encoding: gzip` without actually gzipping the
- *   body — the prior behavior of this interceptor — was wrong: the
- *   header told the server the body was gzipped when it was not.
- *   Servers strict-parsing the header would reject the request.
- *
- * Partners whose backends require true request-body compression
- * should add their own compressing interceptor in front of the SDK's
- * network stack.
- */
-export function createGzipInterceptor(): Interceptor {
-  return {
-    attach(client: AxiosInstance): void {
-      client.interceptors.request.use((requestConfig) => {
-        requestConfig.headers.set("Accept-Encoding", "gzip");
-        return requestConfig;
-      });
-    },
-  };
-}

package/src/data/api/interceptors/logging_interceptor.ts

@@ -1,155 +0,0 @@
-import type {
-  AxiosInstance,
-  AxiosResponse,
-  AxiosError,
-  InternalAxiosRequestConfig,
-} from "axios";
-import {
-  LogLevel,
-  type NetworkLoggingConfig,
-} from "../../../core/models/network_config";
-import { ALWAYS_REDACT, ALWAYS_REDACT_BODY_KEYS } from "./sensitive_headers";
-
-/**
- * Logging interceptor.
- *
- * Levels:
- *   - `none`:    silent
- *   - `basic`:   request line + response status line
- *   - `headers`: basic + request/response headers (with redaction)
- *   - `body`:    headers + response body / error body (request body
- *                is large — multipart binaries — and not logged)
- *
- * Header redaction: the auth interceptor adds sensitive headers
- * (`SmileID-Token`, `smileid-partner-id`) and partners can extend
- * the redaction list via
- * `n.logging((l) => { l.redactHeaders = ['x-proxy-secret']; })`.
- *
- * One concrete security guard: redact list is case-insensitive —
- * partners pass `'x-Partner-Token'` and we redact `'x-partner-token'`
- * too.
- */
-
-// Canonical redact set lives in a dedicated module so a new sensitive
-// header can be added in one place and picked up by every logging path.
-
-export function attachLoggingInterceptor(
-  client: AxiosInstance,
-  config: NetworkLoggingConfig,
-): { request: number; response: number } {
-  if (!config.enabled || config.level === LogLevel.none) {
-    // Attach no-op interceptors so `eject(...)` calls match.
-    const noopReq = client.interceptors.request.use((c) => c);
-    const noopRes = client.interceptors.response.use((r) => r);
-    return { request: noopReq, response: noopRes };
-  }
-
-  const partnerRedact = new Set(
-    config.redactHeaders.map((h) => h.toLowerCase()),
-  );
-
-  const requestId = client.interceptors.request.use((c) => {
-    logRequest(c, config.level, partnerRedact);
-    return c;
-  });
-
-  const responseId = client.interceptors.response.use(
-    (response) => {
-      logResponse(response, config.level);
-      return response;
-    },
-    (error: AxiosError) => {
-      logError(error, config.level);
-      return Promise.reject(error);
-    },
-  );
-
-  return { request: requestId, response: responseId };
-}
-
-function logRequest(
-  config: InternalAxiosRequestConfig,
-  level: NetworkLoggingConfig["level"],
-  partnerRedact: ReadonlySet<string>,
-): void {
-  const method = (config.method ?? "GET").toUpperCase();
-  const url = `${config.baseURL ?? ""}${config.url ?? ""}`;
-  // eslint-disable-next-line no-console
-  console.log(`[UseSmileID] → ${method} ${url}`);
-  if (level === LogLevel.headers || level === LogLevel.body) {
-    const redacted = redactHeaders(
-      config.headers as unknown as Record<string, unknown>,
-      partnerRedact,
-    );
-    // eslint-disable-next-line no-console
-    console.log("[UseSmileID]   headers:", redacted);
-  }
-}
-
-function logResponse(
-  response: AxiosResponse,
-  level: NetworkLoggingConfig["level"],
-): void {
-  // eslint-disable-next-line no-console
-  console.log(
-    `[UseSmileID] ← ${response.status} ${response.statusText} ${response.config.url ?? ""}`,
-  );
-  if (level === LogLevel.body) {
-    // eslint-disable-next-line no-console
-    console.log("[UseSmileID]   body:", redactBody(response.data));
-  }
-}
-
-function logError(
-  error: AxiosError,
-  level: NetworkLoggingConfig["level"],
-): void {
-  const status = error.response?.status ?? "no-response";
-  // eslint-disable-next-line no-console
-  console.warn(
-    `[UseSmileID] ✗ ${status} ${error.config?.url ?? ""} — ${error.message}`,
-  );
-  if (level === LogLevel.body && error.response) {
-    // eslint-disable-next-line no-console
-    console.warn("[UseSmileID]   body:", redactBody(error.response.data));
-  }
-}
-
-const MAX_REDACT_DEPTH = 6;
-
-/**
- * Copy of `data` safe to log — sensitive keys masked, recursion capped
- * at {@link MAX_REDACT_DEPTH}. Never mutates the input.
- */
-function redactBody(data: unknown, depth: number = 0): unknown {
-  if (depth >= MAX_REDACT_DEPTH) return "<depth-limit>";
-  if (Array.isArray(data)) {
-    return data.map((item) => redactBody(item, depth + 1));
-  }
-  if (data !== null && typeof data === "object") {
-    const out: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(data)) {
-      out[key] = ALWAYS_REDACT_BODY_KEYS.has(key.toLowerCase())
-        ? "<redacted>"
-        : redactBody(value, depth + 1);
-    }
-    return out;
-  }
-  return data;
-}
-
-function redactHeaders(
-  headers: Record<string, unknown>,
-  partnerRedact: ReadonlySet<string>,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(headers ?? {})) {
-    const lower = key.toLowerCase();
-    if (ALWAYS_REDACT.has(lower) || partnerRedact.has(lower)) {
-      out[key] = "<redacted>";
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}

package/src/data/api/interceptors/sensitive_headers.ts

@@ -1,46 +0,0 @@
-/**
- * Canonical list of HTTP headers the SDK redacts unconditionally from
- * any partner-visible log line, regardless of whether the partner
- * remembered to populate `redactHeaders` themselves.
- *
- * These headers carry credentials, session tokens, or partner-id signals
- * that would let a bystander reading the console output impersonate the
- * partner's backend. The logging interceptor replaces the value with
- * `██` while preserving the header name, so the audit trail still
- * shows the header was present.
- *
- * Partners can extend this set via
- * `n.logging((l) => { l.redactHeaders = ['x-partner-proxy-secret']; })` —
- * the auto-applied + partner-supplied lists are unioned before logging.
- *
- * Names are stored lowercase; the logging interceptor matches
- * case-insensitively.
- */
-export const ALWAYS_REDACT: ReadonlySet<string> = new Set(
-  [
-    "smileid-token",
-    "smileid-partner-id",
-    "smileid-api-key",
-    "smileid-device-nonce",
-    "authorization",
-    "cookie",
-    "set-cookie",
-  ].map((h) => h.toLowerCase()),
-);
-
-/**
- * JSON body fields redacted unconditionally from `LogLevel.body` log
- * lines — credentials the server may echo back (token exchange,
- * signed-response envelopes). Matched case-insensitively by full key.
- */
-export const ALWAYS_REDACT_BODY_KEYS: ReadonlySet<string> = new Set(
-  [
-    "token",
-    "api_key",
-    "apikey",
-    "signature",
-    "secret",
-    "authorization",
-    "session_id",
-  ].map((k) => k.toLowerCase()),
-);

package/src/data/api/interceptors/smile_auth_interceptor.ts

@@ -1,73 +0,0 @@
-import type { AxiosInstance, InternalAxiosRequestConfig } from "axios";
-import { sourceSdkIdentifier } from "@smileid/usesmileid_bridge";
-
-import type { PartnerConfig } from "../../../core/models/network_config";
-import { currentRequestTimestamp } from "../../security/request_timestamp";
-import type { TokenHolder } from "../auth/token_holder";
-
-/**
- * Auth interceptor.
- *
- * Responsibilities:
- *   1. Stamp the partner-supplied auth token onto every outbound
- *      request as the `smileid-token` header.
- *   2. Add the canonical SDK identification headers
- *      (`smileid-source-sdk`, `smileid-source-sdk-version`,
- *      `smileid-partner-id`, `callback-url`).
- *   3. Stamp `smileid-request-timestamp` (epoch ms) before the request-MAC
- *      interceptor runs, so it is part of the signed `smileid-*` set and the
- *      MAC reuses it as the salt.
- *
- * Token exchange is the partner application's responsibility — it
- * fetches a short-lived v3 token from its own backend and supplies the
- * result via the network DSL's `config.token`. The interceptor reads
- * the current value from the shared {@link TokenHolder} so a refreshed
- * value written by `TokenRefreshInterceptor` is observed automatically
- * by the next outgoing request.
- */
-
-const SDK_VERSION = "12.0.1";
-
-export type SmileAuthInterceptorOptions = {
-  readonly partnerConfig: PartnerConfig;
-  readonly tokenHolder: TokenHolder;
-};
-
-export class SmileAuthInterceptor {
-  private readonly _partnerConfig: PartnerConfig;
-  private readonly _tokenHolder: TokenHolder;
-
-  constructor(options: SmileAuthInterceptorOptions) {
-    this._partnerConfig = options.partnerConfig;
-    this._tokenHolder = options.tokenHolder;
-  }
-
-  /**
-   * Attach to an axios instance. Returns the interceptor ID so the
-   * caller can detach later if needed (typically just on instance
-   * disposal — the interceptor's lifetime tracks the instance).
-   */
-  attach(client: AxiosInstance): { request: number } {
-    const requestId = client.interceptors.request.use(async (config) => {
-      return this._onRequest(config);
-    });
-    return { request: requestId };
-  }
-
-  private async _onRequest(
-    config: InternalAxiosRequestConfig,
-  ): Promise<InternalAxiosRequestConfig> {
-    config.headers.set("smileid-token", this._tokenHolder.current);
-    config.headers.set("smileid-source-sdk", sourceSdkIdentifier());
-    config.headers.set("smileid-source-sdk-version", SDK_VERSION);
-    config.headers.set("smileid-partner-id", this._partnerConfig.partnerId);
-    if (this._partnerConfig.callbackUrl) {
-      config.headers.set("callback-url", this._partnerConfig.callbackUrl);
-    }
-    // Generated at request time and stamped before the request-MAC interceptor
-    // runs, so it is part of the signed `smileid-*` header set and the MAC
-    // reuses the same value as its salt rather than reading the clock again.
-    config.headers.set("smileid-request-timestamp", currentRequestTimestamp());
-    return config;
-  }
-}