@01.software/sdk 0.41.1 → 0.42.0

package/dist/index.cjs

@@ -22,7 +22,6 @@ var src_exports = {};
 __export(src_exports, {
   ApiError: () => ApiError,
   AuthError: () => AuthError,
-  BaseApi: () => BaseApi,
   COLLECTIONS: () => COLLECTIONS,
   COMMERCE_NOTIFICATION_EVENTS: () => COMMERCE_NOTIFICATION_EVENTS,
   COMMERCE_NOTIFICATION_EVENT_TYPE: () => COMMERCE_NOTIFICATION_EVENT_TYPE,
@@ -36,7 +35,6 @@ __export(src_exports, {
   ContentClient: () => ContentClient,
   CustomerAuth: () => CustomerAuth,
   CustomerNamespace: () => CustomerNamespace,
-  DiscountApi: () => DiscountApi,
   EventsClient: () => EventsClient,
   GoneError: () => GoneError,
   IMAGE_SIZES: () => IMAGE_SIZES,
@@ -44,12 +42,10 @@ __export(src_exports, {
   NetworkError: () => NetworkError,
   NotFoundError: () => NotFoundError,
   ORDER_CHANGED_EVENT_TYPE: () => ORDER_CHANGED_EVENT_TYPE,
-  OrderApi: () => OrderApi,
   PRODUCT_PLP_FIND_OPTIONS: () => PRODUCT_PLP_FIND_OPTIONS,
   PRODUCT_UPSERT_READONLY_FIELD_REASON: () => PRODUCT_UPSERT_READONLY_FIELD_REASON,
   PRODUCT_UPSERT_UNKNOWN_FIELD_REASON: () => PRODUCT_UPSERT_UNKNOWN_FIELD_REASON,
   PermissionError: () => PermissionError,
-  ProductApi: () => ProductApi,
   ProductSelectionCodecError: () => ProductSelectionCodecError,
   RateLimitError: () => RateLimitError,
   RealtimeConnection: () => RealtimeConnection,
@@ -57,7 +53,6 @@ __export(src_exports, {
   SERVER_COLLECTIONS: () => SERVER_COLLECTIONS,
   SERVER_ONLY_COLLECTIONS: () => SERVER_ONLY_COLLECTIONS,
   ServiceUnavailableError: () => ServiceUnavailableError,
-  ShippingApi: () => ShippingApi,
   TimeoutError: () => TimeoutError,
   UsageLimitError: () => UsageLimitError,
   ValidationError: () => ValidationError,
@@ -360,6 +355,14 @@ var createValidationError = (message, details, userMessage, suggestion, status)
 var createApiError = (message, status, details, userMessage, suggestion, requestId) => new ApiError(message, status, details, userMessage, suggestion, requestId);
 var createConfigError = (message, details, userMessage, suggestion) => new ConfigError(message, details, userMessage, suggestion);
 var createTimeoutError = (message, details, userMessage, suggestion) => new TimeoutError(message, details, userMessage, suggestion);
+var createGoneError = (message, details, userMessage, suggestion) => new GoneError(message, details, userMessage, suggestion);
+var createServiceUnavailableError = (message, retryAfter, details, userMessage, suggestion) => new ServiceUnavailableError(
+  message,
+  retryAfter,
+  details,
+  userMessage,
+  suggestion
+);
 var createUsageLimitError = (message, usage, details, userMessage, suggestion) => new UsageLimitError(message, usage, details, userMessage, suggestion);
 var createAuthError = (message, details, userMessage, suggestion, requestId) => new AuthError(message, details, userMessage, suggestion, requestId);
 var createPermissionError = (message, details, userMessage, suggestion, requestId) => new PermissionError(message, details, userMessage, suggestion, requestId);
@@ -384,7 +387,7 @@ function requirePublishableKeyForSecret(apiName, publishableKey, secretKey) {
   return publishableKey ?? "";
 }
 
-// src/core/client/types.ts
+// src/core/internal/utils/api-url.ts
 function resolveApiUrl(apiUrl) {
   if (apiUrl) {
     return apiUrl.replace(/\/$/, "");
@@ -401,7 +404,7 @@ function resolveApiUrl(apiUrl) {
 // src/core/internal/utils/http.ts
 var DEFAULT_TIMEOUT = 3e4;
 var STOREFRONT_BROWSER_TIMEOUT = 15e3;
-var DEFAULT_RETRYABLE_STATUSES = [408, 429, 500, 502, 503, 504];
+var DEFAULT_RETRYABLE_STATUSES = [408, 500, 502, 503, 504];
 var NON_RETRYABLE_STATUSES = [400, 401, 403, 404, 409, 422];
 var SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
 var DEFAULT_MAX_RETRIES = 3;
@@ -518,7 +521,12 @@ function attachRequestId(err, id) {
   if (id) err.requestId = id;
   return err;
 }
-function createHttpStatusError(status, parsed, details, requestId) {
+function parseRetryAfter(response) {
+  const raw = response.headers.get("Retry-After");
+  if (!raw) return void 0;
+  return parseInt(raw, 10) || void 0;
+}
+function mapResponseToError(status, parsed, details, requestId, retryAfter) {
   const errorDetails = {
     ...details,
     ...parsed.errors && { errors: parsed.errors },
@@ -581,6 +589,41 @@ function createHttpStatusError(status, parsed, details, requestId) {
       requestId
     );
   }
+  if (status === 410) {
+    return attachRequestId(
+      createGoneError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 429) {
+    return attachRequestId(
+      createRateLimitError(
+        parsed.errorMessage,
+        retryAfter,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 503) {
+    return attachRequestId(
+      createServiceUnavailableError(
+        parsed.errorMessage,
+        retryAfter,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
   return attachRequestId(
     createNetworkError(
       parsed.errorMessage,
@@ -699,26 +742,17 @@ async function httpFetch(url, options) {
           method: requestInit.method || "GET",
           attempt: attempt + 1
         };
-        if (NON_RETRYABLE_STATUSES.includes(response.status)) {
-          throw createHttpStatusError(
-            response.status,
-            parsed,
-            details,
-            requestId
-          );
-        }
-        const error = attachRequestId(
-          createNetworkError(
-            parsed.errorMessage,
-            response.status,
-            details,
-            parsed.userMessage,
-            getErrorSuggestion(response.status)
-          ),
-          requestId
+        const retryAfter = parseRetryAfter(response);
+        const error = mapResponseToError(
+          response.status,
+          parsed,
+          details,
+          requestId,
+          retryAfter
         );
         const method2 = (requestInit.method || "GET").toUpperCase();
-        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method2) && retryConfig.retryableStatuses.includes(response.status)) {
+        const isTerminal = error instanceof RateLimitError || error instanceof UsageLimitError;
+        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method2) && !isTerminal && !NON_RETRYABLE_STATUSES.includes(response.status) && retryConfig.retryableStatuses.includes(response.status)) {
           lastError = error;
           const retryDelay = retryConfig.retryDelay(attempt);
           debugLog(debug, "error", `Retrying in ${retryDelay}ms...`, error);
@@ -809,9 +843,6 @@ function productDetailCatalogQuery(params) {
   }
   return `/api/products/detail/catalog?${search}`;
 }
-function listingGroupsQuery(params) {
-  return `/api/products/listing-groups?ids=${params.productIds.map(encodeURIComponent).join(",")}`;
-}
 function listingGroupsCatalogQuery(params) {
   return `/api/products/listing-groups/catalog?ids=${params.productIds.map(encodeURIComponent).join(",")}`;
 }
@@ -1738,81 +1769,126 @@ var CustomerNamespace = class {
   }
 };
 
+// src/core/api/endpoints.ts
+var COMMERCE_ENDPOINTS = {
+  orders: {
+    create: "/api/orders/create",
+    update: "/api/orders/update",
+    confirmPayment: "/api/orders/confirm-payment",
+    byPayment: "/api/orders/by-payment",
+    cancel: "/api/orders/cancel",
+    resolveCancelRefund: "/api/orders/resolve-cancel-refund",
+    checkout: "/api/orders/checkout",
+    createFulfillment: "/api/orders/create-fulfillment",
+    updateFulfillment: "/api/orders/update-fulfillment"
+  },
+  transactions: {
+    update: "/api/transactions/update"
+  },
+  returns: {
+    create: "/api/returns/create",
+    update: "/api/returns/update",
+    returnRefund: "/api/returns/return-refund"
+  },
+  fulfillmentOrders: {
+    prepare: "/api/fulfillment-orders/prepare-fulfillment-order"
+  },
+  fulfillments: {
+    bulkImport: "/api/fulfillments/bulk-import"
+  },
+  carts: {
+    mine: "/api/carts/mine",
+    merge: "/api/carts/merge",
+    addItem: "/api/carts/add-item",
+    updateItem: "/api/carts/update-item",
+    removeItem: "/api/carts/remove-item",
+    applyDiscount: "/api/carts/apply-discount",
+    removeDiscount: "/api/carts/remove-discount",
+    clear: "/api/carts/clear"
+  }
+};
+var COMMERCE_ENDPOINT_PATHS = Object.values(
+  COMMERCE_ENDPOINTS
+).flatMap((group) => Object.values(group));
+
 // src/core/api/cart-api.ts
 var CartApi = class extends CustomerScopedApi {
   constructor(options) {
-    super("CartApi", options);
+    super("CartApi", { ...options, requiresCredential: false });
   }
   async execute(endpoint, method, body) {
     return this.request(endpoint, { method, body });
   }
-  getCart(cartId) {
+  /**
+   * Create a cart and receive its `cartToken`. Store the token and pass it to
+   * every subsequent cart operation.
+   */
+  createCart(params = {}) {
+    return this.execute("/api/carts/create", "POST", params);
+  }
+  getCart(cartToken) {
+    return this.execute("/api/carts/get", "POST", { cartToken });
+  }
+  merge(params) {
     return this.execute(
-      `/api/carts/${cartId}?depth=0&joins=false`,
-      "GET"
+      COMMERCE_ENDPOINTS.carts.merge,
+      "POST",
+      params
+    );
+  }
+  /**
+   * Resolve the authenticated customer's active cart by JWT (no `cartToken`
+   * required). Returns the cart and its capability handle, or both `null` when
+   * the customer has no active cart. Requires a customer token.
+   */
+  mine() {
+    return this.execute(
+      COMMERCE_ENDPOINTS.carts.mine,
+      "POST",
+      {}
     );
   }
   addItem(params) {
-    return this.execute("/api/carts/add-item", "POST", params);
+    return this.execute(
+      COMMERCE_ENDPOINTS.carts.addItem,
+      "POST",
+      params
+    );
   }
   updateItem(params) {
-    return this.execute("/api/carts/update-item", "POST", params);
+    return this.execute(
+      COMMERCE_ENDPOINTS.carts.updateItem,
+      "POST",
+      params
+    );
   }
   removeItem(params) {
     return this.execute(
-      "/api/carts/remove-item",
+      COMMERCE_ENDPOINTS.carts.removeItem,
       "POST",
       params
     );
   }
   applyDiscount(params) {
-    return this.execute("/api/carts/apply-discount", "POST", params);
+    return this.execute(
+      COMMERCE_ENDPOINTS.carts.applyDiscount,
+      "POST",
+      params
+    );
   }
   removeDiscount(params) {
-    return this.execute("/api/carts/remove-discount", "POST", params);
-  }
-  clearCart(params) {
     return this.execute(
-      "/api/carts/clear",
+      COMMERCE_ENDPOINTS.carts.removeDiscount,
       "POST",
       params
     );
   }
-};
-
-// src/core/api/base-api.ts
-var BaseApi = class {
-  constructor(apiName, options) {
-    if (!options.secretKey) {
-      throw createConfigError(`secretKey is required for ${apiName}.`);
-    }
-    this.publishableKey = requirePublishableKeyForSecret(
-      apiName,
-      options.publishableKey,
-      options.secretKey
+  clearCart(params) {
+    return this.execute(
+      COMMERCE_ENDPOINTS.carts.clear,
+      "POST",
+      params
     );
-    this.secretKey = options.secretKey;
-    this.apiUrl = options.apiUrl;
-    this.onRequestId = options.onRequestId;
-  }
-  async request(endpoint, body, options) {
-    const method = options?.method ?? "POST";
-    try {
-      const response = await httpFetch(endpoint, {
-        method,
-        apiUrl: this.apiUrl,
-        publishableKey: this.publishableKey,
-        secretKey: this.secretKey,
-        ...body !== void 0 && { body: JSON.stringify(body) },
-        ...options?.headers && { headers: options.headers }
-      });
-      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return parseApiResponse(response, endpoint);
-    } catch (err) {
-      const id = err instanceof SDKError ? err.requestId ?? null : null;
-      this.onRequestId?.(id);
-      throw err;
-    }
   }
 };
 
@@ -3261,6 +3337,7 @@ function compareVariantOrder(a, b) {
 function getVariantAvailableForSale(variant) {
   if (variant.isActive === false) return false;
   if (variant.isUnlimited) return true;
+  if (variant.inventoryPolicy === "continue") return true;
   return (variant.stock ?? 0) - (variant.reservedStock ?? 0) > 0;
 }
 function getVariantAvailableStock(variant) {
@@ -3621,37 +3698,6 @@ function withProductListingCards(response, options) {
     cards: response.docs.map((item) => buildProductListingCard(item, options))
   };
 }
-function rejectLegacyOptionValueSwatchColor(value) {
-  if (Object.prototype.hasOwnProperty.call(
-    value,
-    "swatchColor"
-  )) {
-    throw new TypeError(
-      'Product upsert option values no longer accept removed flat "swatchColor"; use nested "swatch" instead.'
-    );
-  }
-}
-function normalizeProductUpsertOptionValue(value) {
-  rejectLegacyOptionValueSwatchColor(value);
-  return value;
-}
-function normalizeProductUpsertParams(params) {
-  const options = params.options ?? [];
-  const variants = params.variants ?? [];
-  if (!options.length) {
-    return { ...params, options, variants };
-  }
-  return {
-    ...params,
-    options: options.map((option) => ({
-      ...option,
-      values: option.values.map(
-        (value) => normalizeProductUpsertOptionValue(value)
-      )
-    })),
-    variants
-  };
-}
 var PRODUCT_UPSERT_UNKNOWN_FIELD_REASON = "unknown_field";
 var PRODUCT_UPSERT_READONLY_FIELD_REASON = "product_field_readonly";
 function isProductUpsertFieldValidationErrorBody(value) {
@@ -3660,98 +3706,6 @@ function isProductUpsertFieldValidationErrorBody(value) {
   const reason = body.reason;
   return typeof body.error === "string" && typeof body.field === "string" && (reason === PRODUCT_UPSERT_UNKNOWN_FIELD_REASON || reason === PRODUCT_UPSERT_READONLY_FIELD_REASON);
 }
-var ProductApi = class extends BaseApi {
-  constructor(options) {
-    super("ProductApi", options);
-  }
-  /**
-   * Check point-in-time stock availability for one or more product variants.
-   * Results reflect available stock at the moment of the call and are not guaranteed
-   * to remain available by the time an order is placed.
-   */
-  stockCheck(params) {
-    return this.request("/api/products/stock-check", params);
-  }
-  stockSnapshot(params) {
-    return this.request(
-      stockSnapshotQuery(params),
-      void 0,
-      { method: "GET" }
-    );
-  }
-  listingGroups(params) {
-    return this.request(
-      listingGroupsQuery(params),
-      void 0,
-      { method: "GET" }
-    );
-  }
-  listingGroupsCatalog(params) {
-    return this.request(
-      listingGroupsCatalogQuery(params),
-      void 0,
-      { method: "GET" }
-    );
-  }
-  async listingPage(params = {}) {
-    if (params.mode === "full") {
-      const response2 = await this.request(buildProductListingPageUrl(params), void 0, { method: "GET" });
-      return withProductListingCards(response2, params);
-    }
-    const response = await this.request(buildProductListingPageUrl(params), void 0, { method: "GET" });
-    return withProductListingCards(response, params);
-  }
-  /**
-   * Fetch full product detail by slug or id.
-   * Returns a discriminated result so storefronts can distinguish missing,
-   * unpublished, and feature-disabled products.
-   *
-   * Only product-detail 404 responses carrying one of those allowlisted reasons
-   * are mapped to `{ found: false, reason }`. Unknown or uncoded 404s, plus
-   * permission/auth errors such as tenant mismatch, continue to throw typed SDK
-   * errors instead of being collapsed into a storefront absence result.
-   */
-  async detail(params) {
-    try {
-      const product = await this.request(
-        productDetailQuery(params),
-        void 0,
-        { method: "GET" }
-      );
-      return { found: true, product };
-    } catch (err) {
-      const notFoundResult = productDetailResultFromError(err);
-      if (notFoundResult) return notFoundResult;
-      throw err;
-    }
-  }
-  async detailCatalog(params) {
-    try {
-      const product = await this.request(
-        productDetailCatalogQuery(params),
-        void 0,
-        { method: "GET" }
-      );
-      return { found: true, product };
-    } catch (err) {
-      const notFoundResult = productDetailResultFromError(err);
-      if (notFoundResult?.found === false) return notFoundResult;
-      throw err;
-    }
-  }
-  /**
-   * Atomically create or update a product together with its options,
-   * option-values, and variants in a single transaction. Mirrors Shopify's
-   * `productSet` shape and is the canonical write path for the MCP
-   * `product-upsert` tool.
-   */
-  upsert(params) {
-    return this.request(
-      "/api/products/upsert",
-      normalizeProductUpsertParams(params)
-    );
-  }
-};
 
 // src/core/api/order-api.ts
 function idempotencyRequestOptions(idempotencyKey) {
@@ -3761,126 +3715,6 @@ function splitIdempotencyKey(params) {
   const { idempotencyKey, ...body } = params;
   return { body, idempotencyKey };
 }
-function normalizeCreateOrderBody(params) {
-  if (params.items !== void 0) {
-    const { idempotencyKey: _idempotencyKey2, items, ...rest } = params;
-    return { ...rest, orderItems: items };
-  }
-  const { idempotencyKey: _idempotencyKey, ...body } = params;
-  return body;
-}
-var OrderApi = class extends BaseApi {
-  constructor(options) {
-    super("OrderApi", options);
-  }
-  createOrder(params) {
-    const { idempotencyKey } = params;
-    const normalizedBody = normalizeCreateOrderBody(params);
-    return this.request(
-      "/api/orders/create",
-      normalizedBody,
-      idempotencyRequestOptions(idempotencyKey)
-    );
-  }
-  updateOrder(params) {
-    return this.request("/api/orders/update", params);
-  }
-  updateTransaction(params) {
-    return this.request("/api/transactions/update", params);
-  }
-  confirmPayment(params) {
-    const { body, idempotencyKey } = splitIdempotencyKey(params);
-    const headerKey = idempotencyKey ?? params.providerEventId;
-    return this.request(
-      "/api/orders/confirm-payment",
-      body,
-      idempotencyRequestOptions(headerKey)
-    );
-  }
-  cancelOrder(params) {
-    const { idempotencyKey } = params;
-    const body = {
-      orderNumber: params.orderNumber,
-      reasonCode: params.reasonCode,
-      reasonDetail: params.reasonDetail
-    };
-    return this.request(
-      "/api/orders/cancel",
-      body,
-      idempotencyKey ? { headers: { "X-Idempotency-Key": idempotencyKey } } : void 0
-    );
-  }
-  resolveCancelRefund(params) {
-    return this.request(
-      "/api/orders/resolve-cancel-refund",
-      {
-        orderNumber: params.orderNumber,
-        idempotencyKey: params.idempotencyKey,
-        outcome: params.outcome,
-        refundedAmount: params.refundedAmount,
-        pgProvider: params.pgProvider,
-        ...params.pgRefundId ? { pgRefundId: params.pgRefundId } : {}
-      },
-      idempotencyRequestOptions(params.idempotencyKey)
-    );
-  }
-  /**
-   * Returns a `PublicOrder`-compatible shape even when the server backs the
-   * response with a Checkout (checkout/order separation, #1285). `orderNumber`
-   * stays the stable cross-window key. A breaking `PublicCheckout` split is a
-   * deferred follow-up (design D10 / Q3-b); do not change this return type here.
-   */
-  checkout(params) {
-    const { body, idempotencyKey } = splitIdempotencyKey(params);
-    return this.request(
-      "/api/orders/checkout",
-      body,
-      idempotencyRequestOptions(idempotencyKey)
-    );
-  }
-  createFulfillment(params) {
-    const { body, idempotencyKey } = splitIdempotencyKey(params);
-    return this.request(
-      "/api/orders/create-fulfillment",
-      body,
-      idempotencyRequestOptions(idempotencyKey)
-    );
-  }
-  prepareFulfillmentOrder(params) {
-    return this.request(
-      "/api/fulfillment-orders/prepare-fulfillment-order",
-      params
-    );
-  }
-  updateFulfillment(params) {
-    return this.request("/api/orders/update-fulfillment", params);
-  }
-  bulkImportFulfillments(params) {
-    return this.request(
-      "/api/fulfillments/bulk-import",
-      params
-    );
-  }
-  returnWithRefund(params) {
-    const { body, idempotencyKey } = splitIdempotencyKey(params);
-    return this.request(
-      "/api/returns/return-refund",
-      body,
-      idempotencyRequestOptions(idempotencyKey)
-    );
-  }
-  createReturn(params) {
-    const { body, idempotencyKey } = splitIdempotencyKey(params);
-    return this.request(
-      "/api/returns/create",
-      body,
-      idempotencyRequestOptions(idempotencyKey)
-    );
-  }
-  updateReturn(params) {
-    return this.request("/api/returns/update", params);
-  }
-};
 
 // src/core/commerce/commerce-client.ts
 var BrowserCommerceApi = class extends CustomerScopedApi {
@@ -3952,13 +3786,16 @@ var CommerceClient = class {
       }
     };
     this.cart = {
+      create: cartApi.createCart.bind(cartApi),
       get: cartApi.getCart.bind(cartApi),
       addItem: cartApi.addItem.bind(cartApi),
       updateItem: cartApi.updateItem.bind(cartApi),
       removeItem: cartApi.removeItem.bind(cartApi),
       applyDiscount: cartApi.applyDiscount.bind(cartApi),
       removeDiscount: cartApi.removeDiscount.bind(cartApi),
-      clear: cartApi.clearCart.bind(cartApi)
+      clear: cartApi.clearCart.bind(cartApi),
+      merge: cartApi.merge.bind(cartApi),
+      mine: cartApi.mine.bind(cartApi)
     };
     this.orders = {
       checkout: (params) => {
@@ -4164,26 +4001,6 @@ function createClient(options) {
   return new Client(options);
 }
 
-// src/core/api/discount-api.ts
-var DiscountApi = class extends BaseApi {
-  constructor(options) {
-    super("DiscountApi", options);
-  }
-  validate(params) {
-    return this.request("/api/discounts/validate", params);
-  }
-};
-
-// src/core/api/shipping-api.ts
-var ShippingApi = class extends BaseApi {
-  constructor(options) {
-    super("ShippingApi", options);
-  }
-  calculate(params) {
-    return this.request("/api/shipping-policies/calculate", params);
-  }
-};
-
 // src/core/commerce/merge-catalog-stock.ts
 function mergeProductDetailWithStock(catalog, snapshot) {
   const snapshotByVariantId = new Map(