@reactionary/medusa 0.6.4 → 0.6.6

package/factories/inventory/inventory.factory.js

@@ -4,7 +4,25 @@ class MedusaInventoryFactory {
     this.inventorySchema = inventorySchema;
   }
   parseInventory(_context, data) {
-    return this.inventorySchema.parse(data);
+    const { sku, fulfillmentCenterKey, quantity } = data;
+    const identifier = {
+      variant: {
+        sku
+      },
+      fulfillmentCenter: {
+        key: fulfillmentCenterKey
+      }
+    };
+    let status = "outOfStock";
+    if (quantity > 0) {
+      status = "inStock";
+    }
+    const result = {
+      identifier,
+      quantity,
+      status
+    };
+    return this.inventorySchema.parse(result);
   }
 }
 export {

package/factories/order/order.factory.js

@@ -1,10 +1,136 @@
+import {
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
+import { parseMedusaCostBreakdown, parseMedusaItemPrice } from "../../utils/medusa-helpers.js";
 class MedusaOrderFactory {
   orderSchema;
   constructor(orderSchema) {
     this.orderSchema = orderSchema;
   }
-  parseOrder(_context, data) {
-    return this.orderSchema.parse(data);
+  parseOrder(context, data) {
+    const identifier = { key: data.id };
+    const userId = {
+      userId: data.customer_id || ""
+    };
+    const items = (data.items || []).map((item) => {
+      return this.parseOrderItem(context, item, data.currency_code.toUpperCase());
+    });
+    const price = this.parseCostBreakdown(context, data);
+    let orderStatus = "AwaitingPayment";
+    if (data.status === "draft") {
+      orderStatus = "AwaitingPayment";
+    }
+    if (data.status === "pending") {
+      orderStatus = "ReleasedToFulfillment";
+    }
+    if (data.status === "completed") {
+      orderStatus = "Shipped";
+    }
+    if (data.status === "canceled") {
+      orderStatus = "Cancelled";
+    }
+    let inventoryStatus = "NotAllocated";
+    if (data.fulfillment_status === "fulfilled") {
+      inventoryStatus = "Allocated";
+    }
+    const paymentInstructions = data.payment_collections?.map((pc) => {
+      return this.parsePaymentInstruction(context, pc, data);
+    }) || [];
+    const result = {
+      identifier,
+      userId,
+      items,
+      price,
+      orderStatus,
+      inventoryStatus,
+      paymentInstructions
+    };
+    return this.orderSchema.parse(result);
+  }
+  /**
+   * 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
+   */
+  parseOrderItem(context, remoteItem, currency) {
+    const item = {
+      identifier: {
+        key: remoteItem.id
+      },
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: remoteItem.variant_sku || ""
+      }),
+      quantity: remoteItem.quantity || 1,
+      price: this.parseItemPrice(context, remoteItem, currency),
+      inventoryStatus: "Allocated"
+    };
+    return item;
+  }
+  parsePaymentInstruction(_context, remotePayment, order) {
+    const paymentMethodIdentifier = {
+      method: remotePayment.payment_providers?.[0]?.id || "unknown",
+      name: remotePayment.payment_providers?.[0]?.id || "unknown",
+      paymentProcessor: remotePayment.payment_providers?.[0]?.id || "unknown"
+    };
+    let status = "pending";
+    switch (remotePayment.status) {
+      case "not_paid":
+        status = "pending";
+        break;
+      case "awaiting":
+        status = "pending";
+        break;
+      case "authorized":
+        status = "authorized";
+        break;
+      case "partially_authorized":
+        status = "pending";
+        break;
+      case "canceled":
+        status = "canceled";
+        break;
+      case "failed":
+        status = "canceled";
+        break;
+      case "completed":
+        status = "capture";
+        break;
+    }
+    const paymentData = remotePayment.payments?.[0].data || {};
+    const pi = {
+      identifier: {
+        key: remotePayment.id
+      },
+      amount: {
+        value: remotePayment.amount,
+        currency: remotePayment.currency_code?.toUpperCase()
+      },
+      paymentMethod: paymentMethodIdentifier,
+      protocolData: paymentData ? Object.entries(paymentData).map(([key, value]) => ({
+        key,
+        value: String(value)
+      })) : [],
+      status
+    };
+    return pi;
   }
 }
 export {

package/factories/order-search/order-search.factory.js

@@ -1,10 +1,83 @@
+import {
+  AddressIdentifierSchema
+} from "@reactionary/core";
 class MedusaOrderSearchFactory {
   orderSearchResultSchema;
   constructor(orderSearchResultSchema) {
     this.orderSearchResultSchema = orderSearchResultSchema;
   }
-  parseOrderSearchResult(_context, data, _query) {
-    return this.orderSearchResultSchema.parse(data);
+  parseOrderSearchResultItem(context, body) {
+    const identifier = { key: body.id };
+    const userId = {
+      userId: body.customer_id || ""
+    };
+    const customerName = `${body.billing_address?.first_name} ${body.billing_address?.last_name}`;
+    const shippingAddress = this.parseAddress(context, body.shipping_address);
+    const orderDate = new Date(body.created_at).toISOString();
+    let orderStatus = "AwaitingPayment";
+    if (body.status === "draft") {
+      orderStatus = "AwaitingPayment";
+    }
+    if (body.status === "pending") {
+      orderStatus = "ReleasedToFulfillment";
+    }
+    if (body.status === "completed") {
+      orderStatus = "Shipped";
+    }
+    if (body.status === "canceled") {
+      orderStatus = "Cancelled";
+    }
+    let inventoryStatus = "NotAllocated";
+    if (body.fulfillment_status === "fulfilled") {
+      inventoryStatus = "Allocated";
+    }
+    const totalAmount = {
+      currency: body.currency_code.toUpperCase(),
+      value: body.total ? body.total : 0
+    };
+    const order = {
+      identifier,
+      userId,
+      customerName,
+      shippingAddress,
+      orderDate,
+      orderStatus,
+      inventoryStatus,
+      totalAmount
+    };
+    return order;
+  }
+  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: ""
+    };
+  }
+  parseOrderSearchResult(_context, data, query) {
+    const identifier = {
+      ...query.search
+    };
+    const orders = data.orders.map((o) => {
+      return this.parseOrderSearchResultItem(_context, o);
+    });
+    const result = {
+      identifier,
+      pageNumber: (Math.ceil(data.offset / data.limit) || 0) + 1,
+      pageSize: data.limit,
+      totalCount: data.count,
+      totalPages: Math.ceil(data.count / data.limit || 0) + 1,
+      items: orders
+    };
+    return this.orderSearchResultSchema.parse(result);
   }
 }
 export {

package/factories/price/price.factory.js

@@ -3,8 +3,37 @@ class MedusaPriceFactory {
   constructor(priceSchema) {
     this.priceSchema = priceSchema;
   }
-  parsePrice(_context, data, _options) {
-    return this.priceSchema.parse(data);
+  parsePrice(context, data, _options) {
+    const identifier = {
+      variant: {
+        sku: data.variant.sku || ""
+      }
+    };
+    const calculatedPrice = data.variant.calculated_price;
+    let unitPrice;
+    let isOnSale = false;
+    if (calculatedPrice) {
+      const priceToUse = data.mode === "customer" ? calculatedPrice.calculated_amount : calculatedPrice.original_amount;
+      if (data.mode === "customer") {
+        isOnSale = calculatedPrice.calculated_price?.price_list_type === "sale";
+      }
+      unitPrice = {
+        value: priceToUse || 0,
+        currency: calculatedPrice.currency_code?.toUpperCase() || context.languageContext.currencyCode
+      };
+    } else {
+      unitPrice = {
+        value: -1,
+        currency: context.languageContext.currencyCode
+      };
+    }
+    const result = {
+      identifier,
+      tieredPrices: [],
+      unitPrice,
+      onSale: isOnSale
+    };
+    return this.priceSchema.parse(result);
   }
 }
 export {

package/factories/product/product.factory.js

@@ -1,10 +1,163 @@
+import {
+  CategoryIdentifierSchema,
+  ProductIdentifierSchema
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:product");
 class MedusaProductFactory {
   productSchema;
   constructor(productSchema) {
     this.productSchema = productSchema;
   }
-  parseProduct(_context, data) {
-    return this.productSchema.parse(data);
+  parseVariant(_context, 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: attributeIdentifier,
+      name,
+      group: "",
+      values: [
+        {
+          identifier: valueIdentifier,
+          label: String(value),
+          value
+        }
+      ]
+    };
+    return attribute;
+  }
+  parseAttributes(_context, _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;
+  }
+  parseProduct(context, data) {
+    const identifier = ProductIdentifierSchema.parse({
+      key: data.external_id || data.id
+    });
+    const name = data.title;
+    const slug = data.handle;
+    const description = data.description || "" || data.subtitle || "";
+    const parentCategories = [];
+    parentCategories.push(
+      ...data.categories?.map((cat) => cat.metadata?.["external_id"]).map((id) => CategoryIdentifierSchema.parse({ key: id || "" })) || []
+    );
+    const sharedAttributes = this.parseAttributes(context, data);
+    if (!data.variants) {
+      debug("Product has no variants", data);
+      throw new Error("Product has no variants " + data.external_id);
+    }
+    const mainVariant = this.parseVariant(context, data.variants[0], data);
+    const otherVariants = [];
+    if (data.variants.length > 1) {
+      otherVariants.push(
+        ...data.variants.slice(1).map((variant) => this.parseVariant(context, variant, data))
+      );
+    }
+    const result = {
+      brand: "",
+      description,
+      identifier,
+      longDescription: "",
+      mainVariant,
+      manufacturer: "",
+      name,
+      options: [],
+      parentCategories,
+      published: true,
+      sharedAttributes,
+      slug,
+      variants: otherVariants
+    };
+    return this.productSchema.parse(result);
   }
 }
 export {

package/factories/product-associations/product-associations.factory.js

@@ -1,10 +1,46 @@
+import {
+  ImageSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
 class MedusaProductAssociationsFactory {
   productAssociationSchema;
   constructor(productAssociationSchema) {
     this.productAssociationSchema = productAssociationSchema;
   }
-  parseAssociation(_context, data) {
-    return this.productAssociationSchema.parse(data);
+  parseAssociation(context, data) {
+    const heroVariant = data.product.variants?.[0];
+    const identifier = { key: data.product.external_id || data.product.id };
+    const slug = data.product.handle;
+    const name = heroVariant?.title || data.product.title;
+    const variants = [];
+    if (heroVariant) {
+      variants.push(this.parseVariant(context, heroVariant, data.product));
+    }
+    const searchItemResult = {
+      identifier,
+      name,
+      slug,
+      variants
+    };
+    const result = {
+      associationIdentifier: data.identifier,
+      associationReturnType: "productSearchResultItem",
+      product: searchItemResult
+    };
+    return this.productAssociationSchema.parse(result);
+  }
+  parseVariant(_context, variant, product) {
+    const img = ImageSchema.parse({
+      sourceUrl: product.images?.[0].url ?? "",
+      altText: product.title || void 0
+    });
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
+      image: img
+    });
   }
 }
 export {

package/factories/product-search/product-search.factory.js

@@ -1,10 +1,59 @@
+import {
+  ImageSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
 class MedusaProductSearchFactory {
   productSearchResultSchema;
   constructor(productSearchResultSchema) {
     this.productSearchResultSchema = productSearchResultSchema;
   }
-  parseSearchResult(_context, data, _query) {
-    return this.productSearchResultSchema.parse(data);
+  parseSearchResult(context, remote, query) {
+    const products = remote.products.map(
+      (p) => this.parseProductSearchResultItem(context, p)
+    );
+    const result = {
+      identifier: {
+        ...query.search
+      },
+      pageNumber: (Math.ceil(remote.offset / remote.limit) || 0) + 1,
+      pageSize: remote.limit,
+      totalCount: remote.count,
+      totalPages: Math.ceil(remote.count / remote.limit || 0) + 1,
+      items: products,
+      facets: []
+    };
+    result.facets = [];
+    return this.productSearchResultSchema.parse(result);
+  }
+  parseProductSearchResultItem(context, data) {
+    const heroVariant = data.variants?.[0];
+    const identifier = { key: data.external_id || data.id };
+    const slug = data.handle;
+    const name = heroVariant?.title || data.title;
+    const variants = [];
+    if (heroVariant) {
+      variants.push(this.parseVariant(context, heroVariant, data));
+    }
+    const result = {
+      identifier,
+      name,
+      slug,
+      variants
+    };
+    return result;
+  }
+  parseVariant(_context, variant, product) {
+    const img = ImageSchema.parse({
+      sourceUrl: product.images?.[0].url ?? "",
+      altText: product.title || void 0
+    });
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
+      image: img
+    });
   }
 }
 export {

package/factories/profile/profile.factory.js

@@ -3,8 +3,60 @@ class MedusaProfileFactory {
   constructor(profileSchema) {
     this.profileSchema = profileSchema;
   }
-  parseProfile(_context, data) {
-    return this.profileSchema.parse(data);
+  parseProfile(context, data) {
+    const email = data.email;
+    const emailVerified = data.metadata?.["email_verified"] === "true";
+    const phone = data.phone || "";
+    const phoneVerified = data.metadata?.["phone_verified"] === "true";
+    const addresses = data.addresses || [];
+    let billingAddress = void 0;
+    let shippingAddress = void 0;
+    const existingBillingAddress = data.addresses.find(
+      (addr) => addr.is_default_billing
+    );
+    if (existingBillingAddress) {
+      billingAddress = this.parseAddress(context, existingBillingAddress);
+    }
+    const existingShippingAddress = data.addresses.find(
+      (addr) => addr.is_default_shipping
+    );
+    if (existingShippingAddress) {
+      shippingAddress = this.parseAddress(context, existingShippingAddress);
+    }
+    const alternateShippingAddresses = [];
+    alternateShippingAddresses.push(
+      ...addresses.filter((x) => !(x.is_default_billing || x.is_default_shipping)).map((addr) => this.parseAddress(context, addr))
+    );
+    const result = {
+      identifier: {
+        userId: data.id
+      },
+      email,
+      emailVerified,
+      phone,
+      phoneVerified,
+      billingAddress,
+      shippingAddress,
+      alternateShippingAddresses,
+      createdAt: new Date(data.created_at || "").toISOString(),
+      updatedAt: new Date(data.updated_at || "").toISOString()
+    };
+    return this.profileSchema.parse(result);
+  }
+  parseAddress(context, 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 || ""
+    };
   }
 }
 export {

package/package.json

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

package/src/capabilities/cart.capability.d.ts

@@ -1,8 +1,8 @@
-import type { Cache, CartItem, CartFactory, CartFactoryCartOutput, CartFactoryIdentifierOutput, CartFactoryWithOutput, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartQueryById, CostBreakDown, Currency, ItemCostBreakdown, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import type { Cache, CartFactory, CartFactoryCartOutput, CartFactoryIdentifierOutput, CartFactoryWithOutput, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartQueryById, NotFoundError, RequestContext, Result } from '@reactionary/core';
 import { CartCapability } from '@reactionary/core';
 import type { MedusaAPI } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
-import type { StoreAddCartLineItem, StoreCart, StoreCartAddPromotion, StoreCartLineItem, StoreCartRemovePromotion, StoreCreateCart, StoreUpdateCart, StoreUpdateCartLineItem } from '@medusajs/types';
+import type { StoreAddCartLineItem, StoreCartAddPromotion, StoreCartRemovePromotion, StoreCreateCart, StoreUpdateCart, StoreUpdateCartLineItem } from '@medusajs/types';
 import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>, CartFactoryIdentifierOutput<TFactory>> {
     medusaApi: MedusaAPI;
@@ -71,30 +71,4 @@ export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaC
         store: import("@medusajs/js-sdk").Store;
         auth: import("@medusajs/js-sdk").Auth;
     }>;
-    /**
-     * Extension point to control the parsing of a single cart item price
-     * @param remoteItem
-     * @param currency
-     * @returns
-     */
-    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: StoreCart): CostBreakDown;
-    /**
-     * Extension point to control the parsing of a single cart item
-     * @param remoteItem
-     * @param currency
-     * @returns
-     */
-    protected parseCartItem(remoteItem: StoreCartLineItem, currency: Currency): CartItem;
-    /**
-     * Extension point to control the parsing of a single cart
-     * @param remote
-     * @returns
-     */
-    protected parseSingle(remote: StoreCart): CartFactoryCartOutput<TFactory>;
 }