@reactionary/provider-commercetools 0.0.82 → 0.0.83

package/core/client.js

@@ -146,7 +146,10 @@ class CommercetoolsClient {
       })
     });
     const body = await response.json();
-    const scopes = body.scope;
+    if (!body) {
+      return AnonymousIdentitySchema.parse({});
+    }
+    const scopes = body.scope + "";
     if (scopes.indexOf("anonymous_id") > -1) {
       const s = scopes.split(" ");
       const idScope = s.find((x) => x.startsWith("anonymous_id"));

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/provider-commercetools",
-  "version": "0.0.82",
+  "version": "0.0.83",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.82",
+    "@reactionary/core": "0.0.83",
     "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",

package/providers/product-search.provider.js

@@ -34,15 +34,98 @@ class CommercetoolsSearchProvider extends ProductSearchProvider {
   }
   async getClient() {
     const client = await this.client.getClient();
-    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+    return client.withProjectKey({ projectKey: this.config.projectKey }).products();
+  }
+  async getFacetQuery(payload, selectedFacetValue) {
+    return {
+      exact: {
+        field: selectedFacetValue.facet.key,
+        fieldType: "text",
+        value: selectedFacetValue.key
+      }
+    };
+  }
+  async getSearchTermExpression(payload) {
+    return {
+      or: [
+        {
+          fullText: {
+            field: "name",
+            language: `${this.context.languageContext.locale}`,
+            value: payload.search.term
+          }
+        },
+        {
+          fullText: {
+            field: "description",
+            language: `${this.context.languageContext.locale}`,
+            value: payload.search.term
+          }
+        },
+        {
+          fullText: {
+            field: "searchKeywords",
+            language: `${this.context.languageContext.locale}`,
+            value: payload.search.term
+          }
+        }
+      ]
+    };
+  }
+  async getFacetsQuery(payload) {
+    if (payload.search.facets.length === 0) {
+      return void 0;
+    }
+    const facetsToApply = await Promise.all(
+      payload.search.facets.map((facet) => this.getFacetQuery(payload, facet))
+    );
+    if (facetsToApply.length === 0) {
+      return void 0;
+    }
+    if (facetsToApply.length === 1) {
+      return facetsToApply[0];
+    }
+    return {
+      and: facetsToApply
+    };
+  }
+  async getFacetsToReturn(payload) {
+    const facetsToReturn = [];
+    const configFacets = this.config.facetFieldsForSearch || ["category.id"];
+    for (const facet of configFacets) {
+      facetsToReturn.push({
+        distinct: {
+          name: facet,
+          field: facet,
+          fieldType: "text",
+          limit: 50
+        }
+      });
+    }
+    return facetsToReturn;
   }
   async queryByTerm(payload) {
     const client = await this.getClient();
-    const response = await client.search().get({
-      queryArgs: {
+    const facetsToReturn = await this.getFacetsToReturn(payload);
+    const facetsToApply = await this.getFacetsQuery(payload);
+    const searchTermExpression = await this.getSearchTermExpression(payload);
+    let finalFilterExpression = void 0;
+    if (facetsToApply) {
+      finalFilterExpression = {
+        and: [searchTermExpression, facetsToApply]
+      };
+    } else {
+      finalFilterExpression = searchTermExpression;
+    }
+    const response = await client.search().post({
+      body: {
+        query: finalFilterExpression,
+        productProjectionParameters: {
+          storeProjection: this.context.storeIdentifier.key
+        },
         limit: payload.search.paginationOptions.pageSize,
         offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize,
-        [`text.${this.context.languageContext.locale}`]: payload.search.term
+        facets: [...facetsToReturn]
       }
     }).execute();
     const responseBody = response.body;
@@ -85,16 +168,14 @@ class CommercetoolsSearchProvider extends ProductSearchProvider {
       ...query.search
     };
     const products = body.results.map(
-      (p) => this.parseSingle(p)
+      (p) => this.parseSingle(p.productProjection)
     );
     const facets = [];
-    for (const id in body.facets) {
-      const f = body.facets[id];
-      const facetId = FacetIdentifierSchema.parse({
-        key: id
+    for (const facet of body.facets) {
+      const facetIdentifier = FacetIdentifierSchema.parse({
+        key: facet.name
       });
-      const facet = this.parseFacet(facetId, f);
-      facets.push(facet);
+      facets.push(this.parseFacet(facetIdentifier, facet));
     }
     const result = {
       identifier,
@@ -111,22 +192,29 @@ class CommercetoolsSearchProvider extends ProductSearchProvider {
     };
     return result;
   }
-  parseFacet(facetIdentifier, facetValue) {
+  /**
+   * See version 0.0.81 for ProductProjection based facet parsing
+   * @param facetIdentifier
+   * @param facetValue
+   * @returns
+   */
+  parseFacet(facetIdentifier, facet) {
     const result = ProductSearchResultFacetSchema.parse({
       identifier: facetIdentifier,
-      name: facetIdentifier.key,
+      name: facet.name,
       values: []
     });
-    if (facetValue.type === "terms") {
-      for (const ft of facetValue.terms) {
+    const distinctFacet = facet;
+    if (distinctFacet) {
+      distinctFacet.buckets.forEach((bucket) => {
         const facetValueIdentifier = FacetValueIdentifierSchema.parse({
           facet: facetIdentifier,
-          key: ft.term
+          key: bucket.key
         });
         result.values.push(
-          this.parseFacetValue(facetValueIdentifier, ft.term, ft.count)
+          this.parseFacetValue(facetValueIdentifier, bucket.key, bucket.count)
         );
-      }
+      });
     }
     return result;
   }

package/schema/configuration.schema.js

@@ -7,7 +7,8 @@ const CommercetoolsConfigurationSchema = z.looseObject({
   clientId: z.string(),
   clientSecret: z.string(),
   scopes: z.array(z.string()).default(() => []),
-  paymentMethods: PaymentMethodSchema.array().optional().default(() => [])
+  paymentMethods: PaymentMethodSchema.array().optional().default(() => []),
+  facetFieldsForSearch: z.array(z.string()).default(() => [])
 });
 export {
   CommercetoolsConfigurationSchema

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

@@ -1,13 +1,45 @@
+import type { ProductSearchFacetResult as CTProductSearchFacetResult, ProductVariant as CTProductVariant, ProductPagedSearchResponse, ProductProjection, ProductSearchFacetExpression } from '@commercetools/platform-sdk';
+import type { Cache, FacetIdentifier, FacetValueIdentifier, ProductSearchQueryByTerm, ProductSearchResult, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItemVariant, RequestContext } from '@reactionary/core';
 import { ProductSearchProvider } from '@reactionary/core';
-import type { Cache, ProductSearchQueryByTerm, RequestContext, ProductSearchResult, ProductSearchResultItemVariant, FacetIdentifier, ProductSearchResultFacet, FacetValueIdentifier, ProductSearchResultFacetValue } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { ProductVariant as CTProductVariant, FacetResult, ProductProjection, ProductProjectionPagedSearchResponse } from '@commercetools/platform-sdk';
 import type { CommercetoolsClient } from '../core/client.js';
 export declare class CommercetoolsSearchProvider extends ProductSearchProvider {
     protected config: CommercetoolsConfiguration;
     protected client: CommercetoolsClient;
     constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, client: CommercetoolsClient);
-    protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyProductProjectionsRequestBuilder>;
+    protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyProductsRequestBuilder>;
+    protected getFacetQuery(payload: ProductSearchQueryByTerm, selectedFacetValue: FacetValueIdentifier): Promise<{
+        exact: {
+            field: string;
+            fieldType: string;
+            value: string;
+        };
+    }>;
+    protected getSearchTermExpression(payload: ProductSearchQueryByTerm): Promise<{
+        or: {
+            fullText: {
+                field: string;
+                language: string;
+                value: string;
+            };
+        }[];
+    }>;
+    protected getFacetsQuery(payload: ProductSearchQueryByTerm): Promise<{
+        exact: {
+            field: string;
+            fieldType: string;
+            value: string;
+        };
+    } | {
+        and: {
+            exact: {
+                field: string;
+                fieldType: string;
+                value: string;
+            };
+        }[];
+    } | undefined>;
+    protected getFacetsToReturn(payload: ProductSearchQueryByTerm): Promise<ProductSearchFacetExpression[]>;
     queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
     protected parseSingle(body: ProductProjection): {
         identifier: {
@@ -49,7 +81,7 @@ export declare class CommercetoolsSearchProvider extends ProductSearchProvider {
             placeholder: false;
         };
     };
-    protected parsePaginatedResult(body: ProductProjectionPagedSearchResponse, query: ProductSearchQueryByTerm): {
+    protected parsePaginatedResult(body: ProductPagedSearchResponse, query: ProductSearchQueryByTerm): {
         identifier: {
             term: string;
             facets: {
@@ -133,7 +165,13 @@ export declare class CommercetoolsSearchProvider extends ProductSearchProvider {
             }[];
         }[];
     };
-    protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: FacetResult): ProductSearchResultFacet;
+    /**
+     * See version 0.0.81 for ProductProjection based facet parsing
+     * @param facetIdentifier
+     * @param facetValue
+     * @returns
+     */
+    protected parseFacet(facetIdentifier: FacetIdentifier, facet: CTProductSearchFacetResult): ProductSearchResultFacet;
     protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
     protected parseVariant(variant: CTProductVariant, product: ProductProjection): ProductSearchResultItemVariant;
 }

package/src/schema/configuration.schema.d.ts

@@ -28,5 +28,6 @@ export declare const CommercetoolsConfigurationSchema: z.ZodObject<{
         description: z.ZodString;
         isPunchOut: z.ZodBoolean;
     }, z.core.$loose>>>>;
+    facetFieldsForSearch: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>;
 export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;