@reactionary/medusa 0.6.3

package/capabilities/product-associations.capability.js

@@ -0,0 +1,148 @@
+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 {
+  ProductAssociationsCapability,
+  Reactionary,
+  ImageSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  success
+} from "@reactionary/core";
+class MedusaProductAssociationsCapability extends ProductAssociationsCapability {
+  config;
+  medusa;
+  factory;
+  constructor(config, cache, context, medusa, factory) {
+    super(cache, context);
+    this.config = config;
+    this.medusa = medusa;
+    this.factory = factory;
+  }
+  async fetchAssociatedProductsFor(productKey, maxNumberOfAssociations, attributeName) {
+    const client = await this.medusa.getClient();
+    const productResponse = await client.store.product.list({
+      external_id: productKey.key,
+      limit: 1,
+      offset: 0,
+      fields: "metadata.*,external_id"
+    });
+    let product;
+    if (!productResponse.products || productResponse.products.length === 0)
+      return [];
+    else
+      product = productResponse.products[0];
+    if (!product) {
+      return [];
+    }
+    const associationsMetadata = (product.metadata?.[attributeName] || "").split(";");
+    if (!associationsMetadata || associationsMetadata.length === 0 || associationsMetadata[0] === "") {
+      return [];
+    }
+    const associatedProductIds = associationsMetadata.slice(0, maxNumberOfAssociations);
+    const associatedProductsResponse = await client.store.product.list({
+      external_id: associatedProductIds,
+      fields: "+metadata.*,+external_id",
+      offset: 0,
+      limit: maxNumberOfAssociations
+    });
+    return associatedProductsResponse.products.map((product2) => this.parseSingle(product2));
+  }
+  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
+    }));
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+  }
+  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
+    }));
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+  }
+  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
+    }));
+    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
+    });
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], MedusaProductAssociationsCapability.prototype, "getAccessories", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], MedusaProductAssociationsCapability.prototype, "getSpareparts", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], MedusaProductAssociationsCapability.prototype, "getReplacements", 1);
+export {
+  MedusaProductAssociationsCapability
+};

package/capabilities/product-recommendations.capability.js

@@ -0,0 +1,116 @@
+import {
+  error,
+  ImageSchema,
+  ProductRecommendationsCapability,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:product-recommendations");
+class MedusaProductRecommendationsCapability extends ProductRecommendationsCapability {
+  config;
+  medusaApi;
+  constructor(config, cache, context, medusaApi) {
+    super(cache, context);
+    this.config = config;
+    this.medusaApi = medusaApi;
+  }
+  getCollectionPayload(query, collection) {
+    return {
+      collection_id: [collection.id],
+      limit: query.numberOfRecommendations,
+      fields: "+variants.id,+variants.sku,+external_id"
+    };
+  }
+  /**
+   * Get product recommendations from a Medusa collection
+   *
+   * This method fetches products from a specific Medusa collection by name or handle.
+   * It's useful for displaying curated product lists like "Featured Products",
+   * "New Arrivals", "Best Sellers", etc.
+   */
+  async getCollection(query) {
+    const client = await this.medusaApi.getClient();
+    try {
+      if (debug.enabled) {
+        debug(`Fetching collection: ${query.collectionName}`);
+      }
+      const collectionsResponse = await client.store.collection.list({
+        handle: query.collectionName,
+        limit: 1
+      });
+      if (!collectionsResponse.collections || collectionsResponse.collections.length === 0) {
+        if (debug.enabled) {
+          debug(`Collection not found: ${query.collectionName}`);
+        }
+        return error({
+          type: "NotFound",
+          identifier: query.collectionName
+        });
+      }
+      const collection = collectionsResponse.collections[0];
+      if (debug.enabled) {
+        debug(`Found collection: ${collection.title} (${collection.id})`);
+      }
+      const productsResponse = await client.store.product.list(this.getCollectionPayload(query, collection));
+      if (debug.enabled) {
+        debug(`Found ${productsResponse.products.length} products in collection`);
+      }
+      const recommendations = [];
+      for (const productRes of productsResponse.products) {
+        const product = this.parseSearchResultItem(productRes);
+        recommendations.push({
+          recommendationIdentifier: {
+            key: `${collection.id}_${productRes.id}`,
+            algorithm: "collection"
+          },
+          recommendationReturnType: "productSearchResultItem",
+          product
+        });
+      }
+      if (debug.enabled) {
+        debug(`Returning ${recommendations.length} recommendations`);
+      }
+      return success(recommendations);
+    } catch (error2) {
+      if (debug.enabled) {
+        debug(`Error fetching collection recommendations: %O`, error2);
+      }
+      console.error("Error fetching collection recommendations:", error2);
+      return success([]);
+    }
+  }
+  parseSearchResultItem(_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
+    });
+  }
+}
+export {
+  MedusaProductRecommendationsCapability
+};

