@novu/api 0.0.1-alpha.6

package/src/lib/base64.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). 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/src/lib/config.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import { HTTPClient } from "./http";
+import { RetryConfig } from "./retries";
+import { Params, pathToFunc } from "./url";
+
+/**
+ * Contains the list of servers available to the SDK
+ */
+export const ServerList = ["https://api.novu.co", "https://eu.api.novu.co"] as const;
+
+export type SDKOptions = {
+    apiKey?: string | (() => Promise<string>);
+
+    httpClient?: HTTPClient;
+    /**
+     * Allows overriding the default server used by the SDK
+     */
+    serverIdx?: number;
+    /**
+     * Allows overriding the default server URL used by the SDK
+     */
+    serverURL?: string;
+    /**
+     * Allows overriding the default retry config used by the SDK
+     */
+    retryConfig?: RetryConfig;
+};
+
+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: "1.0",
+    sdkVersion: "0.0.1-alpha.6",
+    genVersion: "2.342.6",
+    userAgent: "speakeasy-sdk/typescript 0.0.1-alpha.6 2.342.6 1.0 @novu/api",
+} as const;

package/src/lib/encodings.ts

@@ -0,0 +1,431 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import { bytesToBase64 } from "./base64";
+import { isPlainObject } from "./is-plain-object";
+
+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 {
+  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 === undefined) {
+      return;
+    } else if (Array.isArray(pv)) {
+      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`).join(",");
+    } else if (isPlainObject(pv)) {
+      encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+        return `,${encodeString(k)},${encodeValue(v)}`;
+      }).join("");
+      encValue = encValue.slice(1);
+    } else {
+      encValue = `${encodeValue(pv)}`;
+    }
+
+    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 {
+  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 encValue = "";
+
+    if (pv === undefined) {
+      return;
+    } else if (Array.isArray(pv)) {
+      encValue = mapDefined(pv, (v) => `${encodeValue(v)}`).join(".");
+    } else if (isPlainObject(pv)) {
+      encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+        return `.${encodeString(k)}.${encodeValue(v)}`;
+      }).join("");
+      encValue = encValue.slice(1);
+    } else {
+      const k =
+        options?.explode && isPlainObject(value) ? `${encodeString(pk)}=` : "";
+      encValue = `${k}${encodeValue(pv)}`;
+    }
+
+    out += `.${encValue}`;
+  });
+
+  return out;
+}
+
+type FormEncoder = (
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+) => string;
+
+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]];
+
+    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 = "";
+
+      if (pv === undefined) {
+        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)}`;
+      }
+
+      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 === undefined) {
+      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 {
+  if (value == null) {
+    return "";
+  }
+
+  let out = "";
+
+  const encodeString = (v: string) => {
+    return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+  };
+
+  if (!isPlainObject(value)) {
+    throw new EncodingError(
+      `Value of parameter '${key}' which uses deepObject encoding must be an object`,
+    );
+  }
+
+  Object.entries(value).forEach(([ck, cv]) => {
+    if (cv === undefined) {
+      return;
+    }
+
+    const pk = `${key}[${ck}]`;
+
+    if (isPlainObject(cv)) {
+      throw new EncodingError(
+        `Value of parameter field '${pk}' cannot be an array or object.`,
+      );
+    }
+
+    const pairs: unknown[] = Array.isArray(cv) ? cv : [cv];
+    let encoded = "";
+
+    encoded = mapDefined(pairs, (v) => {
+      return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+    }).join("&");
+
+    out += `&${encoded}`;
+  });
+
+  return out.slice(1);
+}
+
+export function encodeJSON(
+  key: string,
+  value: unknown,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): string {
+  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 => {
+  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 = "";
+
+    if (pv === undefined) {
+      return;
+    } else if (Array.isArray(pv)) {
+      tmp = mapDefined(pv, (v) => `${encodeValue(v)}`).join(",");
+    } else if (isPlainObject(pv)) {
+      tmp = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+        return `,${encodeString(k)},${encodeValue(v)}`;
+      }).join("");
+      tmp = tmp.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}`;
+  });
+
+  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 "null";
+  } else if (typeof value === "undefined") {
+    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[] {
+  return inp.reduce<R[]>((acc, v) => {
+    if (v === undefined) {
+      return acc;
+    }
+
+    const m = mapper(v);
+    if (m === undefined) {
+      return acc;
+    }
+
+    acc.push(m);
+
+    return acc;
+  }, []);
+}
+
+function mapDefinedEntries<K, V, R>(
+  inp: Iterable<[K, V]>,
+  mapper: (v: [K, V]) => R,
+): R[] {
+  const acc: R[] = [];
+  for (const [k, v] of inp) {
+    if (v === undefined) {
+      continue;
+    }
+
+    const m = mapper([k, v]);
+    if (m === undefined) {
+      continue;
+    }
+
+    acc.push(m);
+  }
+
+  return acc;
+}
+
+export function queryJoin(...args: string[]): string {
+  return args.filter(Boolean).join("&");
+}
+
+type QueryEncoderOptions = {
+  explode?: boolean;
+  charEncoding?: "percent" | "none";
+};
+
+type QueryEncoder = (
+  key: string,
+  value: unknown,
+  options?: QueryEncoderOptions,
+) => string;
+
+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);