@thorprovider/adapters 4.3.0 → 5.0.1

package/dist/index.js

@@ -67,8 +67,11 @@ __export(src_exports, {
   buildChannelScopeMetadata: () => buildChannelScopeMetadata,
   calculateDistance: () => calculateDistance,
   createBackendMetadataAdapter: () => createBackendMetadataAdapter,
+  createFetchWithRetry: () => createFetchWithRetry,
   createLogger: () => createLogger,
   createProvider: () => createProvider,
+  extractErrorMessage: () => extractErrorMessage,
+  fetchWithRetry: () => fetchWithRetry,
   filterByChannel: () => filterByChannel,
   filterGlobalOnly: () => filterGlobalOnly,
   geocodeAddress: () => geocodeAddress,
@@ -617,6 +620,9 @@ async function fetchWithRetry(url, init, retryConfig) {
   }
   throw lastError;
 }
+function createFetchWithRetry(retryConfig) {
+  return (url, init) => fetchWithRetry(url, init, retryConfig);
+}
 
 // src/resilience/circuit-breaker.ts
 var CircuitBreaker = class {
@@ -1823,17 +1829,11 @@ var MedusaAuthProvider = class {
   logger;
   authConfig;
   storageManager;
-  /** Medusa backend base URL — needed for raw fetch calls */
-  baseUrl;
-  /** Publishable API key — sent as x-publishable-api-key on store calls */
-  publishableKey;
-  constructor(sdk, authConfig, debug = false, baseUrl = "", publishableKey = "") {
+  constructor(sdk, authConfig, debug = false) {
     this.sdk = sdk;
     this.authConfig = authConfig;
     this.logger = createLogger("MedusaAuthProvider", debug);
     this.storageManager = new AuthStorageManager(authConfig);
-    this.baseUrl = baseUrl;
-    this.publishableKey = publishableKey;
     this.logger.info("Medusa Auth Provider initialized", {
       method: authConfig.method,
       storage: authConfig.storage
@@ -1845,17 +1845,28 @@ var MedusaAuthProvider = class {
   async login(credentials) {
     this.logger.debug("login", { email: credentials.email });
     try {
-      const token = await this.sdk.auth.login("customer", "emailpass", {
+      const loginResult = await this.sdk.auth.login("customer", "emailpass", {
         email: credentials.email,
         password: credentials.password
       });
-      if (typeof token !== "string") {
-        this.logger.warn("Authentication requires additional actions", token);
-        return {
-          requiresAction: true,
-          redirectUrl: token.location
-        };
+      if (typeof loginResult !== "string") {
+        if ("verification_required" in loginResult && loginResult.verification_required) {
+          this.logger.warn("Authentication requires email verification", loginResult);
+          return {
+            requiresAction: true,
+            token: loginResult.token
+          };
+        }
+        if ("location" in loginResult) {
+          this.logger.warn("Authentication requires additional actions", loginResult);
+          return {
+            requiresAction: true,
+            redirectUrl: loginResult.location
+          };
+        }
+        throw new Error("Unexpected login result type");
       }
+      const token = loginResult;
       if (this.authConfig.method === "jwt") {
         await this.storageManager.setToken(token);
       }
@@ -1877,19 +1888,38 @@ var MedusaAuthProvider = class {
   async register(data) {
     this.logger.debug("register", { email: data.email });
     try {
-      const token = await this.sdk.auth.register("customer", "emailpass", {
+      await this.sdk.auth.register("customer", "emailpass", {
         email: data.email,
         password: data.password
       });
-      if (typeof token !== "string") {
-        throw new Error("Registration returned non-string token");
-      }
       const { customer } = await this.sdk.store.customer.create({
         email: data.email,
         first_name: data.first_name,
         last_name: data.last_name,
         phone: data.phone
       });
+      const loginResult = await this.sdk.auth.login("customer", "emailpass", {
+        email: data.email,
+        password: data.password
+      });
+      if (typeof loginResult !== "string") {
+        if ("verification_required" in loginResult && loginResult.verification_required) {
+          this.logger.warn("Registration requires email verification", loginResult);
+          return {
+            requiresAction: true,
+            token: loginResult.token
+          };
+        }
+        if ("location" in loginResult) {
+          this.logger.warn("Registration requires additional actions", loginResult);
+          return {
+            requiresAction: true,
+            redirectUrl: loginResult.location
+          };
+        }
+        throw new Error("Unexpected login result after registration");
+      }
+      const token = loginResult;
       if (this.authConfig.method === "jwt") {
         await this.storageManager.setToken(token);
       }
@@ -2109,81 +2139,6 @@ var MedusaAuthProvider = class {
       void 0
     );
   }
-  // ========================================
-  // Multi-Tenant — Channel Link
-  // ========================================
-  /**
-   * Link the currently authenticated customer to the storefront's sales channel.
-   *
-   * Must be called immediately after a successful `login()` so the customer
-   * appears in the admin panel of the correct storefront channel.
-   *
-   * Implements `POST /store/thor/customers/me/channels`.
-   * Idempotent — returns `{ linked: false, reason: 'already_linked' }` when
-   * the link already exists.
-   *
-   * @throws {ProviderAPIError} When not authenticated (401) or channel cannot
-   *   be resolved from the publishable key (400).
-   */
-  async linkCustomerToChannel() {
-    this.logger.debug("linkCustomerToChannel");
-    if (!this.baseUrl || !this.publishableKey) {
-      throw new ProviderAPIError(
-        "linkCustomerToChannel requires baseUrl and publishableKey to be set on the auth provider.",
-        "CONFIGURATION_ERROR",
-        void 0
-      );
-    }
-    const token = await this.storageManager.getToken();
-    const headers = {
-      "x-publishable-api-key": this.publishableKey,
-      "Content-Type": "application/json"
-    };
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    try {
-      const url = `${this.baseUrl}/store/thor/customers/me/channels`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers
-      });
-      if (response.status === 401) {
-        throw new ProviderAPIError(
-          "linkCustomerToChannel: not authenticated. Call login() first.",
-          "NOT_AUTHENTICATED",
-          401
-        );
-      }
-      if (response.status === 400) {
-        const body = await response.json().catch(() => ({}));
-        throw new ProviderAPIError(
-          `linkCustomerToChannel: could not resolve sales channel from publishable key. ${body?.message ?? ""}`.trim(),
-          "CHANNEL_RESOLUTION_FAILED",
-          400
-        );
-      }
-      if (!response.ok) {
-        const body = await response.json().catch(() => ({}));
-        throw new ProviderAPIError(
-          `linkCustomerToChannel failed with status ${response.status}: ${body?.message ?? "Unknown error"}`,
-          "LINK_CHANNEL_FAILED",
-          response.status
-        );
-      }
-      const data = await response.json();
-      this.logger.info("Customer linked to channel", { linked: data.linked, reason: data.reason });
-      return data;
-    } catch (error) {
-      if (error instanceof ProviderAPIError) throw error;
-      this.logger.error("linkCustomerToChannel failed", error);
-      throw new ProviderAPIError(
-        `linkCustomerToChannel failed: ${error.message}`,
-        "LINK_CHANNEL_FAILED",
-        error
-      );
-    }
-  }
 };
 
 // src/providers/medusa/payment.ts
@@ -2326,290 +2281,6 @@ async function getPaymentMethods(sdk, options) {
   }
 }
 
-// src/providers/medusa/admin.ts
-var MedusaAdminClient = class {
-  baseUrl;
-  apiKey;
-  logger;
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.apiKey = config.apiKey;
-    this.logger = createLogger("MedusaAdminClient", config.debug);
-  }
-  // -----------------------------------------------------------------------
-  // Private — HTTP helper
-  // -----------------------------------------------------------------------
-  async request(method, path, body) {
-    const url = `${this.baseUrl}${path}`;
-    this.logger.debug(`[admin] ${method} ${path}`);
-    const headers = {
-      "x-medusa-access-token": this.apiKey,
-      "Content-Type": "application/json"
-    };
-    const init = {
-      method,
-      headers,
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-    };
-    let response;
-    try {
-      response = await fetch(url, init);
-    } catch (networkError) {
-      throw new ProviderAPIError(
-        `[admin] Network error on ${method} ${path}: ${networkError.message}`,
-        "NETWORK_ERROR",
-        networkError
-      );
-    }
-    if (!response.ok) {
-      let message = `HTTP ${response.status}`;
-      try {
-        const json = await response.json();
-        message = json?.message ?? message;
-      } catch {
-      }
-      throw new ProviderAPIError(
-        `[admin] ${method} ${path} failed: ${message}`,
-        `ADMIN_API_${response.status}`,
-        response.status
-      );
-    }
-    return response.json();
-  }
-  // -----------------------------------------------------------------------
-  // 3.1 — Sales Channel: Customers
-  // -----------------------------------------------------------------------
-  /**
-   * Paginated list of customers linked to a sales channel.
-   *
-   * `GET /admin/thor/sales-channels/:id/customers`
-   */
-  async getChannelCustomers(salesChannelId, options = {}) {
-    const { limit = 20, offset = 0 } = options;
-    return this.request(
-      "GET",
-      `/admin/thor/sales-channels/${salesChannelId}/customers?limit=${limit}&offset=${offset}`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.2 — Sales Channel: API Keys
-  // -----------------------------------------------------------------------
-  /**
-   * Publishable API keys associated with a sales channel.
-   *
-   * `GET /admin/thor/sales-channels/:id/api-keys`
-   */
-  async getChannelApiKeys(salesChannelId) {
-    return this.request(
-      "GET",
-      `/admin/thor/sales-channels/${salesChannelId}/api-keys`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.3 — Sales Channel: Categories
-  // -----------------------------------------------------------------------
-  /**
-   * Product categories assigned to a sales channel.
-   *
-   * `GET /admin/thor/sales-channels/:id/categories`
-   */
-  async getChannelCategories(salesChannelId, options = {}) {
-    const { limit = 20, offset = 0, include_descendants = false } = options;
-    const qs = new URLSearchParams({
-      limit: String(limit),
-      offset: String(offset),
-      include_descendants: String(include_descendants)
-    });
-    return this.request(
-      "GET",
-      `/admin/thor/sales-channels/${salesChannelId}/categories?${qs}`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.4 — Category: Sales Channels
-  // -----------------------------------------------------------------------
-  /**
-   * Sales channels to which a category is assigned.
-   *
-   * `GET /admin/thor/categories/:id/sales-channels`
-   */
-  async getCategorySalesChannels(categoryId) {
-    return this.request(
-      "GET",
-      `/admin/thor/categories/${categoryId}/sales-channels`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.5 — Category: Assign to Sales Channels
-  // -----------------------------------------------------------------------
-  /**
-   * Assign a category to one or more sales channels (idempotent).
-   *
-   * `POST /admin/thor/categories/:id/sales-channels`
-   */
-  async assignCategoryToChannels(categoryId, body) {
-    return this.request(
-      "POST",
-      `/admin/thor/categories/${categoryId}/sales-channels`,
-      body
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.6 — Category: Unassign from Sales Channels
-  // -----------------------------------------------------------------------
-  /**
-   * Remove category assignment from one or more sales channels (idempotent).
-   *
-   * `DELETE /admin/thor/categories/:id/sales-channels`
-   */
-  async unassignCategoryFromChannels(categoryId, body) {
-    return this.request(
-      "DELETE",
-      `/admin/thor/categories/${categoryId}/sales-channels`,
-      body
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.7 — Collection: Sales Channels
-  // -----------------------------------------------------------------------
-  /**
-   * Sales channels to which a collection is assigned.
-   *
-   * `GET /admin/thor/collections/:id/sales-channels`
-   */
-  async getCollectionSalesChannels(collectionId) {
-    return this.request(
-      "GET",
-      `/admin/thor/collections/${collectionId}/sales-channels`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.8 — Collection: Assign to Sales Channels
-  // -----------------------------------------------------------------------
-  /**
-   * Assign a collection to one or more sales channels (idempotent).
-   *
-   * `POST /admin/thor/collections/:id/sales-channels`
-   */
-  async assignCollectionToChannels(collectionId, body) {
-    return this.request(
-      "POST",
-      `/admin/thor/collections/${collectionId}/sales-channels`,
-      body
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.9 — Collection: Unassign from Sales Channels
-  // -----------------------------------------------------------------------
-  /**
-   * Remove collection assignment from one or more sales channels (idempotent).
-   *
-   * `DELETE /admin/thor/collections/:id/sales-channels`
-   */
-  async unassignCollectionFromChannels(collectionId, body) {
-    return this.request(
-      "DELETE",
-      `/admin/thor/collections/${collectionId}/sales-channels`,
-      body
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.10 — Storefront Config: Read
-  // -----------------------------------------------------------------------
-  /**
-   * Read the visual storefront configuration for a channel.
-   * `:id` is the `sales_channel_id`.
-   *
-   * `GET /admin/thor/storefront-config/:id`
-   */
-  async getStorefrontConfig(salesChannelId) {
-    return this.request(
-      "GET",
-      `/admin/thor/storefront-config/${salesChannelId}`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.11 — Storefront Config: Update
-  // -----------------------------------------------------------------------
-  /**
-   * Update the visual storefront configuration for a channel.
-   * Triggers the `storefront_config.updated` event → ISR webhook.
-   *
-   * `PUT /admin/thor/storefront-config/:id`
-   */
-  async updateStorefrontConfig(salesChannelId, body) {
-    return this.request(
-      "PUT",
-      `/admin/thor/storefront-config/${salesChannelId}`,
-      body
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.12 — Site Designer Config: Read
-  // -----------------------------------------------------------------------
-  /**
-   * Read the active Site Designer configuration for a channel, including the
-   * last 10 history entries.
-   *
-   * `GET /admin/thor/site-config/:sales_channel_id`
-   */
-  async getSiteConfig(salesChannelId) {
-    return this.request(
-      "GET",
-      `/admin/thor/site-config/${salesChannelId}`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.13 — Site Designer Config: Update
-  // -----------------------------------------------------------------------
-  /**
-   * Update the Site Designer configuration for a channel.
-   * Creates a new history entry on every PUT.
-   *
-   * `PUT /admin/thor/site-config/:sales_channel_id`
-   */
-  async updateSiteConfig(salesChannelId, body) {
-    return this.request(
-      "PUT",
-      `/admin/thor/site-config/${salesChannelId}`,
-      body
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.14 — Site Designer Config: History
-  // -----------------------------------------------------------------------
-  /**
-   * Full paginated history of Site Designer versions for a channel.
-   * Entries are immutable — they are never deleted.
-   *
-   * `GET /admin/thor/site-config/:sales_channel_id/history`
-   */
-  async getSiteConfigHistory(salesChannelId, options = {}) {
-    const { limit = 20, offset = 0 } = options;
-    return this.request(
-      "GET",
-      `/admin/thor/site-config/${salesChannelId}/history?limit=${limit}&offset=${offset}`
-    );
-  }
-  // -----------------------------------------------------------------------
-  // 3.15 — Site Designer Config: Restore
-  // -----------------------------------------------------------------------
-  /**
-   * Restore a previous Site Designer version.
-   * Internally runs the update workflow with the stored config of the target
-   * version — this creates a **new** history entry and does NOT mutate past
-   * entries.
-   *
-   * `POST /admin/thor/site-config/:sales_channel_id/restore/:version`
-   */
-  async restoreSiteConfig(salesChannelId, version) {
-    return this.request(
-      "POST",
-      `/admin/thor/site-config/${salesChannelId}/restore/${encodeURIComponent(version)}`
-    );
-  }
-};
-
 // src/providers/medusa/index.ts
 var MEDUSA_CART_RETRIEVE_FIELDS = "+items,+items.variant,+items.variant.product,+items.variant.product.thumbnail,+items.variant.options,+items.variant.options.option";
 var MedusaProvider = class {
@@ -2644,18 +2315,6 @@ var MedusaProvider = class {
    * Only created when adminConfig.apiKey is provided.
    */
   sdkAdmin;
-  /**
-   * Admin client for Thor multi-tenant endpoints (`/admin/thor/`).
-   * Available when `adminConfig.apiKey` is provided.
-   *
-   * @example
-   * ```typescript
-   * const { customers } = await commerce.admin.getChannelCustomers('sc_01JXXXXX');
-   * const { api_keys } = await commerce.admin.getChannelApiKeys('sc_01JXXXXX');
-   * await commerce.admin.updateStorefrontConfig('sc_01JXXXXX', { theme_accent_color: '#EF4444', ... });
-   * ```
-   */
-  admin;
   /** Cached distinct product status values — rarely changes, cached for process lifetime */
   _cachedProductStatuses = null;
   /**
@@ -2726,15 +2385,10 @@ var MedusaProvider = class {
         debug: config.debug ?? false
         // No publishableKey or auth config: this instance is admin-only, no JWT needed
       });
-      this.admin = new MedusaAdminClient({
-        baseUrl: config.baseUrl,
-        apiKey: config.adminConfig.apiKey,
-        debug: config.debug
-      });
       this.logger.info("[Admin Auth] Dedicated admin SDK instance created with API key");
     }
     if (config.auth) {
-      this.auth = new MedusaAuthProvider(this.sdk, config.auth, config.debug, config.baseUrl, config.publishableKey);
+      this.auth = new MedusaAuthProvider(this.sdk, config.auth, config.debug);
       this.logger.info("Auth provider initialized");
     }
     this._capabilitiesPromise = this._fetchCapabilities();
@@ -10590,8 +10244,11 @@ function isProviderType(provider, type) {
   buildChannelScopeMetadata,
   calculateDistance,
   createBackendMetadataAdapter,
+  createFetchWithRetry,
   createLogger,
   createProvider,
+  extractErrorMessage,
+  fetchWithRetry,
   filterByChannel,
   filterGlobalOnly,
   geocodeAddress,