@codat/lending 7.2.0 → 7.4.0

package/src/lib/encodings.ts

@@ -16,12 +16,16 @@ export function encodeMatrix(
   key: string,
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
-): string {
+): string | undefined {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
     ? explode(key, value)
     : [[key, value]];
 
+  if (pairs.every(([_, v]) => v == null)) {
+    return;
+  }
+
   const encodeString = (v: string) => {
     return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
   };
@@ -29,21 +33,25 @@ export function encodeMatrix(
 
   pairs.forEach(([pk, pv]) => {
     let tmp = "";
-    let encValue = "";
+    let encValue: string | null | undefined = null;
 
-    if (pv === undefined) {
+    if (pv == null) {
       return;
     } else if (Array.isArray(pv)) {
-      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`).join(",");
+      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
     } else if (isPlainObject(pv)) {
-      encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+      const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
         return `,${encodeString(k)},${encodeValue(v)}`;
-      }).join("");
-      encValue = encValue.slice(1);
+      });
+      encValue = mapped?.join("").slice(1);
     } else {
       encValue = `${encodeValue(pv)}`;
     }
 
+    if (encValue == null) {
+      return;
+    }
+
     const keyPrefix = encodeString(pk);
     tmp = `${keyPrefix}=${encValue}`;
     // trim trailing '=' if value was empty
@@ -66,36 +74,41 @@ export function encodeLabel(
   key: string,
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
-): string {
+): string | undefined {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
     ? explode(key, value)
     : [[key, value]];
 
+  if (pairs.every(([_, v]) => v == null)) {
+    return;
+  }
+
   const encodeString = (v: string) => {
     return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
   };
   const encodeValue = (v: unknown) => encodeString(serializeValue(v));
 
   pairs.forEach(([pk, pv]) => {
-    let encValue = "";
+    let encValue: string | null | undefined = "";
 
-    if (pv === undefined) {
+    if (pv == null) {
       return;
     } else if (Array.isArray(pv)) {
-      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`).join(".");
+      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(".");
     } else if (isPlainObject(pv)) {
-      encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+      const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
         return `.${encodeString(k)}.${encodeValue(v)}`;
-      }).join("");
-      encValue = encValue.slice(1);
+      });
+      encValue = mapped?.join("").slice(1);
     } else {
-      const k =
-        options?.explode && isPlainObject(value) ? `${encodeString(pk)}=` : "";
+      const k = options?.explode && isPlainObject(value)
+        ? `${encodeString(pk)}=`
+        : "";
       encValue = `${k}${encodeValue(pv)}`;
     }
 
-    out += `.${encValue}`;
+    out += encValue == null ? "" : `.${encValue}`;
   });
 
   return out;
