@reactionary/provider-medusa 0.1.5 → 0.1.7

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/provider-medusa",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
-    "@reactionary/core": "0.1.5",
+    "@reactionary/core": "0.1.7",
     "@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/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/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,62 @@ 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
+      }
+    });
+    let candidate = categories.items[0];
+    while (candidate) {
+      const children = await categoryProvider.findChildCategories({
+        parentId: candidate.identifier,
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 10
+        }
+      });
+      if (children.items.length > 0) {
+        candidate = children.items[0];
+      } else {
+        break;
+      }
+    }
+    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: candidate.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,