@reactionary/provider-medusa 0.3.17 → 0.6.1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/provider-medusa",
-  "version": "0.3.17",
+  "version": "0.6.1",
   "type": "module",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "@medusajs/js-sdk": "^2.13.0",
-    "@reactionary/core": "0.3.17",
+    "@reactionary/core": "0.6.1",
     "debug": "^4.4.3",
     "@medusajs/types": "^2.11.0",
     "zod": "4.1.9"

package/providers/cart.provider.js

@@ -21,10 +21,10 @@ import {
   CartProvider,
   CartQueryByIdSchema,
   CartSchema,
+  error,
   ProductVariantIdentifierSchema,
   Reactionary,
-  success,
-  error
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 import { MedusaCartIdentifierSchema } from "../schema/medusa.schema.js";
@@ -54,7 +54,7 @@ class MedusaCartProvider extends CartProvider {
       if (debug.enabled) {
         debug("Fetching cart by ID:", medusaId.key);
       }
-      const cartResponse = await client.store.cart.retrieve(medusaId.key);
+      const cartResponse = await client.store.cart.retrieve(medusaId.key, { fields: this.includedFields });
       if (debug.enabled) {
         debug("Received cart response:", cartResponse);
       }
@@ -73,6 +73,19 @@ class MedusaCartProvider extends CartProvider {
       });
     }
   }