@@ -105,7 +118,7 @@ type FormEncoder = (
   key: string,
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
-) => string;
+) => string | undefined;
 
 function formEncoder(sep: string): FormEncoder {
   return (
@@ -118,6 +131,10 @@ function formEncoder(sep: string): FormEncoder {
       ? explode(key, value)
       : [[key, value]];
 
+    if (pairs.every(([_, v]) => v == null)) {
+      return;
+    }
+
     const encodeString = (v: string) => {
       return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
     };
@@ -128,20 +145,24 @@ function formEncoder(sep: string): FormEncoder {
 
     pairs.forEach(([pk, pv]) => {
       let tmp = "";
-      let encValue = "";
+      let encValue: string | null | undefined = null;
 
-      if (pv === undefined) {
+      if (pv == null) {
         return;
       } else if (Array.isArray(pv)) {
-        encValue = mapDefined(pv, (v) => `${encodeValue(v)}`).join(encodedSep);
+        encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(encodedSep);
       } else if (isPlainObject(pv)) {
         encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
           return `${encodeString(k)}${encodedSep}${encodeValue(v)}`;
-        }).join(encodedSep);
+        })?.join(encodedSep);
       } else {
         encValue = `${encodeValue(pv)}`;
       }
 
+      if (encValue == null) {
+        return;
+      }
+
       tmp = `${encodeString(pk)}=${encValue}`;
 
       // If we end up with the nothing then skip forward
@@ -180,7 +201,7 @@ export function encodeBodyForm(
     let tmp = "";
     let encValue = "";
 
-    if (pv === undefined) {
+    if (pv == null) {
       return;
     } else if (Array.isArray(pv)) {
       encValue = JSON.stringify(pv, jsonReplacer);
@@ -207,14 +228,14 @@ export function encodeDeepObject(
   key: string,
   value: unknown,
   options?: { charEncoding?: "percent" | "none" },
-): string {
+): string | undefined {
   if (value == null) {
-    return "";
+    return;
   }
 
   if (!isPlainObject(value)) {
     throw new EncodingError(
-      `Value of parameter '${key}' which uses deepObject encoding must be an object`,
+      `Value of parameter '${key}' which uses deepObject encoding must be an object or null`,
     );
   }
 
@@ -225,9 +246,9 @@ export function encodeDeepObjectObject(
   key: string,
   value: unknown,
   options?: { charEncoding?: "percent" | "none" },
-): string {
+): string | undefined {
   if (value == null) {
-    return "";
+    return;
   }
 
   let out = "";
@@ -241,7 +262,7 @@ export function encodeDeepObjectObject(
   }
 
   Object.entries(value).forEach(([ck, cv]) => {
-    if (cv === undefined) {
+    if (cv == null) {
       return;
     }
 
@@ -250,19 +271,17 @@ export function encodeDeepObjectObject(
     if (isPlainObject(cv)) {
       const objOut = encodeDeepObjectObject(pk, cv, options);
 
-      out += `&${objOut}`;
+      out += objOut == null ? "" : `&${objOut}`;
 
       return;
     }
 
     const pairs: unknown[] = Array.isArray(cv) ? cv : [cv];
-    let encoded = "";
-
-    encoded = mapDefined(pairs, (v) => {
+    const encoded = mapDefined(pairs, (v) => {
       return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
-    }).join("&");
+    })?.join("&");
 
-    out += `&${encoded}`;
+    out += encoded == null ? "" : `&${encoded}`;
   });
 
   return out.slice(1);
@@ -272,9 +291,9 @@ export function encodeJSON(
   key: string,
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
-): string {
+): string | undefined {
   if (typeof value === "undefined") {
-    return "";
+    return;
   }
 
   const encodeString = (v: string) => {
@@ -290,40 +309,39 @@ export const encodeSimple = (
   key: string,
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
-): string => {
+): string | undefined => {
   let out = "";
   const pairs: [string, unknown][] = options?.explode
     ? explode(key, value)
     : [[key, value]];
 
+  if (pairs.every(([_, v]) => v == null)) {
+    return;
+  }
+
   const encodeString = (v: string) => {
     return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
   };
   const encodeValue = (v: unknown) => encodeString(serializeValue(v));
 
   pairs.forEach(([pk, pv]) => {
-    let tmp = "";
+    let tmp: string | null | undefined = "";
 
-    if (pv === undefined) {
+    if (pv == null) {
       return;
     } else if (Array.isArray(pv)) {
-      tmp = mapDefined(pv, (v) => `${encodeValue(v)}`).join(",");
+      tmp = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
     } else if (isPlainObject(pv)) {
-      tmp = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+      const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
         return `,${encodeString(k)},${encodeValue(v)}`;
-      }).join("");
-      tmp = tmp.slice(1);
+      });
+      tmp = mapped?.join("").slice(1);
     } else {
       const k = options?.explode && isPlainObject(value) ? `${pk}=` : "";
       tmp = `${k}${encodeValue(pv)}`;
     }
 
-    // If we end up with the nothing then skip forward
-    if (!tmp) {
-      return;
-    }
-
-    out += `,${tmp}`;
+    out += tmp ? `,${tmp}` : "";
   });
 
   return out.slice(1);
@@ -341,9 +359,7 @@ function explode(key: string, value: unknown): [string, unknown][] {
 }
 
 function serializeValue(value: unknown): string {
-  if (value === null) {
-    return "null";
-  } else if (typeof value === "undefined") {
+  if (value == null) {
     return "";
   } else if (value instanceof Date) {
     return value.toISOString();
@@ -364,14 +380,14 @@ function jsonReplacer(_: string, value: unknown): unknown {
   }
 }
 
-function mapDefined<T, R>(inp: T[], mapper: (v: T) => R): R[] {
-  return inp.reduce<R[]>((acc, v) => {
-    if (v === undefined) {
+function mapDefined<T, R>(inp: T[], mapper: (v: T) => R): R[] | null {
+  const res = inp.reduce<R[]>((acc, v) => {
+    if (v == null) {
       return acc;
     }
 
     const m = mapper(v);
-    if (m === undefined) {
+    if (m == null) {
       return acc;
     }
 
@@ -379,43 +395,46 @@ function mapDefined<T, R>(inp: T[], mapper: (v: T) => R): R[] {
 
     return acc;
   }, []);
+
+  return res.length ? res : null;
 }
 
 function mapDefinedEntries<K, V, R>(
   inp: Iterable<[K, V]>,
   mapper: (v: [K, V]) => R,
-): R[] {
+): R[] | null {
   const acc: R[] = [];
   for (const [k, v] of inp) {
-    if (v === undefined) {
+    if (v == null) {
       continue;
     }
 
     const m = mapper([k, v]);
-    if (m === undefined) {
+    if (m == null) {
       continue;
     }
 
     acc.push(m);
   }
 
-  return acc;
+  return acc.length ? acc : null;
 }
 
-export function queryJoin(...args: string[]): string {
+export function queryJoin(...args: (string | undefined)[]): string {
   return args.filter(Boolean).join("&");
 }
 
 type QueryEncoderOptions = {
   explode?: boolean;
   charEncoding?: "percent" | "none";
+  allowEmptyValue?: string[];
 };
 
 type QueryEncoder = (
   key: string,
   value: unknown,
   options?: QueryEncoderOptions,
-) => string;
+) => string | undefined;
 
 type BulkQueryEncoder = (
   values: Record<string, unknown>,
@@ -423,7 +442,7 @@ type BulkQueryEncoder = (
 ) => string;
 
 export function queryEncoder(f: QueryEncoder): BulkQueryEncoder {
-  const bulkEncode = function (
+  const bulkEncode = function(
     values: Record<string, unknown>,
     options?: QueryEncoderOptions,
   ): string {
@@ -433,7 +452,19 @@ export function queryEncoder(f: QueryEncoder): BulkQueryEncoder {
       charEncoding: options?.charEncoding ?? "percent",
     };
 
+    const allowEmptySet = new Set(options?.allowEmptyValue ?? []);
+
     const encoded = Object.entries(values).map(([key, value]) => {
+      if (allowEmptySet.has(key)) {
+        if (
+          value === undefined
+          || value === null
+          || value === ""
+          || (Array.isArray(value) && value.length === 0)
+        ) {
+          return `${encodeURIComponent(key)}=`;
+        }
+      }
       return f(key, value, opts);
     });
     return queryJoin(...encoded);
@@ -447,3 +478,20 @@ export const encodeFormQuery = queryEncoder(encodeForm);
 export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+
+export function appendForm(
+  fd: FormData,
+  key: string,
+  value: unknown,
+  fileName?: string,
+): void {
+  if (value == null) {
+    return;
+  } else if (value instanceof Blob && fileName) {
+    fd.append(key, value, fileName);
+  } else if (value instanceof Blob) {
+    fd.append(key, value);
+  } else {
+    fd.append(key, String(value));
+  }
+}

package/src/lib/files.ts

@@ -36,5 +36,47 @@ export async function readableStreamToArrayBuffer(
     offset += chunk.length;
   }
 
-  return concatenatedChunks.buffer;
+  return concatenatedChunks.buffer as ArrayBuffer;
+}
+
+/**
+ * Determines the MIME content type based on a file's extension.
+ * Returns null if the extension is not recognized.
+ */
+export function getContentTypeFromFileName(fileName: string): string | null {
+  if (!fileName) return null;
+
+  const ext = fileName.toLowerCase().split(".").pop();
+  if (!ext) return null;
+
+  const mimeTypes: Record<string, string> = {
+    json: "application/json",
+    xml: "application/xml",
+    html: "text/html",
+    htm: "text/html",
+    txt: "text/plain",
+    csv: "text/csv",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    js: "application/javascript",
+    css: "text/css",
+    zip: "application/zip",
+    tar: "application/x-tar",
+    gz: "application/gzip",
+    mp4: "video/mp4",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+  };
+
+  return mimeTypes[ext] || null;
 }

package/src/lib/matchers.ts

@@ -2,14 +2,14 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import { ResponseValidationError } from "../sdk/models/errors/responsevalidationerror.js";
 import { SDKError } from "../sdk/models/errors/sdkerror.js";
-import { SDKValidationError } from "../sdk/models/errors/sdkvalidationerror.js";
-import { Result } from "../sdk/types/fp.js";
+import { ERR, OK, Result } from "../sdk/types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
-import { safeParse } from "./schemas.js";
 
 export type Encoding =
+  | "jsonl"
   | "json"
   | "text"
   | "bytes"
@@ -19,6 +19,7 @@ export type Encoding =
   | "fail";
 
 const DEFAULT_CONTENT_TYPES: Record<Encoding, string> = {
+  jsonl: "application/jsonl",
   json: "application/json",
   text: "text/plain",
   bytes: "application/octet-stream",
@@ -72,6 +73,21 @@ export function json<T>(
   return { ...options, enc: "json", codes, schema };
 }
 
+export function jsonl<T>(
+  codes: StatusCodePredicate,
+  schema: Schema<T>,
+  options?: MatchOptions,
+): ValueMatcher<T> {
+  return { ...options, enc: "jsonl", codes, schema };
+}
+
+export function jsonlErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  return { ...options, err: true, enc: "jsonl", codes, schema };
+}
 export function textErr<E>(
   codes: StatusCodePredicate,
   schema: Schema<E>,
@@ -159,17 +175,19 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
+  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
-): MatchFunc<T, E | SDKError | SDKValidationError> {
+): MatchFunc<T, E | SDKError | ResponseValidationError> {
   return async function matchFunc(
     response: Response,
+    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
-    [result: Result<T, E | SDKError | SDKValidationError>, raw: unknown]
+    [result: Result<T, E | SDKError | ResponseValidationError>, raw: unknown]
   > {
     let raw: unknown;
     let matcher: Matcher<T, E> | undefined;
@@ -188,21 +206,25 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new SDKError(
-          "Unexpected API response status or content-type",
+        error: new SDKError("Unexpected Status or Content-Type", {
           response,
-          responseBody,
-        ),
-      }, responseBody];
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
+        break;
+      case "jsonl":
+        raw = response.body;
         break;
       case "bytes":
         raw = new Uint8Array(await response.arrayBuffer());
@@ -211,16 +233,19 @@ export function match<T, E>(
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         encoding satisfies never;
@@ -230,11 +255,7 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new SDKError(
-          "API error occurred",
-          response,
-          typeof raw === "string" ? raw : "",
-        ),
+        error: new SDKError("API error occurred", { request, response, body }),
       }, raw];
     }
 
@@ -246,6 +267,9 @@ export function match<T, E>(
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
       };
     } else if (resultKey) {
       data = {
@@ -264,18 +288,20 @@ export function match<T, E>(
     }
 
     if ("err" in matcher) {
-      const result = safeParse(
+      const result = safeParseResponse(
         data,
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
+        { request, response, body },
       );
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(
+        safeParseResponse(
           data,
           (v: unknown) => matcher.schema.parse(v),
           "Response validation failed",
+          { request, response, body },
         ),
         raw,
       ];
@@ -298,25 +324,22 @@ export function unpackHeaders(headers: Headers): Record<string, string[]> {
   return out;
 }
 
-/**
- * Discards the response body to free up resources.
- *
- * To learn why this is need, see the undici docs:
- * https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function discardResponseBody(res: Response) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
-
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
   try {
-    let done = false;
-    while (!done) {
-      const res = await reader.read();
-      done = res.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
   }
 }