@reactionary/medusa 0.6.3

package/capabilities/inventory.capability.js

@@ -0,0 +1,142 @@
+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 {
+  InventoryCapability,
+  InventorySchema,
+  InventoryQueryBySKUSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { MedusaAdminAPI } from "../core/client.js";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:inventory");
+class MedusaInventoryCapability extends InventoryCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async getBySKU(payload) {
+    const sku = payload.variant.sku;
+    const fulfillmentCenterKey = payload.fulfilmentCenter.key;
+    if (debug.enabled) {
+      debug(`Fetching inventory for SKU: ${sku}, fulfillment center: ${fulfillmentCenterKey}`);
+    }
+    try {
+      const adminClient = await new MedusaAdminAPI(this.config, this.context).getClient();
+      const inventoryResponse = await adminClient.admin.inventoryItem.list({
+        sku: [sku],
+        limit: 1,
+        offset: 0
+      });
+      if (!inventoryResponse.inventory_items || inventoryResponse.inventory_items.length === 0) {
+        if (debug.enabled) {
+          debug(`No inventory items found for SKU: ${sku}`);
+        }
+        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+      }
+      const inventoryItem = inventoryResponse.inventory_items[0];
+      const locationsResponse = await adminClient.admin.stockLocation.list({
+        name: fulfillmentCenterKey,
+        limit: 1,
+        offset: 0
+      });
+      let quantity = 0;
+      let locationFound = false;
+      if (locationsResponse.stock_locations && locationsResponse.stock_locations.length > 0) {
+        const location = locationsResponse.stock_locations[0];
+        locationFound = true;
+        const levelsResponse = await adminClient.admin.inventoryItem.listLevels(inventoryItem.id, {
+          location_id: [location.id]
+        });
+        if (levelsResponse.inventory_levels && levelsResponse.inventory_levels.length > 0) {
+          const level = levelsResponse.inventory_levels[0];
+          quantity = level.stocked_quantity - level.reserved_quantity;
+        }
+      }
+      if (!locationFound) {
+        if (debug.enabled) {
+          debug(`No stock location found with name: ${fulfillmentCenterKey}`);
+        }
+        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+      }
+      return success(this.parseSingle({
+        sku: payload.variant.sku,
+        fulfillmentCenterKey,
+        quantity,
+        inventoryItemId: inventoryItem.id
+      }));
+    } catch (error) {
+      if (debug.enabled) {
+        debug(`Error fetching inventory for SKU: ${sku}`, error);
+      }
+      return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
+    }
+  }
+  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({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema
+  })
+], MedusaInventoryCapability.prototype, "getBySKU", 1);
+export {
+  MedusaInventoryCapability
+};

package/capabilities/order-search.capability.js

@@ -0,0 +1,161 @@
+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 {
+  AddressIdentifierSchema,
+  OrderSearchCapability,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:order-search");
+class MedusaOrderSearchCapability extends OrderSearchCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  queryByTermPayload(payload) {
+    const filters = {};
+    if (payload.search.term) {
+      debug("Searching orders by term is not supported in Medusa");
+    }
+    if (payload.search.partNumber) {
+      debug("Searching orders by part number is not supported in Medusa");
+    }
+    if (payload.search.startDate) {
+      debug("Searching orders by start date is not supported in Medusa");
+    }
+    if (payload.search.endDate) {
+      debug("Searching orders by end date is not supported in Medusa");
+    }
+    const statusFilter = (payload.search.orderStatus ?? []).map((status) => {
+      let retStatus = "draft";
+      if (status === "AwaitingPayment") {
+        retStatus = "draft";
+      }
+      if (status === "ReleasedToFulfillment") {
+        retStatus = "pending";
+      }
+      if (status === "Shipped") {
+        retStatus = "completed";
+      }
+      if (status === "Cancelled") {
+        retStatus = "canceled";
+      }
+      return retStatus;
+    });
+    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(
+        `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;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema
+  })
+], MedusaOrderSearchCapability.prototype, "queryByTerm", 1);
+export {
+  MedusaOrderSearchCapability
+};

package/capabilities/order.capability.js

@@ -0,0 +1,179 @@
+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 {
+  OrderCapability,
+  OrderQueryByIdSchema,
+  OrderSchema,
+  Reactionary,
+  success,
+  error,
+  ProductVariantIdentifierSchema
+} 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) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async getById(payload) {
+    debug("getById", payload);
+    const medusa = await this.medusaApi.getClient();
+    try {
+      const response = await medusa.store.order.retrieve(payload.order.key);
+      const order = this.parseSingle(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({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema
+  })
+], MedusaOrderCapability.prototype, "getById", 1);
+export {
+  MedusaOrderCapability
+};

package/capabilities/price.capability.js

@@ -0,0 +1,120 @@
+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 {
+  PriceCapability,
+  PriceSchema,
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:price");
+class MedusaPriceCapability extends PriceCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async getListPrice(payload) {
+    const result = await this.getBySKU(payload, "list");
+    return success(result);
+  }
+  async getCustomerPrice(payload) {
+    const result = await this.getBySKU(payload, "customer");
+    return success(result);
+  }
+  async getBySKU(payload, mode) {
+    const sku = payload.variant.sku;
+    if (debug.enabled) {
+      debug(`Fetching price for SKU: ${sku}`);
+    }
+    try {
+      const productForSKU = await this.medusaApi.resolveProductForSKU(payload.variant.sku);
+      const client = await this.medusaApi.getClient();
+      const product = (await client.store.product.retrieve(
+        productForSKU.id || "",
+        { region_id: (await this.medusaApi.getActiveRegion()).id }
+      )).product;
+      const variant = product.variants?.find((v) => v.sku === sku);
+      if (!variant) {
+        if (debug.enabled) {
+          debug(
+            `Variant with SKU ${sku} not found in product ${product.id}`
+          );
+        }
+        return this.createEmptyPriceResult(sku);
+      }
+      return this.parseSingle(variant, mode);
+    } catch (error) {
+      if (debug.enabled) {
+        debug(
+          `Error fetching price for SKU ${sku}: ${error.message}`
+        );
+      }
+      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({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], MedusaPriceCapability.prototype, "getListPrice", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], MedusaPriceCapability.prototype, "getCustomerPrice", 1);
+export {
+  MedusaPriceCapability
+};