dub 0.10.0 → 0.20.2

package/src/lib/retries.ts

@@ -0,0 +1,226 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+export type BackoffStrategy = {
+  initialInterval: number;
+  maxInterval: number;
+  exponent: number;
+  maxElapsedTime: number;
+};
+
+const defaultBackoff: BackoffStrategy = {
+  initialInterval: 500,
+  maxInterval: 60000,
+  exponent: 1.5,
+  maxElapsedTime: 3600000,
+};
+
+export type RetryConfig =
+  | { strategy: "none" }
+  | {
+      strategy: "backoff";
+      backoff?: BackoffStrategy;
+      retryConnectionErrors?: boolean;
+    };
+
+class PermanentError extends Error {
+  inner: unknown;
+
+  constructor(inner: unknown) {
+    super("Permanent error");
+    this.inner = inner;
+
+    Object.setPrototypeOf(this, PermanentError.prototype);
+  }
+}
+
+class TemporaryError extends Error {
+  res: Response;
+
+  constructor(res: Response) {
+    super("Temporary error");
+    this.res = res;
+
+    Object.setPrototypeOf(this, TemporaryError.prototype);
+  }
+}
+
+export async function retry(
+  fetchFn: () => Promise<Response>,
+  options: {
+    config: RetryConfig;
+    statusCodes: string[];
+  },
+): Promise<Response> {
+  switch (options.config.strategy) {
+    case "backoff":
+      return retryBackoff(
+        wrapFetcher(fetchFn, {
+          statusCodes: options.statusCodes,
+          retryConnectionErrors: !!options.config.retryConnectionErrors,
+        }),
+        options.config.backoff ?? defaultBackoff,
+      );
+    default:
+      return await fetchFn();
+  }
+}
+
+function wrapFetcher(
+  fn: () => Promise<Response>,
+  options: {
+    statusCodes: string[];
+    retryConnectionErrors: boolean;
+  },
+): () => Promise<Response> {
+  return async () => {
+    try {
+      const res = await fn();
+      if (isRetryableResponse(res, options.statusCodes)) {
+        throw new TemporaryError(res);
+      }
+
+      return res;
+    } catch (err) {
+      if (err instanceof TemporaryError) {
+        throw err;
+      }
+
+      if (
+        options.retryConnectionErrors &&
+        (isTimeoutError(err) || isConnectionError(err))
+      ) {
+        throw err;
+      }
+
+      throw new PermanentError(err);
+    }
+  };
+}
+
+function isConnectionError(err: unknown) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+
+  // Covers fetch in Deno as well
+  const isBrowserErr =
+    err instanceof TypeError &&
+    err.message.toLowerCase().startsWith("failed to fetch");
+
+  const isNodeErr =
+    err instanceof TypeError &&
+    err.message.toLowerCase().startsWith("fetch failed");
+
+  const isBunErr = "name" in err && err.name === "ConnectionError";
+
+  const isGenericErr =
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnreset";
+
+  return isBrowserErr || isNodeErr || isGenericErr || isBunErr;
+}
+
+function isTimeoutError(err: unknown) {
+  if (typeof err !== "object" || err == null) {
+    return false;
+  }
+
+  // Fetch in browser, Node.js, Bun, Deno
+  const isNative = "name" in err && err.name === "TimeoutError";
+
+  // Node.js HTTP client and Axios
+  const isGenericErr =
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnaborted";
+
+  return isNative || isGenericErr;
+}
+
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+
+function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
+  const actual = `${res.status}`;
+
+  return statusCodes.some((code) => {
+    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;
+  });
+}
+
+async function retryBackoff(
+  fn: () => Promise<Response>,
+  strategy: BackoffStrategy,
+): Promise<Response> {
+  const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
+
+  const start = Date.now();
+  let x = 0;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    try {
+      const res = await fn();
+      return res;
+    } catch (err) {
+      if (err instanceof PermanentError) {
+        throw err.inner;
+      }
+      const elapsed = Date.now() - start;
+      if (elapsed > maxElapsedTime) {
+        if (err instanceof TemporaryError) {
+          return err.res;
+        }
+
+        throw err;
+      }
+
+      let retryInterval = 0;
+      if (err instanceof TemporaryError && err.res && err.res.headers) {
+        const retryVal = err.res.headers.get("retry-after") || "";
+        if (retryVal != "") {
+          const parsedNumber = Number(retryVal);
+          if (!isNaN(parsedNumber) && Number.isInteger(parsedNumber)) {
+            retryInterval = parsedNumber * 1000;
+          } else {
+            const parsedDate = Date.parse(retryVal);
+            if (!isNaN(parsedDate)) {
+              const deltaMS = parsedDate - Date.now();
+              retryInterval = deltaMS > 0 ? Math.ceil(deltaMS) : 0;
+            }
+          }
+        }
+      }
+
+      if (retryInterval == 0) {
+        retryInterval =
+          initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
+      }
+
+      const d = Math.min(retryInterval, maxInterval);
+
+      await delay(d);
+      x++;
+    }
+  }
+}
+
+async function delay(delay: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}

