@rustrak/client 0.18.1 → 0.19.1

package/dist/utils/http.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.cjs","names":["FIELD_ERROR_CODES","SERVER_ERROR_MESSAGE","TIMEOUT_ERROR_MESSAGE","NETWORK_ERROR_MESSAGE"],"sources":["../../src/utils/http.ts"],"sourcesContent":["import type { ClientConfig } from '../config.js';\nimport {\n  FIELD_ERROR_CODES,\n  type FieldError,\n  type FieldErrorCode,\n  NETWORK_ERROR_MESSAGE,\n  type RustrakError,\n  SERVER_ERROR_MESSAGE,\n  TIMEOUT_ERROR_MESSAGE,\n} from '../errors.js';\n\n/**\n * Internal carrier for a transport failure travelling out of `fetch`.\n *\n * `fetch` signals \"no response\" by rejecting with a `TypeError`, which is also\n * what a genuine bug throws. {@link createFetch} wraps the rejections it\n * recognises in this class so the `Result` boundary in `client.ts` can tell\n * the two apart: this becomes an `Err`, anything else keeps propagating.\n *\n * Never exported from `src/index.ts`.\n */\nexport class RustrakTransportFailure extends Error {\n  public readonly rustrakError: RustrakError;\n\n  constructor(error: RustrakError) {\n    super(error.message);\n    this.name = 'RustrakTransportFailure';\n    this.rustrakError = error;\n  }\n}\n\n/** Narrow a caught value to the internal carrier. */\nexport function isTransportFailure(\n  value: unknown,\n): value is RustrakTransportFailure {\n  return value instanceof RustrakTransportFailure;\n}\n\n/**\n * Read the human-readable message out of an error body.\n *\n * Two shapes are live: every `AppError` sends `{error: {type, message}}` while\n * the ingest rate limiter sends a flat `{error: \"...\"}`. Reading only the flat\n * one turned every structured error into \"[object Object]\". See #204.\n */\nfunction readErrorMessage(body: unknown, status: number): string {\n  const fallback = `HTTP ${status} error`;\n\n  // `typeof body === 'object'` on purpose: a non-JSON body arrives as a plain\n  // string, and property access on a string primitive yields undefined, so a\n  // bare `if (body)` fell through to the generic message only by accident.\n  // Make the fallback deliberate.\n  if (body && typeof body === 'object') {\n    const { error, message } = body as {\n      error?: string | { type?: string; message?: string };\n      message?: string;\n    };\n    const nested = typeof error === 'object' ? error?.message : error;\n    return nested || message || fallback;\n  }\n\n  return fallback;\n}\n\nconst KNOWN_FIELD_ERROR_CODES = new Set<string>(FIELD_ERROR_CODES);\n\nfunction isFieldErrorCode(value: unknown): value is FieldErrorCode {\n  return typeof value === 'string' && KNOWN_FIELD_ERROR_CODES.has(value);\n}\n\n/**\n * Codes already reported by {@link warnUnknownFieldErrorCode}.\n *\n * Module-scoped so a list page rendering fifty rows against a newer server\n * logs once per unknown code rather than once per row. Version skew does not\n * change within a process, so once is the whole signal.\n */\nconst warnedFieldErrorCodes = new Set<string>();\n\n/**\n * Make an unrecognised `code` visible without admitting it into the union.\n *\n * Dropping the entry is correct (see {@link readFieldErrors}), but a silent\n * drop is indistinguishable from \"the server named no field\": a client one\n * release behind a server that added a code loses every inline form error\n * site-wide with nothing anywhere to explain it.\n *\n * `console.warn` is the least intrusive mechanism that a support engineer can\n * actually act on. It needs no change to the public type, so no consumer has\n * to opt in to see it; it lands in the browser devtools console in a client\n * component and on stdout of the Node process (and therefore in whatever log\n * aggregation already exists) in a Server Component. The alternatives were\n * worse: throwing turns a cosmetic degradation into an outage, admitting the\n * code breaks the closed union this drop exists to protect, and a new\n * `fieldsDropped` flag on the union is invisible until somebody thinks to read\n * it, which is the same silence in a new place.\n */\nfunction warnUnknownFieldErrorCode(code: string, field: string): void {\n  if (warnedFieldErrorCodes.has(code)) return;\n  warnedFieldErrorCodes.add(code);\n\n  console.warn(\n    `[@rustrak/client] Dropped a field error with an unrecognised code ` +\n      `\"${code}\" (field \"${field}\"). This client build does not know that ` +\n      `code, so the affected inputs degrade to a form-level error. The ` +\n      `server is most likely newer than @rustrak/client; upgrade the client ` +\n      `to match the server version.`,\n  );\n}\n\n/**\n * Read `error.fields` out of an `AppError` body.\n *\n * Returns `undefined` rather than `[]` when there is nothing usable, so the\n * key stays absent on the `RustrakError` and a consumer can test for it.\n *\n * Entries are validated one by one and a malformed or unrecognised one is\n * dropped, never coerced. `FieldErrorCode` is a closed union: admitting a code\n * this build has never heard of would hand a consumer a value its own\n * exhaustive `switch` cannot see. A newer server adding a code therefore\n * degrades to a form-level error here, which is the same place an older client\n * already lands, and is announced once via\n * {@link warnUnknownFieldErrorCode} so the skew is not silent.\n *\n * `message` survives only alongside `code: 'custom'`. The server enforces the\n * same rule at construction, but the docs on both sides tell consumers to\n * select translated copy from `(field, code)` for every other code, so a\n * `message` that reaches them there is untranslatable English a careless\n * consumer would render. Dropping it here makes the rule true of the value, not\n * only of its producer.\n */\n/**\n * Read `error.incident_id` out of a 5xx `AppError` body.\n *\n * The one thing a 500 is willing to say about itself. `error_response` replaced\n * its `Display` with a fixed string so a `sqlx::Error`'s constraint and column\n * names stay off the wire (gh-233), and logged the detail under this id; a user\n * quoting it is what lets an operator find that line.\n *\n * Returns `undefined`, never `null` or `''`, for the three bodies that carry no\n * id: a proxy-generated 502/503, a server older than gh-233, and a 500 whose\n * body is not JSON at all. The caller omits the key entirely in that case, so\n * `'incidentId' in error` stays an honest test.\n */\nfunction readIncidentId(body: unknown): string | undefined {\n  const raw =\n    body && typeof body === 'object'\n      ? (body as { error?: { incident_id?: unknown } }).error?.incident_id\n      : undefined;\n\n  return typeof raw === 'string' && raw.length > 0 ? raw : undefined;\n}\n\nfunction readFieldErrors(body: unknown): FieldError[] | undefined {\n  const raw =\n    body && typeof body === 'object'\n      ? (body as { error?: { fields?: unknown } }).error?.fields\n      : undefined;\n\n  if (!Array.isArray(raw)) {\n    return undefined;\n  }\n\n  const fields = raw.flatMap((entry) => readFieldError(entry) ?? []);\n  return fields.length > 0 ? fields : undefined;\n}\n\n/** One entry of `error.fields`, or `undefined` when it is unusable. */\nfunction readFieldError(entry: unknown): FieldError | undefined {\n  if (typeof entry !== 'object' || entry === null) return undefined;\n\n  const { field, code, message } = entry as Record<string, unknown>;\n  if (typeof field !== 'string') return undefined;\n  if (!isFieldErrorCode(code)) {\n    if (typeof code === 'string') warnUnknownFieldErrorCode(code, field);\n    return undefined;\n  }\n\n  return code === 'custom' && typeof message === 'string'\n    ? { field, code, message }\n    : { field, code };\n}\n\n/**\n * `Retry-After` in seconds, when the server sent a parseable one.\n *\n * RFC 9110 §10.2.3 allows two forms and a proxy in front of the Rust process\n * may send either. `Number.parseInt` read only the first, and read it too\n * loosely: it dropped the HTTP-date form entirely as `NaN`, and it returned\n * `-5` from `-5` and `3` from `3abc`, both of which a consumer would pass\n * straight to `setTimeout`.\n *\n * A date already in the past yields `0`, meaning \"retry now\", which is the\n * literal reading of the header.\n */\nfunction readRetryAfter(response: Response): number | undefined {\n  const header = response.headers.get('Retry-After')?.trim();\n  if (!header) {\n    return undefined;\n  }\n\n  // delta-seconds: digits only. No sign, no trailing junk.\n  if (/^\\d+$/.test(header)) {\n    return Number.parseInt(header, 10);\n  }\n\n  // A signed number is neither a valid delta-seconds nor an HTTP-date, and it\n  // must not reach `Date.parse`: V8 reads `-5` as a year and would turn a\n  // nonsense header into \"retry now\".\n  if (/^[+-]\\d+$/.test(header)) {\n    return undefined;\n  }\n\n  const date = Date.parse(header);\n  if (Number.isNaN(date)) {\n    return undefined;\n  }\n\n  return Math.max(0, Math.ceil((date - Date.now()) / 1000));\n}\n\n/**\n * Attach `fields` to an error, or leave the key off entirely.\n *\n * The key is omitted rather than set to `undefined` so `'fields' in error`\n * stays an honest test and the object round-trips through `structuredClone`\n * with the same shape it was built with.\n */\nfunction annotate<E extends RustrakError & { fields?: readonly FieldError[] }>(\n  base: E,\n  fields: readonly FieldError[] | undefined,\n): E {\n  return fields === undefined ? base : { ...base, fields };\n}\n\n/**\n * Map an HTTP status onto a `RustrakError` kind.\n *\n * Total by construction: every 5xx redacts, every other unanticipated status\n * lands on `client_error`, so no status is unrepresentable.\n */\nexport function transformHttpError(\n  response: Response,\n  body: unknown,\n): RustrakError {\n  const status = response.status;\n\n  // 5xx never carries a server-supplied message. The server redacts its own\n  // `Display` now (gh-233), but this stays: a 502 from a reverse proxy and a\n  // server older than that fix both still send prose, and every consumer of\n  // this client renders `error.message` somewhere. Discard it here, once,\n  // rather than trusting 128 call sites to remember.\n  //\n  // `incidentId` is the exception, and the reason the redaction is no longer\n  // lossy: it names the log line carrying what the body dropped, and is\n  // omitted entirely when the body has none.\n  if (status >= 500) {\n    const base = {\n      kind: 'server_error',\n      status,\n      message: SERVER_ERROR_MESSAGE,\n    } as const;\n    const incidentId = readIncidentId(body);\n\n    return incidentId === undefined ? base : { ...base, incidentId };\n  }\n\n  const message = readErrorMessage(body, status);\n\n  // Read once, for every non-5xx status. `AppError::with_field` works on all\n  // eight Rust variants, so restricting this to 400 and 409 meant an\n  // annotation added to, say, the `Forbidden` in `routes/team.rs` would be\n  // serialised, documented in `openapi.json`, and invisible to every consumer\n  // with no test failing anywhere. It costs nothing when the key is absent:\n  // `readFieldErrors` returns `undefined` without allocating.\n  const fields = readFieldErrors(body);\n\n  switch (status) {\n    case 400:\n      // The key is omitted rather than set to `undefined` so that\n      // `'fields' in error` stays an honest test, matching `retryAfter` below.\n      return annotate({ kind: 'validation', status, message }, fields);\n    case 401:\n      return annotate({ kind: 'unauthenticated', status, message }, fields);\n    case 403:\n      return annotate({ kind: 'forbidden', status, message }, fields);\n    case 404:\n      return annotate({ kind: 'not_found', status, message }, fields);\n    case 409:\n      return annotate({ kind: 'conflict', status, message }, fields);\n    case 410:\n      return annotate({ kind: 'gone', status, message }, fields);\n    case 413:\n      return annotate({ kind: 'payload_too_large', status, message }, fields);\n    case 429: {\n      const retryAfter = readRetryAfter(response);\n      return annotate(\n        retryAfter === undefined\n          ? { kind: 'rate_limited', status, message }\n          : { kind: 'rate_limited', status, message, retryAfter },\n        fields,\n      );\n    }\n    default:\n      return annotate({ kind: 'client_error', status, message }, fields);\n  }\n}\n\n/** Statuses a `Response` may not be constructed with a body for. */\nconst NULL_BODY = new Set([101, 103, 204, 205, 304]);\n\n/** Statuses worth repeating: the request may well succeed a moment later. */\nconst RETRY_STATUSES = new Set([408, 500, 502, 503, 504]);\n\n/**\n * Only methods that are safe to send twice. A `POST` that timed out at the\n * proxy may still have created the row, and a second one creates another.\n */\nconst RETRY_METHODS = new Set(['GET', 'HEAD', 'PUT', 'DELETE']);\n\n/**\n * The `fetch` every request goes through: timeout, retries, and the line\n * between a transport failure and a bug.\n *\n * The body is read here, inside the same `try` as the request, so a\n * connection that dies halfway through a body is a transport failure like\n * one that never connected, not an error the generated client half-parses.\n *\n * Retries wait 300ms, then 600ms, and so on. A caller's own `AbortSignal`\n * aborting is not a transport failure: it rethrows as the `AbortError` the\n * caller asked for.\n */\nexport function createFetch(config: ClientConfig): typeof fetch {\n  const timeout = config.timeout ?? 30_000;\n  const maxRetries = config.maxRetries ?? 2;\n\n  return async (input, init) => {\n    const request = new Request(input, init);\n    const retries = RETRY_METHODS.has(request.method) ? maxRetries : 0;\n\n    for (let n = 0; ; n++) {\n      const outcome = await attempt(request, timeout);\n      // A timeout is not repeated: the server may still be working on it.\n      const retryable =\n        outcome instanceof Response\n          ? RETRY_STATUSES.has(outcome.status)\n          : outcome.reason === 'unreachable';\n      if (n < retries && retryable) {\n        await sleep(n);\n        continue;\n      }\n      if (outcome instanceof Response) return outcome;\n      throw new RustrakTransportFailure(outcome);\n    }\n  };\n}\n\n/** One try: the response with its body read, or the failure it ended in. */\nasync function attempt(\n  request: Request,\n  timeout: number,\n): Promise<Response | Extract<RustrakError, { kind: 'network' }>> {\n  try {\n    const response = await fetch(request.clone(), {\n      signal: AbortSignal.any([request.signal, AbortSignal.timeout(timeout)]),\n    });\n    const body = await response.arrayBuffer();\n    // The generated client returns `{}` unvalidated for `Content-Length: 0`.\n    // Without it an empty 200 is parsed, and validated, like any other.\n    const headers = new Headers(response.headers);\n    headers.delete('Content-Length');\n    return new Response(NULL_BODY.has(response.status) ? null : body, {\n      status: response.status,\n      statusText: response.statusText,\n      headers,\n    });\n  } catch (error) {\n    if (request.signal.aborted) throw error;\n    // No `cause`, and never `error.message`: both embed the resolved host and\n    // port, which must not ride along into a serialized payload or a UI.\n    return error instanceof DOMException && error.name === 'TimeoutError'\n      ? { kind: 'network', message: TIMEOUT_ERROR_MESSAGE, reason: 'timeout' }\n      : {\n          kind: 'network',\n          message: NETWORK_ERROR_MESSAGE,\n          reason: 'unreachable',\n        };\n  }\n}\n\nfunction sleep(attempt: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, 300 * 2 ** attempt));\n}\n"],"mappings":"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"}

package/dist/utils/http.mjs

@@ -0,0 +1,336 @@
+import { FIELD_ERROR_CODES, NETWORK_ERROR_MESSAGE, SERVER_ERROR_MESSAGE, TIMEOUT_ERROR_MESSAGE } from "../errors.mjs";
+//#region src/utils/http.ts
+/**
+* Internal carrier for a transport failure travelling out of `fetch`.
+*
+* `fetch` signals "no response" by rejecting with a `TypeError`, which is also
+* what a genuine bug throws. {@link createFetch} wraps the rejections it
+* recognises in this class so the `Result` boundary in `client.ts` can tell
+* the two apart: this becomes an `Err`, anything else keeps propagating.
+*
+* Never exported from `src/index.ts`.
+*/
+var RustrakTransportFailure = class extends Error {
+	rustrakError;
+	constructor(error) {
+		super(error.message);
+		this.name = "RustrakTransportFailure";
+		this.rustrakError = error;
+	}
+};
+/** Narrow a caught value to the internal carrier. */
+function isTransportFailure(value) {
+	return value instanceof RustrakTransportFailure;
+}
+/**
+* Read the human-readable message out of an error body.
+*
+* Two shapes are live: every `AppError` sends `{error: {type, message}}` while
+* the ingest rate limiter sends a flat `{error: "..."}`. Reading only the flat
+* one turned every structured error into "[object Object]". See #204.
+*/
+function readErrorMessage(body, status) {
+	const fallback = `HTTP ${status} error`;
+	if (body && typeof body === "object") {
+		const { error, message } = body;
+		return (typeof error === "object" ? error?.message : error) || message || fallback;
+	}
+	return fallback;
+}
+const KNOWN_FIELD_ERROR_CODES = new Set(FIELD_ERROR_CODES);
+function isFieldErrorCode(value) {
+	return typeof value === "string" && KNOWN_FIELD_ERROR_CODES.has(value);
+}
+/**
+* Codes already reported by {@link warnUnknownFieldErrorCode}.
+*
+* Module-scoped so a list page rendering fifty rows against a newer server
+* logs once per unknown code rather than once per row. Version skew does not
+* change within a process, so once is the whole signal.
+*/
+const warnedFieldErrorCodes = /* @__PURE__ */ new Set();
+/**
+* Make an unrecognised `code` visible without admitting it into the union.
+*
+* Dropping the entry is correct (see {@link readFieldErrors}), but a silent
+* drop is indistinguishable from "the server named no field": a client one
+* release behind a server that added a code loses every inline form error
+* site-wide with nothing anywhere to explain it.
+*
+* `console.warn` is the least intrusive mechanism that a support engineer can
+* actually act on. It needs no change to the public type, so no consumer has
+* to opt in to see it; it lands in the browser devtools console in a client
+* component and on stdout of the Node process (and therefore in whatever log
+* aggregation already exists) in a Server Component. The alternatives were
+* worse: throwing turns a cosmetic degradation into an outage, admitting the
+* code breaks the closed union this drop exists to protect, and a new
+* `fieldsDropped` flag on the union is invisible until somebody thinks to read
+* it, which is the same silence in a new place.
+*/
+function warnUnknownFieldErrorCode(code, field) {
+	if (warnedFieldErrorCodes.has(code)) return;
+	warnedFieldErrorCodes.add(code);
+	console.warn(`[@rustrak/client] Dropped a field error with an unrecognised code "${code}" (field "${field}"). This client build does not know that code, so the affected inputs degrade to a form-level error. The server is most likely newer than @rustrak/client; upgrade the client to match the server version.`);
+}
+/**
+* Read `error.fields` out of an `AppError` body.
+*
+* Returns `undefined` rather than `[]` when there is nothing usable, so the
+* key stays absent on the `RustrakError` and a consumer can test for it.
+*
+* Entries are validated one by one and a malformed or unrecognised one is
+* dropped, never coerced. `FieldErrorCode` is a closed union: admitting a code
+* this build has never heard of would hand a consumer a value its own
+* exhaustive `switch` cannot see. A newer server adding a code therefore
+* degrades to a form-level error here, which is the same place an older client
+* already lands, and is announced once via
+* {@link warnUnknownFieldErrorCode} so the skew is not silent.
+*
+* `message` survives only alongside `code: 'custom'`. The server enforces the
+* same rule at construction, but the docs on both sides tell consumers to
+* select translated copy from `(field, code)` for every other code, so a
+* `message` that reaches them there is untranslatable English a careless
+* consumer would render. Dropping it here makes the rule true of the value, not
+* only of its producer.
+*/
+/**
+* Read `error.incident_id` out of a 5xx `AppError` body.
+*
+* The one thing a 500 is willing to say about itself. `error_response` replaced
+* its `Display` with a fixed string so a `sqlx::Error`'s constraint and column
+* names stay off the wire (gh-233), and logged the detail under this id; a user
+* quoting it is what lets an operator find that line.
+*
+* Returns `undefined`, never `null` or `''`, for the three bodies that carry no
+* id: a proxy-generated 502/503, a server older than gh-233, and a 500 whose
+* body is not JSON at all. The caller omits the key entirely in that case, so
+* `'incidentId' in error` stays an honest test.
+*/
+function readIncidentId(body) {
+	const raw = body && typeof body === "object" ? body.error?.incident_id : void 0;
+	return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+function readFieldErrors(body) {
+	const raw = body && typeof body === "object" ? body.error?.fields : void 0;
+	if (!Array.isArray(raw)) return;
+	const fields = raw.flatMap((entry) => readFieldError(entry) ?? []);
+	return fields.length > 0 ? fields : void 0;
+}
+/** One entry of `error.fields`, or `undefined` when it is unusable. */
+function readFieldError(entry) {
+	if (typeof entry !== "object" || entry === null) return void 0;
+	const { field, code, message } = entry;
+	if (typeof field !== "string") return void 0;
+	if (!isFieldErrorCode(code)) {
+		if (typeof code === "string") warnUnknownFieldErrorCode(code, field);
+		return;
+	}
+	return code === "custom" && typeof message === "string" ? {
+		field,
+		code,
+		message
+	} : {
+		field,
+		code
+	};
+}
+/**
+* `Retry-After` in seconds, when the server sent a parseable one.
+*
+* RFC 9110 §10.2.3 allows two forms and a proxy in front of the Rust process
+* may send either. `Number.parseInt` read only the first, and read it too
+* loosely: it dropped the HTTP-date form entirely as `NaN`, and it returned
+* `-5` from `-5` and `3` from `3abc`, both of which a consumer would pass
+* straight to `setTimeout`.
+*
+* A date already in the past yields `0`, meaning "retry now", which is the
+* literal reading of the header.
+*/
+function readRetryAfter(response) {
+	const header = response.headers.get("Retry-After")?.trim();
+	if (!header) return;
+	if (/^\d+$/.test(header)) return Number.parseInt(header, 10);
+	if (/^[+-]\d+$/.test(header)) return;
+	const date = Date.parse(header);
+	if (Number.isNaN(date)) return;
+	return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+}
+/**
+* Attach `fields` to an error, or leave the key off entirely.
+*
+* The key is omitted rather than set to `undefined` so `'fields' in error`
+* stays an honest test and the object round-trips through `structuredClone`
+* with the same shape it was built with.
+*/
+function annotate(base, fields) {
+	return fields === void 0 ? base : {
+		...base,
+		fields
+	};
+}
+/**
+* Map an HTTP status onto a `RustrakError` kind.
+*
+* Total by construction: every 5xx redacts, every other unanticipated status
+* lands on `client_error`, so no status is unrepresentable.
+*/
+function transformHttpError(response, body) {
+	const status = response.status;
+	if (status >= 500) {
+		const base = {
+			kind: "server_error",
+			status,
+			message: SERVER_ERROR_MESSAGE
+		};
+		const incidentId = readIncidentId(body);
+		return incidentId === void 0 ? base : {
+			...base,
+			incidentId
+		};
+	}
+	const message = readErrorMessage(body, status);
+	const fields = readFieldErrors(body);
+	switch (status) {
+		case 400: return annotate({
+			kind: "validation",
+			status,
+			message
+		}, fields);
+		case 401: return annotate({
+			kind: "unauthenticated",
+			status,
+			message
+		}, fields);
+		case 403: return annotate({
+			kind: "forbidden",
+			status,
+			message
+		}, fields);
+		case 404: return annotate({
+			kind: "not_found",
+			status,
+			message
+		}, fields);
+		case 409: return annotate({
+			kind: "conflict",
+			status,
+			message
+		}, fields);
+		case 410: return annotate({
+			kind: "gone",
+			status,
+			message
+		}, fields);
+		case 413: return annotate({
+			kind: "payload_too_large",
+			status,
+			message
+		}, fields);
+		case 429: {
+			const retryAfter = readRetryAfter(response);
+			return annotate(retryAfter === void 0 ? {
+				kind: "rate_limited",
+				status,
+				message
+			} : {
+				kind: "rate_limited",
+				status,
+				message,
+				retryAfter
+			}, fields);
+		}
+		default: return annotate({
+			kind: "client_error",
+			status,
+			message
+		}, fields);
+	}
+}
+/** Statuses a `Response` may not be constructed with a body for. */
+const NULL_BODY = /* @__PURE__ */ new Set([
+	101,
+	103,
+	204,
+	205,
+	304
+]);
+/** Statuses worth repeating: the request may well succeed a moment later. */
+const RETRY_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	500,
+	502,
+	503,
+	504
+]);
+/**
+* Only methods that are safe to send twice. A `POST` that timed out at the
+* proxy may still have created the row, and a second one creates another.
+*/
+const RETRY_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"PUT",
+	"DELETE"
+]);
+/**
+* The `fetch` every request goes through: timeout, retries, and the line
+* between a transport failure and a bug.
+*
+* The body is read here, inside the same `try` as the request, so a
+* connection that dies halfway through a body is a transport failure like
+* one that never connected, not an error the generated client half-parses.
+*
+* Retries wait 300ms, then 600ms, and so on. A caller's own `AbortSignal`
+* aborting is not a transport failure: it rethrows as the `AbortError` the
+* caller asked for.
+*/
+function createFetch(config) {
+	const timeout = config.timeout ?? 3e4;
+	const maxRetries = config.maxRetries ?? 2;
+	return async (input, init) => {
+		const request = new Request(input, init);
+		const retries = RETRY_METHODS.has(request.method) ? maxRetries : 0;
+		for (let n = 0;; n++) {
+			const outcome = await attempt(request, timeout);
+			const retryable = outcome instanceof Response ? RETRY_STATUSES.has(outcome.status) : outcome.reason === "unreachable";
+			if (n < retries && retryable) {
+				await sleep(n);
+				continue;
+			}
+			if (outcome instanceof Response) return outcome;
+			throw new RustrakTransportFailure(outcome);
+		}
+	};
+}
+/** One try: the response with its body read, or the failure it ended in. */
+async function attempt(request, timeout) {
+	try {
+		const response = await fetch(request.clone(), { signal: AbortSignal.any([request.signal, AbortSignal.timeout(timeout)]) });
+		const body = await response.arrayBuffer();
+		const headers = new Headers(response.headers);
+		headers.delete("Content-Length");
+		return new Response(NULL_BODY.has(response.status) ? null : body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	} catch (error) {
+		if (request.signal.aborted) throw error;
+		return error instanceof DOMException && error.name === "TimeoutError" ? {
+			kind: "network",
+			message: TIMEOUT_ERROR_MESSAGE,
+			reason: "timeout"
+		} : {
+			kind: "network",
+			message: NETWORK_ERROR_MESSAGE,
+			reason: "unreachable"
+		};
+	}
+}
+function sleep(attempt) {
+	return new Promise((resolve) => setTimeout(resolve, 300 * 2 ** attempt));
+}
+//#endregion
+export { RustrakTransportFailure, createFetch, isTransportFailure, transformHttpError };
+
+//# sourceMappingURL=http.mjs.map

package/dist/utils/http.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.mjs","names":[],"sources":["../../src/utils/http.ts"],"sourcesContent":["import type { ClientConfig } from '../config.js';\nimport {\n  FIELD_ERROR_CODES,\n  type FieldError,\n  type FieldErrorCode,\n  NETWORK_ERROR_MESSAGE,\n  type RustrakError,\n  SERVER_ERROR_MESSAGE,\n  TIMEOUT_ERROR_MESSAGE,\n} from '../errors.js';\n\n/**\n * Internal carrier for a transport failure travelling out of `fetch`.\n *\n * `fetch` signals \"no response\" by rejecting with a `TypeError`, which is also\n * what a genuine bug throws. {@link createFetch} wraps the rejections it\n * recognises in this class so the `Result` boundary in `client.ts` can tell\n * the two apart: this becomes an `Err`, anything else keeps propagating.\n *\n * Never exported from `src/index.ts`.\n */\nexport class RustrakTransportFailure extends Error {\n  public readonly rustrakError: RustrakError;\n\n  constructor(error: RustrakError) {\n    super(error.message);\n    this.name = 'RustrakTransportFailure';\n    this.rustrakError = error;\n  }\n}\n\n/** Narrow a caught value to the internal carrier. */\nexport function isTransportFailure(\n  value: unknown,\n): value is RustrakTransportFailure {\n  return value instanceof RustrakTransportFailure;\n}\n\n/**\n * Read the human-readable message out of an error body.\n *\n * Two shapes are live: every `AppError` sends `{error: {type, message}}` while\n * the ingest rate limiter sends a flat `{error: \"...\"}`. Reading only the flat\n * one turned every structured error into \"[object Object]\". See #204.\n */\nfunction readErrorMessage(body: unknown, status: number): string {\n  const fallback = `HTTP ${status} error`;\n\n  // `typeof body === 'object'` on purpose: a non-JSON body arrives as a plain\n  // string, and property access on a string primitive yields undefined, so a\n  // bare `if (body)` fell through to the generic message only by accident.\n  // Make the fallback deliberate.\n  if (body && typeof body === 'object') {\n    const { error, message } = body as {\n      error?: string | { type?: string; message?: string };\n      message?: string;\n    };\n    const nested = typeof error === 'object' ? error?.message : error;\n    return nested || message || fallback;\n  }\n\n  return fallback;\n}\n\nconst KNOWN_FIELD_ERROR_CODES = new Set<string>(FIELD_ERROR_CODES);\n\nfunction isFieldErrorCode(value: unknown): value is FieldErrorCode {\n  return typeof value === 'string' && KNOWN_FIELD_ERROR_CODES.has(value);\n}\n\n/**\n * Codes already reported by {@link warnUnknownFieldErrorCode}.\n *\n * Module-scoped so a list page rendering fifty rows against a newer server\n * logs once per unknown code rather than once per row. Version skew does not\n * change within a process, so once is the whole signal.\n */\nconst warnedFieldErrorCodes = new Set<string>();\n\n/**\n * Make an unrecognised `code` visible without admitting it into the union.\n *\n * Dropping the entry is correct (see {@link readFieldErrors}), but a silent\n * drop is indistinguishable from \"the server named no field\": a client one\n * release behind a server that added a code loses every inline form error\n * site-wide with nothing anywhere to explain it.\n *\n * `console.warn` is the least intrusive mechanism that a support engineer can\n * actually act on. It needs no change to the public type, so no consumer has\n * to opt in to see it; it lands in the browser devtools console in a client\n * component and on stdout of the Node process (and therefore in whatever log\n * aggregation already exists) in a Server Component. The alternatives were\n * worse: throwing turns a cosmetic degradation into an outage, admitting the\n * code breaks the closed union this drop exists to protect, and a new\n * `fieldsDropped` flag on the union is invisible until somebody thinks to read\n * it, which is the same silence in a new place.\n */\nfunction warnUnknownFieldErrorCode(code: string, field: string): void {\n  if (warnedFieldErrorCodes.has(code)) return;\n  warnedFieldErrorCodes.add(code);\n\n  console.warn(\n    `[@rustrak/client] Dropped a field error with an unrecognised code ` +\n      `\"${code}\" (field \"${field}\"). This client build does not know that ` +\n      `code, so the affected inputs degrade to a form-level error. The ` +\n      `server is most likely newer than @rustrak/client; upgrade the client ` +\n      `to match the server version.`,\n  );\n}\n\n/**\n * Read `error.fields` out of an `AppError` body.\n *\n * Returns `undefined` rather than `[]` when there is nothing usable, so the\n * key stays absent on the `RustrakError` and a consumer can test for it.\n *\n * Entries are validated one by one and a malformed or unrecognised one is\n * dropped, never coerced. `FieldErrorCode` is a closed union: admitting a code\n * this build has never heard of would hand a consumer a value its own\n * exhaustive `switch` cannot see. A newer server adding a code therefore\n * degrades to a form-level error here, which is the same place an older client\n * already lands, and is announced once via\n * {@link warnUnknownFieldErrorCode} so the skew is not silent.\n *\n * `message` survives only alongside `code: 'custom'`. The server enforces the\n * same rule at construction, but the docs on both sides tell consumers to\n * select translated copy from `(field, code)` for every other code, so a\n * `message` that reaches them there is untranslatable English a careless\n * consumer would render. Dropping it here makes the rule true of the value, not\n * only of its producer.\n */\n/**\n * Read `error.incident_id` out of a 5xx `AppError` body.\n *\n * The one thing a 500 is willing to say about itself. `error_response` replaced\n * its `Display` with a fixed string so a `sqlx::Error`'s constraint and column\n * names stay off the wire (gh-233), and logged the detail under this id; a user\n * quoting it is what lets an operator find that line.\n *\n * Returns `undefined`, never `null` or `''`, for the three bodies that carry no\n * id: a proxy-generated 502/503, a server older than gh-233, and a 500 whose\n * body is not JSON at all. The caller omits the key entirely in that case, so\n * `'incidentId' in error` stays an honest test.\n */\nfunction readIncidentId(body: unknown): string | undefined {\n  const raw =\n    body && typeof body === 'object'\n      ? (body as { error?: { incident_id?: unknown } }).error?.incident_id\n      : undefined;\n\n  return typeof raw === 'string' && raw.length > 0 ? raw : undefined;\n}\n\nfunction readFieldErrors(body: unknown): FieldError[] | undefined {\n  const raw =\n    body && typeof body === 'object'\n      ? (body as { error?: { fields?: unknown } }).error?.fields\n      : undefined;\n\n  if (!Array.isArray(raw)) {\n    return undefined;\n  }\n\n  const fields = raw.flatMap((entry) => readFieldError(entry) ?? []);\n  return fields.length > 0 ? fields : undefined;\n}\n\n/** One entry of `error.fields`, or `undefined` when it is unusable. */\nfunction readFieldError(entry: unknown): FieldError | undefined {\n  if (typeof entry !== 'object' || entry === null) return undefined;\n\n  const { field, code, message } = entry as Record<string, unknown>;\n  if (typeof field !== 'string') return undefined;\n  if (!isFieldErrorCode(code)) {\n    if (typeof code === 'string') warnUnknownFieldErrorCode(code, field);\n    return undefined;\n  }\n\n  return code === 'custom' && typeof message === 'string'\n    ? { field, code, message }\n    : { field, code };\n}\n\n/**\n * `Retry-After` in seconds, when the server sent a parseable one.\n *\n * RFC 9110 §10.2.3 allows two forms and a proxy in front of the Rust process\n * may send either. `Number.parseInt` read only the first, and read it too\n * loosely: it dropped the HTTP-date form entirely as `NaN`, and it returned\n * `-5` from `-5` and `3` from `3abc`, both of which a consumer would pass\n * straight to `setTimeout`.\n *\n * A date already in the past yields `0`, meaning \"retry now\", which is the\n * literal reading of the header.\n */\nfunction readRetryAfter(response: Response): number | undefined {\n  const header = response.headers.get('Retry-After')?.trim();\n  if (!header) {\n    return undefined;\n  }\n\n  // delta-seconds: digits only. No sign, no trailing junk.\n  if (/^\\d+$/.test(header)) {\n    return Number.parseInt(header, 10);\n  }\n\n  // A signed number is neither a valid delta-seconds nor an HTTP-date, and it\n  // must not reach `Date.parse`: V8 reads `-5` as a year and would turn a\n  // nonsense header into \"retry now\".\n  if (/^[+-]\\d+$/.test(header)) {\n    return undefined;\n  }\n\n  const date = Date.parse(header);\n  if (Number.isNaN(date)) {\n    return undefined;\n  }\n\n  return Math.max(0, Math.ceil((date - Date.now()) / 1000));\n}\n\n/**\n * Attach `fields` to an error, or leave the key off entirely.\n *\n * The key is omitted rather than set to `undefined` so `'fields' in error`\n * stays an honest test and the object round-trips through `structuredClone`\n * with the same shape it was built with.\n */\nfunction annotate<E extends RustrakError & { fields?: readonly FieldError[] }>(\n  base: E,\n  fields: readonly FieldError[] | undefined,\n): E {\n  return fields === undefined ? base : { ...base, fields };\n}\n\n/**\n * Map an HTTP status onto a `RustrakError` kind.\n *\n * Total by construction: every 5xx redacts, every other unanticipated status\n * lands on `client_error`, so no status is unrepresentable.\n */\nexport function transformHttpError(\n  response: Response,\n  body: unknown,\n): RustrakError {\n  const status = response.status;\n\n  // 5xx never carries a server-supplied message. The server redacts its own\n  // `Display` now (gh-233), but this stays: a 502 from a reverse proxy and a\n  // server older than that fix both still send prose, and every consumer of\n  // this client renders `error.message` somewhere. Discard it here, once,\n  // rather than trusting 128 call sites to remember.\n  //\n  // `incidentId` is the exception, and the reason the redaction is no longer\n  // lossy: it names the log line carrying what the body dropped, and is\n  // omitted entirely when the body has none.\n  if (status >= 500) {\n    const base = {\n      kind: 'server_error',\n      status,\n      message: SERVER_ERROR_MESSAGE,\n    } as const;\n    const incidentId = readIncidentId(body);\n\n    return incidentId === undefined ? base : { ...base, incidentId };\n  }\n\n  const message = readErrorMessage(body, status);\n\n  // Read once, for every non-5xx status. `AppError::with_field` works on all\n  // eight Rust variants, so restricting this to 400 and 409 meant an\n  // annotation added to, say, the `Forbidden` in `routes/team.rs` would be\n  // serialised, documented in `openapi.json`, and invisible to every consumer\n  // with no test failing anywhere. It costs nothing when the key is absent:\n  // `readFieldErrors` returns `undefined` without allocating.\n  const fields = readFieldErrors(body);\n\n  switch (status) {\n    case 400:\n      // The key is omitted rather than set to `undefined` so that\n      // `'fields' in error` stays an honest test, matching `retryAfter` below.\n      return annotate({ kind: 'validation', status, message }, fields);\n    case 401:\n      return annotate({ kind: 'unauthenticated', status, message }, fields);\n    case 403:\n      return annotate({ kind: 'forbidden', status, message }, fields);\n    case 404:\n      return annotate({ kind: 'not_found', status, message }, fields);\n    case 409:\n      return annotate({ kind: 'conflict', status, message }, fields);\n    case 410:\n      return annotate({ kind: 'gone', status, message }, fields);\n    case 413:\n      return annotate({ kind: 'payload_too_large', status, message }, fields);\n    case 429: {\n      const retryAfter = readRetryAfter(response);\n      return annotate(\n        retryAfter === undefined\n          ? { kind: 'rate_limited', status, message }\n          : { kind: 'rate_limited', status, message, retryAfter },\n        fields,\n      );\n    }\n    default:\n      return annotate({ kind: 'client_error', status, message }, fields);\n  }\n}\n\n/** Statuses a `Response` may not be constructed with a body for. */\nconst NULL_BODY = new Set([101, 103, 204, 205, 304]);\n\n/** Statuses worth repeating: the request may well succeed a moment later. */\nconst RETRY_STATUSES = new Set([408, 500, 502, 503, 504]);\n\n/**\n * Only methods that are safe to send twice. A `POST` that timed out at the\n * proxy may still have created the row, and a second one creates another.\n */\nconst RETRY_METHODS = new Set(['GET', 'HEAD', 'PUT', 'DELETE']);\n\n/**\n * The `fetch` every request goes through: timeout, retries, and the line\n * between a transport failure and a bug.\n *\n * The body is read here, inside the same `try` as the request, so a\n * connection that dies halfway through a body is a transport failure like\n * one that never connected, not an error the generated client half-parses.\n *\n * Retries wait 300ms, then 600ms, and so on. A caller's own `AbortSignal`\n * aborting is not a transport failure: it rethrows as the `AbortError` the\n * caller asked for.\n */\nexport function createFetch(config: ClientConfig): typeof fetch {\n  const timeout = config.timeout ?? 30_000;\n  const maxRetries = config.maxRetries ?? 2;\n\n  return async (input, init) => {\n    const request = new Request(input, init);\n    const retries = RETRY_METHODS.has(request.method) ? maxRetries : 0;\n\n    for (let n = 0; ; n++) {\n      const outcome = await attempt(request, timeout);\n      // A timeout is not repeated: the server may still be working on it.\n      const retryable =\n        outcome instanceof Response\n          ? RETRY_STATUSES.has(outcome.status)\n          : outcome.reason === 'unreachable';\n      if (n < retries && retryable) {\n        await sleep(n);\n        continue;\n      }\n      if (outcome instanceof Response) return outcome;\n      throw new RustrakTransportFailure(outcome);\n    }\n  };\n}\n\n/** One try: the response with its body read, or the failure it ended in. */\nasync function attempt(\n  request: Request,\n  timeout: number,\n): Promise<Response | Extract<RustrakError, { kind: 'network' }>> {\n  try {\n    const response = await fetch(request.clone(), {\n      signal: AbortSignal.any([request.signal, AbortSignal.timeout(timeout)]),\n    });\n    const body = await response.arrayBuffer();\n    // The generated client returns `{}` unvalidated for `Content-Length: 0`.\n    // Without it an empty 200 is parsed, and validated, like any other.\n    const headers = new Headers(response.headers);\n    headers.delete('Content-Length');\n    return new Response(NULL_BODY.has(response.status) ? null : body, {\n      status: response.status,\n      statusText: response.statusText,\n      headers,\n    });\n  } catch (error) {\n    if (request.signal.aborted) throw error;\n    // No `cause`, and never `error.message`: both embed the resolved host and\n    // port, which must not ride along into a serialized payload or a UI.\n    return error instanceof DOMException && error.name === 'TimeoutError'\n      ? { kind: 'network', message: TIMEOUT_ERROR_MESSAGE, reason: 'timeout' }\n      : {\n          kind: 'network',\n          message: NETWORK_ERROR_MESSAGE,\n          reason: 'unreachable',\n        };\n  }\n}\n\nfunction sleep(attempt: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, 300 * 2 ** attempt));\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rustrak/client",
-  "version": "0.18.1",
+  "version": "0.19.1",
   "description": "Type-safe TypeScript client for the Rustrak self-hosted error tracking API",
   "homepage": "https://rustrak.dev/sdks/client",
   "repository": {
@@ -16,14 +16,15 @@
   },
   "type": "module",
   "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -46,24 +47,28 @@
     "node": ">=20"
   },
   "dependencies": {
-    "ky": "2.2.0",
     "zod": "4.6.7"
   },
   "devDependencies": {
+    "@hey-api/openapi-ts": "0.99.0",
     "@types/node": "26.6.5",
-    "@vitest/coverage-v8": "5.0.4",
+    "@vitest/coverage-v8": "5.0.5",
     "msw": "3.0.3",
-    "tsup": "8.5.1",
+    "tsdown": "0.23.1",
     "typescript": "6.0.3",
-    "vitest": "5.0.4"
+    "vitest": "5.0.5"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "generate": "openapi-ts && node scripts/generate-readme.ts",
+    "generate:check": "RUSTRAK_CLIENT_OUT=node_modules/.cache/generated-check openapi-ts && diff -r node_modules/.cache/generated-check src/generated && node scripts/generate-readme.ts --check",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "check-types": "tsc --noEmit",
+    "lint": "biome check .",
+    "format:check": "biome format .",
     "clean": "rm -rf dist"
   }
 }