@novu/api 0.0.1-alpha.6

package/src/lib/http.ts

@@ -0,0 +1,508 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import { never as znever } from "zod";
+import { parse } from "./schemas";
+import { isPlainObject } from "./is-plain-object";
+import * as errors from "../models/errors";
+
+export type Fetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+export type Awaitable<T> = T | Promise<T>;
+
+const DEFAULT_FETCHER: Fetcher = (input, init) => {
+    // If input is a Request and init is undefined, Bun will discard the method,
+    // headers, body and other options that were set on the request object.
+    // Node.js and browers would ignore an undefined init value. This check is
+    // therefore needed for interop with Bun.
+    if (init == null) {
+        return fetch(input);
+    } else {
+        return fetch(input, init);
+    }
+};
+
+export type RequestInput = {
+    /**
+     * The URL the request will use.
+     */
+    url: URL;
+    /**
+     * Options used to create a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).
+     */
+    options?: RequestInit | undefined;
+};
+
+export interface HTTPClientOptions {
+    fetcher?: Fetcher;
+}
+
+export type BeforeRequestHook = (req: Request) => Awaitable<Request | void>;
+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 requestHooks: BeforeRequestHook[] = [];
+    private requestErrorHooks: RequestErrorHook[] = [];
+    private responseHooks: ResponseHook[] = [];
+
+    constructor(private options: HTTPClientOptions = {}) {
+        this.fetcher = options.fetcher || DEFAULT_FETCHER;
+    }
+
+    async request(request: Request): Promise<Response> {
+        let req = request;
+        for (const hook of this.requestHooks) {
+            const nextRequest = await hook(req);
+            if (nextRequest) {
+                req = nextRequest;
+            }
+        }
+
+        try {
+            const res = await this.fetcher(req);
+
+            for (const hook of this.responseHooks) {
+                await hook(res, req);
+            }
+
+            return res;
+        } catch (err) {
+            for (const hook of this.requestErrorHooks) {
+                await hook(err, req);
+            }
+
+            throw err;
+        }
+    }
+
+    /**
+     * Registers a hook that is called before a request is made. The hook function
+     * can mutate the request or return a new request. This may be useful to add
+     * additional information to request such as request IDs and tracing headers.
+     */
+    addHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
+    /**
+     * Registers a hook that is called when a request cannot be made due to a
+     * network error.
+     */
+    addHook(hook: "requestError", fn: RequestErrorHook): this;
+    /**
+     * Registers a hook that is called when a response has been received from the
+     * server.
+     */
+    addHook(hook: "response", fn: ResponseHook): this;
+    addHook(
+        ...args:
+            | [hook: "beforeRequest", fn: BeforeRequestHook]
+            | [hook: "requestError", fn: RequestErrorHook]
+            | [hook: "response", fn: ResponseHook]
+    ) {
+        if (args[0] === "beforeRequest") {
+            this.requestHooks.push(args[1]);
+        } else if (args[0] === "requestError") {
+            this.requestErrorHooks.push(args[1]);
+        } else if (args[0] === "response") {
+            this.responseHooks.push(args[1]);
+        } else {
+            throw new Error(`Invalid hook type: ${args[0]}`);
+        }
+        return this;
+    }
+
+    /** Removes a hook that was previously registered with `addHook`. */
+    removeHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
+    /** Removes a hook that was previously registered with `addHook`. */
+    removeHook(hook: "requestError", fn: RequestErrorHook): this;
+    /** Removes a hook that was previously registered with `addHook`. */
+    removeHook(hook: "response", fn: ResponseHook): this;
+    removeHook(
+        ...args:
+            | [hook: "beforeRequest", fn: BeforeRequestHook]
+            | [hook: "requestError", fn: RequestErrorHook]
+            | [hook: "response", fn: ResponseHook]
+    ): this {
+        let target: unknown[];
+        if (args[0] === "beforeRequest") {
+            target = this.requestHooks;
+        } else if (args[0] === "requestError") {
+            target = this.requestErrorHooks;
+        } else if (args[0] === "response") {
+            target = this.responseHooks;
+        } else {
+            throw new Error(`Invalid hook type: ${args[0]}`);
+        }
+
+        const index = target.findIndex((v) => v === args[1]);
+        if (index >= 0) {
+            target.splice(index, 1);
+        }
+
+        return this;
+    }
+
+    clone(): HTTPClient {
+        const child = new HTTPClient(this.options);
+        child.requestHooks = this.requestHooks.slice();
+        child.requestErrorHooks = this.requestErrorHooks.slice();
+        child.responseHooks = this.responseHooks.slice();
+
+        return child;
+    }
+}
+
+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;
+
+function matchContentType(response: Response, pattern: string): boolean {
+    // `*` is a special case which means anything is acceptable.
+    if (pattern === "*") {
+        return true;
+    }
+
+    let contentType = response.headers.get("content-type")?.trim() || "application/octet-stream";
+    contentType = contentType.toLowerCase();
+
+    const wantParts = pattern.toLowerCase().trim().split(mediaParamSeparator);
+    const [wantType = "", ...wantParams] = wantParts;
+
+    if (wantType.split("/").length !== 2) {
+        return false;
+    }
+
+    const gotParts = contentType.split(mediaParamSeparator);
+    const [gotType = "", ...gotParams] = gotParts;
+
+    const [type = "", subtype = ""] = gotType.split("/");
+    if (!type || !subtype) {
+        return false;
+    }
+
+    if (
+        wantType !== "*/*" &&
+        gotType !== wantType &&
+        `${type}/*` !== wantType &&
+        `*/${subtype}` !== wantType
+    ) {
+        return false;
+    }
+
+    if (gotParams.length < wantParams.length) {
+        return false;
+    }
+
+    const params = new Set(gotParams);
+    for (const wantParam of wantParams) {
+        if (!params.has(wantParam)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+
+export function matchStatusCode(response: Response, codes: StatusCodePredicate): boolean {
+    const actual = `${response.status}`;
+    const expectedCodes = Array.isArray(codes) ? codes : [codes];
+    if (!expectedCodes.length) {
+        return false;
+    }
+
+    return expectedCodes.some((ec) => {
+        const code = `${ec}`;
+
+        if (code === "default") {
+            return true;
+        }
+
+        if (!codeRangeRE.test(`${code}`)) {
+            return code === actual;
+        }
+
+        const expectFamily = code.charAt(0);
+        if (!expectFamily) {
+            throw new Error("Invalid status code range");
+        }
+
+        const actualFamily = actual.charAt(0);
+        if (!actualFamily) {
+            throw new Error(`Invalid response status code: ${actual}`);
+        }
+
+        return actualFamily === expectFamily;
+    });
+}
+
+export function matchResponse(
+    response: Response,
+    code: StatusCodePredicate,
+    contentTypePattern: string
+): boolean {
+    return matchStatusCode(response, code) && matchContentType(response, contentTypePattern);
+}
+
+const headerValRE = /, */;
+export function unpackHeaders(headers: Headers): Record<string, string[]> {
+    const out: Record<string, string[]> = {};
+
+    for (const [k, v] of headers.entries()) {
+        out[k] = v.split(headerValRE);
+    }
+
+    return out;
+}
+
+type ResponseMatcherSchema<T> =
+    | { parse: (data: unknown) => T }
+    | { inboundSchema: { parse: (data: unknown) => T } };
+
+type SerializationMethod = "sse" | "json" | "rawBytes" | "rawStream" | "text" | "void" | "fail";
+
+const defaultContentTypes: Record<SerializationMethod, string> = {
+    sse: "text/event-stream",
+    json: "application/json",
+    rawBytes: "application/octet-stream",
+    rawStream: "application/octet-stream",
+    text: "text/plain",
+    void: "",
+    fail: "",
+};
+
+type ResponsePredicateMatch<Result> = {
+    method: SerializationMethod;
+    codes: StatusCodePredicate;
+    ctype: string;
+    schema: ResponseMatcherSchema<Result | Error>;
+    hdrs: boolean;
+    key: string | undefined;
+    err: boolean;
+    fail: boolean;
+};
+
+type ResponsePredicateOptions = {
+    /** Content type to match on. */
+    ctype?: string;
+    /** Pass HTTP headers to deserializer. */
+    hdrs?: boolean;
+} & (
+    | {
+          /** The result key to store the deserialized value into. */
+          key?: string;
+          fail?: never;
+          err?: never;
+      }
+    | {
+          /** Indicates the matched response must throw the built-in error. */
+          fail: true;
+          key?: never;
+          err?: never;
+      }
+    | {
+          /** Indicates the matched response is a custom error. */
+          err: true;
+          key?: never;
+          fail?: never;
+      }
+);
+
+export class ResponseMatcher<Result> {
+    private predicates: ResponsePredicateMatch<Result>[] = [];
+
+    #any<T extends Result | Error>(
+        method: SerializationMethod,
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: ResponsePredicateOptions
+    ) {
+        const ctype = opts?.ctype || defaultContentTypes[method];
+        const hdrs = !!opts?.hdrs;
+        const key = opts?.key;
+        const err = !!opts?.err;
+        const fail = !!opts?.fail;
+        this.predicates.push({
+            method,
+            codes,
+            ctype,
+            schema,
+            hdrs,
+            key,
+            err,
+            fail,
+        });
+        return this;
+    }
+
+    json<T extends Result | Error>(
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: ResponsePredicateOptions
+    ): this {
+        return this.#any("json", codes, schema, opts);
+    }
+    bytes<T extends Result | Error>(
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: ResponsePredicateOptions
+    ): this {
+        return this.#any("rawBytes", codes, schema, opts);
+    }
+    stream<T extends Result | Error>(
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: ResponsePredicateOptions
+    ): this {
+        return this.#any("rawStream", codes, schema, opts);
+    }
+    text<T extends Result | Error>(
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: ResponsePredicateOptions
+    ): this {
+        return this.#any("text", codes, schema, opts);
+    }
+    sse<T extends Result | Error>(
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: Omit<ResponsePredicateOptions, "err" | "fail">
+    ): this {
+        return this.#any("sse", codes, schema, opts);
+    }
+    void<T extends Result | Error>(
+        codes: StatusCodePredicate,
+        schema: ResponseMatcherSchema<T>,
+        opts?: Pick<ResponsePredicateOptions, "hdrs">
+    ): this {
+        return this.#any("void", codes, schema, opts);
+    }
+    fail(codes: StatusCodePredicate): this {
+        return this.#any("fail", codes, znever(), { fail: true });
+    }
+
+    async match(
+        response: Response,
+        // flat
+        options?: {
+            resultKey?: string;
+            extraFields?: Record<string, unknown>;
+        }
+    ): Promise<[result: Result, rawData: unknown]> {
+        let pred: ResponsePredicateMatch<Result> | undefined;
+        for (const predicate of this.predicates) {
+            const { codes, ctype } = predicate;
+            if (ctype && matchResponse(response, codes, ctype)) {
+                pred = predicate;
+                break;
+            } else if (!ctype && matchStatusCode(response, codes)) {
+                pred = predicate;
+                break;
+            }
+        }
+        if (pred == null) {
+            const responseBody = await response.text();
+            throw new errors.SDKError(
+                "Unexpected API response status or content-type",
+                response,
+                responseBody
+            );
+        }
+
+        const { method, schema } = pred;
+
+        let raw: unknown;
+        switch (method) {
+            case "json":
+                raw = await response.json();
+                break;
+            case "rawBytes":
+                raw = await response.arrayBuffer();
+                break;
+            case "rawStream":
+                raw = response.body;
+                break;
+            case "text":
+                raw = await response.text();
+                break;
+            case "sse":
+                raw = response.body;
+                break;
+            case "void":
+                raw = await discardResponseBody(response);
+                break;
+            case "fail":
+                raw = await response.text();
+                break;
+            default:
+                method satisfies never;
+                throw new Error(`Unsupported response type: ${method}`);
+        }
+
+        const resultKey = pred.key || options?.resultKey;
+        let data: unknown;
+        if (pred.fail) {
+            throw new errors.SDKError(
+                "API error occurred",
+                response,
+                typeof raw === "string" ? raw : ""
+            );
+        } else if (pred.err) {
+            data = {
+                ...options?.extraFields,
+                ...(pred.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+                ...(isPlainObject(raw) ? raw : null),
+            };
+        } else if (resultKey) {
+            data = {
+                ...options?.extraFields,
+                ...(pred.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+                [resultKey]: raw,
+            };
+        } else if (pred.hdrs) {
+            data = {
+                ...options?.extraFields,
+                ...(pred.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+                ...(isPlainObject(raw) ? raw : null),
+            };
+        } else {
+            data = raw;
+        }
+
+        const parser = "inboundSchema" in schema ? schema.inboundSchema : schema;
+        const body = parse(data, (v: unknown) => parser.parse(v), "Response validation failed");
+
+        if (body instanceof Error) {
+            throw body;
+        }
+
+        return [body, raw];
+    }
+}
+
+/**
+ * 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;
+    }
+
+    try {
+        let done = false;
+        while (!done) {
+            const res = await reader.read();
+            done = res.done;
+        }
+    } finally {
+        reader.releaseLock();
+    }
+}

package/src/lib/is-plain-object.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.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.
+*/
+
+// Taken from https://github.com/sindresorhus/is-plain-obj/blob/97f38e8836f86a642cce98fc6ab3058bc36df181/index.js
+
+export function isPlainObject(value: unknown): value is object {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const prototype = Object.getPrototypeOf(value);
+  return (
+    (prototype === null ||
+      prototype === Object.prototype ||
+      Object.getPrototypeOf(prototype) === null) &&
+    !(Symbol.toStringTag in value) &&
+    !(Symbol.iterator in value)
+  );
+}

package/src/lib/primitives.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+export type Remap<Inp, Mapping extends { [k in keyof Inp]?: string | null }> = {
+  [k in keyof Inp as Mapping[k] extends string /* if we have a string mapping for this key then use it */
+    ? Mapping[k]
+    : Mapping[k] extends null /* if the mapping is to `null` then drop the key */
+    ? never
+    : k /* otherwise keep the key as-is */]: Inp[k];
+};
+
+/**
+ * Converts or omits an object's keys according to a mapping.
+ *
+ * @param inp An object whose keys will be remapped
+ * @param mappings A mapping of original keys to new keys. If a key is not present in the mapping, it will be left as is. If a key is mapped to `null`, it will be removed in the resulting object.
+ * @returns A new object with keys remapped or omitted according to the mappings
+ */
+export function remap<
+  Inp extends Record<string, unknown>,
+  const Mapping extends { [k in keyof Inp]?: string | null },
+>(inp: Inp, mappings: Mapping): Remap<Inp, Mapping> {
+  let out: any = {};
+
+  if (!Object.keys(mappings).length) {
+    out = inp;
+    return out;
+  }
+
+  for (const [k, v] of Object.entries(inp)) {
+    const j = mappings[k];
+    if (j === null) {
+      continue;
+    }
+    out[j ?? k] = v;
+  }
+
+  return out;
+}