@steamsets/client-ts 0.12.8 → 0.13.0

package/src/funcs/settingsSendEmailVerification.ts

@@ -65,12 +65,27 @@ export async function settingsSendEmailVerification(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "account.v1.settings.send-email-verification",
     oAuth2Scopes: [],
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -89,19 +104,8 @@ export async function settingsSendEmailVerification(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["404", "422", "429", "4XX", "500", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig
-      || {
-        strategy: "backoff",
-        backoff: {
-          initialInterval: 500,
-          maxInterval: 60000,
-          exponent: 1.5,
-          maxElapsedTime: 3600000,
-        },
-        retryConnectionErrors: true,
-      },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/settingsUpdate.ts

@@ -67,12 +67,27 @@ export async function settingsUpdate(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "account.v1.settings.update",
     oAuth2Scopes: [],
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -91,19 +106,8 @@ export async function settingsUpdate(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["422", "429", "4XX", "500", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig
-      || {
-        strategy: "backoff",
-        backoff: {
-          initialInterval: 500,
-          maxInterval: 60000,
-          exponent: 1.5,
-          maxElapsedTime: 3600000,
-        },
-        retryConnectionErrors: true,
-      },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/settingsUpdateImage.ts

@@ -60,12 +60,27 @@ export async function settingsUpdateImage(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "account.v1.settings.update-image",
     oAuth2Scopes: [],
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -84,19 +99,8 @@ export async function settingsUpdateImage(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["404", "422", "4XX", "500", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig
-      || {
-        strategy: "backoff",
-        backoff: {
-          initialInterval: 500,
-          maxInterval: 60000,
-          exponent: 1.5,
-          maxElapsedTime: 3600000,
-        },
-        retryConnectionErrors: true,
-      },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/settingsUploadImages.ts

@@ -60,12 +60,27 @@ export async function settingsUploadImages(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "account.v1.settings.upload-images",
     oAuth2Scopes: [],
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -84,19 +99,8 @@ export async function settingsUploadImages(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["422", "4XX", "500", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig
-      || {
-        strategy: "backoff",
-        backoff: {
-          initialInterval: 500,
-          maxInterval: 60000,
-          exponent: 1.5,
-          maxElapsedTime: 3600000,
-        },
-        retryConnectionErrors: true,
-      },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/funcs/settingsVerifyEmail.ts

@@ -60,12 +60,27 @@ export async function settingsVerifyEmail(
 
   const secConfig = await extractSecurity(client._options.token);
   const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
   const context = {
     operationID: "account.v1.settings.verfy-email",
     oAuth2Scopes: [],
     securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
   };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
@@ -84,19 +99,8 @@ export async function settingsVerifyEmail(
   const doResult = await client._do(req, {
     context,
     errorCodes: ["404", "422", "429", "4XX", "500", "5XX"],
-    retryConfig: options?.retries
-      || client._options.retryConfig
-      || {
-        strategy: "backoff",
-        backoff: {
-          initialInterval: 500,
-          maxInterval: 60000,
-          exponent: 1.5,
-          maxElapsedTime: 3600000,
-        },
-        retryConnectionErrors: true,
-      },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
     return doResult;

package/src/hooks/types.ts

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

package/src/lib/config.ts

@@ -55,8 +55,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.12.8",
-  genVersion: "2.445.1",
+  sdkVersion: "0.13.0",
+  genVersion: "2.447.4",
   userAgent:
-    "speakeasy-sdk/typescript 0.12.8 2.445.1 1.0.0 @steamsets/client-ts",
+    "speakeasy-sdk/typescript 0.13.0 2.447.4 1.0.0 @steamsets/client-ts",
 } as const;

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));
 }

package/src/lib/sdks.ts

@@ -220,8 +220,8 @@ export class ClientSDK {
     options: {
       context: HookContext;
       errorCodes: number | string | (number | string)[];
-      retryConfig?: RetryConfig | undefined;
-      retryCodes?: string[] | undefined;
+      retryConfig: RetryConfig;
+      retryCodes: string[];
     },
   ): Promise<
     Result<
@@ -233,8 +233,6 @@ export class ClientSDK {
     >
   > {
     const { context, errorCodes } = options;
-    const retryConfig = options.retryConfig || { strategy: "none" };
-    const retryCodes = options.retryCodes || [];
 
     return retry(
       async () => {
@@ -245,22 +243,28 @@ export class ClientSDK {
 
         let response = await this.#httpClient.request(req);
 
-        if (matchStatusCode(response, errorCodes)) {
-          const result = await this.#hooks.afterError(context, response, null);
-          if (result.error) {
-            throw result.error;
+        try {
+          if (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);
           }
-          response = result.response || response;
-        } else {
-          response = await this.#hooks.afterSuccess(context, response);
+        } finally {
+          await logResponse(this.#logger, response, req)
+            .catch(e => this.#logger?.log("Failed to log response:", e));
         }
 
-        await logResponse(this.#logger, response, req)
-          .catch(e => this.#logger?.log("Failed to log response:", e));
-
         return response;
       },
-      { config: retryConfig, statusCodes: retryCodes },
+      { config: options.retryConfig, statusCodes: options.retryCodes },
     ).then(
       (r) => OK(r),
       (err) => {

package/src/models/components/chosenrole.ts

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const ChosenRoleRole = {
+  User: "user",
+  Donator: "donator",
+  Staff: "staff",
+  Developer: "developer",
+  Partner: "partner",
+  Owner: "owner",
+  Amethyst: "amethyst",
+  Amber: "amber",
+  Emerald: "emerald",
+  Sapphire: "sapphire",
+  Ruby: "ruby",
+  Diamond: "diamond",
+  Contributor: "contributor",
+  EarlySupporter: "early_supporter",
+  Beta: "beta",
+  Translator: "translator",
+  Top100: "top_100",
+  BadgeScout: "badge_scout",
+} as const;
+export type ChosenRoleRole = ClosedEnum<typeof ChosenRoleRole>;
+
+export type ChosenRole = {
+  role: ChosenRoleRole;
+  /**
+   * The tier of the donation
+   */
+  tier: string;
+};
+
+/** @internal */
+export const ChosenRoleRole$inboundSchema: z.ZodNativeEnum<
+  typeof ChosenRoleRole
+> = z.nativeEnum(ChosenRoleRole);
+
+/** @internal */
+export const ChosenRoleRole$outboundSchema: z.ZodNativeEnum<
+  typeof ChosenRoleRole
+> = ChosenRoleRole$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChosenRoleRole$ {
+  /** @deprecated use `ChosenRoleRole$inboundSchema` instead. */
+  export const inboundSchema = ChosenRoleRole$inboundSchema;
+  /** @deprecated use `ChosenRoleRole$outboundSchema` instead. */
+  export const outboundSchema = ChosenRoleRole$outboundSchema;
+}
+
+/** @internal */
+export const ChosenRole$inboundSchema: z.ZodType<
+  ChosenRole,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  role: ChosenRoleRole$inboundSchema,
+  tier: z.string(),
+});
+
+/** @internal */
+export type ChosenRole$Outbound = {
+  role: string;
+  tier: string;
+};
+
+/** @internal */
+export const ChosenRole$outboundSchema: z.ZodType<
+  ChosenRole$Outbound,
+  z.ZodTypeDef,
+  ChosenRole
+> = z.object({
+  role: ChosenRoleRole$outboundSchema,
+  tier: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChosenRole$ {
+  /** @deprecated use `ChosenRole$inboundSchema` instead. */
+  export const inboundSchema = ChosenRole$inboundSchema;
+  /** @deprecated use `ChosenRole$outboundSchema` instead. */
+  export const outboundSchema = ChosenRole$outboundSchema;
+  /** @deprecated use `ChosenRole$Outbound` instead. */
+  export type Outbound = ChosenRole$Outbound;
+}

package/src/models/components/index.ts

@@ -9,6 +9,7 @@ export * from "./accountsearch.js";
 export * from "./accountsearchidstruct.js";
 export * from "./accountsearchvanitystruct.js";
 export * from "./bestleaderboardrank.js";
+export * from "./chosenrole.js";
 export * from "./city.js";
 export * from "./colortag.js";
 export * from "./connection.js";

package/src/models/components/v1getsettingsbody.ts

@@ -5,6 +5,12 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { ClosedEnum } from "../../types/enums.js";
+import {
+  ChosenRole,
+  ChosenRole$inboundSchema,
+  ChosenRole$Outbound,
+  ChosenRole$outboundSchema,
+} from "./chosenrole.js";
 import {
   Connection,
   Connection$inboundSchema,
@@ -59,6 +65,7 @@ export type V1GetSettingsBody = {
    * A URL to the JSON Schema for this object.
    */
   dollarSchema?: string | undefined;
+  chosenRole: ChosenRole | null;
   /**
    * The color the account is using
    */
@@ -141,6 +148,7 @@ export const V1GetSettingsBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   $schema: z.string().optional(),
+  chosenRole: z.nullable(ChosenRole$inboundSchema),
   color: z.string(),
   colors: z.string(),
   connections: z.nullable(z.array(Connection$inboundSchema)),
@@ -166,6 +174,7 @@ export const V1GetSettingsBody$inboundSchema: z.ZodType<
 /** @internal */
 export type V1GetSettingsBody$Outbound = {
   $schema?: string | undefined;
+  chosenRole: ChosenRole$Outbound | null;
   color: string;
   colors: string;
   connections: Array<Connection$Outbound> | null;
@@ -189,6 +198,7 @@ export const V1GetSettingsBody$outboundSchema: z.ZodType<
   V1GetSettingsBody
 > = z.object({
   dollarSchema: z.string().optional(),
+  chosenRole: z.nullable(ChosenRole$outboundSchema),
   color: z.string(),
   colors: z.string(),
   connections: z.nullable(z.array(Connection$outboundSchema)),