dub 0.44.0 → 0.45.1

package/src/funcs/linksUpsert.ts

@@ -77,12 +77,20 @@ export async function linksUpsert(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "upsertLink",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -112,9 +120,8 @@ export async function linksUpsert(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/metatagsGet.ts

@@ -66,12 +66,20 @@ export async function metatagsGet(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "getMetatags",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -90,9 +98,8 @@ export async function metatagsGet(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["4XX", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/qrCodesGet.ts

@@ -84,12 +84,20 @@ export async function qrCodesGet(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "getQRCode",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -120,9 +128,8 @@ export async function qrCodesGet(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/tagsCreate.ts

@@ -77,12 +77,20 @@ export async function tagsCreate(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "createTag",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -112,9 +120,8 @@ export async function tagsCreate(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/tagsDelete.ts

@@ -83,12 +83,20 @@ export async function tagsDelete(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "deleteTag",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -118,9 +126,8 @@ export async function tagsDelete(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/tagsList.ts

@@ -59,12 +59,20 @@ export async function tagsList(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "getTags",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -93,9 +101,8 @@ export async function tagsList(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/tagsUpdate.ts

@@ -87,12 +87,20 @@ export async function tagsUpdate(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "updateTag",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -122,9 +130,8 @@ export async function tagsUpdate(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/trackCustomer.ts

@@ -27,6 +27,8 @@ import { Result } from "../types/fp.js";
  *
  * @remarks
  * Track a customer for an authenticated workspace.
+ *
+ * @deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
  */
 export async function trackCustomer(
   client: DubCore,
@@ -78,12 +80,20 @@ export async function trackCustomer(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "trackCustomer",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -113,9 +123,8 @@ export async function trackCustomer(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/trackLead.ts

@@ -76,12 +76,20 @@ export async function trackLead(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "trackLead",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -111,9 +119,8 @@ export async function trackLead(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/trackSale.ts

@@ -76,12 +76,20 @@ export async function trackSale(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "trackSale",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -111,9 +119,8 @@ export async function trackSale(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/workspacesGet.ts

@@ -80,12 +80,20 @@ export async function workspacesGet(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "getWorkspace",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -115,9 +123,8 @@ export async function workspacesGet(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/workspacesUpdate.ts

@@ -87,12 +87,20 @@ export async function workspacesUpdate(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "updateWorkspace",
     oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -122,9 +130,8 @@ export async function workspacesUpdate(
       "500",
       "5XX",
     ],
-    retryConfig: options?.retries
-      || client._options.retryConfig,
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/hooks/types.ts

@@ -3,11 +3,15 @@
  */
 
 import { HTTPClient, RequestInput } from "../lib/http.js";
+import { RetryConfig } from "../lib/retries.js";
+import { SecurityState } from "../lib/security.js";
 
 export type HookContext = {
   operationID: string;
   oAuth2Scopes?: string[];
   securitySource?: any | (() => Promise<any>);
+  retryConfig: RetryConfig;
+  resolvedSecurity: SecurityState | null;
 };
 
 export type Awaitable<T> = T | Promise<T>;

package/src/lib/config.ts

@@ -57,7 +57,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.1",
-  sdkVersion: "0.44.0",
-  genVersion: "2.442.11",
-  userAgent: "speakeasy-sdk/typescript 0.44.0 2.442.11 0.0.1 dub",
+  sdkVersion: "0.45.1",
+  genVersion: "2.457.2",
+  userAgent: "speakeasy-sdk/typescript 0.45.1 2.457.2 0.0.1 dub",
 } as const;

package/src/lib/primitives.ts

@@ -2,6 +2,26 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+class InvariantError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvariantError";
+  }
+}
+
+export function invariant(
+  condition: unknown,
+  message: string,
+): asserts condition {
+  if (!condition) {
+    throw new InvariantError(message);
+  }
+}
+
+export type ExactPartial<T> = {
+  [P in keyof T]?: T[P] | undefined;
+};
+
 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]

package/src/lib/retries.ts

@@ -26,23 +26,44 @@ export type RetryConfig =
       retryConnectionErrors?: boolean;
     };
 
-class PermanentError extends Error {
-  inner: unknown;
+/**
+ * PermanentError is an error that is not recoverable. Throwing this error will
+ * cause a retry loop to terminate.
+ */
+export class PermanentError extends Error {
+  /** The underlying cause of the error. */
+  override readonly cause: unknown;
+
+  constructor(message: string, options?: { cause?: unknown }) {
+    let msg = message;
+    if (options?.cause) {
+      msg += `: ${options.cause}`;
+    }
 
-  constructor(inner: unknown) {
-    super("Permanent error");
-    this.inner = inner;
+    super(msg, options);
+    this.name = "PermanentError";
+    // In older runtimes, the cause field would not have been assigned through
+    // the super() call.
+    if (typeof this.cause === "undefined") {
+      this.cause = options?.cause;
+    }
 
     Object.setPrototypeOf(this, PermanentError.prototype);
   }
 }
 
-class TemporaryError extends Error {
-  res: Response;
+/**
+ * TemporaryError is an error is used to signal that an HTTP request can be
+ * retried as part of a retry loop. If retry attempts are exhausted and this
+ * error is thrown, the response will be returned to the caller.
+ */
+export class TemporaryError extends Error {
+  response: Response;
 
-  constructor(res: Response) {
-    super("Temporary error");
-    this.res = res;
+  constructor(message: string, response: Response) {
+    super(message);
+    this.response = response;
+    this.name = "TemporaryError";
 
     Object.setPrototypeOf(this, TemporaryError.prototype);
   }
@@ -80,11 +101,14 @@ function wrapFetcher(
     try {
       const res = await fn();
       if (isRetryableResponse(res, options.statusCodes)) {
-        throw new TemporaryError(res);
+        throw new TemporaryError(
+          "Response failed with retryable status code",
+          res,
+        );
       }
 
       return res;
-    } catch (err) {
+    } catch (err: unknown) {
       if (err instanceof TemporaryError) {
         throw err;
       }
@@ -96,7 +120,7 @@ function wrapFetcher(
         throw err;
       }
 
-      throw new PermanentError(err);
+      throw new PermanentError("Permanent error", { cause: err });
     }
   };
 }
@@ -139,37 +163,25 @@ async function retryBackoff(
     try {
       const res = await fn();
       return res;
-    } catch (err) {
+    } catch (err: unknown) {
       if (err instanceof PermanentError) {
-        throw err.inner;
+        throw err.cause;
       }
       const elapsed = Date.now() - start;
       if (elapsed > maxElapsedTime) {
         if (err instanceof TemporaryError) {
-          return err.res;
+          return err.response;
         }
 
         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 (err instanceof TemporaryError) {
+        retryInterval = retryIntervalFromResponse(err.response);
       }
 
-      if (retryInterval == 0) {
+      if (retryInterval <= 0) {
         retryInterval =
           initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
       }
@@ -182,6 +194,26 @@ async function retryBackoff(
   }
 }
 
+function retryIntervalFromResponse(res: Response): number {
+  const retryVal = res.headers.get("retry-after") || "";
+  if (!retryVal) {
+    return 0;
+  }
+
+  const parsedNumber = Number(retryVal);
+  if (Number.isInteger(parsedNumber)) {
+    return parsedNumber * 1000;
+  }
+
+  const parsedDate = Date.parse(retryVal);
+  if (Number.isInteger(parsedDate)) {
+    const deltaMS = parsedDate - Date.now();
+    return deltaMS > 0 ? Math.ceil(deltaMS) : 0;
+  }
+
+  return 0;
+}
+
 async function delay(delay: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, delay));
 }