@fastpix/fastpix-node 2.0.6 → 2.0.7

package/src/lib/base64.ts

@@ -11,7 +11,7 @@ export function bytesToBase64(u8arr: Uint8Array): string {
 }
 
 export function bytesFromBase64(encoded: string): Uint8Array {
-  return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+  return Uint8Array.from(atob(encoded), (c) => c.codePointAt(0) ?? 0);
 }
 
 export function stringToBytes(str: string): Uint8Array {

package/src/lib/config.ts

@@ -67,8 +67,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "2.0.5",
+  sdkVersion: "2.0.7",
   genVersion: "2.781.2",
   userAgent:
-    "fastpix-sdk/typescript 2.0.5 2.781.2 1.0.0 @fastpix/fastpix-node",
+    "fastpix-sdk/typescript 2.0.7 2.781.2 1.0.0 @fastpix/fastpix-node",
 } as const;

package/src/lib/dlv.ts

@@ -43,12 +43,10 @@ export function dlv<T = any>(
   obj: any,
   key: string | string[],
   def?: T,
-  p?: number,
   undef?: never,
 ): T | undefined {
   key = Array.isArray(key) ? key : key.split(".");
-  for (p = 0; p < key.length; p++) {
-    const k = key[p];
+  for (const k of key) {
     obj = k != null && obj ? obj[k] : undef;
   }
   return obj === undef ? def : obj;

package/src/lib/encodings.ts

@@ -294,7 +294,7 @@ export function encodeJSON(
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
 ): string | undefined {
-  if (typeof value === "undefined") {
+  if (value === undefined) {
     return;
   }
 
@@ -367,11 +367,24 @@ function serializeValue(value: unknown): string {
     return value.toISOString();
   } else if (value instanceof Uint8Array) {
     return bytesToBase64(value);
-  } else if (typeof value === "object") {
-    return JSON.stringify(value, jsonReplacer);
   }
 
-  return `${value}`;
+  switch (typeof value) {
+    case "object":
+      return JSON.stringify(value, jsonReplacer);
+    case "string":
+      return value;
+    case "symbol":
+      return value.toString();
+    case "function":
+      return value.name;
+    case "number":
+    case "bigint":
+    case "boolean":
+      return value.toString();
+    default:
+      return "";
+  }
 }
 
 function jsonReplacer(_: string, value: unknown): unknown {
@@ -498,6 +511,6 @@ export function appendForm(
       appendForm(fd, key, v);
     });
   } else {
-    fd.append(key, String(value));
+    fd.append(key, serializeValue(value));
   }
 }

package/src/lib/files.ts

@@ -38,7 +38,7 @@ export async function readableStreamToArrayBuffer(
     offset += chunk.length;
   }
 
-  return concatenatedChunks.buffer as ArrayBuffer;
+  return concatenatedChunks.buffer;
 }
 
 /**

package/src/lib/http.ts

@@ -43,13 +43,13 @@ export type RequestErrorHook = (err: unknown, req: Request) => Awaitable<void>;
 export type ResponseHook = (res: Response, req: Request) => Awaitable<void>;
 
 export class HTTPClient {
-  private fetcher: Fetcher;
+  private readonly fetcher: Fetcher;
   private requestHooks: BeforeRequestHook[] = [];
   private requestErrorHooks: RequestErrorHook[] = [];
   private responseHooks: ResponseHook[] = [];
 
-  constructor(private options: HTTPClientOptions = {}) {
-    this.fetcher = options.fetcher || DEFAULT_FETCHER;
+  constructor(private readonly options: HTTPClientOptions = {}) {
+    this.fetcher = options.fetcher ?? DEFAULT_FETCHER;
   }
 
   async request(request: Request): Promise<Response> {
@@ -135,7 +135,7 @@ export class HTTPClient {
       throw new Error(`Invalid hook type: ${args[0]}`);
     }
 
-    const index = target.findIndex((v) => v === args[1]);
+    const index = target.indexOf(args[1]);
     if (index >= 0) {
       target.splice(index, 1);
     }
@@ -156,8 +156,12 @@ export class HTTPClient {
 export type StatusCodePredicate = number | string | (number | string)[];
 
 // A semicolon surrounded by optional whitespace characters is used to separate
-// segments in a media type string.
-const mediaParamSeparator = /\s*;\s*/g;
+// segments in a media type string. Splitting on the literal `;` and trimming
+// each segment avoids the super-linear backtracking of a `/\s*;\s*/` regex while
+// producing identical results for the (already trimmed) inputs used below.
+function splitMediaTypeSegments(value: string): string[] {
+  return value.split(";").map((segment) => segment.trim());
+}
 
 export function matchContentType(response: Response, pattern: string): boolean {
   // `*` is a special case which means anything is acceptable.
@@ -169,14 +173,14 @@ export function matchContentType(response: Response, pattern: string): boolean {
     response.headers.get("content-type")?.trim() || "application/octet-stream";
   contentType = contentType.toLowerCase();
 
-  const wantParts = pattern.toLowerCase().trim().split(mediaParamSeparator);
+  const wantParts = splitMediaTypeSegments(pattern.toLowerCase().trim());
   const [wantType = "", ...wantParams] = wantParts;
 
   if (wantType.split("/").length !== 2) {
     return false;
   }
 
-  const gotParts = contentType.split(mediaParamSeparator);
+  const gotParts = splitMediaTypeSegments(contentType);
   const [gotType = "", ...gotParams] = gotParts;
 
   const [type = "", subtype = ""] = gotType.split("/");
@@ -207,7 +211,7 @@ export function matchContentType(response: Response, pattern: string): boolean {
   return true;
 }
 
-const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+const codeRangeRE = /^\dxx$/i;
 
 export function matchStatusCode(
   response: Response,

package/src/lib/matchers.ts

@@ -181,6 +181,95 @@ export type MatchFunc<T, E> = (
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
+function selectMatcher<T, E>(
+  response: Response,
+  matchers: Array<Matcher<T, E>>,
+): Matcher<T, E> | undefined {
+  for (const match of matchers) {
+    const { codes } = match;
+    const ctpattern = "ctype" in match
+      ? match.ctype
+      : DEFAULT_CONTENT_TYPES[match.enc];
+    const matched = ctpattern
+      ? matchResponse(response, codes, ctpattern)
+      : matchStatusCode(response, codes);
+    if (matched) {
+      return match;
+    }
+  }
+  return undefined;
+}
+
+async function decodeResponseBody(
+  encoding: Encoding,
+  response: Response,
+): Promise<{ body: string; raw: unknown }> {
+  let body = "";
+  let raw: unknown;
+  switch (encoding) {
+    case "json":
+      body = await response.text();
+      raw = JSON.parse(body);
+      break;
+    case "jsonl":
+    case "stream":
+    case "sse":
+      raw = response.body;
+      break;
+    case "bytes":
+      raw = new Uint8Array(await response.arrayBuffer());
+      break;
+    case "text":
+    case "fail":
+      body = await response.text();
+      raw = body;
+      break;
+    case "nil":
+      body = await response.text();
+      raw = undefined;
+      break;
+    default:
+      encoding satisfies never;
+      throw new Error(`Unsupported response type: ${encoding}`);
+  }
+  return { body, raw };
+}
+
+function buildResponseData<T, E>(
+  matcher: ValueMatcher<T> | ErrorMatcher<E>,
+  raw: unknown,
+  context: {
+    request: Request;
+    response: Response;
+    body: string;
+    resultKey?: string | undefined;
+    extraFields?: Record<string, unknown> | undefined;
+  },
+): unknown {
+  const { request, response, body, resultKey, extraFields } = context;
+  const headers = matcher.hdrs
+    ? { Headers: unpackHeaders(response.headers) }
+    : null;
+
+  if ("err" in matcher) {
+    return {
+      ...extraFields,
+      ...headers,
+      ...(isPlainObject(raw) ? raw : null),
+      request$: request,
+      response$: response,
+      body$: body,
+    };
+  }
+  if (resultKey) {
+    return { ...extraFields, ...headers, [resultKey]: raw };
+  }
+  if (matcher.hdrs) {
+    return { ...extraFields, ...headers, ...(isPlainObject(raw) ? raw : null) };
+  }
+  return raw;
+}
+
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
 ): MatchFunc<T, E | FastpixDefaultError | ResponseValidationError> {
@@ -194,21 +283,7 @@ export function match<T, E>(
       raw: unknown,
     ]
   > {
-    let raw: unknown;
-    let matcher: Matcher<T, E> | undefined;
-    for (const match of matchers) {
-      const { codes } = match;
-      const ctpattern = "ctype" in match
-        ? match.ctype
-        : DEFAULT_CONTENT_TYPES[match.enc];
-      if (ctpattern && matchResponse(response, codes, ctpattern)) {
-        matcher = match;
-        break;
-      } else if (!ctpattern && matchStatusCode(response, codes)) {
-        matcher = match;
-        break;
-      }
-    }
+    const matcher = selectMatcher(response, matchers);
 
     if (!matcher) {
       return [{
@@ -218,44 +293,10 @@ export function match<T, E>(
           request,
           body: await response.text().catch(() => ""),
         }),
-      }, raw];
+      }, undefined];
     }
 
-    const encoding = matcher.enc;
-    let body = "";
-    switch (encoding) {
-      case "json":
-        body = await response.text();
-        raw = JSON.parse(body);
-        break;
-      case "jsonl":
-        raw = response.body;
-        break;
-      case "bytes":
-        raw = new Uint8Array(await response.arrayBuffer());
-        break;
-      case "stream":
-        raw = response.body;
-        break;
-      case "text":
-        body = await response.text();
-        raw = body;
-        break;
-      case "sse":
-        raw = response.body;
-        break;
-      case "nil":
-        body = await response.text();
-        raw = undefined;
-        break;
-      case "fail":
-        body = await response.text();
-        raw = body;
-        break;
-      default:
-        encoding satisfies never;
-        throw new Error(`Unsupported response type: ${encoding}`);
-    }
+    const { body, raw } = await decodeResponseBody(matcher.enc, response);
 
     if (matcher.enc === "fail") {
       return [{
@@ -268,33 +309,13 @@ export function match<T, E>(
       }, raw];
     }
 
-    const resultKey = matcher.key || options?.resultKey;
-    let data: unknown;
-
-    if ("err" in matcher) {
-      data = {
-        ...options?.extraFields,
-        ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-        ...(isPlainObject(raw) ? raw : null),
-        request$: request,
-        response$: response,
-        body$: body,
-      };
-    } else if (resultKey) {
-      data = {
-        ...options?.extraFields,
-        ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-        [resultKey]: raw,
-      };
-    } else if (matcher.hdrs) {
-      data = {
-        ...options?.extraFields,
-        ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-        ...(isPlainObject(raw) ? raw : null),
-      };
-    } else {
-      data = raw;
-    }
+    const data = buildResponseData(matcher, raw, {
+      request,
+      response,
+      body,
+      resultKey: matcher.key || options?.resultKey,
+      extraFields: options?.extraFields,
+    });
 
     if ("err" in matcher) {
       const result = safeParseResponse(

package/src/lib/primitives.ts

@@ -129,7 +129,7 @@ export function compactMap<T>(
   const out: Record<string, T> = {};
 
   for (const [k, v] of Object.entries(values)) {
-    if (typeof v !== "undefined") {
+    if (v !== undefined) {
       out[k] = v;
     }
   }

package/src/lib/retries.ts

@@ -38,15 +38,16 @@ export class PermanentError extends Error {
 
   constructor(message: string, options?: { cause?: unknown }) {
     let msg = message;
-    if (options?.cause) {
-      msg += `: ${options.cause}`;
+    if (options?.cause != null) {
+      const { cause } = options;
+      msg += `: ${cause instanceof Error ? cause.toString() : JSON.stringify(cause)}`;
     }
 
     super(msg, options);
     this.name = "PermanentError";
     // In older runtimes, the cause field would not have been assigned through
     // the super() call.
-    if (typeof this.cause === "undefined") {
+    if (this.cause === undefined) {
       this.cause = options?.cause;
     }
 
@@ -78,18 +79,16 @@ export async function retry(
     statusCodes: string[];
   },
 ): Promise<Response> {
-  switch (options.config.strategy) {
-    case "backoff":
-      return retryBackoff(
-        wrapFetcher(fetchFn, {
-          statusCodes: options.statusCodes,
-          retryConnectionErrors: !!options.config.retryConnectionErrors,
-        }),
-        options.config.backoff ?? defaultBackoff,
-      );
-    default:
-      return await fetchFn();
+  if (options.config.strategy === "backoff") {
+    return retryBackoff(
+      wrapFetcher(fetchFn, {
+        statusCodes: options.statusCodes,
+        retryConnectionErrors: !!options.config.retryConnectionErrors,
+      }),
+      options.config.backoff ?? defaultBackoff,
+    );
   }
+  return await fetchFn();
 }
 
 function wrapFetcher(
@@ -127,7 +126,7 @@ function wrapFetcher(
   };
 }
 
-const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+const codeRangeRE = /^\dxx$/i;
 
 function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
   const actual = `${res.status}`;
@@ -151,45 +150,66 @@ function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
   });
 }
 
+type RetryDecision =
+  | { kind: "wait"; delay: number }
+  | { kind: "return"; response: Response }
+  | { kind: "throw"; error: unknown };
+
+function nextRetryDecision(
+  err: unknown,
+  elapsed: number,
+  strategy: BackoffStrategy,
+  attempt: number,
+): RetryDecision {
+  if (err instanceof PermanentError) {
+    return { kind: "throw", error: err.cause };
+  }
+
+  if (elapsed > strategy.maxElapsedTime) {
+    return err instanceof TemporaryError
+      ? { kind: "return", response: err.response }
+      : { kind: "throw", error: err };
+  }
+
+  let retryInterval =
+    err instanceof TemporaryError
+      ? retryIntervalFromResponse(err.response)
+      : 0;
+
+  if (retryInterval <= 0) {
+    retryInterval =
+      strategy.initialInterval * Math.pow(attempt, strategy.exponent) +
+      // non-security use: random jitter added to retry backoff to avoid
+      // thundering-herd; cryptographic randomness is unnecessary here.
+      Math.random() * 1000; // NOSONAR(typescript:S2245)
+  }
+
+  return {
+    kind: "wait",
+    delay: Math.min(retryInterval, strategy.maxInterval),
+  };
+}
+
 async function retryBackoff(
   fn: () => Promise<Response>,
   strategy: BackoffStrategy,
 ): Promise<Response> {
-  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
-
   const start = Date.now();
   let x = 0;
 
   while (true) {
     try {
-      const res = await fn();
-      return res;
+      return await fn();
     } catch (err: unknown) {
-      if (err instanceof PermanentError) {
-        throw err.cause;
+      const decision = nextRetryDecision(err, Date.now() - start, strategy, x);
+      if (decision.kind === "return") {
+        return decision.response;
       }
-      const elapsed = Date.now() - start;
-      if (elapsed > maxElapsedTime) {
-        if (err instanceof TemporaryError) {
-          return err.response;
-        }
-
-        throw err;
+      if (decision.kind === "throw") {
+        throw decision.error;
       }
 
-      let retryInterval = 0;
-      if (err instanceof TemporaryError) {
-        retryInterval = retryIntervalFromResponse(err.response);
-      }
-
-      if (retryInterval <= 0) {
-        retryInterval =
-          initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
-      }
-
-      const d = Math.min(retryInterval, maxInterval);
-
-      await delay(d);
+      await delay(decision.delay);
       x++;
     }
   }

package/src/lib/schemas.ts

@@ -78,7 +78,7 @@ export function collectExtraKeys<
         }
 
         const v = val[key];
-        if (typeof v === "undefined") {
+        if (v === "undefined") {
           continue;
         }