ce-storefront 0.1.0 → 0.2.1

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]
@@ -38,3 +58,65 @@ export function remap<
 
   return out;
 }
+
+export function combineSignals(
+  ...signals: Array<AbortSignal | null | undefined>
+): AbortSignal | null {
+  const filtered: AbortSignal[] = [];
+  for (const signal of signals) {
+    if (signal) {
+      filtered.push(signal);
+    }
+  }
+
+  switch (filtered.length) {
+    case 0:
+    case 1:
+      return filtered[0] || null;
+    default:
+      if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
+        return AbortSignal.any(filtered);
+      }
+      return abortSignalAny(filtered);
+  }
+}
+
+export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController();
+  const result = controller.signal;
+  if (!signals.length) {
+    return controller.signal;
+  }
+
+  if (signals.length === 1) {
+    return signals[0] || controller.signal;
+  }
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal;
+    }
+  }
+
+  function abort(this: AbortSignal) {
+    controller.abort(this.reason);
+    clean();
+  }
+
+  const signalRefs: WeakRef<AbortSignal>[] = [];
+  function clean() {
+    for (const signalRef of signalRefs) {
+      const signal = signalRef.deref();
+      if (signal) {
+        signal.removeEventListener("abort", abort);
+      }
+    }
+  }
+
+  for (const signal of signals) {
+    signalRefs.push(new WeakRef(signal));
+    signal.addEventListener("abort", abort);
+  }
+
+  return result;
+}

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/lib/security.ts

@@ -4,6 +4,14 @@
 
 import * as components from "../models/components/index.js";
 