package/capabilities/product-search.capability.js

@@ -0,0 +1,177 @@
+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 {
+  ProductSearchCapability,
+  ProductSearchQueryByTermSchema,
+  ImageSchema,
+  ProductVariantIdentifierSchema,
+  ProductVariantOptionSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultItemVariantSchema,
+  Reactionary,
+  ProductSearchResultSchema,
+  FacetValueIdentifierSchema,
+  FacetIdentifierSchema,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:search");
+class MedusaProductSearchCapability extends ProductSearchCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async resolveCategoryIdByExternalId(externalId) {
+    const sdk = await this.medusaApi.getClient();
+    let offset = 0;
+    const limit = 50;
+    let candidate = void 0;
+    while (true) {
+      try {
+        const categoryResult = await sdk.store.category.list({
+          offset,
+          limit
+        });
+        if (categoryResult.product_categories.length === 0) {
+          break;
+        }
+        candidate = categoryResult.product_categories.find(
+          (cat) => cat.metadata?.["external_id"] === externalId
+        );
+        if (candidate) {
+          break;
+        }
+        offset += limit;
+      } catch (error) {
+        throw new Error(
+          "Category not found " + externalId + " due to error: " + error
+        );
+        break;
+      }
+    }
+    return candidate || null;
+  }
+  queryByTermPayload(payload, categoryIdToFind) {
+    const finalSearch = (payload.search.term || "").trim().replace("*", "");
+    return {
+      q: finalSearch,
+      ...categoryIdToFind ? { category_id: categoryIdToFind } : {},
+      limit: payload.search.paginationOptions.pageSize,
+      fields: "+metadata.*,+external_id",
+      offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
+    };
+  }
+  async queryByTerm(payload) {
+    const client = await this.medusaApi.getClient();
+    let categoryIdToFind = null;
+    if (payload.search.categoryFilter?.key) {
+      debug(
+        `Resolving category filter for key: ${payload.search.categoryFilter.key}`
+      );
+      const category = await this.resolveCategoryIdByExternalId(
+        payload.search.categoryFilter.key
+      );
+      if (category) {
+        categoryIdToFind = category.id;
+        debug(
+          `Resolved category filter key ${payload.search.categoryFilter.key} to id: ${categoryIdToFind}`
+        );
+      } else {
+        debug(
+          `Could not resolve category filter for key: ${payload.search.categoryFilter.key}`
+        );
+      }
+    }
+    const response = await client.store.product.list(this.queryByTermPayload(payload, categoryIdToFind));
+    const result = this.parsePaginatedResult(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);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], MedusaProductSearchCapability.prototype, "queryByTerm", 1);
+export {
+  MedusaProductSearchCapability
+};

package/capabilities/product.capability.js

@@ -0,0 +1,252 @@
+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 {
+  CategoryIdentifierSchema,
+  ProductIdentifierSchema,
+  ProductCapability,
+  ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
+  ProductQueryBySlugSchema,
+  ProductSchema,
+  Reactionary,
+  success,
+  error
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:product");
+class MedusaProductCapability extends ProductCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  alwaysIncludedFields = ["+metadata.*", "+categories.metadata.*", "+external_id"];
+  factory;
+  getByIdPayload(payload) {
+    return {
+      external_id: payload.identifier.key,
+      limit: 1,
+      offset: 0,
+      fields: this.alwaysIncludedFields.join(",")
+    };
+  }
+  async getById(payload) {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(`Fetching product by ID: ${payload.identifier.key}`);
+    }
+    const response = await client.store.product.list(
+      this.getByIdPayload(payload)
+    );
+    if (response.count === 0) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+    return success(this.parseSingle(response.products[0]));
+  }
+  getBySlugPayload(payload) {
+    return {
+      handle: payload.slug,
+      limit: 1,
+      offset: 0,
+      fields: this.alwaysIncludedFields.join(",")
+    };
+  }
+  async getBySlug(payload) {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(`Fetching product by slug: ${payload.slug}`);
+    }
+    const response = await client.store.product.list(this.getBySlugPayload(payload));
+    if (debug.enabled) {
+      debug(`Found ${response.count} products for slug: ${payload.slug}`);
+    }
+    if (response.count === 0) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+    return success(this.parseSingle(response.products[0]));
+  }
+  async getBySKU(payload) {
+    if (debug.enabled) {
+      debug(`Fetching product by SKU: ${Array.isArray(payload) ? payload.join(", ") : payload}`);
+    }
+    const sku = payload.variant.sku;
+    const product = await this.medusaApi.resolveProductForSKU(sku);
+    const variant = product.variants?.find((v) => v.sku === sku);
+    if (!variant) {
+      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;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], MedusaProductCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], MedusaProductCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], MedusaProductCapability.prototype, "getBySKU", 1);
+export {
+  MedusaProductCapability
+};