@reactionary/medusa 0.6.4 → 0.6.6

package/capabilities/product.capability.js

@@ -10,16 +10,14 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
-  CategoryIdentifierSchema,
-  ProductIdentifierSchema,
+  error,
   ProductCapability,
   ProductQueryByIdSchema,
   ProductQueryBySKUSchema,
   ProductQueryBySlugSchema,
   ProductSchema,
   Reactionary,
-  success,
-  error
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:product");
@@ -31,7 +29,11 @@ class MedusaProductCapability extends ProductCapability {
     this.factory = factory;
   }
   config;
-  alwaysIncludedFields = ["+metadata.*", "+categories.metadata.*", "+external_id"];
+  alwaysIncludedFields = [
+    "+metadata.*",
+    "+categories.metadata.*",
+    "+external_id"
+  ];
   factory;
   getByIdPayload(payload) {
     return {
@@ -55,7 +57,7 @@ class MedusaProductCapability extends ProductCapability {
         identifier: payload
       });
     }
-    return success(this.parseSingle(response.products[0]));
+    return success(this.factory.parseProduct(this.context, response.products[0]));
   }
   getBySlugPayload(payload) {
     return {
@@ -70,7 +72,9 @@ class MedusaProductCapability extends ProductCapability {
     if (debug.enabled) {
       debug(`Fetching product by slug: ${payload.slug}`);
     }
-    const response = await client.store.product.list(this.getBySlugPayload(payload));
+    const response = await client.store.product.list(
+      this.getBySlugPayload(payload)
+    );
     if (debug.enabled) {
       debug(`Found ${response.count} products for slug: ${payload.slug}`);
     }
@@ -80,11 +84,15 @@ class MedusaProductCapability extends ProductCapability {
         identifier: payload
       });
     }
-    return success(this.parseSingle(response.products[0]));
+    return success(
+      this.factory.parseProduct(this.context, response.products[0])
+    );
   }
   async getBySKU(payload) {
     if (debug.enabled) {
-      debug(`Fetching product by SKU: ${Array.isArray(payload) ? payload.join(", ") : payload}`);
+      debug(
+        `Fetching product by SKU: ${Array.isArray(payload) ? payload.join(", ") : payload}`
+      );
     }
     const sku = payload.variant.sku;
     const product = await this.medusaApi.resolveProductForSKU(sku);
@@ -93,128 +101,7 @@ class MedusaProductCapability extends ProductCapability {
       throw new Error(`Variant with SKU ${sku} not found`);
     }
     product.variants = product.variants?.filter((v) => v.sku === sku).concat(product.variants?.filter((v) => v.sku !== sku)) || [];
-    return success(this.parseSingle(product));
-  }
-  parseSingle(_body) {
-    const identifier = ProductIdentifierSchema.parse({ key: _body.external_id || _body.id });
-    const name = _body.title;
-    const slug = _body.handle;
-    const description = _body.description || "" || _body.subtitle || "";
-    const parentCategories = [];
-    parentCategories.push(
-      ..._body.categories?.map((cat) => cat.metadata?.["external_id"]).map((id) => CategoryIdentifierSchema.parse({ key: id || "" })) || []
-    );
-    const sharedAttributes = this.parseAttributes(_body);
-    if (!_body.variants) {
-      debug("Product has no variants", _body);
-      throw new Error("Product has no variants " + _body.external_id);
-    }
-    const mainVariant = this.parseVariant(_body.variants[0], _body);
-    const otherVariants = [];
-    if (_body.variants.length > 1) {
-      otherVariants.push(
-        ..._body.variants.slice(1).map((variant) => this.parseVariant(variant, _body))
-      );
-    }
-    const result = {
-      brand: "",
-      description,
-      identifier,
-      longDescription: "",
-      mainVariant,
-      manufacturer: "",
-      name,
-      options: [],
-      parentCategories,
-      published: true,
-      sharedAttributes,
-      slug,
-      variants: otherVariants
-    };
-    return this.factory.parseProduct(this.context, result);
-  }
-  parseVariant(variant, product) {
-    const options = (variant.options ?? []).map((option) => {
-      const optionId = { key: option.option_id || "" };
-      const title = option.option?.title || "?";
-      const valueIdentifier = { key: option.option_id || "", option: optionId };
-      const value = option.value || "";
-      const result2 = {
-        identifier: optionId,
-        name: title,
-        value: {
-          identifier: valueIdentifier,
-          label: value
-        }
-      };
-      return result2;
-    });
-    const result = {
-      identifier: {
-        sku: variant.sku || ""
-      },
-      name: variant.title || product.title,
-      upc: variant.upc || "",
-      ean: variant.ean || "",
-      images: (product.images || []).map((img) => {
-        return {
-          sourceUrl: img.url,
-          altText: variant.title || product.title || ""
-        };
-      }),
-      options,
-      gtin: variant.ean || "",
-      barcode: variant.ean || ""
-    };
-    return result;
-  }
-  createSynthAttribute(key, name, value) {
-    const attributeIdentifier = { key };
-    const valueIdentifier = { key: `${key}-${value}` };
-    const attribute = {
-      identifier: { key },
-      name,
-      group: "",
-      values: [
-        {
-          identifier: valueIdentifier,
-          label: String(value),
-          value
-        }
-      ]
-    };
-    return attribute;
-  }
-  parseAttributes(_body) {
-    const sharedAttributes = [];
-    if (_body.origin_country) {
-      sharedAttributes.push(this.createSynthAttribute("origin_country", "Origin Country", _body.origin_country));
-    }
-    if (_body.height) {
-      sharedAttributes.push(this.createSynthAttribute("height", "Height", String(_body.height)));
-    }
-    if (_body.weight) {
-      sharedAttributes.push(this.createSynthAttribute("weight", "Weight", String(_body.weight)));
-    }
-    if (_body.length) {
-      sharedAttributes.push(this.createSynthAttribute("length", "Length", String(_body.length)));
-    }
-    if (_body.width) {
-      sharedAttributes.push(this.createSynthAttribute("width", "Width", String(_body.width)));
-    }
-    if (_body.material) {
-      sharedAttributes.push(this.createSynthAttribute("material", "Material", _body.material));
-    }
-    if (_body.metadata) {
-      const keysToExclude = ["reactionaryaccessories", "reactionaryreplacements", "reactionaryspareparts"];
-      for (const [key, value] of Object.entries(_body.metadata)) {
-        if (keysToExclude.includes(key)) {
-          continue;
-        }
-        sharedAttributes.push(this.createSynthAttribute(key, key, String(value)));
-      }
-    }
-    return sharedAttributes;
+    return success(this.factory.parseProduct(this.context, product));
   }
 }
 __decorateClass([

package/capabilities/profile.capability.js

@@ -11,17 +11,17 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 import {
   ProfileCapability,
-  Reactionary,
-  ProfileSchema,
-  ProfileMutationUpdateSchema,
   ProfileMutationAddShippingAddressSchema,
-  ProfileMutationUpdateShippingAddressSchema,
-  ProfileMutationRemoveShippingAddressSchema,
   ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationRemoveShippingAddressSchema,
   ProfileMutationSetBillingAddressSchema,
-  success,
+  ProfileMutationUpdateSchema,
+  ProfileMutationUpdateShippingAddressSchema,
   ProfileQueryByIdSchema,
-  error
+  ProfileSchema,
+  Reactionary,
+  error,
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:profile");
@@ -45,7 +45,7 @@ class MedusaProfileCapability extends ProfileCapability {
         type: "NotFound"
       });
     }
-    const model = this.parseSingle(customerResponse.customer);
+    const model = this.factory.parseProfile(this.context, customerResponse.customer);
     return success(model);
   }
   updatePayload(payload) {
@@ -67,7 +67,7 @@ class MedusaProfileCapability extends ProfileCapability {
     }
     const customer = customerResponse.customer;
     const updatedResponse = await client.store.customer.update(this.updatePayload(payload), { fields: this.includedFields.join(",") });
-    const model = this.parseSingle(updatedResponse.customer);
+    const model = this.factory.parseProfile(this.context, updatedResponse.customer);
     return success(model);
   }
   addShippingAddressPayload(payload) {
@@ -97,7 +97,7 @@ class MedusaProfileCapability extends ProfileCapability {
         error: "Failed to add shipping address"
       });
     }