+type OAuth2PasswordFlow = {
+  username: string;
+  password?: string | undefined;
+  clientID: string;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
 export enum SecurityErrorCode {
   Incomplete = "incomplete",
   UnrecognisedSecurityType = "unrecognized_security_type",
@@ -37,6 +45,7 @@ export type SecurityState = {
   headers: Record<string, string>;
   queryParams: Record<string, string>;
   cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
 };
 
 type SecurityInputBasic = {
@@ -73,7 +82,18 @@ type SecurityInputOAuth2 = {
 
 type SecurityInputOAuth2ClientCredentials = {
   type: "oauth2:client_credentials";
-  value: string | null | undefined;
+  value:
+    | { clientID?: string | undefined; clientSecret?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
   fieldName: string;
 };
 
@@ -89,6 +109,7 @@ export type SecurityInput =
   | SecurityInputAPIKey
   | SecurityInputOAuth2
   | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
   | SecurityInputOIDC
   | SecurityInputCustom;
 
@@ -100,6 +121,7 @@ export function resolveSecurity(
     headers: {},
     queryParams: {},
     cookies: {},
+    oauth2: { type: "none" },
   };
 
   const option = options.find((opts) => {
@@ -110,6 +132,12 @@ export function resolveSecurity(
         return o.value.username != null || o.value.password != null;
       } else if (o.type === "http:custom") {
         return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        return o.value.clientID != null || o.value.clientSecret != null;
       } else if (typeof o.value === "string") {
         return !!o.value;
       } else {
@@ -152,6 +180,9 @@ export function resolveSecurity(
       case "oauth2":
         applyBearer(state, spec);
         break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
       case "oauth2:client_credentials":
         break;
       case "openIdConnect":
@@ -179,9 +210,13 @@ function applyBasic(
 
 function applyBearer(
   state: SecurityState,
-  spec: SecurityInputBearer | SecurityInputOAuth2 | SecurityInputOIDC,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
 ) {
-  if (spec.value == null) {
+  if (typeof spec.value !== "string" || !spec.value) {
     return;
   }
 
@@ -192,6 +227,7 @@ function applyBearer(
 
   state.headers[spec.fieldName] = value;
 }
+
 export function resolveGlobalSecurity(
   security: Partial<components.Security> | null | undefined,
 ): SecurityState | null {

package/src/models/components/analyticsevent.ts

@@ -3,7 +3,10 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const Type = {
   Track: "track",
@@ -133,6 +136,20 @@ export namespace Context$ {
   export type Outbound = Context$Outbound;
 }
 
+export function contextToJSON(context: Context): string {
+  return JSON.stringify(Context$outboundSchema.parse(context));
+}
+
+export function contextFromJSON(
+  jsonString: string,
+): SafeParseResult<Context, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Context$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Context' from JSON`,
+  );
+}
+
 /** @internal */
 export const Properties$inboundSchema: z.ZodType<
   Properties,
@@ -163,6 +180,20 @@ export namespace Properties$ {
   export type Outbound = Properties$Outbound;
 }
 
+export function propertiesToJSON(properties: Properties): string {
+  return JSON.stringify(Properties$outboundSchema.parse(properties));
+}
+
+export function propertiesFromJSON(
+  jsonString: string,
+): SafeParseResult<Properties, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Properties$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Properties' from JSON`,
+  );
+}
+
 /** @internal */
 export const AnalyticsEvent$inboundSchema: z.ZodType<
   AnalyticsEvent,
@@ -222,3 +253,17 @@ export namespace AnalyticsEvent$ {
   /** @deprecated use `AnalyticsEvent$Outbound` instead. */
   export type Outbound = AnalyticsEvent$Outbound;
 }
+
+export function analyticsEventToJSON(analyticsEvent: AnalyticsEvent): string {
+  return JSON.stringify(AnalyticsEvent$outboundSchema.parse(analyticsEvent));
+}
+
+export function analyticsEventFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsEvent' from JSON`,
+  );
+}

package/src/models/components/banktransfer.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const BankTransferTransactionType = {
   Payment: "payment",
@@ -213,3 +216,17 @@ export namespace BankTransfer$ {
   /** @deprecated use `BankTransfer$Outbound` instead. */
   export type Outbound = BankTransfer$Outbound;
 }
+
+export function bankTransferToJSON(bankTransfer: BankTransfer): string {
+  return JSON.stringify(BankTransfer$outboundSchema.parse(bankTransfer));
+}
+
+export function bankTransferFromJSON(
+  jsonString: string,
+): SafeParseResult<BankTransfer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BankTransfer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BankTransfer' from JSON`,
+  );
+}

package/src/models/components/business.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Business = {
   businessType: string;
@@ -66,3 +69,17 @@ export namespace Business$ {
   /** @deprecated use `Business$Outbound` instead. */
   export type Outbound = Business$Outbound;
 }
+
+export function businessToJSON(business: Business): string {
+  return JSON.stringify(Business$outboundSchema.parse(business));
+}
+
+export function businessFromJSON(
+  jsonString: string,
+): SafeParseResult<Business, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Business$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Business' from JSON`,
+  );
+}

package/src/models/components/cardpayment.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const TransactionType = {
   Payment: "payment",
@@ -235,3 +238,17 @@ export namespace CardPayment$ {
   /** @deprecated use `CardPayment$Outbound` instead. */
   export type Outbound = CardPayment$Outbound;
 }
+
+export function cardPaymentToJSON(cardPayment: CardPayment): string {
+  return JSON.stringify(CardPayment$outboundSchema.parse(cardPayment));
+}
+
+export function cardPaymentFromJSON(
+  jsonString: string,
+): SafeParseResult<CardPayment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CardPayment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CardPayment' from JSON`,
+  );
+}

package/src/models/components/cart.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   CartItem,
   CartItem$inboundSchema,
@@ -174,6 +177,20 @@ export namespace CartMetadata$ {
   export type Outbound = CartMetadata$Outbound;
 }
 
+export function cartMetadataToJSON(cartMetadata: CartMetadata): string {
+  return JSON.stringify(CartMetadata$outboundSchema.parse(cartMetadata));
+}
+
+export function cartMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<CartMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CartMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CartMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const Cart$inboundSchema: z.ZodType<Cart, z.ZodTypeDef, unknown> = z
   .object({
@@ -348,3 +365,17 @@ export namespace Cart$ {
   /** @deprecated use `Cart$Outbound` instead. */
   export type Outbound = Cart$Outbound;
 }
+
+export function cartToJSON(cart: Cart): string {
+  return JSON.stringify(Cart$outboundSchema.parse(cart));
+}
+
+export function cartFromJSON(
+  jsonString: string,
+): SafeParseResult<Cart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Cart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Cart' from JSON`,
+  );
+}

package/src/models/components/cartitem.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Type of tax applied (e.g., GST).
@@ -276,3 +279,17 @@ export namespace CartItem$ {
   /** @deprecated use `CartItem$Outbound` instead. */
   export type Outbound = CartItem$Outbound;
 }
+
+export function cartItemToJSON(cartItem: CartItem): string {
+  return JSON.stringify(CartItem$outboundSchema.parse(cartItem));
+}
+
+export function cartItemFromJSON(
+  jsonString: string,
+): SafeParseResult<CartItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CartItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CartItem' from JSON`,
+  );
+}

package/src/models/components/country.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Country list model
@@ -88,3 +91,17 @@ export namespace Country$ {
   /** @deprecated use `Country$Outbound` instead. */
   export type Outbound = Country$Outbound;
 }
+
+export function countryToJSON(country: Country): string {
+  return JSON.stringify(Country$outboundSchema.parse(country));
+}
+
+export function countryFromJSON(
+  jsonString: string,
+): SafeParseResult<Country, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Country$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Country' from JSON`,
+  );
+}

package/src/models/components/countrystate.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Country wise states model
@@ -65,3 +68,17 @@ export namespace CountryState$ {
   /** @deprecated use `CountryState$Outbound` instead. */
   export type Outbound = CountryState$Outbound;
 }
+
+export function countryStateToJSON(countryState: CountryState): string {
+  return JSON.stringify(CountryState$outboundSchema.parse(countryState));
+}
+
+export function countryStateFromJSON(
+  jsonString: string,
+): SafeParseResult<CountryState, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CountryState$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CountryState' from JSON`,
+  );
+}