@orq-ai/node 3.4.0-rc.37 → 3.5.11

package/packages/orq-rc/src/lib/base64.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export function bytesToBase64(u8arr: Uint8Array): string {
+  return btoa(String.fromCodePoint(...u8arr));
+}
+
+export function bytesFromBase64(encoded: string): Uint8Array {
+  return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+}
+
+export function stringToBytes(str: string): Uint8Array {
+  return new TextEncoder().encode(str);
+}
+
+export function stringFromBytes(u8arr: Uint8Array): string {
+  return new TextDecoder().decode(u8arr);
+}
+
+export function stringToBase64(str: string): string {
+  return bytesToBase64(stringToBytes(str));
+}
+
+export function stringFromBase64(b64str: string): string {
+  return stringFromBytes(bytesFromBase64(b64str));
+}
+
+export const zodOutbound = z
+  .instanceof(Uint8Array)
+  .or(z.string().transform(stringToBytes));
+
+export const zodInbound = z
+  .instanceof(Uint8Array)
+  .or(z.string().transform(bytesFromBase64));

package/packages/orq-rc/src/lib/config.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { HTTPClient } from "./http.js";
+import { Logger } from "./logger.js";
+import { RetryConfig } from "./retries.js";
+import { Params, pathToFunc } from "./url.js";
+
+/**
+ * Contains the list of servers available to the SDK
+ */
+export const ServerList = [
+  "https://my.orq.ai",
+] as const;
+
+export type SDKOptions = {
+  apiKey?: string | (() => Promise<string>) | undefined;
+
+  /**
+   * Allows setting the contactId parameter for all supported operations
+   */
+  contactId?: string | undefined;
+
+  /**
+   * Allows setting the environment parameter for all supported operations
+   */
+  environment?: string | undefined;
+
+  httpClient?: HTTPClient;
+  /**
+   * Allows overriding the default server used by the SDK
+   */
+  serverIdx?: number | undefined;
+  /**
+   * Allows overriding the default server URL used by the SDK
+   */
+  serverURL?: string | undefined;
+  /**
+   * Allows overriding the default retry config used by the SDK
+   */
+  retryConfig?: RetryConfig;
+  timeoutMs?: number;
+  debugLogger?: Logger;
+};
+
+export function serverURLFromOptions(options: SDKOptions): URL | null {
+  let serverURL = options.serverURL;
+
+  const params: Params = {};
+
+  if (!serverURL) {
+    const serverIdx = options.serverIdx ?? 0;
+    if (serverIdx < 0 || serverIdx >= ServerList.length) {
+      throw new Error(`Invalid server index ${serverIdx}`);
+    }
+    serverURL = ServerList[serverIdx] || "";
+  }
+
+  const u = pathToFunc(serverURL)(params);
+  return new URL(u);
+}
+
+export const SDK_METADATA = {
+  language: "typescript",
+  openapiDocVersion: "2.0",
+  sdkVersion: "3.6.0-rc.9",
+  genVersion: "2.603.1",
+  userAgent: "speakeasy-sdk/typescript 3.6.0-rc.9 2.603.1 2.0 @orq-ai/node",
+} as const;

package/packages/orq-rc/src/lib/dlv.ts

@@ -0,0 +1,53 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/*
+MIT License
+
+Copyright (c) 2024 Jason Miller <jason@developit.ca> (http://jasonformat.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/**
+ * @param obj The object to walk
+ * @param key The key path to walk the object with
+ * @param def A default value to return if the result is undefined
+ *
+ * @example
+ * dlv(obj, "a.b.c.d")
+ * @example
+ * dlv(object, ["a", "b", "c", "d"])
+ * @example
+ * dlv(object, "foo.bar.baz", "Hello, default value!")
+ */
+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];
+    obj = k != null && obj ? obj[k] : undef;
+  }
+  return obj === undef ? def : obj;
+}

package/packages/orq-rc/src/lib/encodings.ts

