syllable-sdk 0.1.0-alpha.7 → 0.1.0-alpha.71

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,40 @@ 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)}=` : "";
       encValue = `${k}${encodeValue(pv)}`;
     }
 
-    out += `.${encValue}`;
+    out += encValue == null ? "" : `.${encValue}`;
   });
 
   return out;
@@ -105,7 +117,7 @@ type FormEncoder = (
   key: string,
   value: unknown,
   options?: { explode?: boolean; charEncoding?: "percent" | "none" },
-) => string;
+) => string | undefined;
 
 function formEncoder(sep: string): FormEncoder {
   return (
@@ -118,6 +130,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 +144,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 +200,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 +227,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 +245,9 @@ export function encodeDeepObjectObject(
   key: string,
   value: unknown,
   options?: { charEncoding?: "percent" | "none" },
-): string {
+): string | undefined {
   if (value == null) {
-    return "";
+    return;
   }
 
   let out = "";
@@ -241,7 +261,7 @@ export function encodeDeepObjectObject(
   }
 
   Object.entries(value).forEach(([ck, cv]) => {
-    if (cv === undefined) {
+    if (cv == null) {
       return;
     }
 
@@ -250,19 +270,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 +290,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 +308,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 +358,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 +379,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,30 +394,32 @@ 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("&");
 }
 
@@ -415,7 +432,7 @@ type QueryEncoder = (
   key: string,
   value: unknown,
   options?: QueryEncoderOptions,
-) => string;
+) => string | undefined;
 
 type BulkQueryEncoder = (
   values: Record<string, unknown>,
@@ -447,3 +464,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/primitives.ts

@@ -58,3 +58,79 @@ export function remap<
 
   return out;
 }
+
+export function combineSignals(
+  ...signals: Array<AbortSignal | null | undefined>
+): AbortSignal | null {
+  const filtered: AbortSignal[] = [];
+  for (const signal of signals) {
+    if (signal) {
+      filtered.push(signal);
+    }
+  }
+
+  switch (filtered.length) {
+    case 0:
+    case 1:
+      return filtered[0] || null;
+    default:
+      if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
+        return AbortSignal.any(filtered);
+      }
+      return abortSignalAny(filtered);
+  }
+}
+
+export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController();
+  const result = controller.signal;
+  if (!signals.length) {
+    return controller.signal;
+  }
+
+  if (signals.length === 1) {
+    return signals[0] || controller.signal;
+  }
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal;
+    }
+  }
+
+  function abort(this: AbortSignal) {
+    controller.abort(this.reason);
+    clean();
+  }
+
+  const signalRefs: WeakRef<AbortSignal>[] = [];
+  function clean() {
+    for (const signalRef of signalRefs) {
+      const signal = signalRef.deref();
+      if (signal) {
+        signal.removeEventListener("abort", abort);
+      }
+    }
+  }
+
+  for (const signal of signals) {
+    signalRefs.push(new WeakRef(signal));
+    signal.addEventListener("abort", abort);
+  }
+
+  return result;
+}
+
+export function compactMap<T>(
+  values: Record<string, T | undefined>,
+): Record<string, T> {
+  const out: Record<string, T> = {};
+
+  for (const [k, v] of Object.entries(values)) {
+    if (typeof v !== "undefined") {
+      out[k] = v;
+    }
+  }
+
+  return out;
+}

package/src/lib/retries.ts

@@ -158,7 +158,6 @@ async function retryBackoff(
   const start = Date.now();
   let x = 0;
 
-  // eslint-disable-next-line no-constant-condition
   while (true) {
     try {
       const res = await fn();

package/src/lib/schemas.ts

@@ -57,6 +57,7 @@ export function collectExtraKeys<
 >(
   obj: ZodObject<Shape, "strip", Catchall>,
   extrasKey: K,
+  optional: boolean,
 ): ZodEffects<
   typeof obj,
   & output<ZodObject<Shape, "strict">>
@@ -81,6 +82,10 @@ export function collectExtraKeys<
       delete val[key];
     }
 
+    if (optional && Object.keys(extras).length === 0) {
+      return val;
+    }
+
     return { ...val, [extrasKey]: extras };
   });
 }

package/src/lib/sdks.ts

@@ -42,6 +42,10 @@ export type RequestOptions = {
    * Specifies the status codes which should be retried using the given retry policy.
    */
   retryCodes?: string[];
+  /**
+   * Overrides the base server URL that will be used by an operation.
+   */
+  serverURL?: string | URL;
   /**
    * Sets various request options on the `fetch` call made by an SDK method.
    *
@@ -53,7 +57,7 @@ export type RequestOptions = {
 type RequestConfig = {
   method: string;
   path: string;
-  baseURL?: string | URL;
+  baseURL?: string | URL | undefined;
   query?: string;
   body?: RequestInit["body"];
   headers?: HeadersInit;
@@ -123,6 +127,7 @@ export class ClientSDK {
     const inputURL = new URL(path, reqURL);
 
     if (path) {
+      reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
       reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
     }
 
@@ -130,7 +135,10 @@ export class ClientSDK {
 
     const secQuery: string[] = [];
     for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      secQuery.push(encodeForm(k, v, { charEncoding: "percent" }));
+      const q = encodeForm(k, v, { charEncoding: "percent" });
+      if (typeof q !== "undefined") {
+        secQuery.push(q);
+      }
     }
     if (secQuery.length) {
       finalQuery += `&${secQuery.join("&")}`;

package/src/lib/security.ts

@@ -4,7 +4,6 @@
 
 import * as components from "../models/components/index.js";
 import { env } from "./env.js";
-
 type OAuth2PasswordFlow = {
   username: string;
   password?: string | undefined;
@@ -118,7 +117,7 @@ export function resolveSecurity(
   ...options: SecurityInput[][]
 ): SecurityState | null {
   const state: SecurityState = {
-    basic: { username: "", password: "" },
+    basic: {},
     headers: {},
     queryParams: {},
     cookies: {},