package/src/lib/schemas.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import { ZodError } from "zod";
+import * as errors from "../models/errors";
+
+/**
+ * Utility function that executes some code which may throw a ZodError. It
+ * intercepts this error and converts it to an SDKValidationError so as to not
+ * leak Zod implementation details to user code.
+ */
+export function parse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMessage: string): Out {
+    try {
+        return fn(rawValue);
+    } catch (err) {
+        if (err instanceof ZodError) {
+            throw new errors.SDKValidationError(errorMessage, err, rawValue);
+        }
+        throw err;
+    }
+}

package/src/lib/sdks.ts

@@ -0,0 +1,139 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import { HTTPClient, matchResponse, matchStatusCode, unpackHeaders } from "./http";
+import { SecurityState, resolveSecurity, resolveGlobalSecurity } from "./security";
+import { pathToFunc } from "./url";
+import { encodeForm } from "./encodings";
+import { stringToBase64 } from "./base64";
+import { SDKHooks, HookContext } from "../hooks";
+
+export type RequestOptions = {
+    fetchOptions?: Omit<RequestInit, "method" | "body">;
+};
+
+type RequestConfig = {
+    method: string;
+    path: string;
+    baseURL?: string | URL;
+    query?: string;
+    body?: RequestInit["body"];
+    headers?: HeadersInit;
+    security?: SecurityState | null;
+};
+
+export class ClientSDK {
+    private readonly client: HTTPClient;
+    protected readonly baseURL: URL | null;
+    protected readonly hooks$: SDKHooks;
+
+    constructor(init: { client: HTTPClient; baseURL: URL | null; hooks: SDKHooks }) {
+        const url = init.baseURL;
+        if (url) {
+            url.pathname = url.pathname.replace(/\/+$/, "") + "/";
+        }
+
+        this.hooks$ = init.hooks;
+        const { baseURL, client } = this.hooks$.sdkInit({ baseURL: url, client: init.client });
+        this.baseURL = baseURL;
+        this.client = client;
+    }
+
+    protected createRequest$(conf: RequestConfig, options?: RequestOptions) {
+        const { method, path, query, headers: opHeaders, security } = conf;
+
+        const base = conf.baseURL ?? this.baseURL;
+        if (!base) {
+            throw new TypeError("No base URL provided for operation");
+        }
+        const reqURL = new URL(base);
+        const inputURL = new URL(path, reqURL);
+
+        if (path) {
+            reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+        }
+
+        let finalQuery = query || "";
+
+        const secQuery: string[] = [];
+        for (const [k, v] of Object.entries(security?.queryParams || {})) {
+            secQuery.push(encodeForm(k, v, { charEncoding: "percent" }));
+        }
+        if (secQuery.length) {
+            finalQuery += `&${secQuery.join("&")}`;
+        }
+
+        if (finalQuery) {
+            const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
+            reqURL.search = `?${q}`;
+        }
+
+        const headers = new Headers(opHeaders);
+
+        const username = security?.basic.username;
+        const password = security?.basic.password;
+        if (username != null || password != null) {
+            const encoded = stringToBase64([username || "", password || ""].join(":"));
+            headers.set("Authorization", `Basic ${encoded}`);
+        }
+
+        const securityHeaders = new Headers(security?.headers || {});
+        for (const [k, v] of securityHeaders) {
+            headers.set(k, v);
+        }
+
+        let cookie = headers.get("cookie") || "";
+        for (const [k, v] of Object.entries(security?.cookies || {})) {
+            cookie += `; ${k}=${v}`;
+        }
+        cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
+        headers.set("cookie", cookie);
+
+        const userHeaders = new Headers(options?.fetchOptions?.headers);
+        for (const [k, v] of userHeaders) {
+            headers.set(k, v);
+        }
+
+        return new Request(reqURL, {
+            ...options?.fetchOptions,
+            body: conf.body ?? null,
+            headers,
+            method,
+        });
+    }
+
+    protected async do$(
+        req: Request,
+        options: {
+            context: HookContext;
+            errorCodes: number | string | (number | string)[];
+        }
+    ) {
+        const { context, errorCodes } = options;
+
+        let response = await this.client.request(await this.hooks$.beforeRequest(context, req));
+
+        if (this.matchStatusCode(response, errorCodes)) {
+            const result = await this.hooks$.afterError(context, response, null);
+            if (result.error) {
+                throw result.error;
+            }
+            response = result.response || response;
+        } else {
+            response = await this.hooks$.afterSuccess(context, response);
+        }
+
+        return response;
+    }
+
+    protected unpackHeaders = unpackHeaders;
+
+    protected matchStatusCode = matchStatusCode;
+    protected matchResponse = matchResponse;
+
+    protected templateURLComponent = pathToFunc;
+
+    protected resolveSecurity = resolveSecurity;
+    protected resolveGlobalSecurity = resolveGlobalSecurity;
+}