+  /**
+   * Extension point for the `add` operation to control the payload sent to Medusa when adding an item to the cart. By default, it only includes the variant ID and quantity, but you can override it to include more fields as needed.
+   *
+   * @param payload
+   * @param variantId
+   * @returns
+   */
+  addPayload(payload, variantId) {
+    return {
+      variant_id: variantId,
+      quantity: payload.quantity
+    };
+  }
   async add(payload) {
     try {
       const client = await this.getClient();
@@ -94,10 +107,7 @@ class MedusaCartProvider extends CartProvider {
       const variantId = await this.medusaApi.resolveVariantId(payload.variant.sku);
       const response = await client.store.cart.createLineItem(
         medusaId.key,
-        {
-          variant_id: variantId,
-          quantity: payload.quantity
-        },
+        this.addPayload(payload, variantId),
         {
           fields: this.includedFields
         }
@@ -132,6 +142,16 @@ class MedusaCartProvider extends CartProvider {
       handleProviderError("remove item from cart", error2);
     }
   }
+  /**
+   * Extension point for the `changeQuantity` operation to control the payload sent to Medusa when changing the quantity of an item in the cart. By default, it only includes the new quantity, but you can override it to include more fields as needed.
+   * @param payload
+   * @returns
+   */
+  changeQuantityPayload(payload) {
+    return {
+      quantity: payload.quantity
+    };
+  }
   async changeQuantity(payload) {
     if (payload.quantity < 1) {
       throw new Error(
@@ -144,9 +164,7 @@ class MedusaCartProvider extends CartProvider {
       const response = await client.store.cart.updateLineItem(
         medusaId.key,
         payload.item.key,
-        {
-          quantity: payload.quantity
-        },
+        this.changeQuantityPayload(payload),
         {
           fields: this.includedFields
         }
@@ -181,7 +199,7 @@ class MedusaCartProvider extends CartProvider {
         identifier: void 0
       });
     } catch (err) {
-      debug("Failed to get active cart ID:", error);
+      debug("Failed to get active cart ID:", err);
       return error({
         type: "NotFound",
         identifier: void 0
@@ -213,17 +231,28 @@ class MedusaCartProvider extends CartProvider {
       return success(void 0);
     }
   }
+  /**
+   * Extension point to apply a coupon code to the cart. By default, it only includes the coupon code, but you can override it to include more fields as needed.
+   * @param payload
+   * @returns
+   */
+  applyCouponCodePayload(payload) {
+    return {
+      promo_codes: [payload.couponCode]
+    };
+  }
   async applyCouponCode(payload) {
     try {
       const client = await this.getClient();
       const medusaId = payload.cart;
-      const response = await client.store.cart.update(
-        medusaId.key,
+      const response = await client.client.fetch(
+        `/store/carts/${medusaId.key}/promotions`,
         {
-          promo_codes: [payload.couponCode]
-        },
-        {
-          fields: this.includedFields
+          method: "POST",
+          body: this.applyCouponCodePayload(payload),
+          query: {
+            fields: this.includedFields
+          }
         }
       );
       if (response.cart) {
@@ -234,73 +263,86 @@ class MedusaCartProvider extends CartProvider {
       handleProviderError("apply coupon code", error2);
     }
   }
+  /**
+   * Extension point to remove a coupon code from the cart. By default, it only includes the coupon code to be removed, but you can override it to include more fields as needed.
+   * @param payload
+   * @returns
+   */
+  removeCouponCodePayload(payload) {
+    return {
+      promo_codes: [payload.couponCode]
+    };
+  }
   async removeCouponCode(payload) {
     try {
       const client = await this.getClient();
       const medusaId = payload.cart;
-      const cartResponse = await client.store.cart.retrieve(medusaId.key);
-      if (cartResponse.cart?.promotions) {
-        const manualDiscounts = cartResponse.cart.promotions.filter(
-          (x) => !x.is_automatic && x.code
-        );
-        const remainingCodes = manualDiscounts.filter((x) => x.code !== payload.couponCode).map((promotion) => promotion.code) || [];
-        const response = await client.store.cart.update(
-          medusaId.key,
-          {
-            promo_codes: remainingCodes || []
-          },
-          {
+      const response = await client.client.fetch(
+        `/store/carts/${medusaId.key}/promotions`,
+        {
+          method: "DELETE",
+          body: this.removeCouponCodePayload(payload),
+          query: {
             fields: this.includedFields
           }
-        );
-        if (response.cart) {
-          return success(this.parseSingle(response.cart));
         }
+      );
+      if (response.cart) {
+        return success(this.parseSingle(response.cart));
       }
       throw new Error("Failed to remove coupon code");
     } catch (error2) {
       handleProviderError("remove coupon code", error2);
     }
   }
+  /**
+   * Extension point to control the payload sent to Medusa when changing the currency of the cart. By default, it only includes the new region ID, but you can override it to include more fields as needed.
+   * @param payload
+   * @param newRegionId
+   * @returns
+   */
+  changeCurrencyPayload(payload, newRegionId) {
+    return {
+      region_id: newRegionId
+    };
+  }
   async changeCurrency(payload) {
     try {
       const client = await this.getClient();
-      const currentCartResponse = await client.store.cart.retrieve(
-        payload.cart.key
-      );
-      client.store.cart.update(
+      const newRegionId = (await this.medusaApi.getActiveRegion()).id;
+      const updatedCartResponse = await client.store.cart.update(
         payload.cart.key,
-        {
-          region_id: (await this.medusaApi.getActiveRegion()).id
-        },
+        this.changeCurrencyPayload(payload, newRegionId),
         {
           fields: this.includedFields
         }
       );
-      if (!currentCartResponse.cart) {
-        throw new Error("Cart not found");
-      }
-      const newCartResponse = await client.store.cart.retrieve(
-        payload.cart.key
-      );
-      if (newCartResponse.cart) {
+      if (updatedCartResponse.cart) {
         this.medusaApi.setSessionData({
-          activeCartId: newCartResponse.cart.id
+          activeCartId: updatedCartResponse.cart.id
         });
-        return success(this.parseSingle(newCartResponse.cart));
+        return success(this.parseSingle(updatedCartResponse.cart));
       }
       throw new Error("Failed to change currency");
     } catch (error2) {
       handleProviderError("change currency", error2);
     }
   }
+  /**
+   * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
+   * @param currency
+   * @returns
+   */
+  createCartPayload(currency) {
+    return {
+      currency_code: (currency || this.context.languageContext.currencyCode || "").toLowerCase()
+    };
+  }
   async createCart(currency) {
     try {
       const client = await this.getClient();
       const response = await client.store.cart.create(
-        {
-          currency_code: (currency || this.context.languageContext.currencyCode || "").toLowerCase()
-        },
+        this.createCartPayload(currency),
         {
           fields: this.includedFields
         }
@@ -383,12 +425,32 @@ class MedusaCartProvider extends CartProvider {
     for (const remoteItem of allItems) {
       items.push(this.parseCartItem(remoteItem, price.grandTotal.currency));
     }
+    const appliedPromotions = [];
+    if (remote.promotions) {
+      for (const promo of remote.promotions) {
+        const promotionName = promo.code;
+        let promoDescription = "";
+        if (promo.application_method?.type === "percentage") {
+          promoDescription = `-${promo.application_method.value}%`;
+        }
+        if (promo.application_method?.type === "fixed") {
+          promoDescription = `-${promo.application_method.value} ${price.grandTotal.currency}`;
+        }
+        appliedPromotions.push({
+          code: promo.code || "",
+          isCouponCode: promo.is_automatic ? false : true,
+          name: promotionName || promoDescription,
+          description: promoDescription
+        });
+      }
+    }
     const result = {
       identifier,
       name,
       description,
       price,
       items,
+      appliedPromotions,
       userId: {
         userId: "???"
       }
@@ -427,8 +489,8 @@ __decorateClass([
 ], MedusaCartProvider.prototype, "getActiveCartId", 1);
 __decorateClass([
   Reactionary({
-    inputSchema: CartMutationDeleteCartSchema,
-    outputSchema: CartSchema
+    cache: false,
+    inputSchema: CartMutationDeleteCartSchema
   })
 ], MedusaCartProvider.prototype, "deleteCart", 1);
 __decorateClass([

package/providers/category.provider.js

@@ -71,13 +71,16 @@ class MedusaCategoryProvider extends CategoryProvider {
     }
     return success(this.parseSingle(candidate));
   }
-  async getBySlug(payload) {
-    const sdk = await this.medusaApi.getClient();
-    const categoryResult = await sdk.store.category.list({
+  getBySlugPayload(payload) {
+    return {
       handle: payload.slug,
       limit: 1,
       offset: 0
-    });
+    };
+  }
+  async getBySlug(payload) {
+    const sdk = await this.medusaApi.getClient();
+    const categoryResult = await sdk.store.category.list(this.getBySlugPayload(payload));
     if (categoryResult.count === 0) {
       return error({
         type: "NotFound",
@@ -107,31 +110,37 @@ class MedusaCategoryProvider extends CategoryProvider {
     results = results.reverse();
     return success(results);
   }
+  findChildCategoriesPayload(payload, actualParent) {
+    return {
+      fields: "+metadata,+parent_category.metadata",
+      parent_category_id: actualParent.id,
+      limit: payload.paginationOptions.pageSize,
+      offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize
+    };
+  }
   async findChildCategories(payload) {
     const sdk = await this.medusaApi.getClient();
-    const actualParentId = await this.resolveCategoryIdByExternalId(
+    const actualParent = await this.resolveCategoryIdByExternalId(
       payload.parentId.key
     );
-    if (!actualParentId) {
+    if (!actualParent) {
       throw new Error("Parent category not found " + payload.parentId.key);
     }
-    const response = await sdk.store.category.list({
-      fields: "+metadata,+parent_category.metadata",
-      parent_category_id: actualParentId.id,
-      limit: payload.paginationOptions.pageSize,
-      offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize
-    });
+    const response = await sdk.store.category.list(this.findChildCategoriesPayload(payload, actualParent));
     const result = this.parsePaginatedResult(response);
     return success(result);
   }
-  async findTopCategories(payload) {
-    const sdk = await this.medusaApi.getClient();
-    const response = await sdk.store.category.list({
+  findTopCategoriesPayload(payload) {
+    return {
       fields: "+metadata",
       parent_category_id: "null",
       limit: payload.paginationOptions.pageSize,
       offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize
-    });
+    };
+  }
+  async findTopCategories(payload) {
+    const sdk = await this.medusaApi.getClient();
+    const response = await sdk.store.category.list(this.findTopCategoriesPayload(payload));
     const result = this.parsePaginatedResult(response);
     return success(result);
   }

package/providers/checkout.provider.js

@@ -58,6 +58,16 @@ class MedusaCheckoutProvider extends CheckoutProvider {
     this.includedFields = ["+items.*"].join(",");
     this.config = config;
   }
+  initiateCheckoutForCartPayload(payload) {
+    return {
+      billing_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
+      shipping_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
+      email: payload.notificationEmail,
+      metadata: {
+        sms_notification: payload.notificationPhone
+      }
+    };
+  }
   async initiateCheckoutForCart(payload) {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
@@ -67,14 +77,7 @@ class MedusaCheckoutProvider extends CheckoutProvider {
     }
     const response = await client.store.cart.update(
       payload.cart.identifier.key,
-      {
-        billing_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
-        shipping_address: payload.billingAddress ? this.mapAddressToStoreAddress(payload.billingAddress) : void 0,
-        email: payload.notificationEmail,
-        metadata: {
-          sms_notification: payload.notificationPhone
-        }
-      },
+      this.initiateCheckoutForCartPayload(payload),
       {
         fields: this.includedFields
       }
@@ -88,21 +91,27 @@ class MedusaCheckoutProvider extends CheckoutProvider {
     });
     return success(this.parseSingle(response.cart));
   }
+  setShippingAddressPayload(payload) {
+    return {
+      shipping_address: this.mapAddressToStoreAddress(payload.shippingAddress)
+    };
+  }
   async setShippingAddress(payload) {
     const client = await this.medusaApi.getClient();
     const response = await client.store.cart.update(
       payload.checkout.key,
-      {
-        shipping_address: this.mapAddressToStoreAddress(
-          payload.shippingAddress
-        )
-      },
+      this.setShippingAddressPayload(payload),
       {
         fields: this.includedFields
       }
     );
     return success(this.parseSingle(response.cart));
   }
+  getAvailableShippingMethodsPayload(payload) {
+    return {
+      cart_id: payload.checkout.key
+    };
+  }
   async getAvailableShippingMethods(payload) {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
@@ -110,9 +119,9 @@ class MedusaCheckoutProvider extends CheckoutProvider {
         `Fetching available shipping methods for checkout with key: ${payload.checkout.key}`
       );
     }
-    const shippingMethodResponse = await client.store.fulfillment.listCartOptions({
-      cart_id: payload.checkout.key
-    });
+    const shippingMethodResponse = await client.store.fulfillment.listCartOptions(
+      this.getAvailableShippingMethodsPayload(payload)
+    );
     const shippingMethods = [];
     for (const sm of shippingMethodResponse.shipping_options) {
       shippingMethods.push(
@@ -136,6 +145,11 @@ class MedusaCheckoutProvider extends CheckoutProvider {
     }
     return success(shippingMethods);
   }
+  getAvailablePaymentMethodsPayload(payload, regionId) {
+    return {
+      region_id: regionId
+    };
+  }
   async getAvailablePaymentMethods(payload) {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
@@ -144,9 +158,12 @@ class MedusaCheckoutProvider extends CheckoutProvider {
       );
     }
     const checkout = await client.store.cart.retrieve(payload.checkout.key);
-    const paymentMethodResponse = await client.store.payment.listPaymentProviders({
-      region_id: checkout.cart.region_id || (await this.medusaApi.getActiveRegion()).id
-    });
+    const paymentMethodResponse = await client.store.payment.listPaymentProviders(
+      this.getAvailablePaymentMethodsPayload(
+        payload,
+        checkout.cart.region_id || (await this.medusaApi.getActiveRegion()).id
+      )
+    );
     const paymentMethods = [];
     for (const pm of paymentMethodResponse.payment_providers) {
       paymentMethods.push(
@@ -170,6 +187,15 @@ class MedusaCheckoutProvider extends CheckoutProvider {
     }
     return success(paymentMethods);
   }
+  addPaymentInstructionPayload(payload) {
+    return {
+      provider_id: payload.paymentInstruction.paymentMethod.method,
+      data: payload.paymentInstruction.protocolData.reduce((acc, curr) => {
+        acc[curr.key] = curr.value;
+        return acc;
+      }, {})
+    };
+  }
   async addPaymentInstruction(payload) {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
@@ -181,13 +207,7 @@ class MedusaCheckoutProvider extends CheckoutProvider {
       const cartResponse = await client.store.cart.retrieve(
         payload.checkout.key
       );
-      const paymentSessionResponse = await client.store.payment.initiatePaymentSession(cartResponse.cart, {
-        provider_id: payload.paymentInstruction.paymentMethod.method,
-        data: payload.paymentInstruction.protocolData.reduce((acc, curr) => {
-          acc[curr.key] = curr.value;
-          return acc;
-        }, {})
-      });
+      const paymentSessionResponse = await client.store.payment.initiatePaymentSession(cartResponse.cart, this.addPaymentInstructionPayload(payload));
       const updatedCartResponse = await client.store.cart.retrieve(
         payload.checkout.key,
         {
@@ -205,18 +225,21 @@ class MedusaCheckoutProvider extends CheckoutProvider {
   removePaymentInstruction(payload) {
     throw new Error("Method not implemented.");
   }
+  setShippingInstructionPayload(payload) {
+    return {
+      option_id: payload.shippingInstruction.shippingMethod.key,
+      data: {
+        consent_for_unattended_delivery: payload.shippingInstruction.consentForUnattendedDelivery + "",
+        instructions: payload.shippingInstruction.instructions || ""
+      }
+    };
+  }
   async setShippingInstruction(payload) {
     const client = await this.medusaApi.getClient();
     const medusaId = payload.checkout;
     try {
       if (payload.shippingInstruction.shippingMethod) {
-        await client.store.cart.addShippingMethod(medusaId.key, {
-          option_id: payload.shippingInstruction.shippingMethod.key,
-          data: {
-            consent_for_unattended_delivery: payload.shippingInstruction.consentForUnattendedDelivery + "",
-            instructions: payload.shippingInstruction.instructions || ""
-          }
-        });
+        await client.store.cart.addShippingMethod(medusaId.key, this.setShippingInstructionPayload(payload));
       }
       await client.store.cart.update(medusaId.key, {
         metadata: {

package/providers/order-search.provider.js

@@ -25,9 +25,8 @@ class MedusaOrderSearchProvider extends OrderSearchProvider {
     this.medusaApi = medusaApi;
     this.config = config;
   }
-  async queryByTerm(payload) {
-    debug("queryByTerm", payload);
-    const medusa = await this.medusaApi.getClient();
+  queryByTermPayload(payload) {
+    const filters = {};
     if (payload.search.term) {
       debug("Searching orders by term is not supported in Medusa");
     }
@@ -56,11 +55,16 @@ class MedusaOrderSearchProvider extends OrderSearchProvider {
       }
       return retStatus;
     });
-    const response = await medusa.store.order.list({
+    return {
       status: statusFilter,
       limit: payload.search.paginationOptions.pageSize,
       offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
-    });
+    };
+  }
+  async queryByTerm(payload) {
+    debug("queryByTerm", payload);
+    const medusa = await this.medusaApi.getClient();
+    const response = await medusa.store.order.list(this.queryByTermPayload(payload));
     const result = this.parsePaginatedResult(response, payload);
     if (debug.enabled) {
       debug(

package/providers/product-recommendations.provider.js

@@ -14,6 +14,13 @@ class MedusaProductRecommendationsProvider extends ProductRecommendationsProvide
     this.config = config;
     this.medusaApi = medusaApi;
   }
+  getCollectionPayload(query, collection) {
+    return {
+      collection_id: [collection.id],
+      limit: query.numberOfRecommendations,
+      fields: "+variants.id,+variants.sku,+external_id"
+    };
+  }
   /**
    * Get product recommendations from a Medusa collection
    *
@@ -44,11 +51,7 @@ class MedusaProductRecommendationsProvider extends ProductRecommendationsProvide
       if (debug.enabled) {
         debug(`Found collection: ${collection.title} (${collection.id})`);
       }
-      const productsResponse = await client.store.product.list({
-        collection_id: [collection.id],
-        limit: query.numberOfRecommendations,
-        fields: "+variants.id,+variants.sku,+external_id"
-      });
+      const productsResponse = await client.store.product.list(this.getCollectionPayload(query, collection));
       if (debug.enabled) {
         debug(`Found ${productsResponse.products.length} products in collection`);
       }

package/providers/product-search.provider.js

@@ -61,6 +61,16 @@ class MedusaSearchProvider extends ProductSearchProvider {
     }
     return candidate || null;
   }
+  queryByTermPayload(payload, categoryIdToFind) {
+    const finalSearch = (payload.search.term || "").trim().replace("*", "");
+    return {
+      q: finalSearch,
+      ...categoryIdToFind ? { category_id: categoryIdToFind } : {},
+      limit: payload.search.paginationOptions.pageSize,
+      fields: "+metadata.*,+external_id",
+      offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
+    };
+  }
   async queryByTerm(payload) {
     const client = await this.medusaApi.getClient();
     let categoryIdToFind = null;
@@ -82,14 +92,7 @@ class MedusaSearchProvider extends ProductSearchProvider {
         );
       }
     }
-    const finalSearch = (payload.search.term || "").trim().replace("*", "");
-    const response = await client.store.product.list({
-      q: finalSearch,
-      ...categoryIdToFind ? { category_id: categoryIdToFind } : {},
-      limit: payload.search.paginationOptions.pageSize,
-      fields: "+metadata.*,+external_id",
-      offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
-    });
+    const response = await client.store.product.list(this.queryByTermPayload(payload, categoryIdToFind));
     const result = this.parsePaginatedResult(response);
     if (debug.enabled) {
       debug(

package/providers/product.provider.js

@@ -30,18 +30,21 @@ class MedusaProductProvider extends ProductProvider {
     this.alwaysIncludedFields = ["+metadata.*", "+categories.metadata.*", "+external_id"];
     this.config = config;
   }
+  getByIdPayload(payload) {
+    return {
+      external_id: payload.identifier.key,
+      limit: 1,
+      offset: 0,
+      fields: this.alwaysIncludedFields.join(",")
+    };
+  }
   async getById(payload) {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
       debug(`Fetching product by ID: ${payload.identifier.key}`);
     }
     const response = await client.store.product.list(
-      {
-        external_id: payload.identifier.key,
-        limit: 1,
-        offset: 0,
-        fields: this.alwaysIncludedFields.join(",")
-      }
+      this.getByIdPayload(payload)
     );
     if (response.count === 0) {
       return error({
@@ -51,17 +54,20 @@ class MedusaProductProvider extends ProductProvider {
     }
     return success(this.parseSingle(response.products[0]));
   }
+  getBySlugPayload(payload) {
+    return {
+      handle: payload.slug,
+      limit: 1,
+      offset: 0,
+      fields: this.alwaysIncludedFields.join(",")
+    };
+  }
   async getBySlug(payload) {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
       debug(`Fetching product by slug: ${payload.slug}`);
     }
-    const response = await client.store.product.list({
-      handle: payload.slug,
-      limit: 1,
-      offset: 0,
-      fields: this.alwaysIncludedFields.join(",")
-    });
+    const response = await client.store.product.list(this.getBySlugPayload(payload));
     if (debug.enabled) {
       debug(`Found ${response.count} products for slug: ${payload.slug}`);
     }

package/providers/profile.provider.js

@@ -45,6 +45,13 @@ class MedusaProfileProvider extends ProfileProvider {
     const model = this.parseSingle(customerResponse.customer);
     return success(model);
   }
+  updatePayload(payload) {
+    const updateData = {};
+    if (payload.phone !== void 0) {
+      updateData.phone = payload.phone;
+    }
+    return updateData;
+  }
   async update(payload) {
     debug("update", payload);
     const client = await this.medusaApi.getClient();
@@ -56,16 +63,16 @@ class MedusaProfileProvider extends ProfileProvider {
       });
     }
     const customer = customerResponse.customer;
-    const updatedResponse = await client.store.customer.update({
-      phone: payload.phone ?? customer.phone
-    }, { fields: this.includedFields.join(",") });
+    const updatedResponse = await client.store.customer.update(this.updatePayload(payload), { fields: this.includedFields.join(",") });
     const model = this.parseSingle(updatedResponse.customer);
     return success(model);
   }
+  addShippingAddressPayload(payload) {
+    return this.createMedusaAddress(payload.address);
+  }
   async addShippingAddress(payload) {
     debug("addShippingAddress", payload);
     const client = await this.medusaApi.getClient();
-    const medusaAddress = this.createMedusaAddress(payload.address);
     const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
     if (!customer.customer) {
       return error({
@@ -80,7 +87,7 @@ class MedusaProfileProvider extends ProfileProvider {
         error: "Address with the same nickname already exists"
       });
     }
-    const response = await client.store.customer.createAddress(medusaAddress, { fields: this.includedFields.join(",") });
+    const response = await client.store.customer.createAddress(this.addShippingAddressPayload(payload), { fields: this.includedFields.join(",") });
     if (!response.customer) {
       return error({
         type: "InvalidInput",
@@ -90,6 +97,9 @@ class MedusaProfileProvider extends ProfileProvider {
     const model = this.parseSingle(response.customer);
     return success(model);
   }
+  updateShippingAddressPayload(payload) {
+    return this.createMedusaAddress(payload.address);
+  }
   async updateShippingAddress(payload) {
     debug("updateShippingAddress", payload);
     const client = await this.medusaApi.getClient();
@@ -100,7 +110,6 @@ class MedusaProfileProvider extends ProfileProvider {
         identifier: payload.identifier
       });
     }
-    const medusaAddress = this.createMedusaAddress(payload.address);
     const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
     if (!existingAddress) {
       return error({
@@ -108,7 +117,7 @@ class MedusaProfileProvider extends ProfileProvider {
         identifier: payload.address.identifier
       });
     }
-    const response = await client.store.customer.updateAddress(existingAddress.id, medusaAddress, { fields: this.includedFields.join(",") });
+    const response = await client.store.customer.updateAddress(existingAddress.id, this.updateShippingAddressPayload(payload), { fields: this.includedFields.join(",") });
     if (!response.customer) {
       return error({
         type: "InvalidInput",
@@ -146,6 +155,11 @@ class MedusaProfileProvider extends ProfileProvider {
     const model = this.parseSingle(customerAfterDelete.customer);
     return success(model);
   }
+  makeShippingAddressDefaultPayload(payload) {
+    return {
+      is_default_shipping: true
+    };
+  }
   async makeShippingAddressDefault(payload) {
     debug("makeShippingAddressDefault", payload);
     const client = await this.medusaApi.getClient();
@@ -165,14 +179,17 @@ class MedusaProfileProvider extends ProfileProvider {
     }
     const response = await client.store.customer.updateAddress(
       existingAddress.id,
-      {
-        is_default_shipping: true
-      },
+      this.makeShippingAddressDefaultPayload(payload),
       { fields: this.includedFields.join(",") }
     );
     const model = this.parseSingle(response.customer);
     return success(model);
   }
+  setBillingAddressPayload(payload) {
+    const newAddr = this.createMedusaAddress(payload.address);
+    newAddr.is_default_billing = true;
+    return newAddr;
+  }
   async setBillingAddress(payload) {
     debug("setBillingAddress", payload);
     const client = await this.medusaApi.getClient();
@@ -191,8 +208,7 @@ class MedusaProfileProvider extends ProfileProvider {
         error: "Another address with the same nickname already exists"
       });
     }
-    const newAddr = this.createMedusaAddress(payload.address);
-    newAddr.is_default_billing = true;
+    const newAddr = this.setBillingAddressPayload(payload);
     const existingBillingAddress = customer.addresses.find((addr) => addr.is_default_billing);
     if (existingBillingAddress) {
       const updateAddressResponse = await client.store.customer.updateAddress(existingBillingAddress.id, newAddr, { fields: this.includedFields.join(",") });

package/src/providers/cart.provider.d.ts

@@ -2,7 +2,7 @@ import type { Cache, Cart, CartIdentifier, CartItem, CartMutationApplyCoupon, Ca
 import { CartProvider } from '@reactionary/core';
 import type { MedusaAPI } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
-import type MedusaTypes = require('@medusajs/types');
+import type { StoreAddCartLineItem, StoreCart, StoreCartAddPromotion, StoreCartLineItem, StoreCartRemovePromotion, StoreCreateCart, StoreUpdateCart, StoreUpdateCartLineItem } from '@medusajs/types';
 export declare class MedusaCartProvider extends CartProvider {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
@@ -15,14 +15,53 @@ export declare class MedusaCartProvider extends CartProvider {
     protected includedFields: string;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
     getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
+    /**
+     * Extension point for the `add` operation to control the payload sent to Medusa when adding an item to the cart. By default, it only includes the variant ID and quantity, but you can override it to include more fields as needed.
+     *
+     * @param payload
+     * @param variantId
+     * @returns
+     */
+    protected addPayload(payload: CartMutationItemAdd, variantId: string): StoreAddCartLineItem;
     add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
     remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
+    /**
+     * Extension point for the `changeQuantity` operation to control the payload sent to Medusa when changing the quantity of an item in the cart. By default, it only includes the new quantity, but you can override it to include more fields as needed.
+     * @param payload
+     * @returns
+     */
+    protected changeQuantityPayload(payload: CartMutationItemQuantityChange): StoreUpdateCartLineItem;
     changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
     getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
     deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
+    /**
+     * Extension point to apply a coupon code to the cart. By default, it only includes the coupon code, but you can override it to include more fields as needed.
+     * @param payload
+     * @returns
+     */
+    protected applyCouponCodePayload(payload: CartMutationApplyCoupon): StoreCartAddPromotion;
     applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
+    /**
+     * Extension point to remove a coupon code from the cart. By default, it only includes the coupon code to be removed, but you can override it to include more fields as needed.
+     * @param payload
+     * @returns
+     */
+    protected removeCouponCodePayload(payload: CartMutationRemoveCoupon): StoreCartRemovePromotion;
     removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
+    /**
+     * Extension point to control the payload sent to Medusa when changing the currency of the cart. By default, it only includes the new region ID, but you can override it to include more fields as needed.
+     * @param payload
+     * @param newRegionId
+     * @returns
+     */
+    protected changeCurrencyPayload(payload: CartMutationChangeCurrency, newRegionId: string): StoreUpdateCart;
     changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
+    /**
+     * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
+     * @param currency
+     * @returns
+     */
+    protected createCartPayload(currency?: string): StoreCreateCart;
     protected createCart(currency?: string): Promise<CartIdentifier>;
     protected getClient(): Promise<{
         client: import("@medusajs/js-sdk").Client;
@@ -36,24 +75,24 @@ export declare class MedusaCartProvider extends CartProvider {
      * @param currency
      * @returns
      */
-    protected parseItemPrice(remoteItem: MedusaTypes.StoreCartLineItem, currency: Currency): ItemCostBreakdown;
+    protected parseItemPrice(remoteItem: StoreCartLineItem, currency: Currency): ItemCostBreakdown;
     /**
      * Extension point to control the parsing of the cost breakdown of a cart
      * @param remote
      * @returns
      */
-    protected parseCostBreakdown(remote: MedusaTypes.StoreCart): CostBreakDown;
+    protected parseCostBreakdown(remote: StoreCart): CostBreakDown;
     /**
      * Extension point to control the parsing of a single cart item
      * @param remoteItem
      * @param currency
      * @returns
      */
-    protected parseCartItem(remoteItem: MedusaTypes.StoreCartLineItem, currency: Currency): CartItem;
+    protected parseCartItem(remoteItem: StoreCartLineItem, currency: Currency): CartItem;
     /**
      * Extension point to control the parsing of a single cart
      * @param remote
      * @returns
      */
-    protected parseSingle(remote: MedusaTypes.StoreCart): Cart;
+    protected parseSingle(remote: StoreCart): Cart;
 }

package/src/providers/category.provider.d.ts

@@ -8,8 +8,19 @@ export declare class MedusaCategoryProvider extends CategoryProvider {
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
     protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
     getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
+    protected getBySlugPayload(payload: CategoryQueryBySlug): {
+        handle: string;
+        limit: number;
+        offset: number;
+    };
     getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
     getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
+    protected findChildCategoriesPayload(payload: CategoryQueryForChildCategories, actualParent: StoreProductCategory): {
+        fields: string;
+        parent_category_id: string;
+        limit: number;
+        offset: number;
+    };
     findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<{
         pageNumber: number;
         pageSize: number;
@@ -17,6 +28,12 @@ export declare class MedusaCategoryProvider extends CategoryProvider {
         totalPages: number;
         items: Category[];
     }>>;
+    protected findTopCategoriesPayload(payload: CategoryQueryForTopCategories): {
+        fields: string;
+        parent_category_id: string;
+        limit: number;
+        offset: number;
+    };
     findTopCategories(payload: CategoryQueryForTopCategories): Promise<import("@reactionary/core").Ok<{
         pageNumber: number;
         pageSize: number;

package/src/providers/checkout.provider.d.ts

@@ -1,4 +1,4 @@
-import type { StoreCart, StoreCartAddress, StoreCartLineItem } from '@medusajs/types';
+import type { StoreAddCartShippingMethods, StoreCart, StoreCartAddress, StoreCartLineItem, StoreInitializePaymentSession, StoreUpdateCart } from '@medusajs/types';
 import type { Address, Cache, Checkout, CheckoutIdentifier, CheckoutItem, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, CostBreakDown, Currency, ItemCostBreakdown, PaymentMethod, RequestContext, ShippingMethod, Result, NotFoundError } from '@reactionary/core';
 import { CheckoutProvider } from '@reactionary/core';
 import type { MedusaAPI } from '../core/client.js';
@@ -18,13 +18,23 @@ export declare class MedusaCheckoutProvider extends CheckoutProvider {
      */
     protected includedFields: string;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
+    protected initiateCheckoutForCartPayload(payload: CheckoutMutationInitiateCheckout): StoreUpdateCart;
     initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<Checkout>>;
     getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>>;
+    protected setShippingAddressPayload(payload: CheckoutMutationSetShippingAddress): StoreUpdateCart;
     setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<Checkout>>;
+    protected getAvailableShippingMethodsPayload(payload: CheckoutQueryForAvailableShippingMethods): {
+        cart_id: string;
+    };
     getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<ShippingMethod[]>>;
+    protected getAvailablePaymentMethodsPayload(payload: CheckoutQueryForAvailablePaymentMethods, regionId: string): {
+        region_id: string;
+    };
     getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<PaymentMethod[]>>;
+    protected addPaymentInstructionPayload(payload: CheckoutMutationAddPaymentInstruction): StoreInitializePaymentSession;
     addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<Checkout>>;
     removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<Checkout>>;
+    protected setShippingInstructionPayload(payload: CheckoutMutationSetShippingInstruction): StoreAddCartShippingMethods;
     setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<Checkout>>;
     finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<Checkout>>;
     /**

package/src/providers/order-search.provider.d.ts

@@ -7,6 +7,7 @@ export declare class MedusaOrderSearchProvider extends OrderSearchProvider {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
+    protected queryByTermPayload(payload: OrderSearchQueryByTerm): any;
     queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>>;
     protected composeAddressFromStoreAddress(storeAddress: StoreOrderAddress): Address;
     protected parseSingle(body: StoreOrder): {

package/src/providers/product-recommendations.provider.d.ts

@@ -1,4 +1,4 @@
-import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import type { StoreCollection, StoreProduct, StoreProductVariant } from '@medusajs/types';
 import { ProductRecommendationsProvider, type Cache, type ProductRecommendation, type ProductRecommendationsByCollectionQuery, type ProductSearchResultItemVariant, type RequestContext, type Result } from '@reactionary/core';
 import type { MedusaAPI } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
@@ -16,6 +16,11 @@ export declare class MedusaProductRecommendationsProvider extends ProductRecomme
     protected config: MedusaConfiguration;
     protected medusaApi: MedusaAPI;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
+    protected getCollectionPayload(query: ProductRecommendationsByCollectionQuery, collection: StoreCollection): {
+        collection_id: string[];
+        limit: number;
+        fields: string;
+    };
     /**
      * Get product recommendations from a Medusa collection
      *

package/src/providers/product-search.provider.d.ts

@@ -7,6 +7,7 @@ export declare class MedusaSearchProvider extends ProductSearchProvider {
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
     protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
+    protected queryByTermPayload(payload: ProductSearchQueryByTerm, categoryIdToFind: string | null): any;
     queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
     protected parsePaginatedResult(remote: StoreProductListResponse): {
         identifier: {

package/src/providers/product.provider.d.ts

@@ -8,7 +8,19 @@ export declare class MedusaProductProvider extends ProductProvider {
     protected config: MedusaConfiguration;
     protected alwaysIncludedFields: string[];
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
+    protected getByIdPayload(payload: ProductQueryById): {
+        external_id: string;
+        limit: number;
+        offset: number;
+        fields: string;
+    };
     getById(payload: ProductQueryById): Promise<Result<Product>>;
+    protected getBySlugPayload(payload: ProductQueryBySlug): {
+        handle: string;
+        limit: number;
+        offset: number;
+        fields: string;
+    };
     getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;
     getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>>;
     protected parseSingle(_body: StoreProduct): Product;

package/src/providers/profile.provider.d.ts

@@ -18,11 +18,18 @@ export declare class MedusaProfileProvider extends ProfileProvider {
     protected includedFields: string[];
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
     getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>>;
+    protected updatePayload(payload: ProfileMutationUpdate): any;
     update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
+    protected addShippingAddressPayload(payload: ProfileMutationAddShippingAddress): StoreCreateCustomerAddress;
     addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    protected updateShippingAddressPayload(payload: ProfileMutationUpdateShippingAddress): StoreCreateCustomerAddress;
     updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
     removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    protected makeShippingAddressDefaultPayload(payload: ProfileMutationMakeShippingAddressDefault): {
+        is_default_shipping: boolean;
+    };
     makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
+    protected setBillingAddressPayload(payload: ProfileMutationSetBillingAddress): StoreCreateCustomerAddress;
     setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
     protected createMedusaAddress(address: Address): StoreCreateCustomerAddress;
     protected parseAddress(address: StoreCustomerAddress): Address;