@reactionary/medusa 0.6.3

package/README.md

@@ -0,0 +1,11 @@
+# medusa
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build medusa` to build the library.
+
+## Running unit tests
+
+Run `nx test medusa` to execute the unit tests via [Vitest](https://vitest.dev/).

package/capabilities/cart.capability.js

@@ -0,0 +1,517 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartCapability,
+  CartQueryByIdSchema,
+  CartSchema,
+  error,
+  ProductVariantIdentifierSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { MedusaCartIdentifierSchema } from "../schema/medusa.schema.js";
+import {
+  handleProviderError,
+  parseMedusaCostBreakdown,
+  parseMedusaItemPrice
+} from "../utils/medusa-helpers.js";
+const debug = createDebug("reactionary:medusa:cart");
+class MedusaCartCapability extends CartCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  /**
+   * This controls which fields are always included when fetching a cart
+   * You can override this in a subclass to add more fields as needed.
+   *
+   * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
+   */
+  includedFields = ["+items.*"].join(",");
+  async getById(payload) {
+    try {
+      const client = await this.getClient();
+      const medusaId = payload.cart;
+      if (debug.enabled) {
+        debug("Fetching cart by ID:", medusaId.key);
+      }
+      const cartResponse = await client.store.cart.retrieve(medusaId.key, { fields: this.includedFields });
+      if (debug.enabled) {
+        debug("Received cart response:", cartResponse);
+      }
+      if (cartResponse.cart) {
+        return success(this.parseSingle(cartResponse.cart));
+      }
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    } catch (err) {
+      debug("Failed to get cart by ID:", error);
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+  }
+  /**
+   * 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();
+      let cartIdentifier = payload.cart;
+      if (!cartIdentifier) {
+        cartIdentifier = await this.createCart();
+      }
+      const medusaId = cartIdentifier;
+      if (debug.enabled) {
+        debug(
+          "Adding item to cart ID:",
+          medusaId.key,
+          "SKU:",
+          payload.variant.sku,
+          "Quantity:",
+          payload.quantity
+        );
+      }
+      const variantId = await this.medusaApi.resolveVariantId(payload.variant.sku);
+      const response = await client.store.cart.createLineItem(
+        medusaId.key,
+        this.addPayload(payload, variantId),
+        {
+          fields: this.includedFields
+        }
+      );
+      if (debug.enabled) {
+        debug("Received add item response:", response);
+      }
+      if (response.cart) {
+        return success(this.parseSingle(response.cart));
+      }
+      throw new Error("Failed to add item to cart");
+    } catch (error2) {
+      handleProviderError("add item to cart", error2);
+    }
+  }
+  async remove(payload) {
+    try {
+      const client = await this.getClient();
+      const medusaId = payload.cart;
+      const response = await client.store.cart.deleteLineItem(
+        medusaId.key,
+        payload.item.key,
+        {
+          fields: this.includedFields
+        }
+      );
+      if (response.parent) {
+        return success(this.parseSingle(response.parent));
+      }
+      throw new Error("Failed to remove item from cart");
+    } catch (error2) {
+      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(
+        "Changing quantity to 0 is not allowed. Use the remove call instead."
+      );
+    }
+    try {
+      const client = await this.getClient();
+      const medusaId = payload.cart;
+      const response = await client.store.cart.updateLineItem(
+        medusaId.key,
+        payload.item.key,
+        this.changeQuantityPayload(payload),
+        {
+          fields: this.includedFields
+        }
+      );
+      if (response.cart) {
+        return success(this.parseSingle(response.cart));
+      }
+      throw new Error("Failed to change item quantity");
+    } catch (error2) {
+      handleProviderError("change item quantity", error2);
+    }
+  }
+  async getActiveCartId() {
+    try {
+      const client = await this.getClient();
+      const sessionData = this.medusaApi.getSessionData();
+      const activeCartId = sessionData.activeCartId;
+      if (activeCartId) {
+        try {
+          await client.store.cart.retrieve(activeCartId);
+          return success(this.factory.parseCartIdentifier(this.context, {
+            key: activeCartId,
+            region_id: (await this.medusaApi.getActiveRegion()).id
+          }));
+        } catch {
+        }
+      }
+      return error({
+        type: "NotFound",
+        identifier: void 0
+      });
+    } catch (err) {
+      debug("Failed to get active cart ID:", err);
+      return error({
+        type: "NotFound",
+        identifier: void 0
+      });
+    }
+  }
+  async deleteCart(payload) {
+    try {
+      const client = await this.getClient();
+      const medusaId = payload.cart;
+      if (medusaId.key) {
+        const sessionData = this.medusaApi.getSessionData();
+        if (sessionData.activeCartId) {
+          delete sessionData.activeCartId;
+          this.medusaApi.setSessionData({
+            activeCartId: void 0
+          });
+        }
+      }
+      const cartResponse = await client.store.cart.retrieve(medusaId.key);
+      if (cartResponse.cart) {
+        for (const item of cartResponse.cart.items || []) {
+          await client.store.cart.deleteLineItem(medusaId.key, item.id);
+        }
+      }
+      return success(void 0);
+    } catch (error2) {
+      debug("Failed to delete cart:", error2);
+      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.client.fetch(
+        `/store/carts/${medusaId.key}/promotions`,
+        {
+          method: "POST",
+          body: this.applyCouponCodePayload(payload),
+          query: {
+            fields: this.includedFields
+          }
+        }
+      );
+      if (response.cart) {
+        return success(this.parseSingle(response.cart));
+      }
+      throw new Error("Failed to apply coupon code");
+    } catch (error2) {
+      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 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));
+      }
+      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 newRegionId = (await this.medusaApi.getActiveRegion()).id;
+      const updatedCartResponse = await client.store.cart.update(
+        payload.cart.key,
+        this.changeCurrencyPayload(payload, newRegionId),
+        {
+          fields: this.includedFields
+        }
+      );
+      if (updatedCartResponse.cart) {
+        this.medusaApi.setSessionData({
+          activeCartId: updatedCartResponse.cart.id
+        });
+        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(
+        this.createCartPayload(currency),
+        {
+          fields: this.includedFields
+        }
+      );
+      if (response.cart) {
+        const cartIdentifier = this.factory.parseCartIdentifier(this.context, {
+          key: response.cart.id,
+          region_id: response.cart.region_id
+        });
+        this.medusaApi.setSessionData({
+          activeCartId: cartIdentifier.key
+        });
+        return cartIdentifier;
+      }
+      throw new Error("Failed to create cart");
+    } catch (error2) {
+      handleProviderError("create cart", error2);
+    }
+  }
+  async getClient() {
+    return this.medusaApi.getClient();
+  }
+  /**
+   * Extension point to control the parsing of a single cart item price
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseItemPrice(remoteItem, currency) {
+    return parseMedusaItemPrice(remoteItem, currency);
+  }
+  /**
+   * Extension point to control the parsing of the cost breakdown of a cart
+   * @param remote
+   * @returns
+   */
+  parseCostBreakdown(remote) {
+    return parseMedusaCostBreakdown(remote);
+  }
+  /**
+   * Extension point to control the parsing of a single cart item
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseCartItem(remoteItem, currency) {
+    const item = {
+      identifier: {
+        key: remoteItem.id
+      },
+      product: {
+        key: remoteItem.product_id || ""
+      },
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: remoteItem.variant_sku || ""
+      }),
+      quantity: remoteItem.quantity || 1,
+      price: parseMedusaItemPrice(remoteItem, currency)
+    };
+    return item;
+  }
+  /**
+   * Extension point to control the parsing of a single cart
+   * @param remote
+   * @returns
+   */
+  parseSingle(remote) {
+    const identifier = MedusaCartIdentifierSchema.parse({
+      key: remote.id,
+      region_id: remote.region_id
+    });
+    const name = "" + (remote.metadata?.["name"] || "");
+    const description = "" + (remote.metadata?.["description"] || "");
+    const price = this.parseCostBreakdown(remote);
+    const items = new Array();
+    const allItems = remote.items || [];
+    allItems.sort(
+      (a, b) => a.created_at && b.created_at ? new Date(a.created_at).getTime() - new Date(b.created_at).getTime() : 0
+    );
+    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: "???"
+      }
+    };
+    return this.factory.parseCart(this.context, result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "remove", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "changeQuantity", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: CartIdentifierSchema
+  })
+], MedusaCartCapability.prototype, "getActiveCartId", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: CartMutationDeleteCartSchema
+  })
+], MedusaCartCapability.prototype, "deleteCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "applyCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "removeCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema
+  })
+], MedusaCartCapability.prototype, "changeCurrency", 1);
+export {
+  MedusaCartCapability
+};