@thorprovider/adapters 5.0.11 → 5.0.12

package/dist/index.mjs

@@ -1033,6 +1033,12 @@ function transformProduct(product, currencyCode) {
       title: product.collection.title ?? "",
       handle: product.collection.handle ?? ""
     }] : void 0,
+    categories: product.categories?.map((category) => ({
+      id: category.id,
+      name: category.name ?? "",
+      handle: category.handle ?? "",
+      parentCategoryId: category.parent_category_id ?? void 0
+    })),
     productType: product.type?.value ?? void 0,
     vendor: void 0,
     // Medusa doesn't have vendor field
@@ -1805,6 +1811,7 @@ var MedusaAuthProvider = class {
       if (this.authConfig.method === "jwt") {
         await this.storageManager.setToken(token);
       }
+      await this.linkCustomerChannel();
       const customer = await this.getCurrentCustomer();
       this.logger.info("Login successful", { customerId: customer?.id });
       return {
@@ -1812,6 +1819,7 @@ var MedusaAuthProvider = class {
         customer: customer ?? void 0
       };
     } catch (error) {
+      if (error instanceof ProviderAPIError) throw error;
       this.logger.error("Login failed", error);
       throw new ProviderAPIError(
         `Authentication failed: ${error.message}`,
@@ -1823,16 +1831,14 @@ var MedusaAuthProvider = class {
   async register(data) {
     this.logger.debug("register", { email: data.email });
     try {
-      await this.sdk.auth.register("customer", "emailpass", {
+      const registrationToken = await this.sdk.auth.register("customer", "emailpass", {
         email: data.email,
         password: data.password
       });
-      const { customer } = await this.sdk.store.customer.create({
-        email: data.email,
-        first_name: data.first_name,
-        last_name: data.last_name,
-        phone: data.phone
-      });
+      if (this.authConfig.method === "jwt" && typeof registrationToken === "string") {
+        await this.storageManager.setToken(registrationToken);
+      }
+      const linked = await this.createChannelLinkedCustomer(data);
       const loginResult = await this.sdk.auth.login("customer", "emailpass", {
         email: data.email,
         password: data.password
@@ -1858,12 +1864,20 @@ var MedusaAuthProvider = class {
       if (this.authConfig.method === "jwt") {
         await this.storageManager.setToken(token);
       }
+      const customer = await this.getCurrentCustomer();
+      if (!customer || customer.id !== linked.id) {
+        throw new ProviderAPIError(
+          "Registration created an auth identity without a linked customer.",
+          "CUSTOMER_LINK_INCOMPLETE"
+        );
+      }
       this.logger.info("Registration successful", { customerId: customer.id });
       return {
         token: this.authConfig.method === "jwt" ? token : void 0,
-        customer: transformCustomer(customer, customer.email)
+        customer
       };
     } catch (error) {
+      if (error instanceof ProviderAPIError) throw error;
       this.logger.error("Registration failed", error);
       throw new ProviderAPIError(
         `Registration failed: ${error.message}`,
@@ -1872,6 +1886,79 @@ var MedusaAuthProvider = class {
       );
     }
   }
+  /**
+   * Create and channel-link a customer through `POST /store/thor/customers`.
+   *
+   * The request carries the registration token (read by the SDK from the
+   * request-scoped custom storage) and the publishable key; the backend links
+   * the customer to the publishable-key sales channel. A route that is
+   * unavailable fails closed with a typed error — there is no silent native
+   * fallback that would leave the customer unlinked.
+   */
+  async createChannelLinkedCustomer(data) {
+    const response = await this.fetchChannelAccountRoute(
+      "/store/thor/customers",
+      {
+        method: "POST",
+        body: {
+          email: data.email,
+          first_name: data.first_name,
+          last_name: data.last_name,
+          phone: data.phone
+        }
+      }
+    );
+    const id = response?.customer?.id;
+    if (typeof id !== "string" || id.length === 0) {
+      throw new ProviderAPIError(
+        "Channel-linked customer creation returned no customer id.",
+        "CUSTOMER_LINK_INCOMPLETE"
+      );
+    }
+    return { id };
+  }
+  /**
+   * Link the authenticated customer to the publishable-key sales channel
+   * through `POST /store/thor/customers/me/channels` (idempotent). Called after
+   * login so history is channel-scoped for the current storefront.
+   */
+  async linkCustomerChannel() {
+    const response = await this.fetchChannelAccountRoute("/store/thor/customers/me/channels", { method: "POST" });
+    if (response?.linked === false && response?.reason !== "already_linked") {
+      throw new ProviderAPIError(
+        "Customer channel link did not complete.",
+        "CUSTOMER_LINK_INCOMPLETE"
+      );
+    }
+  }
+  /**
+   * Call a Thor channel account route through the SDK client, which attaches
+   * the request-scoped customer/registration token and the publishable key. A
+   * missing client or an unavailable route (404/405/501) fails closed with a
+   * typed `CUSTOMER_LINK_UNAVAILABLE` error.
+   */
+  async fetchChannelAccountRoute(path, init) {
+    const client = this.sdk.client;
+    if (!client || typeof client.fetch !== "function") {
+      throw new ProviderAPIError(
+        `The channel account route ${path} is unavailable in this SDK.`,
+        "CUSTOMER_LINK_UNAVAILABLE"
+      );
+    }
+    try {
+      return await client.fetch(path, init);
+    } catch (error) {
+      const status = error?.status || error?.statusCode;
+      if (status === 404 || status === 405 || status === 501) {
+        throw new ProviderAPIError(
+          `The channel account route ${path} is unavailable (status ${status}).`,
+          "CUSTOMER_LINK_UNAVAILABLE",
+          status
+        );
+      }
+      throw error;
+    }
+  }
   async logout() {
     this.logger.debug("logout");
     try {
@@ -2218,6 +2305,14 @@ async function getPaymentMethods(sdk, options) {
 
 // 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,+items.total,+items.unit_price,+items.item_subtotal,+items.item_total,+shipping_methods,+shipping_methods.id,+shipping_methods.shipping_option_id";
+var CUSTOMER_ORDERS_DEFAULT_PAGE_SIZE = 10;
+var CUSTOMER_ORDERS_MAX_PAGE_SIZE = 100;
+function normalizeCustomerOrdersPage(options) {
+  const page = Number.isInteger(options.page) && options.page > 0 ? options.page : 1;
+  const requested = Number.isInteger(options.pageSize) && options.pageSize > 0 ? options.pageSize : CUSTOMER_ORDERS_DEFAULT_PAGE_SIZE;
+  const pageSize = Math.min(requested, CUSTOMER_ORDERS_MAX_PAGE_SIZE);
+  return { page, pageSize, limit: pageSize, offset: (page - 1) * pageSize };
+}
 var MEDUSA_ORDER_COMPLETION_FIELDS = "*items";
 var DEFAULT_CATALOG_PAGE_SIZE = 50;
 function resolveCatalogPageSize(configured) {
@@ -2581,7 +2676,7 @@ var MedusaProvider = class {
   }
   /** Fields needed to price a product variant for the current region. */
   buildProductFields(regionId) {
-    const baseFields = "+variants,+variants.inventory_quantity,+options,+images,+tags";
+    const baseFields = "+variants,+variants.inventory_quantity,+options,+images,+tags,+categories.*";
     const pricingFields = ",+variants.calculated_price,+variants.prices";
     return regionId ? baseFields + pricingFields : baseFields;
   }
@@ -4139,13 +4234,17 @@ var MedusaProvider = class {
   // Order Operations
   // ============================================
   /**
-   * Get all orders for a customer (storefront).
+   * Get all orders for a customer (storefront) as an array (legacy surface).
    *
-   * Note: This retrieves orders from the storefront API (store.order.list),
-   * which returns orders only for the authenticated customer in the JWT.
+   * Delegates to the channel-scoped paginated contract
+   * ({@link customerOrdersPage}) and returns that window's orders. The backend
+   * (`GET /store/thor/orders`) scopes by BOTH the authenticated customer and
+   * the sales channel resolved from the publishable key, so cross-channel
+   * orders are excluded by the backend before pagination and **no client-side
+   * channel filter runs**.
    *
-   * @param options - Order query options (supports callbacks for custom backends)
-   * @returns Array of orders for the authenticated customer
+   * @param options - Order query options (supports a custom fetcher)
+   * @returns Array of orders for the authenticated customer on the store channel
    *
    * @example
    * ```typescript
@@ -4159,32 +4258,68 @@ var MedusaProvider = class {
       this.logger.debug("Using custom fetcher for orders");
       return customFetcher(options);
     }
-    this.logger.info("Getting orders for authenticated customer");
+    const page = await this.customerOrdersPage({
+      page: 1,
+      pageSize: options.limit ?? CUSTOMER_ORDERS_MAX_PAGE_SIZE,
+      salesChannelId
+    });
+    return page.orders;
+  }
+  /**
+   * Channel-scoped, paginated order history for the authenticated customer.
+   *
+   * Calls the backend route `GET /store/thor/orders`, which requires the
+   * customer session and scopes `order` by `customer_id` **and** the
+   * `sales_channel_id` resolved from the publishable key, returning
+   * `{ orders, count, limit, offset }` with the backend's real total computed
+   * before pagination.
+   *
+   * The `salesChannelId` option is the store's explicitly configured channel.
+   * When supplied, every returned order is asserted to belong to it; a
+   * foreign-channel order (for example from a multi-channel publishable key that
+   * silently resolved an arbitrary first id) fails closed with a typed error
+   * rather than being presented as the customer's history.
+   *
+   * @param options - Bounded pagination window and the store's sales channel
+   * @returns The backend's `{ orders, count, limit, offset }`
+   */
+  async customerOrdersPage(options = {}) {
+    const { page, pageSize, limit, offset } = normalizeCustomerOrdersPage(options);
+    const { salesChannelId } = options;
+    this.logger.info("Getting channel-scoped customer orders", { page, pageSize });
     try {
-      const result = await this.withRetry(
-        async () => this.sdk.store.order.list({
-          // Medusa v2 JS-SDK automatically includes authorization header if JWT is present
-          fields: "+items,+items.variant,+items.variant.product,+shipping_address,+billing_address,+customer"
+      const response = await this.withRetry(
+        async () => this.sdk.client.fetch("/store/thor/orders", {
+          method: "GET",
+          query: { limit, offset }
         }),
-        "getOrders",
+        "customerOrdersPage",
         {}
       );
-      const orders = result.orders ?? [];
-      this.logger.debug(`Found ${orders.length} orders for customer`);
-      const transformed = orders.map((order) => transformOrder(order));
-      const channelId = salesChannelId ?? process.env.NEXT_PUBLIC_SALES_CHANNEL_ID;
-      if (channelId) {
-        const scoped = filterByChannel(transformed, channelId);
-        this.logger.debug(
-          `Channel scoping: ${scoped.length}/${transformed.length} orders match channel ${channelId}`
+      const rawOrders = response.orders ?? [];
+      this.logger.debug(`Found ${rawOrders.length} channel-scoped orders for customer`);
+      if (salesChannelId) {
+        const foreign = rawOrders.find(
+          (order) => typeof order?.sales_channel_id === "string" && order.sales_channel_id !== salesChannelId
         );
-        return scoped;
+        if (foreign) {
+          throw new ProviderAPIError(
+            `Channel-scoped order history returned an order outside the store's sales channel (${salesChannelId}).`,
+            "medusa"
+          );
+        }
       }
-      return transformed;
+      return {
+        orders: rawOrders.map((order) => transformOrder(order)),
+        count: typeof response.count === "number" ? response.count : rawOrders.length,
+        limit: typeof response.limit === "number" ? response.limit : limit,
+        offset: typeof response.offset === "number" ? response.offset : offset
+      };
     } catch (error) {
+      if (error instanceof ProviderAPIError) throw error;
       const status = error?.status || error?.statusCode;
       const errorMessage = extractErrorMessage(error);
-      this.logger.error("Error getting orders", { error: errorMessage });
+      this.logger.error("Error getting channel-scoped orders", { error: errorMessage });
       throw new ProviderAPIError(
         `Failed to fetch orders: ${errorMessage}`,
         "medusa",
@@ -9831,7 +9966,7 @@ var categoryFixtures = [
     description: "Complementary products for cart and bundle flows."
   }
 ];
-var productFixtures = [
+var heroProductFixtures = [
   {
     id: "mock-product-aurora-jacket",
     handle: "aurora-jacket",
@@ -9963,6 +10098,119 @@ var productFixtures = [
     ]
   }
 ];
+var generatedBlueprints = [
+  {
+    categoryHandle: "jackets",
+    noun: "Jacket",
+    productType: "outerwear",
+    vendor: "Thor Atelier",
+    tags: ["outerwear", "layer"],
+    variantName: "Size",
+    variantValues: ["S", "M"],
+    names: ["Alpine", "Boreal", "Cinder", "Drift", "Ember", "Fjord", "Harbor", "Meridian", "Nomad", "Tundra", "Vantage"],
+    description: "A considered layering piece in a brushed weave.",
+    basePrice: 118,
+    baseHue: 210
+  },
+  {
+    categoryHandle: "dresses",
+    noun: "Dress",
+    productType: "dress",
+    vendor: "Thor Atelier",
+    tags: ["dress", "editorial"],
+    variantName: "Size",
+    variantValues: ["S", "M"],
+    names: ["Amber", "Camille", "Dahlia", "Elara", "Iris", "Lumen", "Nova", "Rosalind", "Vera"],
+    description: "Cut from a fluid cloth for editorial styling.",
+    basePrice: 142,
+    baseHue: 330
+  },
+  {
+    categoryHandle: "home",
+    noun: "Lamp",
+    productType: "decor",
+    vendor: "Thor Home",
+    tags: ["home", "decor", "interior"],
+    variantName: "Finish",
+    variantValues: ["Brass"],
+    names: ["Atlas", "Copper", "Dune", "Onyx", "Quill", "Slate", "Terra", "Verdant"],
+    description: "A calm sculptural accent for modern interiors.",
+    basePrice: 74,
+    baseHue: 40
+  },
+  {
+    categoryHandle: "accessories",
+    noun: "Bag",
+    productType: "bag",
+    vendor: "Thor Atelier",
+    tags: ["accessory", "everyday"],
+    variantName: "Color",
+    variantValues: ["Juniper"],
+    names: ["Cove", "Fable", "Juniper", "Kestrel", "Marlowe", "Piper", "Rune"],
+    description: "An everyday carry with a textured finish.",
+    basePrice: 68,
+    baseHue: 280
+  }
+];
+var GENERATED_CREATED_AT_BASE = Date.parse("2025-12-30T00:00:00.000Z");
+var GENERATED_COLLECTION_POOL = ["new-arrivals", "best-sellers", "studio-essentials"];
+function buildGeneratedProductFixtures() {
+  const fixtures = [];
+  let globalIndex = 0;
+  for (const blueprint of generatedBlueprints) {
+    const noun = blueprint.noun.toLowerCase();
+    blueprint.names.forEach((name, localIndex) => {
+      const handle = `${name.toLowerCase()}-${noun}`;
+      const title = `${name} ${blueprint.noun}`;
+      const price = blueprint.basePrice + localIndex * 7 + localIndex % 3 * 0.5;
+      const quantityAvailable = globalIndex * 5 % 17;
+      const primaryCollection = GENERATED_COLLECTION_POOL[globalIndex % GENERATED_COLLECTION_POOL.length];
+      const collectionHandles = [primaryCollection];
+      if (globalIndex % 5 === 0) {
+        const secondary = GENERATED_COLLECTION_POOL[(globalIndex + 1) % GENERATED_COLLECTION_POOL.length];
+        if (secondary !== primaryCollection) {
+          collectionHandles.push(secondary);
+        }
+      }
+      const createdAt = new Date(GENERATED_CREATED_AT_BASE - globalIndex * 864e5).toISOString();
+      const variants = blueprint.variantValues.map((value, variantIndex) => ({
+        id: `mock-variant-${handle}-${value.toLowerCase()}`,
+        title: value,
+        price,
+        quantityAvailable: Math.max(0, quantityAvailable - variantIndex),
+        selectedOptions: [{ name: blueprint.variantName, value }]
+      }));
+      fixtures.push({
+        id: `mock-product-${handle}`,
+        handle,
+        title,
+        description: `${title} - ${blueprint.description}`,
+        imageLabel: title,
+        imageHue: (blueprint.baseHue + localIndex * 13) % 360,
+        collectionHandles,
+        categoryHandle: blueprint.categoryHandle,
+        productType: blueprint.productType,
+        vendor: blueprint.vendor,
+        tags: [...blueprint.tags],
+        options: [
+          {
+            id: `${handle}-${blueprint.variantName.toLowerCase()}`,
+            name: blueprint.variantName,
+            values: [...blueprint.variantValues]
+          }
+        ],
+        variants,
+        createdAt
+      });
+      globalIndex += 1;
+    });
+  }
+  return fixtures;
+}
+var productFixtures = [
+  ...heroProductFixtures,
+  ...buildGeneratedProductFixtures()
+];
 var stockLocationFixture = {
   id: "mock-stock-primary",
   name: "Mock Main Warehouse",
@@ -10079,6 +10327,20 @@ function buildProducts(currencyCode) {
         title: collection.title,
         handle: collection.handle
       })),
+      categories: (() => {
+        const category = categoryFixtures.find(
+          (item) => item.handle === product.categoryHandle
+        );
+        if (!category) return void 0;
+        return [
+          {
+            id: category.id,
+            name: category.name,
+            handle: category.handle,
+            parentCategoryId: category.parentCategoryId
+          }
+        ];
+      })(),
       productType: product.productType,
       vendor: product.vendor,
       tags: product.tags,