@01.software/sdk 0.33.0 → 0.34.0

package/dist/client.cjs

@@ -218,9 +218,12 @@ 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 NON_RETRYABLE_STATUSES = [400, 401, 403, 404, 409, 422];
 var SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
+var DEFAULT_MAX_RETRIES = 3;
+var STOREFRONT_BROWSER_MAX_RETRIES = 1;
 function debugLog(debug, type, message, data) {
   if (!debug) return;
   const shouldLog = debug === true || type === "request" && debug.logRequests || type === "response" && debug.logResponses || type === "error" && debug.logErrors;
@@ -413,15 +416,18 @@ async function httpFetch(url, options) {
     publishableKey,
     secretKey,
     customerToken,
-    timeout = DEFAULT_TIMEOUT,
+    timeout: timeoutOption = DEFAULT_TIMEOUT,
     debug,
     retry,
     onUnauthorized,
     ...requestInit
   } = options || {};
   const baseUrl = resolveApiUrl(apiUrl);
+  const method = (requestInit.method || "GET").toUpperCase();
+  const isPublishableKeyBrowserGet = typeof window !== "undefined" && !secretKey && !customerToken && Boolean(publishableKey) && SAFE_METHODS.includes(method);
+  const timeout = timeoutOption === DEFAULT_TIMEOUT && isPublishableKeyBrowserGet ? STOREFRONT_BROWSER_TIMEOUT : timeoutOption;
   const retryConfig = {
-    maxRetries: retry?.maxRetries ?? 3,
+    maxRetries: retry?.maxRetries ?? (isPublishableKeyBrowserGet ? STOREFRONT_BROWSER_MAX_RETRIES : DEFAULT_MAX_RETRIES),
     retryableStatuses: retry?.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES,
     retryDelay: retry?.retryDelay ?? ((attempt) => Math.min(1e3 * 2 ** attempt, 1e4))
   };
@@ -529,8 +535,8 @@ async function httpFetch(url, options) {
           ),
           requestId
         );