-    const model = this.parseSingle(response.customer);
+    const model = this.factory.parseProfile(this.context, response.customer);
     return success(model);
   }
   updateShippingAddressPayload(payload) {
@@ -127,7 +127,7 @@ class MedusaProfileCapability extends ProfileCapability {
         error: "Failed to add shipping address"
       });
     }
-    const model = this.parseSingle(response.customer);
+    const model = this.factory.parseProfile(this.context, response.customer);
     return success(model);
   }
   async removeShippingAddress(payload) {
@@ -155,7 +155,7 @@ class MedusaProfileCapability extends ProfileCapability {
       });
     }
     const customerAfterDelete = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
-    const model = this.parseSingle(customerAfterDelete.customer);
+    const model = this.factory.parseProfile(this.context, customerAfterDelete.customer);
     return success(model);
   }
   makeShippingAddressDefaultPayload(payload) {
@@ -185,7 +185,7 @@ class MedusaProfileCapability extends ProfileCapability {
       this.makeShippingAddressDefaultPayload(payload),
       { fields: this.includedFields.join(",") }
     );
-    const model = this.parseSingle(response.customer);
+    const model = this.factory.parseProfile(this.context, response.customer);
     return success(model);
   }
   setBillingAddressPayload(payload) {
@@ -220,7 +220,7 @@ class MedusaProfileCapability extends ProfileCapability {
       const createAddressResponse = await client.store.customer.createAddress(newAddr, { fields: this.includedFields.join(",") });
       customer = createAddressResponse.customer;
     }
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
   createMedusaAddress(address) {
@@ -236,55 +236,6 @@ class MedusaProfileCapability extends ProfileCapability {
       country_code: address.countryCode
     };
   }
-  parseAddress(address) {
-    return {
-      identifier: {
-        nickName: address.address_name || ""
-      },
-      firstName: address.first_name || "",
-      lastName: address.last_name || "",
-      streetAddress: address.address_1 || "",
-      streetNumber: address.address_2 || "",
-      city: address.city || "",
-      region: address.province || "",
-      postalCode: address.postal_code || "",
-      countryCode: address.country_code || ""
-    };
-  }
-  parseSingle(customer) {
-    const email = customer.email;
-    const emailVerified = customer.metadata?.["email_verified"] === "true";
-    const phone = customer.phone || "";
-    const phoneVerified = customer.metadata?.["phone_verified"] === "true";
-    const addresses = customer.addresses || [];
-    let billingAddress = void 0;
-    let shippingAddress = void 0;
-    const existingBillingAddress = customer.addresses.find((addr) => addr.is_default_billing);
-    if (existingBillingAddress) {
-      billingAddress = this.parseAddress(existingBillingAddress);
-    }
-    const existingShippingAddress = customer.addresses.find((addr) => addr.is_default_shipping);
-    if (existingShippingAddress) {
-      shippingAddress = this.parseAddress(existingShippingAddress);
-    }
-    const alternateShippingAddresses = [];
-    alternateShippingAddresses.push(...addresses.filter((x) => !(x.is_default_billing || x.is_default_shipping)).map((addr) => this.parseAddress(addr)));
-    const result = {
-      identifier: {
-        userId: customer.id
-      },
-      email,
-      emailVerified,
-      phone,
-      phoneVerified,
-      billingAddress,
-      shippingAddress,
-      alternateShippingAddresses,
-      createdAt: new Date(customer.created_at || "").toISOString(),
-      updatedAt: new Date(customer.updated_at || "").toISOString()
-    };
-    return this.factory.parseProfile(this.context, result);
-  }
 }
 __decorateClass([
   Reactionary({

package/factories/cart/cart.factory.js

@@ -1,3 +1,8 @@
+import {
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
+import { MedusaCartIdentifierSchema } from "../../schema/medusa.schema.js";
+import { parseMedusaCostBreakdown, parseMedusaItemPrice } from "../../utils/medusa-helpers.js";
 class MedusaCartFactory {
   cartSchema;
   cartIdentifierSchema;
@@ -5,12 +10,96 @@ class MedusaCartFactory {
     this.cartSchema = cartSchema;
     this.cartIdentifierSchema = cartIdentifierSchema;
   }
-  parseCart(_context, data) {
-    return this.cartSchema.parse(data);
+  parseCart(context, data) {
+    const identifier = MedusaCartIdentifierSchema.parse({
+      key: data.id,
+      region_id: data.region_id
+    });
+    const name = "" + (data.metadata?.["name"] || "");
+    const description = "" + (data.metadata?.["description"] || "");
+    const price = this.parseCostBreakdown(context, data);
+    const items = new Array();
+    const allItems = data.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(context, remoteItem, price.grandTotal.currency));
+    }
+    const appliedPromotions = [];
+    if (data.promotions) {
+      for (const promo of data.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.cartSchema.parse(result);
   }
   parseCartIdentifier(_context, data) {
     return this.cartIdentifierSchema.parse(data);
   }
+  /**
+  * Extension point to control the parsing of a single cart item price
+  * @param remoteItem
+  * @param currency
+  * @returns
+  */
+  parseItemPrice(_context, remoteItem, currency) {
+    return parseMedusaItemPrice(remoteItem, currency);
+  }
+  /**
+   * Extension point to control the parsing of the cost breakdown of a cart
+   * @param remote
+   * @returns
+   */
+  parseCostBreakdown(_context, remote) {
+    return parseMedusaCostBreakdown(remote);
+  }
+  /**
+   * Extension point to control the parsing of a single cart item
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseCartItem(context, 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: this.parseItemPrice(context, remoteItem, currency)
+    };
+    return item;
+  }
 }
 export {
   MedusaCartFactory

package/factories/category/category.factory.js

@@ -1,3 +1,6 @@
+import {
+  CategoryIdentifierSchema
+} from "@reactionary/core";
 class MedusaCategoryFactory {
   categorySchema;
   categoryPaginatedResultSchema;
@@ -6,10 +9,37 @@ class MedusaCategoryFactory {
     this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
   }
   parseCategory(_context, data) {
-    return this.categorySchema.parse(data);
+    const identifier = CategoryIdentifierSchema.parse({
+      key: data.metadata?.["external_id"] || ""
+    });
+    const name = data.name;
+    const slug = data.handle;
+    const text = data.description || data.name || "";
+    const parentCategory = data.parent_category_id ? { key: data.parent_category?.metadata?.["external_id"] + "" || "" } : void 0;
+    const result = {
+      identifier,
+      name,
+      slug,
+      text,
+      parentCategory,
+      images: []
+    };
+    return this.categorySchema.parse(result);
   }
-  parseCategoryPaginatedResult(_context, data) {
-    return this.categoryPaginatedResultSchema.parse(data);
+  parseCategoryPaginatedResult(context, data) {
+    const items = data.product_categories.map((x) => this.parseCategory(context, x));
+    const totalPages = Math.ceil(
+      (data.count ?? 0) / Math.max(data.product_categories.length, 1)
+    );
+    const pageNumber = data.count === 0 ? 1 : Math.floor(data.offset / data.product_categories.length) + 1;
+    const result = {
+      pageNumber,
+      pageSize: Math.max(data.product_categories.length, 1),
+      totalCount: data.count,
+      totalPages,
+      items
+    };
+    return this.categoryPaginatedResultSchema.parse(result);
   }
 }
 export {

package/factories/checkout/checkout.factory.js

@@ -1,3 +1,12 @@
+import {
+  AddressIdentifierSchema,
+  MonetaryAmountSchema,
+  ShippingMethodIdentifierSchema
+} from "@reactionary/core";
+import {
+  parseMedusaCostBreakdown,
+  parseMedusaItemPrice
+} from "../../utils/medusa-helpers.js";
 class MedusaCheckoutFactory {
   checkoutSchema;
   shippingMethodSchema;
@@ -7,14 +16,188 @@ class MedusaCheckoutFactory {
     this.shippingMethodSchema = shippingMethodSchema;
     this.paymentMethodSchema = paymentMethodSchema;
   }
-  parseCheckout(_context, data) {
-    return this.checkoutSchema.parse(data);
+  /**
+   * Extension point to control the parsing of a single cart item price
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseItemPrice(_context, remoteItem, currency) {
+    return parseMedusaItemPrice(remoteItem, currency);
+  }
+  /**
+   * Extension point to control the parsing of the cost breakdown of a cart
+   * @param remote
+   * @returns
+   */
+  parseCostBreakdown(_context, remote) {
+    return parseMedusaCostBreakdown(remote);
+  }
+  /**
+   * Extension point to control the parsing of a single checkout item
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+  parseCheckoutItem(context, remoteItem, currency) {
+    const item = {
+      identifier: {
+        key: remoteItem.id
+      },
+      variant: {
+        sku: remoteItem.variant_sku || ""
+      },
+      quantity: remoteItem.quantity || 1,
+      price: this.parseItemPrice(context, remoteItem, currency)
+    };
+    return item;
+  }
+  /**
+   * Extension point to control the parsing of an address from a store cart address
+   * @param storeAddress
+   * @returns
+   */
+  parseAddress(_context, storeAddress) {
+    return {
+      identifier: AddressIdentifierSchema.parse({
+        nickName: storeAddress.id
+      }),
+      firstName: storeAddress.first_name || "",
+      lastName: storeAddress.last_name || "",
+      streetAddress: storeAddress.address_1 || "",
+      streetNumber: storeAddress.address_2 || "",
+      city: storeAddress.city || "",
+      postalCode: storeAddress.postal_code || "",
+      countryCode: storeAddress.country_code || "",
+      region: ""
+    };
+  }
+  parseCheckout(context, data) {
+    const identifier = {
+      key: data.id
+      //        region_id: remote.region_id,
+    };
+    const name = "" + (data.metadata?.["name"] || "");
+    const description = "" + (data.metadata?.["description"] || "");
+    const price = this.parseCostBreakdown(context, data);
+    const items = new Array();
+    for (const remoteItem of data.items || []) {
+      items.push(
+        this.parseCheckoutItem(context, remoteItem, price.grandTotal.currency)
+      );
+    }
+    const billingAddress = data.billing_address ? this.parseAddress(context, data.billing_address) : void 0;
+    const shippingAddress = data.shipping_address ? this.parseAddress(context, data.shipping_address) : void 0;
+    const backupUnattendedDelivery = data.metadata?.["consent_for_unattended_delivery"] !== void 0 ? data.metadata?.["consent_for_unattended_delivery"] === "true" : void 0;
+    const backupInstructions = data.metadata?.["instructions"] !== void 0 ? data.metadata?.["instructions"] + "" : void 0;
+    const backupPickupPoint = data.metadata?.["pickup_point"] !== void 0 ? data.metadata?.["pickup_point"] + "" : void 0;
+    let shippingInstruction;
+    data.shipping_methods?.forEach((sm) => {
+      let pickupPoint = "";
+      let instructions = "";
+      let consentForUnattendedDelivery = false;
+      if (sm.data) {
+        pickupPoint = sm.data["pickup_point"] + "" || "";
+        instructions = sm.data["instructions"] + "" || "";
+        consentForUnattendedDelivery = sm.data["consent_for_unattended_delivery"] === "true";
+      }
+      if (!pickupPoint) {
+        pickupPoint = backupPickupPoint || "";
+      }
+      if (!instructions) {
+        instructions = backupInstructions || "";
+      }
+      if (!consentForUnattendedDelivery) {
+        consentForUnattendedDelivery = backupUnattendedDelivery || false;
+      }
+      shippingInstruction = {
+        shippingMethod: { key: sm.shipping_option_id },
+        consentForUnattendedDelivery,
+        instructions,
+        pickupPoint
+      };
+    });
+    const paymentInstructions = new Array();
+    for (const remotePayment of data.payment_collection?.payment_sessions || []) {
+      if (remotePayment.status === "canceled" || remotePayment.status === "error") {
+        console.warn(
+          `Skipping payment session ${remotePayment.id} with status ${remotePayment.status}`
+        );
+        continue;
+      }
+      const paymentMethodIdentifier = {
+        method: remotePayment.provider_id,
+        name: remotePayment.provider_id,
+        paymentProcessor: remotePayment.provider_id
+      };
+      paymentInstructions.push({
+        identifier: {
+          key: remotePayment.id
+        },
+        amount: {
+          value: remotePayment.amount,
+          currency: remotePayment.currency_code?.toUpperCase()
+        },
+        paymentMethod: paymentMethodIdentifier,
+        protocolData: remotePayment.data ? Object.entries(remotePayment.data).map(([key, value]) => ({
+          key,
+          value: String(value)
+        })) : [],
+        status: "pending"
+      });
+    }
+    const originalCartReference = {
+      key: data.id,
+      region: data.region_id
+    };
+    let resultingOrder = void 0;
+    if (data.metadata?.["order_id"]) {
+      resultingOrder = {
+        key: data.metadata?.["order_id"] + "" || "",
+        display_id: Number(data.metadata?.["order_display_id"] + "" || "0")
+      };
+    }
+    const result = {
+      identifier,
+      name,
+      description,
+      price,
+      items,
+      originalCartReference,
+      paymentInstructions,
+      readyForFinalization: false,
+      billingAddress,
+      resultingOrder,
+      shippingAddress,
+      shippingInstruction
+    };
+    return this.checkoutSchema.parse(result);
   }
   parseShippingMethod(_context, data) {
-    return this.shippingMethodSchema.parse(data);
+    const sm = {
+      identifier: ShippingMethodIdentifierSchema.parse({ key: data.id }),
+      name: data.name,
+      description: data.type.description || "",
+      price: MonetaryAmountSchema.parse({
+        value: data.calculated_price.calculated_amount || 0,
+        currency: data.calculated_price.currency_code?.toUpperCase()
+      }),
+      deliveryTime: ""
+    };
+    return this.shippingMethodSchema.parse(sm);
   }
   parsePaymentMethod(_context, data) {
-    return this.paymentMethodSchema.parse(data);
+    const pm = {
+      identifier: {
+        method: data.id,
+        name: data.id,
+        paymentProcessor: data.id
+      },
+      logo: void 0,
+      description: data.id,
+      isPunchOut: true
+    };
+    return this.paymentMethodSchema.parse(pm);
   }
 }
 export {