package/src/lib/security.ts

@@ -0,0 +1,180 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+import * as components from "../models/components";
+
+export enum SecurityErrorCode {
+    Incomplete = "incomplete",
+    UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+    constructor(public code: SecurityErrorCode, message: string) {
+        super(message);
+        this.name = "SecurityError";
+    }
+
+    static incomplete(): SecurityError {
+        return new SecurityError(
+            SecurityErrorCode.Incomplete,
+            "Security requirements not met in order to perform the operation"
+        );
+    }
+    static unrecognizedType(type: string): SecurityError {
+        return new SecurityError(
+            SecurityErrorCode.UnrecognisedSecurityType,
+            `Unrecognised security type: ${type}`
+        );
+    }
+}
+
+export type SecurityState = {
+    basic: { username?: string | undefined; password?: string | undefined };
+    headers: Record<string, string>;
+    queryParams: Record<string, string>;
+    cookies: Record<string, string>;
+};
+
+type SecurityInputBasic = {
+    type: "http:basic";
+    value: { username?: string | undefined; password?: string | undefined } | null | undefined;
+};
+
+type SecurityInputBearer = {
+    type: "http:bearer";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+    type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputOIDC = {
+    type: "openIdConnect";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+    type: "oauth2";
+    value: string | null | undefined;
+    fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+    type: "oauth2:client_credentials";
+    value: string | null | undefined;
+    fieldName: "clientID" | "clientSecret";
+};
+
+export type SecurityInput =
+    | SecurityInputBasic
+    | SecurityInputBearer
+    | SecurityInputAPIKey
+    | SecurityInputOAuth2
+    | SecurityInputOAuth2ClientCredentials
+    | SecurityInputOIDC;
+
+export function resolveSecurity(...options: SecurityInput[][]): SecurityState | null {
+    const state: SecurityState = {
+        basic: { username: "", password: "" },
+        headers: {},
+        queryParams: {},
+        cookies: {},
+    };
+
+    const option = options.find((opts) => {
+        return opts.every((o) => {
+            if (o.value == null) {
+                return false;
+            } else if (o.type === "http:basic") {
+                return o.value.username != null || o.value.password != null;
+            } else if (typeof o.value === "string") {
+                return !!o.value;
+            } else {
+                throw new Error(
+                    `Unrecognized security type: ${o.type} (value type: ${typeof o.value})`
+                );
+            }
+        });
+    });
+    if (option == null) {
+        return null;
+    }
+
+    option.forEach((spec) => {
+        if (spec.value == null) {
+            return;
+        }
+
+        const { type } = spec;
+
+        switch (type) {
+            case "apiKey:header":
+                state.headers[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:query":
+                state.queryParams[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:cookie":
+                state.cookies[spec.fieldName] = spec.value;
+                break;
+            case "http:basic":
+                applyBasic(state, spec);
+                break;
+            case "http:bearer":
+                applyBearer(state, spec);
+                break;
+            case "oauth2":
+                applyBearer(state, spec);
+                break;
+            case "oauth2:client_credentials":
+                break;
+            case "openIdConnect":
+                applyBearer(state, spec);
+                break;
+            default:
+                spec satisfies never;
+                throw SecurityError.unrecognizedType(type);
+        }
+    });
+
+    return state;
+}
+
+function applyBasic(state: SecurityState, spec: SecurityInputBasic) {
+    if (spec.value == null) {
+        return;
+    }
+
+    state.basic = spec.value;
+}
+
+function applyBearer(
+    state: SecurityState,
+    spec: SecurityInputBearer | SecurityInputOAuth2 | SecurityInputOIDC
+) {
+    if (spec.value == null) {
+        return;
+    }
+
+    let value = spec.value;
+    if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+        value = `Bearer ${value}`;
+    }
+
+    state.headers[spec.fieldName] = value;
+}
+export function resolveGlobalSecurity(security: Partial<components.Security> | null | undefined) {
+    return resolveSecurity([
+        {
+            fieldName: "Authorization",
+            type: "http:bearer",
+            value: security?.token,
+        },
+    ]);
+}

package/src/lib/url.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Record<string, string | number>) => string {
+  const paramRE = /\{([a-zA-Z0-9_]+?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
+
+      const value = params[placeholder];
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          `Parameter '${placeholder}' must be a string or number`,
+        );
+      }
+
+      return options?.charEncoding === "percent"
+        ? encodeURIComponent(`${value}`)
+        : `${value}`;
+    });
+  };
+}

package/src/models/components/index.ts

@@ -0,0 +1,8 @@
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+
+export * from "./linkschema";
+export * from "./security";
+export * from "./tagschema";
+export * from "./workspaceschema";