@reactionary/medusa 0.6.4 → 0.6.6

package/capabilities/inventory.capability.js

@@ -11,13 +11,14 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 import {
   InventoryCapability,
-  InventorySchema,
   InventoryQueryBySKUSchema,
+  InventorySchema,
   Reactionary,
-  success
+  success,
+  error
 } from "@reactionary/core";
-import { MedusaAdminAPI } from "../core/client.js";
 import createDebug from "debug";
+import { MedusaAdminAPI } from "../core/client.js";
 const debug = createDebug("reactionary:medusa:inventory");
 class MedusaInventoryCapability extends InventoryCapability {
   constructor(config, cache, context, medusaApi, factory) {
@@ -45,7 +46,7 @@ class MedusaInventoryCapability extends InventoryCapability {
         if (debug.enabled) {
           debug(`No inventory items found for SKU: ${sku}`);
         }
-        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+        return error({ type: "NotFound", identifier: payload.variant });
       }
       const inventoryItem = inventoryResponse.inventory_items[0];
       const locationsResponse = await adminClient.admin.stockLocation.list({
@@ -70,66 +71,21 @@ class MedusaInventoryCapability extends InventoryCapability {
         if (debug.enabled) {
           debug(`No stock location found with name: ${fulfillmentCenterKey}`);
         }
-        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+        return error({ type: "NotFound", identifier: payload.fulfilmentCenter });
       }
-      return success(this.parseSingle({
+      return success(this.factory.parseInventory(this.context, {
         sku: payload.variant.sku,
         fulfillmentCenterKey,
         quantity,
         inventoryItemId: inventoryItem.id
       }));
-    } catch (error) {
+    } catch (err) {
       if (debug.enabled) {
-        debug(`Error fetching inventory for SKU: ${sku}`, error);
+        debug(`Error fetching inventory for SKU: ${sku}`, err);
       }
-      return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+      return error({ type: "NotFound", identifier: payload.variant });
     }
   }
-  parseSingle(_body) {
-    const { sku, fulfillmentCenterKey, quantity } = _body;
-    const identifier = {
-      variant: {
-        sku
-      },
-      fulfillmentCenter: {
-        key: fulfillmentCenterKey
-      }
-    };
-    let status = "outOfStock";
-    if (quantity > 0) {
-      status = "inStock";
-    }
-    const result = {
-      identifier,
-      quantity,
-      status
-    };
-    return this.factory.parseInventory(this.context, result);
-  }
-  /**
-   * Utility function to create an empty inventory result.
-   * This is used when no inventory is found for a given SKU + fulfillment center combination.
-   * @param sku
-   * @param fulfillmentCenterKey
-   * @returns
-   */
-  createEmptyInventoryResult(sku, fulfillmentCenterKey) {
-    const identifier = {
-      variant: { sku },
-      fulfillmentCenter: { key: fulfillmentCenterKey }
-    };
-    const quantity = 0;
-    const status = "outOfStock";
-    const result = {
-      identifier,
-      quantity,
-      status
-    };
-    return this.factory.parseInventory(this.context, result);
-  }
-  getResourceName() {
-    return "inventory";
-  }
 }
 __decorateClass([
   Reactionary({

package/capabilities/order-search.capability.js

@@ -10,7 +10,6 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
-  AddressIdentifierSchema,
   OrderSearchCapability,
   OrderSearchQueryByTermSchema,
   OrderSearchResultSchema,
@@ -68,86 +67,13 @@ class MedusaOrderSearchCapability extends OrderSearchCapability {
     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);
+    const result = this.factory.parseOrderSearchResult(this.context, response, payload);
     if (debug.enabled) {
       debug(
         `Search for term "${payload.search.term}" returned ${response.orders.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
       );
     }
-    return success(this.factory.parseOrderSearchResult(this.context, result, payload));
-  }
-  composeAddressFromStoreAddress(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: ""
-    };
-  }
-  parseSingle(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.composeAddressFromStoreAddress(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;
-  }
-  parsePaginatedResult(body, query) {
-    const identifier = {
-      ...query.search
-    };
-    const orders = body.orders.map((o) => {
-      return this.parseSingle(o);
-    });
-    const result = {
-      identifier,
-      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
-      pageSize: body.limit,
-      totalCount: body.count,
-      totalPages: Math.ceil(body.count / body.limit || 0) + 1,
-      items: orders
-    };
-    return result;
+    return success(result);
   }
 }
 __decorateClass([

package/capabilities/order.capability.js

@@ -14,13 +14,10 @@ import {
   OrderQueryByIdSchema,
   OrderSchema,
   Reactionary,
-  success,
-  error,
-  ProductVariantIdentifierSchema
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 import { handleProviderError } from "../utils/medusa-helpers.js";
-import { parseMedusaItemPrice, parseMedusaCostBreakdown } from "../utils/medusa-helpers.js";
 const debug = createDebug("reactionary:medusa:order");
 class MedusaOrderCapability extends OrderCapability {
   constructor(config, cache, context, medusaApi, factory) {
@@ -36,137 +33,12 @@ class MedusaOrderCapability extends OrderCapability {
     const medusa = await this.medusaApi.getClient();
     try {
       const response = await medusa.store.order.retrieve(payload.order.key);
-      const order = this.parseSingle(response.order);
+      const order = this.factory.parseOrder(this.context, response.order);
       return success(order);
     } catch (err) {
       return handleProviderError("order", err);
     }
   }
-  /**
-   * 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
-   */
-  parseOrderItem(remoteItem, currency) {
-    const item = {
-      identifier: {
-        key: remoteItem.id
-      },
-      variant: ProductVariantIdentifierSchema.parse({
-        sku: remoteItem.variant_sku || ""
-      }),
-      quantity: remoteItem.quantity || 1,
-      price: this.parseItemPrice(remoteItem, currency),
-      inventoryStatus: "Allocated"
-    };
-    return item;
-  }
-  parsePaymentInstruction(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;
-  }
-  parseSingle(body) {
-    const identifier = { key: body.id };
-    const userId = {
-      userId: body.customer_id || ""
-    };
-    const items = (body.items || []).map((item) => {
-      return this.parseOrderItem(item, body.currency_code.toUpperCase());
-    });
-    const price = this.parseCostBreakdown(body);
-    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 paymentInstructions = body.payment_collections?.map((pc) => {
-      return this.parsePaymentInstruction(pc, body);
-    }) || [];
-    const result = {
-      identifier,
-      userId,
-      items,
-      price,
-      orderStatus,
-      inventoryStatus,
-      paymentInstructions
-    };
-    return this.factory.parseOrder(this.context, result);
-  }
 }
 __decorateClass([
   Reactionary({

package/capabilities/price.capability.js

@@ -10,10 +10,10 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
-  PriceCapability,
-  PriceSchema,
   CustomerPriceQuerySchema,
   ListPriceQuerySchema,
+  PriceCapability,
+  PriceSchema,
   Reactionary,
   success
 } from "@reactionary/core";
@@ -57,7 +57,7 @@ class MedusaPriceCapability extends PriceCapability {
         }
         return this.createEmptyPriceResult(sku);
       }
-      return this.parseSingle(variant, mode);
+      return this.factory.parsePrice(this.context, { variant, mode });
     } catch (error) {
       if (debug.enabled) {
         debug(
@@ -67,41 +67,6 @@ class MedusaPriceCapability extends PriceCapability {
       return this.createEmptyPriceResult(sku);
     }
   }
-  parseSingle(variant, mode) {
-    const identifier = {
-      variant: {
-        sku: variant.sku || ""
-      }
-    };
-    const calculatedPrice = variant.calculated_price;
-    let unitPrice;
-    let isOnSale = false;
-    if (calculatedPrice) {
-      const priceToUse = mode === "customer" ? calculatedPrice.calculated_amount : calculatedPrice.original_amount;
-      if (mode === "customer") {
-        isOnSale = calculatedPrice.calculated_price?.price_list_type === "sale";
-      }
-      unitPrice = {
-        value: priceToUse || 0,
-        currency: calculatedPrice.currency_code?.toUpperCase() || this.context.languageContext.currencyCode
-      };
-    } else {
-      unitPrice = {
-        value: -1,
-        currency: this.context.languageContext.currencyCode
-      };
-    }
-    const result = {
-      identifier,
-      tieredPrices: [],
-      unitPrice,
-      onSale: isOnSale
-    };
-    return this.factory.parsePrice(this.context, result);
-  }
-  getResourceName() {
-    return "price";
-  }
 }
 __decorateClass([
   Reactionary({

package/capabilities/product-associations.capability.js

@@ -12,9 +12,6 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   ProductAssociationsCapability,
   Reactionary,
-  ImageSchema,
-  ProductSearchResultItemVariantSchema,
-  ProductVariantIdentifierSchema,
   success
 } from "@reactionary/core";
 class MedusaProductAssociationsCapability extends ProductAssociationsCapability {
@@ -54,69 +51,37 @@ class MedusaProductAssociationsCapability extends ProductAssociationsCapability
       offset: 0,
       limit: maxNumberOfAssociations
     });
-    return associatedProductsResponse.products.map((product2) => this.parseSingle(product2));
+    return associatedProductsResponse.products || [];
   }
   async getAccessories(query) {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, "reactionaryaccessories");
-    const result = associatedProducts.map((product) => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-accessory-${product.identifier.key}`
-      },
-      associationReturnType: "productSearchResultItem",
-      product
+    const result = associatedProducts.map((product) => this.factory.parseAssociation(this.context, {
+      product,
+      identifier: {
+        key: `${query.forProduct.key}-accessory-${product.external_id}`
+      }
     }));
-    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+    return success(result);
   }
   async getSpareparts(query) {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, "reactionaryspareparts");
-    const result = associatedProducts.map((product) => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-sparepart-${product.identifier.key}`
-      },
-      associationReturnType: "productSearchResultItem",
-      product
+    const result = associatedProducts.map((product) => this.factory.parseAssociation(this.context, {
+      product,
+      identifier: {
+        key: `${query.forProduct.key}-sparepart-${product.external_id}`
+      }
     }));
-    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+    return success(result);
   }
   async getReplacements(query) {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, "reactionaryreplacements");
-    const result = associatedProducts.map((product) => ({
-      associationIdentifier: {
-        key: `${query.forProduct.key}-replacement-${product.identifier.key}`
-      },
-      associationReturnType: "productSearchResultItem",
-      product
+    const result = associatedProducts.map((product) => this.factory.parseAssociation(this.context, {
+      product,
+      identifier: {
+        key: `${query.forProduct.key}-replacement-${product.external_id}`
+      }
     }));
-    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
-  }
-  parseSingle(_body) {
-    const heroVariant = _body.variants?.[0];
-    const identifier = { key: _body.external_id || _body.id };
-    const slug = _body.handle;
-    const name = heroVariant?.title || _body.title;
-    const variants = [];
-    if (heroVariant) {
-      variants.push(this.parseVariant(heroVariant, _body));
-    }
-    const result = {
-      identifier,
-      name,
-      slug,
-      variants
-    };
-    return result;
-  }
-  parseVariant(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
-    });
+    return success(result);
   }
 }
 __decorateClass([

package/capabilities/product-search.capability.js

@@ -10,17 +10,12 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
   ProductSearchCapability,
   ProductSearchQueryByTermSchema,
-  ImageSchema,
-  ProductVariantIdentifierSchema,
-  ProductVariantOptionSchema,
-  ProductOptionIdentifierSchema,
-  ProductSearchResultItemVariantSchema,
-  Reactionary,
   ProductSearchResultSchema,
-  FacetValueIdentifierSchema,
-  FacetIdentifierSchema,
+  Reactionary,
   success
 } from "@reactionary/core";
 import createDebug from "debug";
@@ -74,6 +69,16 @@ class MedusaProductSearchCapability extends ProductSearchCapability {
       offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
     };
   }
+  async createCategoryNavigationFilter(payload) {
+    const facetIdentifier = FacetIdentifierSchema.parse({
+      key: "categories"
+    });
+    const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+      facet: facetIdentifier,
+      key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key
+    });
+    return success(facetValueIdentifier);
+  }
   async queryByTerm(payload) {
     const client = await this.medusaApi.getClient();
     let categoryIdToFind = null;
@@ -96,70 +101,13 @@ class MedusaProductSearchCapability extends ProductSearchCapability {
       }
     }
     const response = await client.store.product.list(this.queryByTermPayload(payload, categoryIdToFind));
-    const result = this.parsePaginatedResult(response, payload);
+    const result = this.factory.parseSearchResult(this.context, response, payload);
     if (debug.enabled) {
       debug(
         `Search for term "${payload.search.term}" returned ${response.products.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
       );
     }
-    return success(this.factory.parseSearchResult(this.context, result, payload));
-  }
-  parsePaginatedResult(remote, query) {
-    const products = remote.products.map(
-      (p) => this.parseSingle(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 result;
-  }
-  parseSingle(_body) {
-    const heroVariant = _body.variants?.[0];
-    const identifier = { key: _body.external_id || _body.id };
-    const slug = _body.handle;
-    const name = heroVariant?.title || _body.title;
-    const variants = [];
-    if (heroVariant) {
-      variants.push(this.parseVariant(heroVariant, _body));
-    }
-    const result = {
-      identifier,
-      name,
-      slug,
-      variants
-    };
-    return result;
-  }
-  parseVariant(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
-    });
-  }
-  async createCategoryNavigationFilter(payload) {
-    const facetIdentifier = FacetIdentifierSchema.parse({
-      key: "categories"
-    });
-    const facetValueIdentifier = FacetValueIdentifierSchema.parse({
-      facet: facetIdentifier,
-      key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key
-    });
-    return success(facetValueIdentifier);
+    return success(result);
   }
 }
 __decorateClass([