@fanth/payment-router-sdk 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -1,448 +1,88 @@
-'use strict';
-
-var jose = require('jose');
-
-// src/defaults.ts
-var DEFAULT_BASE_URL = "https://payment-r.fanth.pl";
-
-// src/errors.ts
-var PaymentRouterError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = new.target.name;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
 };
-var PaymentRouterApiError = class extends PaymentRouterError {
-  status;
-  /** The `error` field of the response body, when the router sent one. */
-  code;
-  /** The parsed (or raw string) response body, for anything the typed fields do not cover. */
-  body;
-  constructor(message, status, code, body) {
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PaymentRouterClient: () => PaymentRouterClient,
+  PaymentRouterError: () => PaymentRouterError
+});
+module.exports = __toCommonJS(index_exports);
+var import_jose = require("jose");
+var PaymentRouterError = class extends Error {
+  constructor(message, status, body) {
     super(message);
     this.status = status;
-    this.code = code;
     this.body = body;
   }
 };
-var RateLimitedError = class extends PaymentRouterApiError {
-};
-var InvalidWebhookUrlError = class extends PaymentRouterApiError {
-  /** The router's human-readable reason, e.g. "webhookUrl must use https". */
-  get reason() {
-    return this.code ?? this.message;
-  }
-};
-var PaymentRouterNetworkError = class extends PaymentRouterError {
-};
-var PaymentRouterValidationError = class extends PaymentRouterError {
-};
-var CallbackVerificationError = class extends PaymentRouterError {
-  /** Machine-readable failure reason, for logging and metrics. */
-  reason;
-  constructor(reason, message, options) {
-    super(message, options);
-    this.reason = reason;
-  }
-};
-
-// src/http.ts
-var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
-async function requestJson(options, path, init) {
-  const url = new URL(path, ensureTrailingSlash(options.baseUrl)).toString();
-  let lastError;
-  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
-    if (attempt > 0) {
-      await sleep(options.retryDelayMs * 2 ** (attempt - 1));
-    }
-    let response;
-    try {
-      response = await options.fetch(url, {
-        ...init,
-        headers: { ...options.headers, ...init.headers },
-        signal: init.signal ?? AbortSignal.timeout(options.timeoutMs)
-      });
-    } catch (error2) {
-      lastError = new PaymentRouterNetworkError(`request to ${url} failed: ${describe(error2)}`, { cause: error2 });
-      continue;
-    }
-    if (response.ok) {
-      return await response.json();
-    }
-    const error = await toApiError(response);
-    if (!RETRYABLE_STATUSES.has(response.status)) {
-      throw error;
-    }
-    lastError = error;
-  }
-  throw lastError ?? new PaymentRouterNetworkError(`request to ${url} failed for an unknown reason`);
-}
-async function toApiError(response) {
-  const body = await readBody(response);
-  const code = extractCode(body);
-  const message = `payment-router responded ${response.status}${code ? `: ${code}` : ""}`;
-  if (response.status === 429) return new RateLimitedError(message, response.status, code, body);
-  if (response.status === 422) return new InvalidWebhookUrlError(message, response.status, code, body);
-  return new PaymentRouterApiError(message, response.status, code, body);
-}
-async function readBody(response) {
-  const text = await response.text().catch(() => "");
-  if (text.length === 0) return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function extractCode(body) {
-  if (typeof body !== "object" || body === null) return null;
-  const error = body.error;
-  if (typeof error === "string") return error;
-  const issues = error?.issues;
-  const first = issues?.[0]?.message;
-  return typeof first === "string" ? first : null;
-}
-function describe(error) {
-  if (error instanceof Error) return `${error.name}: ${error.message}`;
-  return "unknown error";
-}
-function ensureTrailingSlash(url) {
-  return url.endsWith("/") ? url : `${url}/`;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/headers.ts
-var SIGNATURE_HEADER = "x-payment-router-signature";
-var ROUTE_ID_HEADER = "x-payment-router-id";
-var GATEWAY_HEADER = "x-payment-router-gateway";
-var EXTERNAL_ID_HEADER = "x-payment-router-external-id";
-var FORWARDED_HOST_HEADER = "x-forwarded-host";
-
-// src/verify.ts
-var DEFAULT_MAX_AGE_SECONDS = 300;
-var CallbackVerifier = class {
-  issuer;
-  maxAgeSeconds;
-  clockToleranceSeconds;
-  getKey;
-  constructor(options = {}) {
-    const baseUrl = stripTrailingSlash(options.baseUrl ?? DEFAULT_BASE_URL);
-    this.issuer = options.issuer ?? baseUrl;
-    this.maxAgeSeconds = options.maxAgeSeconds ?? DEFAULT_MAX_AGE_SECONDS;
-    this.clockToleranceSeconds = options.clockToleranceSeconds ?? 5;
-    this.getKey = options.keyStore ?? jose.createRemoteJWKSet(new URL(options.jwksUrl ?? jwksUrlFor(baseUrl)), {
-      ...options.fetch ? { [jose.customFetch]: options.fetch } : {}
-    });
-  }
-  /**
-   * Verify a token against the body it is supposed to cover.
-   *
-   * @throws {CallbackVerificationError} always, when the callback cannot be trusted.
-   */
-  async verify(input) {
-    const token = input.token?.trim();
-    if (!token) {
-      throw new CallbackVerificationError("missing_signature", `no ${SIGNATURE_HEADER} header on the callback`);
-    }
-    let payload;
-    try {
-      ({ payload } = await jose.jwtVerify(token, this.getKey, {
-        issuer: this.issuer,
-        algorithms: ["EdDSA"],
-        maxTokenAge: this.maxAgeSeconds,
-        clockTolerance: this.clockToleranceSeconds
-      }));
-    } catch (error) {
-      throw new CallbackVerificationError("invalid_signature", `callback signature is not valid: ${describe2(error)}`, {
-        cause: error
-      });
-    }
-    const claims = toClaims(payload);
-    const actual = await sha256Hex(input.rawBody);
-    if (!timingSafeEqual(actual, claims.bodySha256)) {
-      throw new CallbackVerificationError(
-        "body_mismatch",
-        "callback body does not match the body_sha256 claim - pass the raw bytes you received, not re-serialized JSON"
-      );
-    }
-    return { claims, rawBody: toText(input.rawBody) };
-  }
-  /**
-   * Verify a fetch-API `Request` (Workers, Hono, Next.js route handlers, Deno, Bun).
-   *
-   * The body is read here, so do not read it yourself first - clone the request if you need it.
-   */
-  async verifyRequest(request) {
-    if (request.bodyUsed) {
-      throw new CallbackVerificationError(
-        "body_already_consumed",
-        "request body was already read - pass a request.clone() or use verify({ token, rawBody })"
-      );
-    }
-    return this.verify({ token: request.headers.get(SIGNATURE_HEADER), rawBody: await request.text() });
-  }
-  /**
-   * The plain version, for any framework: headers and the raw body in, the same raw body back out,
-   * or it throws. Handy when all you want is a guard at the top of a webhook handler.
-   *
-   * The body must be the raw bytes as they arrived - a parsed-and-re-serialized JSON body hashes
-   * differently and will be rejected. Use {@link verify} when you also want the claims.
-   */
-  async verifyWebhook(headers, rawBody) {
-    const { rawBody: body } = await this.verify({ token: readHeader(headers, SIGNATURE_HEADER), rawBody });
-    return body;
-  }
-};
-function jwksUrlFor(baseUrl) {
-  return new URL("/.well-known/jwks.json", baseUrl).toString();
-}
-function readHeader(headers, name) {
-  if (typeof headers.get === "function") {
-    return headers.get(name);
-  }
-  const bag = headers;
-  const value = bag[name] ?? bag[name.toLowerCase()] ?? bag[name.toUpperCase()];
-  if (Array.isArray(value)) return value[0] ?? null;
-  return value ?? null;
-}
-function toClaims(payload) {
-  const routeId = payload.route_id;
-  const gateway = payload.gateway;
-  const bodySha256 = payload.body_sha256;
-  const externalId = payload.external_id;
-  if (typeof routeId !== "string" || typeof gateway !== "string" || typeof bodySha256 !== "string") {
-    throw new CallbackVerificationError("malformed_claims", "callback token is missing route_id, gateway or body_sha256");
-  }
-  if (typeof payload.iat !== "number" || typeof payload.exp !== "number") {
-    throw new CallbackVerificationError("malformed_claims", "callback token is missing iat or exp");
-  }
-  return {
-    routeId,
-    gateway,
-    externalId: typeof externalId === "string" ? externalId : null,
-    bodySha256,
-    issuer: payload.iss ?? "",
-    issuedAt: new Date(payload.iat * 1e3),
-    expiresAt: new Date(payload.exp * 1e3),
-    raw: payload
-  };
-}
 async function sha256Hex(data) {
-  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new PaymentRouterValidationError("WebCrypto is unavailable - Node 18+, Workers, Deno and Bun all provide it");
-  }
-  const digest = await subtle.digest("SHA-256", bytes);
-  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function timingSafeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) {
-    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  }
-  return diff === 0;
-}
-function toText(body) {
-  return typeof body === "string" ? body : new TextDecoder().decode(body);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(data));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-function describe2(error) {
-  if (error instanceof Error) return error.message;
-  return "unknown error";
-}
-function stripTrailingSlash(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
-}
-
-// src/client.ts
-var DEFAULTS = {
-  timeoutMs: 1e4,
-  maxRetries: 2,
-  retryDelayMs: 200
-};
+var DEFAULT_BASE_URL = "https://payment-r.fanth.pl";
 var PaymentRouterClient = class {
-  baseUrl;
-  http;
-  verifierOptions;
-  cachedVerifier = null;
-  constructor(options = {}) {
-    this.baseUrl = stripTrailingSlash2(assertAbsoluteUrl(options.baseUrl ?? DEFAULT_BASE_URL, "baseUrl"));
-    this.verifierOptions = {
-      // The client's own fetch carries whatever a proxy in front of the router needs, and the
-      // JWKS lives on that same origin - so it fits the key fetch too, unless overridden.
-      ...options.fetch ? { fetch: options.fetch } : {},
-      ...options.verifier
-    };
-    this.http = {
-      baseUrl: this.baseUrl,
-      fetch: options.fetch ?? defaultFetch(),
-      timeoutMs: options.timeoutMs ?? DEFAULTS.timeoutMs,
-      maxRetries: options.maxRetries ?? DEFAULTS.maxRetries,
-      retryDelayMs: options.retryDelayMs ?? DEFAULTS.retryDelayMs,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...options.headers
-      }
-    };
-  }
-  /**
-   * Register a webhook URL and get back the route whose `id` you send to the gateway as its
-   * external payment id.
-   *
-   * @throws {InvalidWebhookUrlError} the router refused the URL (not https, or a private host).
-   * @throws {RateLimitedError} the router's per-IP limit on route creation was hit.
-   */
-  async createRoute(input) {
-    const payload = {
-      webhookUrl: assertAbsoluteUrl(input.webhookUrl, "webhookUrl"),
-      ...input.externalId !== void 0 ? { externalId: assertExternalId(input.externalId) } : {},
-      ...input.expiresAt !== void 0 ? { expiresAt: toIsoString(input.expiresAt) } : {}
-    };
-    const route = await requestJson(this.http, "v1/routes", {
+  #baseUrl;
+  #jwks;
+  constructor(baseUrl = DEFAULT_BASE_URL) {
+    this.#baseUrl = baseUrl.replace(/\/+$/, "");
+    this.#jwks = (0, import_jose.createRemoteJWKSet)(new URL("/.well-known/jwks.json", this.#baseUrl));
+  }
+  /** Register a webhook URL, get back the route id to hand the gateway plus its callback URLs. */
+  async createRoute(options) {
+    const res = await fetch(new URL("/v1/routes", this.#baseUrl), {
       method: "POST",
-      body: JSON.stringify(payload)
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        webhookUrl: options.webhookUrl,
+        externalId: options.externalId,
+        expiresAt: options.expiresAt instanceof Date ? options.expiresAt.toISOString() : options.expiresAt
+      })
     });
-    return parseRoute(route);
-  }
-  /**
-   * The URL to paste into a gateway's dashboard as its single webhook URL. The same for every
-   * route, so it can be read off the client without creating one.
-   */
-  callbackUrl(gateway) {
-    return new URL(`webhooks/${encodeURIComponent(gateway)}`, `${this.baseUrl}/`).toString();
-  }
-  /** Where the router publishes the public keys that verify forwarded callbacks. */
-  get jwksUrl() {
-    return jwksUrlFor(this.baseUrl);
-  }
-  /**
-   * Headers and the raw body in, the same raw body back out - or it throws. The short way to guard
-   * a webhook handler: verifies the router's EdDSA JWT against its published keys, and checks that
-   * the body still hashes to what the token claims.
-   *
-   * The body must be the raw bytes as they arrived - parsed-and-re-serialized JSON hashes
-   * differently and will be rejected. Use {@link verifyCallback} when you also want the claims.
-   *
-   * @throws {CallbackVerificationError} when the callback cannot be trusted.
-   */
-  async verifyWebhook(headers, rawBody) {
-    return this.verifier().verifyWebhook(headers, rawBody);
-  }
-  /**
-   * Verify a fetch-API `Request` (Workers, Hono, Next.js, Deno, Bun) and get its claims back.
-   *
-   * The body is read here, so do not read it yourself first - clone the request if you need it.
-   */
-  async verifyRequest(request) {
-    return this.verifier().verifyRequest(request);
-  }
-  /** Verify a token against the body it covers, and get the claims back. */
-  async verifyCallback(input) {
-    return this.verifier().verify(input);
+    const data = await res.json();
+    if (!res.ok) {
+      const message = data?.error ?? "request_failed";
+      throw new PaymentRouterError(message, res.status, data);
+    }
+    return data;
   }
   /**
-   * Built on first use and kept around: the verifier caches the router's key set, so reusing one
-   * client saves a JWKS fetch per callback.
+   * Verify the `X-Payment-Router-Signature` JWT on a forwarded callback. `rawBody` must be the
+   * exact bytes received, since the signature binds `body_sha256`. Throws if the token is
+   * invalid, expired, or the body does not match what was signed.
    */
-  verifier() {
-    this.cachedVerifier ??= new CallbackVerifier({ baseUrl: this.baseUrl, ...this.verifierOptions });
-    return this.cachedVerifier;
+  async verifyCallback(token, rawBody) {
+    const { payload } = await (0, import_jose.jwtVerify)(token, this.#jwks, { issuer: this.#baseUrl });
+    const bodySha256 = await sha256Hex(rawBody);
+    if (payload.body_sha256 !== bodySha256) {
+      throw new Error("callback body does not match signature");
+    }
+    return {
+      routeId: payload.route_id,
+      gateway: payload.gateway,
+      externalId: payload.external_id ?? null,
+      bodySha256
+    };
   }
 };
-function parseRoute(raw) {
-  return {
-    id: raw.id,
-    webhookUrl: raw.webhookUrl,
-    externalId: raw.externalId ?? null,
-    expiresAt: raw.expiresAt ? new Date(raw.expiresAt) : null,
-    createdAt: new Date(raw.createdAt),
-    callbackUrls: raw.callbackUrls ?? null
-  };
-}
-function isRouteExpired(route, now = /* @__PURE__ */ new Date()) {
-  return route.expiresAt !== null && route.expiresAt.getTime() < now.getTime();
-}
-function callbackUrlFor(route, gateway) {
-  return route.callbackUrls?.[gateway] ?? null;
-}
-function assertAbsoluteUrl(value, field) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new PaymentRouterValidationError(`${field} must be an absolute URL, got "${value}"`);
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new PaymentRouterValidationError(`${field} must use http or https, got "${url.protocol}"`);
-  }
-  return value;
-}
-function assertExternalId(value) {
-  if (value.length === 0 || value.length > 256) {
-    throw new PaymentRouterValidationError("externalId must be between 1 and 256 characters");
-  }
-  return value;
-}
-function toIsoString(value) {
-  const date = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    throw new PaymentRouterValidationError(`expiresAt is not a valid date: ${String(value)}`);
-  }
-  return date.toISOString();
-}
-function defaultFetch() {
-  if (typeof globalThis.fetch !== "function") {
-    throw new PaymentRouterValidationError(
-      "no global fetch available - pass one via the `fetch` option (Node 18+ has it built in)"
-    );
-  }
-  return globalThis.fetch.bind(globalThis);
-}
-function stripTrailingSlash2(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
-}
-
-// src/node.ts
-async function readRawBody(request) {
-  const chunks = [];
-  const encoder = new TextEncoder();
-  for await (const chunk of request) {
-    chunks.push(typeof chunk === "string" ? encoder.encode(chunk) : chunk);
-  }
-  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return new TextDecoder().decode(body);
-}
-
-exports.CallbackVerificationError = CallbackVerificationError;
-exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
-exports.EXTERNAL_ID_HEADER = EXTERNAL_ID_HEADER;
-exports.FORWARDED_HOST_HEADER = FORWARDED_HOST_HEADER;
-exports.GATEWAY_HEADER = GATEWAY_HEADER;
-exports.InvalidWebhookUrlError = InvalidWebhookUrlError;
-exports.PaymentRouterApiError = PaymentRouterApiError;
-exports.PaymentRouterClient = PaymentRouterClient;
-exports.PaymentRouterError = PaymentRouterError;
-exports.PaymentRouterNetworkError = PaymentRouterNetworkError;
-exports.PaymentRouterValidationError = PaymentRouterValidationError;
-exports.ROUTE_ID_HEADER = ROUTE_ID_HEADER;
-exports.RateLimitedError = RateLimitedError;
-exports.SIGNATURE_HEADER = SIGNATURE_HEADER;
-exports.callbackUrlFor = callbackUrlFor;
-exports.isRouteExpired = isRouteExpired;
-exports.jwksUrlFor = jwksUrlFor;
-exports.parseRoute = parseRoute;
-exports.readHeader = readHeader;
-exports.readRawBody = readRawBody;
-exports.sha256Hex = sha256Hex;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PaymentRouterClient,
+  PaymentRouterError
+});