@reactionary/provider-medusa 0.1.4 → 0.1.6

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/provider-medusa",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
-    "@reactionary/core": "0.1.4",
+    "@reactionary/core": "0.1.6",
     "@medusajs/js-sdk": "^2.0.0",
     "debug": "^4.3.4",
     "@medusajs/types": "^2.11.0",

package/providers/product-search.provider.js

@@ -19,7 +19,9 @@ import {
   ProductSearchResultItemVariantSchema,
   createPaginatedResponseSchema,
   Reactionary,
-  ProductSearchResultSchema
+  ProductSearchResultSchema,
+  FacetValueIdentifierSchema,
+  FacetIdentifierSchema
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:search");
@@ -29,10 +31,53 @@ class MedusaSearchProvider extends ProductSearchProvider {
     this.client = client;
     this.config = config;
   }
+  async resolveCategoryIdByExternalId(externalId) {
+    const sdk = await this.client.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;
+  }
   async queryByTerm(payload) {
     const client = await this.client.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 finalSearch = (payload.search.term || "").trim().replace("*", "");
     const response = await client.store.product.list({
-      q: payload.search.term,
+      q: finalSearch,
+      ...categoryIdToFind ? { category_id: categoryIdToFind } : {},
       limit: payload.search.paginationOptions.pageSize,
       offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
     });
@@ -121,6 +166,16 @@ class MedusaSearchProvider extends ProductSearchProvider {
       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 facetValueIdentifier;
+  }
   parseFacetValue(facetValueIdentifier, label, count) {
     throw new Error("Method not implemented.");
   }

package/providers/product.provider.js

@@ -93,6 +93,12 @@ class MedusaProductProvider extends ProductProvider {
       throw new Error("Product has no variants " + _body.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 meta = {
       cache: { hit: false, key: this.generateCacheKeySingle(identifier) },
       placeholder: false
@@ -110,7 +116,8 @@ class MedusaProductProvider extends ProductProvider {
       parentCategories,
       published: true,
       sharedAttributes,
-      slug
+      slug,
+      variants: otherVariants
     };
     return result;
   }

package/src/providers/product-search.provider.d.ts

@@ -1,11 +1,12 @@
-import { ProductSearchProvider, type Cache, type RequestContext, type ProductSearchQueryByTerm, type ProductSearchResult, type ProductSearchResultItem, type ProductSearchResultItemVariant, type FacetIdentifier, type FacetValueIdentifier, type ProductSearchResultFacet, type ProductSearchResultFacetValue } from '@reactionary/core';
+import { ProductSearchProvider, type Cache, type RequestContext, type ProductSearchQueryByTerm, type ProductSearchResult, type ProductSearchResultItem, type ProductSearchResultItemVariant, type FacetIdentifier, type FacetValueIdentifier, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import type { MedusaClient } from '../core/client.js';
-import type { StoreProduct, StoreProductListResponse, StoreProductVariant } from '@medusajs/types';
+import type { StoreProduct, StoreProductCategory, StoreProductListResponse, StoreProductVariant } from '@medusajs/types';
 export declare class MedusaSearchProvider extends ProductSearchProvider {
     client: MedusaClient;
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
+    protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
     queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
     protected parsePaginatedResult(remote: StoreProductListResponse): {
         identifier: {
@@ -72,6 +73,7 @@ export declare class MedusaSearchProvider extends ProductSearchProvider {
     };
     protected parseSingle(_body: StoreProduct): ProductSearchResultItem;
     protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<FacetValueIdentifier>;
     protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
     protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown): ProductSearchResultFacet;
 }

package/test/product.provider.spec.js

@@ -10,6 +10,9 @@ const testData = {
     slug: "lv-ca31-scart-cable-101080",
     image: "https://images.icecat.biz/img/norm/high/101080-3513.jpg",
     sku: "4960999194479"
+  },
+  productWithMultiVariants: {
+    slug: "hp-gk859aa-mouse-office-bluetooth-laser-1600-dpi-1377612"
   }
 };
 describe("Medusa Product Provider", () => {
@@ -35,16 +38,20 @@ describe("Medusa Product Provider", () => {
     expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
     expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
   });
-  it("should be able to get a product by slug", async () => {
-    const result = await provider.getBySlug({ slug: testData.product.slug });
+  it("should be able to get a product with multiple variants by slug", async () => {
+    const result = await provider.getBySlug({ slug: testData.productWithMultiVariants.slug });
     expect(result).toBeTruthy();
     if (result) {
       expect(result.meta.placeholder).toBe(false);
       expect(result.identifier.key).toBeTruthy();
-      expect(result.name).toBe(testData.product.name);
+      expect(result.slug).toBe(testData.productWithMultiVariants.slug);
       expect(result.mainVariant).toBeDefined();
-      expect(result.mainVariant.identifier.sku).toBe(testData.product.sku);
-      expect(result.mainVariant.images[0].sourceUrl).toBe(testData.product.image);
+      expect(result.variants.length).toBeGreaterThan(0);
+      expect(result.variants[0].identifier.sku).toBeTruthy();
+      expect(result.variants[0].identifier.sku).not.toBe(result.mainVariant.identifier.sku);
+      expect(result.sharedAttributes.length).toBeGreaterThan(1);
+      expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
+      expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
     }
   });
   it("should be able to get a product by sku", async () => {

package/test/search.provider.spec.js

@@ -4,6 +4,7 @@ import { describe, expect, it } from "vitest";
 import { MedusaSearchProvider } from "../providers/product-search.provider.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
 import { MedusaClient } from "../index.js";
+import { MedusaCategoryProvider } from "../providers/category.provider.js";
 const testData = {
   searchTerm: "printer"
 };
@@ -16,6 +17,12 @@ describe("Medusa Search Provider", () => {
     reqCtx,
     client
   );
+  const categoryProvider = new MedusaCategoryProvider(
+    getMedusaTestConfiguration(),
+    new NoOpCache(),
+    reqCtx,
+    client
+  );
   it("should be able to get a result by term", async () => {
     const result = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
       term: testData.searchTerm,
@@ -54,6 +61,47 @@ describe("Medusa Search Provider", () => {
       secondPage.items[0].identifier.key
     );
   });
+  it("should be able to apply a top level category filter", async () => {
+    const categories = await categoryProvider.findTopCategories({
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2
+      }
+    });
+    const unfilteredSearch = await provider.queryByTerm({
+      search: {
+        term: "",
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 1
+        },
+        facets: [],
+        filters: []
+      }
+    });
+    expect(unfilteredSearch.totalCount).toBeGreaterThan(0);
+    const breadCrumb = await categoryProvider.getBreadcrumbPathToCategory({
+      id: categories.items[1].identifier
+    });
+    expect(breadCrumb.length).toBeGreaterThan(0);
+    const categoryFilter = await provider.createCategoryNavigationFilter({
+      categoryPath: breadCrumb
+    });
+    const filteredSearch = await provider.queryByTerm({
+      search: {
+        term: "",
+        categoryFilter,
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 1
+        },
+        facets: [],
+        filters: []
+      }
+    });
+    expect(filteredSearch.totalCount).toBeLessThan(unfilteredSearch.totalCount);
+    expect(filteredSearch.totalCount).toBeGreaterThan(0);
+  });
   it("should be able to change page size", async () => {
     const smallPage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
       term: testData.searchTerm,