@@ -0,0 +1,483 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { bytesToBase64 } from "./base64.js";
+import { isPlainObject } from "./is-plain-object.js";
+
+export class EncodingError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "EncodingError";
+  }
+}
+
+export function encodeMatrix(
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): 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 encValue: string | null | undefined = null;
+
+    if (pv == null) {
+      return;
+    } else if (Array.isArray(pv)) {
+      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
+    } else if (isPlainObject(pv)) {
+      const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+        return `,${encodeString(k)},${encodeValue(v)}`;
+      });
+      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
+    if (tmp === `${keyPrefix}=`) {
+      tmp = tmp.slice(0, -1);
+    }
+
+    // If we end up with the nothing then skip forward
+    if (!tmp) {
+      return;
+    }
+
+    out += `;${tmp}`;
+  });
+
+  return out;
+}
+
+export function encodeLabel(
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): 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: string | null | undefined = "";
+
+    if (pv == null) {
+      return;
+    } else if (Array.isArray(pv)) {
+      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(".");
+    } else if (isPlainObject(pv)) {
+      const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+        return `.${encodeString(k)}.${encodeValue(v)}`;
+      });
+      encValue = mapped?.join("").slice(1);
+    } else {
+      const k =
+        options?.explode && isPlainObject(value) ? `${encodeString(pk)}=` : "";
+      encValue = `${k}${encodeValue(pv)}`;
+    }
+
+    out += encValue == null ? "" : `.${encValue}`;
+  });
+
+  return out;
+}
+
+type FormEncoder = (
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+) => string | undefined;
+
+function formEncoder(sep: string): FormEncoder {
+  return (
+    key: string,
+    value: unknown,
+    options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+  ) => {
+    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));
+
+    const encodedSep = encodeString(sep);
+
+    pairs.forEach(([pk, pv]) => {
+      let tmp = "";
+      let encValue: string | null | undefined = null;
+
+      if (pv == null) {
+        return;
+      } else if (Array.isArray(pv)) {
+        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);
+      } else {
+        encValue = `${encodeValue(pv)}`;
+      }
+
+      if (encValue == null) {
+        return;
+      }
+
+      tmp = `${encodeString(pk)}=${encValue}`;
+
+      // If we end up with the nothing then skip forward
+      if (!tmp || tmp === "=") {
+        return;
+      }
+
+      out += `&${tmp}`;
+    });
+
+    return out.slice(1);
+  };
+}
+
+export const encodeForm = formEncoder(",");
+export const encodeSpaceDelimited = formEncoder(" ");
+export const encodePipeDelimited = formEncoder("|");
+
+export function encodeBodyForm(
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): string {
+  let out = "";
+  const pairs: [string, unknown][] = options?.explode
+    ? explode(key, value)
+    : [[key, value]];
+
+  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 encValue = "";
+
+    if (pv == null) {
+      return;
+    } else if (Array.isArray(pv)) {
+      encValue = JSON.stringify(pv, jsonReplacer);
+    } else if (isPlainObject(pv)) {
+      encValue = JSON.stringify(pv, jsonReplacer);
+    } else {
+      encValue = `${encodeValue(pv)}`;
+    }
+
+    tmp = `${encodeString(pk)}=${encValue}`;
+
+    // If we end up with the nothing then skip forward
+    if (!tmp || tmp === "=") {
+      return;
+    }
+
+    out += `&${tmp}`;
+  });
+
+  return out.slice(1);
+}
+
+export function encodeDeepObject(
+  key: string,
+  value: unknown,
+  options?: { charEncoding?: "percent" | "none" },
+): string | undefined {
+  if (value == null) {
+    return;
+  }
+
+  if (!isPlainObject(value)) {
+    throw new EncodingError(
+      `Value of parameter '${key}' which uses deepObject encoding must be an object or null`,
+    );
+  }
+
+  return encodeDeepObjectObject(key, value, options);
+}
+
+export function encodeDeepObjectObject(
+  key: string,
+  value: unknown,
+  options?: { charEncoding?: "percent" | "none" },
+): string | undefined {
+  if (value == null) {
+    return;
+  }
+
+  let out = "";
+
+  const encodeString = (v: string) => {
+    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+  };
+
+  if (!isPlainObject(value)) {
+    throw new EncodingError(`Expected parameter '${key}' to be an object.`);
+  }
+
+  Object.entries(value).forEach(([ck, cv]) => {
+    if (cv == null) {
+      return;
+    }
+
+    const pk = `${key}[${ck}]`;
+
+    if (isPlainObject(cv)) {
+      const objOut = encodeDeepObjectObject(pk, cv, options);
+
+      out += objOut == null ? "" : `&${objOut}`;
+
+      return;
+    }
+
+    const pairs: unknown[] = Array.isArray(cv) ? cv : [cv];
+    const encoded = mapDefined(pairs, (v) => {
+      return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+    })?.join("&");
+
+    out += encoded == null ? "" : `&${encoded}`;
+  });
+
+  return out.slice(1);
+}
+
+export function encodeJSON(
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): string | undefined {
+  if (typeof value === "undefined") {
+    return;
+  }
+
+  const encodeString = (v: string) => {
+    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+  };
+
+  const encVal = encodeString(JSON.stringify(value, jsonReplacer));
+
+  return options?.explode ? encVal : `${encodeString(key)}=${encVal}`;
+}
+
+export const encodeSimple = (
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): 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: string | null | undefined = "";
+
+    if (pv == null) {
+      return;
+    } else if (Array.isArray(pv)) {
+      tmp = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
+    } else if (isPlainObject(pv)) {
+      const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+        return `,${encodeString(k)},${encodeValue(v)}`;
+      });
+      tmp = mapped?.join("").slice(1);
+    } else {
+      const k = options?.explode && isPlainObject(value) ? `${pk}=` : "";
+      tmp = `${k}${encodeValue(pv)}`;
+    }
+
+    out += tmp ? `,${tmp}` : "";
+  });
+
+  return out.slice(1);
+};
+
+function explode(key: string, value: unknown): [string, unknown][] {
+  if (Array.isArray(value)) {
+    return value.map((v) => [key, v]);
+  } else if (isPlainObject(value)) {
+    const o = value ?? {};
+    return Object.entries(o).map(([k, v]) => [k, v]);
+  } else {
+    return [[key, value]];
+  }
+}
+
+function serializeValue(value: unknown): string {
+  if (value == null) {
+    return "";
+  } else if (value instanceof Date) {
+    return value.toISOString();
+  } else if (value instanceof Uint8Array) {
+    return bytesToBase64(value);
+  } else if (typeof value === "object") {
+    return JSON.stringify(value, jsonReplacer);
+  }
+
+  return `${value}`;
+}
+
+function jsonReplacer(_: string, value: unknown): unknown {
+  if (value instanceof Uint8Array) {
+    return bytesToBase64(value);
+  } else {
+    return value;
+  }
+}
+
+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 == null) {
+      return acc;
+    }
+
+    acc.push(m);
+
+    return acc;
+  }, []);
+
+  return res.length ? res : null;
+}
+
+function mapDefinedEntries<K, V, R>(
+  inp: Iterable<[K, V]>,
+  mapper: (v: [K, V]) => R,
+): R[] | null {
+  const acc: R[] = [];
+  for (const [k, v] of inp) {
+    if (v == null) {
+      continue;
+    }
+
+    const m = mapper([k, v]);
+    if (m == null) {
+      continue;
+    }
+
+    acc.push(m);
+  }
+
+  return acc.length ? acc : null;
+}
+
+export function queryJoin(...args: (string | undefined)[]): string {
+  return args.filter(Boolean).join("&");
+}
+
+type QueryEncoderOptions = {
+  explode?: boolean;
+  charEncoding?: "percent" | "none";
+};
+
+type QueryEncoder = (
+  key: string,
+  value: unknown,
+  options?: QueryEncoderOptions,
+) => string | undefined;
+
+type BulkQueryEncoder = (
+  values: Record<string, unknown>,
+  options?: QueryEncoderOptions,
+) => string;
+
+export function queryEncoder(f: QueryEncoder): BulkQueryEncoder {
+  const bulkEncode = function (
+    values: Record<string, unknown>,
+    options?: QueryEncoderOptions,
+  ): string {
+    const opts: QueryEncoderOptions = {
+      ...options,
+      explode: options?.explode ?? true,
+      charEncoding: options?.charEncoding ?? "percent",
+    };
+
+    const encoded = Object.entries(values).map(([key, value]) => {
+      return f(key, value, opts);
+    });
+    return queryJoin(...encoded);
+  };
+
+  return bulkEncode;
+}
+
+export const encodeJSONQuery = queryEncoder(encodeJSON);
+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/packages/orq-rc/src/lib/env.ts

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { dlv } from "./dlv.js";
+
+import * as z from "zod";
+import { SDKOptions } from "./config.js";
+
+export interface Env {
+  ORQ_API_KEY?: string | undefined;
+
+  /**
+   * Sets the contactId parameter for all supported operations
+   */
+  ORQ_CONTACT_ID?: string | undefined;
+
+  /**
+   * Sets the environment parameter for all supported operations
+   */
+  ORQ_ENVIRONMENT?: string | undefined;
+
+  ORQ_DEBUG?: boolean | undefined;
+}
+
+export const envSchema: z.ZodType<Env, z.ZodTypeDef, unknown> = z.object({
+  ORQ_API_KEY: z.string().optional(),
+
+  ORQ_CONTACT_ID: z.string().optional(),
+  ORQ_ENVIRONMENT: z.string().optional(),
+
+  ORQ_DEBUG: z.coerce.boolean().optional(),
+});
+
+let envMemo: Env | undefined = undefined;
+/**
+ * Reads and validates environment variables.
+ */
+export function env(): Env {
+  if (envMemo) {
+    return envMemo;
+  }
+
+  envMemo = envSchema.parse(
+    dlv(globalThis, "process.env") ?? dlv(globalThis, "Deno.env") ?? {},
+  );
+  return envMemo;
+}
+
+/**
+ * Clears the cached env object. Useful for testing with a fresh environment.
+ */
+export function resetEnv() {
+  envMemo = undefined;
+}
+
+/**
+ * Populates global parameters with environment variables.
+ */
+export function fillGlobals(options: SDKOptions): SDKOptions {
+  const clone = { ...options };
+
+  const envVars = env();
+
+  if (typeof envVars.ORQ_CONTACT_ID !== "undefined") {
+    clone.contactId ??= envVars.ORQ_CONTACT_ID;
+  }
+  if (typeof envVars.ORQ_ENVIRONMENT !== "undefined") {
+    clone.environment ??= envVars.ORQ_ENVIRONMENT;
+  }
+
+  return clone;
+}