-        const method = (requestInit.method || "GET").toUpperCase();
-        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method) && retryConfig.retryableStatuses.includes(response.status)) {
+        const method2 = (requestInit.method || "GET").toUpperCase();
+        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method2) && retryConfig.retryableStatuses.includes(response.status)) {
           lastError = error;
           const retryDelay = retryConfig.retryDelay(attempt);
           debugLog(debug, "error", `Retrying in ${retryDelay}ms...`, error);
@@ -542,8 +548,8 @@ async function httpFetch(url, options) {
       return response;
     } catch (error) {
       debugLog(debug, "error", url, error);
-      const method = (requestInit.method || "GET").toUpperCase();
-      const isSafe = SAFE_METHODS.includes(method);
+      const method2 = (requestInit.method || "GET").toUpperCase();
+      const isSafe = SAFE_METHODS.includes(method2);
       if (error instanceof Error && error.name === "AbortError") {
         const timeoutError = createTimeoutError(
           `Request timed out after ${timeout}ms.`,
@@ -602,6 +608,35 @@ async function httpFetch(url, options) {
   throw lastError ?? new NetworkError("Request failed after retries");
 }
 
+// src/core/internal/utils/query-string.ts
+function productDetailQuery(params) {
+  const search = new URLSearchParams();
+  if ("slug" in params) {
+    search.set("slug", params.slug);
+  } else {
+    search.set("id", params.id);
+  }
+  return `/api/products/detail?${search}`;
+}
+function productDetailCatalogQuery(params) {
+  const search = new URLSearchParams();
+  if ("slug" in params) {
+    search.set("slug", params.slug);
+  } else {
+    search.set("id", params.id);
+  }
+  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(",")}`;
+}
+function stockSnapshotQuery(params) {
+  return `/api/products/stock?variantIds=${params.variantIds.map(encodeURIComponent).join(",")}`;
+}
+
 // src/core/collection/http-client.ts
 var HttpClient = class {
   constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized, onRequestId, apiUrl) {
@@ -920,6 +955,8 @@ async function parseApiResponse(response, endpoint) {
 }
 
 // src/core/community/community-client.ts
+var DEFAULT_POST_LIST_SORT = "-lastActivityAt";
+var DEFAULT_COMMENT_LIST_SORT = "-createdAt";
 var CommunityClient = class {
   constructor(options) {
     this.publishableKey = requirePublishableKeyForSecret(
@@ -938,6 +975,40 @@ var CommunityClient = class {
     const entries = Object.entries(params).filter((e) => e[1] !== void 0).map(([k, v]) => [k, String(v)]);
     return entries.length ? `?${new URLSearchParams(entries).toString()}` : "";
   }
+  buildPostsListQuery(params) {
+    const urlParams = new URLSearchParams();
+    const sort = params?.sort ?? DEFAULT_POST_LIST_SORT;
+    urlParams.set("sort", sort);
+    if (params?.limit !== void 0) urlParams.set("limit", String(params.limit));
+    if (params?.page !== void 0) urlParams.set("page", String(params.page));
+    if (params?.categoryId !== void 0) {
+      urlParams.set("where[categories][in]", params.categoryId);
+    }
+    if (params?.tagId !== void 0) {
+      urlParams.set("where[tags][in]", params.tagId);
+    }
+    return `/api/posts?${urlParams.toString()}`;
+  }
+  buildCommentsListQuery(params) {
+    const urlParams = new URLSearchParams();
+    const sort = params.sort ?? DEFAULT_COMMENT_LIST_SORT;
+    urlParams.set("sort", sort);
+    if (params.postId !== void 0) {
+      urlParams.set("where[post][equals]", params.postId);
+    }
+    if (params.parentId !== void 0) {
+      urlParams.set("where[parent][equals]", params.parentId);
+    }
+    if (params.rootComment !== void 0) {
+      urlParams.set("where[rootComment][equals]", params.rootComment);
+    }
+    if (params.topLevelOnly) {
+      urlParams.set("where[parent][exists]", "false");
+    }
+    if (params.limit !== void 0) urlParams.set("limit", String(params.limit));
+    if (params.page !== void 0) urlParams.set("page", String(params.page));
+    return `/api/comments?${urlParams.toString()}`;
+  }
   async execute(endpoint, method, body) {
     const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
     try {
@@ -961,6 +1032,28 @@ var CommunityClient = class {
   createPost(params) {
     return this.execute("/api/posts", "POST", params);
   }
+  /**
+   * Public post feed. Server applies the same visibility contract as
+   * `communityPostRead` (published + visible + moderation-safe).
+   */
+  listPosts(params) {
+    return this.execute(
+      this.buildPostsListQuery(params),
+      "GET"
+    );
+  }
+  listPostCategories(params) {
+    return this.execute(
+      `/api/post-categories${this.buildQuery(params)}`,
+      "GET"
+    );
+  }
+  listPostTags(params) {
+    return this.execute(
+      `/api/post-tags${this.buildQuery(params)}`,
+      "GET"
+    );
+  }
   getMyPosts(params) {
     return this.execute(
       `/api/posts/my${this.buildQuery(params)}`,
@@ -996,16 +1089,37 @@ var CommunityClient = class {
     }
     return this.execute("/api/comments", "POST", body);
   }
+  /**
+   * List comments for a post.
+   *
+   * - Default: all visible comments on the post (any depth).
+   * - `topLevelOnly: true`: only root comments (`parent` unset).
+   * - `rootComment`: comments belonging to a thread rooted at that comment.
+   */
   listComments(params) {
-    const { postId, page, limit, rootComment } = params;
-    const urlParams = new URLSearchParams();
-    urlParams.set("where[post][equals]", postId);
-    urlParams.set("sort", "-createdAt");
-    if (limit !== void 0) urlParams.set("limit", String(limit));
-    if (page !== void 0) urlParams.set("page", String(page));
-    if (rootComment !== void 0) urlParams.set("where[rootComment][equals]", rootComment);
+    const { postId, page, limit, rootComment, topLevelOnly, sort } = params;
+    return this.execute(
+      this.buildCommentsListQuery({
+        postId,
+        page,
+        limit,
+        rootComment,
+        topLevelOnly,
+        sort
+      }),
+      "GET"
+    );
+  }
+  /** Direct replies to a comment (`where[parent][equals]`). */
+  listReplies(params) {
+    const { commentId, page, limit, sort } = params;
     return this.execute(
-      `/api/comments?${urlParams.toString()}`,
+      this.buildCommentsListQuery({
+        parentId: commentId,
+        page,
+        limit,
+        sort
+      }),
       "GET"
     );
   }
@@ -1033,10 +1147,18 @@ var CommunityClient = class {
   }
   // Reactions
   addReaction(params) {
-    const { postId, type } = params;
+    const { postId, typeSlug, type } = params;
+    const reactionType = typeSlug ?? type;
+    if (!reactionType) {
+      throw new SDKError(
+        "validation_failed",
+        "addReaction requires typeSlug (or deprecated type)",
+        400
+      );
+    }
     return this.execute("/api/reactions", "POST", {
       post: postId,
-      type
+      type: reactionType
     });
   }
   removeReaction(params) {
@@ -1047,10 +1169,18 @@ var CommunityClient = class {
     );
   }
   addCommentReaction(params) {
-    const { commentId, type } = params;
+    const { commentId, typeSlug, type } = params;
+    const reactionType = typeSlug ?? type;
+    if (!reactionType) {
+      throw new SDKError(
+        "validation_failed",
+        "addCommentReaction requires typeSlug (or deprecated type)",
+        400
+      );
+    }
     return this.execute("/api/reactions", "POST", {
       comment: commentId,
-      type
+      type: reactionType
     });
   }
   removeCommentReaction(params) {
@@ -1066,6 +1196,12 @@ var CommunityClient = class {
       "GET"
     );
   }
+  getCommentReactionSummary(params) {
+    return this.execute(
+      `/api/comments/${params.commentId}/reactions`,
+      "GET"
+    );
+  }
   getReactionTypes() {
     return this.execute(
       "/api/reaction-types?limit=100",
@@ -1090,6 +1226,25 @@ var CommunityClient = class {
       "GET"
     );
   }
+  // Profiles
+  listProfileLists(params) {
+    return this.execute(
+      `/api/customer-profile-lists${this.buildQuery(params)}`,
+      "GET"
+    );
+  }
+  async getProfileList(params) {
+    const query = "slug" in params ? `?where[slug][equals]=${encodeURIComponent(params.slug)}&limit=1` : `?where[id][equals]=${encodeURIComponent(params.id)}&limit=1`;
+    const res = await this.execute(`/api/customer-profile-lists${query}`, "GET");
+    return res.docs[0] ?? null;
+  }
+  updatePublicProfile(body) {
+    return this.execute(
+      "/api/customers/me/profile",
+      "PATCH",
+      body
+    );
+  }
 };
 
 // src/core/customer/customer-auth.ts
@@ -1399,6 +1554,15 @@ function productDetailResultFromError(error) {
   return { found: false, reason };
 }
 
+// src/core/api/order-api.ts
+function idempotencyRequestOptions(idempotencyKey) {
+  return idempotencyKey ? { headers: { "X-Idempotency-Key": idempotencyKey } } : void 0;
+}
+function splitIdempotencyKey(params) {
+  const { idempotencyKey, ...body } = params;
+  return { body, idempotencyKey };
+}
+
 // src/core/commerce/commerce-client.ts
 var CommerceClient = class {
   constructor(options) {
@@ -1409,7 +1573,7 @@ var CommerceClient = class {
       onUnauthorized: options.onUnauthorized,
       onRequestId: options.onRequestId
     });
-    const execute = async (endpoint, body) => {
+    const execute = async (endpoint, body, requestOptions) => {
       const token = options.customerToken();
       try {
         const response = await httpFetch(endpoint, {
@@ -1418,7 +1582,26 @@ var CommerceClient = class {
           publishableKey: options.publishableKey,
           customerToken: token ?? void 0,
           ...token && options.onUnauthorized && { onUnauthorized: options.onUnauthorized },
-          body: JSON.stringify(body)
+          body: JSON.stringify(body),
+          ...requestOptions?.headers && { headers: requestOptions.headers }
+        });
+        options.onRequestId?.(response.headers.get("x-request-id") ?? null);
+        return parseApiResponse(response, endpoint);
+      } catch (err) {
+        const id = err instanceof SDKError ? err.requestId ?? null : null;
+        options.onRequestId?.(id);
+        throw err;
+      }
+    };
+    const executeGet = async (endpoint) => {
+      const token = options.customerToken();
+      try {
+        const response = await httpFetch(endpoint, {
+          method: "GET",
+          apiUrl: options.apiUrl,
+          publishableKey: options.publishableKey,
+          customerToken: token ?? void 0,
+          ...token && options.onUnauthorized && { onUnauthorized: options.onUnauthorized }
         });
         options.onRequestId?.(response.headers.get("x-request-id") ?? null);
         return parseApiResponse(response, endpoint);
@@ -1430,19 +1613,30 @@ var CommerceClient = class {
     };
     this.product = {
       stockCheck: (params) => execute("/api/products/stock-check", params),
-      listingGroups: (params) => execute("/api/products/listing-groups", params),
+      stockSnapshot: (params) => executeGet(stockSnapshotQuery(params)),
+      listingGroups: (params) => executeGet(listingGroupsQuery(params)),
+      listingGroupsCatalog: (params) => executeGet(listingGroupsCatalogQuery(params)),
       detail: async (params) => {
         try {
-          const product = await execute(
-            "/api/products/detail",
-            params
-          );
+          const product = await executeGet(productDetailQuery(params));
           return { found: true, product };
         } catch (err) {
           const notFoundResult = productDetailResultFromError(err);
           if (notFoundResult) return notFoundResult;
           throw err;
         }
+      },
+      detailCatalog: async (params) => {
+        try {
+          const product = await executeGet(
+            productDetailCatalogQuery(params)
+          );
+          return { found: true, product };
+        } catch (err) {
+          const notFoundResult = productDetailResultFromError(err);
+          if (notFoundResult?.found === false) return notFoundResult;
+          throw err;
+        }
       }
     };
     this.cart = {
@@ -1455,7 +1649,14 @@ var CommerceClient = class {
       clear: cartApi.clearCart.bind(cartApi)
     };
     this.orders = {
-      checkout: (params) => execute("/api/orders/checkout", params),
+      checkout: (params) => {
+        const { body, idempotencyKey } = splitIdempotencyKey(params);
+        return execute(
+          "/api/orders/checkout",
+          body,
+          idempotencyRequestOptions(idempotencyKey)
+        );
+      },
       listMine: (params) => options.customerAuth.getMyOrders(params)
     };
     this.discounts = {
@@ -1467,6 +1668,113 @@ var CommerceClient = class {
   }
 };
 
+// src/core/events/events-client.ts
+var EventsClient = class {
+  constructor(options) {
+    const secretKey = options.secretKey;
+    this.publishableKey = requirePublishableKeyForSecret(
+      "EventsClient",
+      options.publishableKey,
+      secretKey
+    );
+    this.apiUrl = options.apiUrl;
+    this.customerToken = options.customerToken;
+    this.onUnauthorized = options.onUnauthorized;
+    this.onRequestId = options.onRequestId;
+  }
+  getRange(params) {
+    return this.execute(
+      buildRangeEndpoint(params),
+      "GET",
+      void 0,
+      { useCustomerAuth: false }
+    );
+  }
+  register(params) {
+    return this.execute(
+      "/api/event-registrations/register",
+      "POST",
+      buildRegistrationRequestBody(params),
+      { useCustomerAuth: true }
+    );
+  }
+  getGuestRegistration(token) {
+    return this.execute(
+      "/api/event-registrations/guest/lookup",
+      "POST",
+      { token },
+      { useCustomerAuth: false }
+    );
+  }
+  cancelGuestRegistration(token, params = {}) {
+    return this.execute(
+      "/api/event-registrations/guest/cancel",
+      "POST",
+      buildGuestCancelRequestBody(token, params),
+      { useCustomerAuth: false }
+    );
+  }
+  async execute(endpoint, method, body, options = {}) {
+    const useCustomerAuth = options.useCustomerAuth === true;
+    const token = useCustomerAuth ? typeof this.customerToken === "function" ? this.customerToken() : this.customerToken : void 0;
+    try {
+      const response = await httpFetch(endpoint, {
+        method,
+        apiUrl: this.apiUrl,
+        publishableKey: this.publishableKey,
+        ...useCustomerAuth && token ? { customerToken: token } : {},
+        ...useCustomerAuth && token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
+        ...body !== void 0 && { body: JSON.stringify(body) }
+      });
+      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;
+    }
+  }
+};
+function buildRegistrationRequestBody(params) {
+  return {
+    event: params.event,
+    occurrence: params.occurrence,
+    ...params.quantity !== void 0 && { quantity: params.quantity },
+    ...params.attendee !== void 0 && { attendee: params.attendee },
+    ...params.answers !== void 0 && { answers: params.answers }
+  };
+}
+function buildGuestCancelRequestBody(token, params) {
+  return {
+    token,
+    ...params.reason !== void 0 && { reason: params.reason }
+  };
+}
+function buildRangeEndpoint(params) {
+  const urlParams = new URLSearchParams();
+  urlParams.set("start", formatDateParam(params.start));
+  urlParams.set("end", formatDateParam(params.end));
+  if (params.limit !== void 0) urlParams.set("limit", String(params.limit));
+  if (params.page !== void 0) urlParams.set("page", String(params.page));
+  appendValues(urlParams, "calendar", params.calendar);
+  appendValues(urlParams, "calendarSlug", params.calendarSlug);
+  appendValues(urlParams, "category", params.category);
+  appendValues(urlParams, "categorySlug", params.categorySlug);
+  appendValues(urlParams, "tag", params.tag);
+  appendValues(urlParams, "tagSlug", params.tagSlug);
+  return `/api/event-occurrences/range?${urlParams.toString()}`;
+}
+function formatDateParam(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+function appendValues(params, key, value) {
+  if (value === void 0) return;
+  const values = Array.isArray(value) ? value : [value];
+  for (const entry of values) {
+    if (entry) params.append(key, entry);
+  }
+}
+
 // src/core/client/client.ts
 var Client = class {
   constructor(options) {
@@ -1512,6 +1820,13 @@ var Client = class {
       onUnauthorized,
       onRequestId
     });
+    this.events = new EventsClient({
+      publishableKey: this.config.publishableKey,
+      apiUrl: this.config.apiUrl,
+      customerToken: () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId
+    });
     this.collections = new ReadOnlyCollectionClient(
       this.config.publishableKey,
       void 0,