@reactionary/provider-commercetools 0.0.59 → 0.0.61

package/README.md

@@ -1,6 +1,33 @@
-# provider-commercetools
+# Commmercetools provider for Reactionary
+
+## Supports
+
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full      |          |
+| productSearch | Full     |  |
+| identity | Full     | |
+| cart | Full     |  |
+| checkout | Full     |  |
+| order | Full     |  |
+| inventory | Full     |  |
+| price | Full   |  |
+| category | Full     |  |
+| store | Full    |  |
+
+
+## Notes
+
+
+
+
+
+
+
+
+
 
-This library was generated with [Nx](https://nx.dev).
 
 ## Building
 
@@ -11,7 +38,7 @@ Run `nx build provider-commercetools` to build the library.
 Run `nx test provider-commercetools` to execute the unit tests via [Jest](https://jestjs.io).
 
 
-# ASSUMPTIONS for backend config
+## Assumptions for backend config
 
 - You will have 2 different channels for prices, one called `Offer Price` and one called `List Price`
 - ProductVariants will all have unique SKU values.

package/core/client.js

@@ -10,7 +10,7 @@ import {
 } from "@reactionary/core";
 import * as crypto from "crypto";
 import createDebug from "debug";
-const debug = createDebug("commercetools:debug");
+const debug = createDebug("reactionary:commercetools");
 class RequestContextTokenCache {
   constructor(context) {
     this.context = context;

package/core/initialize.js

@@ -4,11 +4,12 @@ import {
   InventorySchema,
   PriceSchema,
   ProductSchema,
-  SearchResultSchema,
+  ProductSearchResultSchema,
   CategorySchema,
-  CheckoutSchema
+  CheckoutSchema,
+  ProductSearchResultItemSchema
 } from "@reactionary/core";
-import { CommercetoolsSearchProvider } from "../providers/search.provider.js";
+import { CommercetoolsSearchProvider } from "../providers/product-search.provider.js";
 import { CommercetoolsProductProvider } from "../providers/product.provider.js";
 import { CommercetoolsIdentityProvider } from "../providers/identity.provider.js";
 import { CommercetoolsCartProvider } from "../providers/cart.provider.js";
@@ -22,8 +23,8 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
     if (capabilities.product) {
       client.product = new CommercetoolsProductProvider(configuration, ProductSchema, cache);
     }
-    if (capabilities.search) {
-      client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, cache);
+    if (capabilities.productSearch) {
+      client.productSearch = new CommercetoolsSearchProvider(configuration, ProductSearchResultItemSchema, cache);
     }
     if (capabilities.identity) {
       client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, cache);

package/index.js

@@ -5,6 +5,6 @@ export * from "./providers/identity.provider.js";
 export * from "./providers/inventory.provider.js";
 export * from "./providers/price.provider.js";
 export * from "./providers/product.provider.js";
-export * from "./providers/search.provider.js";
+export * from "./providers/product-search.provider.js";
 export * from "./schema/capabilities.schema.js";
 export * from "./schema/configuration.schema.js";

package/package.json

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

package/providers/cart.provider.js

@@ -34,7 +34,7 @@ class CommercetoolsCartProvider extends CartProvider {
         {
           action: "addLineItem",
           quantity: payload.quantity,
-          sku: payload.sku.key
+          sku: payload.variant.sku
         },
         {
           action: "recalculate"
@@ -346,7 +346,7 @@ class CommercetoolsCartProvider extends CartProvider {
       const item = CartItemSchema.parse({});
       item.identifier.key = remoteItem.id;
       item.product.key = remoteItem.productId;
-      item.sku.key = remoteItem.variant.sku || "";
+      item.variant.sku = remoteItem.variant.sku || "";
       item.quantity = remoteItem.quantity;
       const unitPrice = remoteItem.price.value.centAmount;
       const totalPrice = remoteItem.totalPrice.centAmount || 0;

package/providers/checkout.provider.js

@@ -378,7 +378,7 @@ class CommercetoolsCheckoutProvider extends CheckoutProvider {
     for (const remoteItem of remote.lineItems) {
       const item = CheckoutItemSchema.parse({});
       item.identifier.key = remoteItem.id;
-      item.sku.key = remoteItem.variant.sku || "";
+      item.variant.sku = remoteItem.variant.sku || "";
       item.quantity = remoteItem.quantity;
       const unitPrice = remoteItem.price.value.centAmount;
       const totalPrice = remoteItem.totalPrice.centAmount || 0;

package/providers/index.js

@@ -5,7 +5,7 @@ export * from "./inventory.provider.js";
 export * from "./price.provider.js";
 export * from "./product.provider.js";
 export * from "./profile.provider.js";
-export * from "./search.provider.js";
+export * from "./product-search.provider.js";
 export * from "./store.provider.js";
 export * from "./order.provider.js";
 export * from "./checkout.provider.js";

package/providers/inventory.provider.js

@@ -16,7 +16,7 @@ class CommercetoolsInventoryProvider extends InventoryProvider {
     const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).inventory().get({
       queryArgs: {
         where: "sku=:sku AND supplyChannel(id=:channel)",
-        "var.sku": payload.sku.key,
+        "var.sku": payload.variant.sku,
         "var.channel": channelId,
         expand: "supplyChannel"
       }
@@ -28,7 +28,7 @@ class CommercetoolsInventoryProvider extends InventoryProvider {
   parseSingle(body, reqCtx) {
     const model = this.newModel();
     model.identifier = {
-      sku: { key: body.sku || "" },
+      variant: { sku: body.sku || "" },
       fulfillmentCenter: {
         key: body.supplyChannel?.obj?.key || ""
       }

package/providers/order.provider.js

@@ -77,7 +77,7 @@ class CommercetoolsOrderProvider extends OrderProvider {
     for (const remoteItem of remote.lineItems) {
       const item = OrderItemSchema.parse({});
       item.identifier.key = remoteItem.id;
-      item.sku.key = remoteItem.variant.sku || "";
+      item.variant.sku = remoteItem.variant.sku || "";
       item.quantity = remoteItem.quantity;
       const unitPrice = remoteItem.price.value.centAmount;
       const totalPrice = remoteItem.totalPrice.centAmount || 0;

package/providers/price.provider.js

@@ -23,16 +23,16 @@ class CommercetoolsPriceProvider extends PriceProvider {
         priceCurrency: reqCtx.languageContext.currencyCode,
         // storeProjection: reqCtx.storeIdentifier?.key || undefined,
         where: "variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ",
-        "var.skus": payload.map((p) => p.sku.key),
+        "var.skus": payload.map((p) => p.variant.sku),
         limit: payload.length
       }
     }).execute();
     const result = [];
     const allReturnedVariants = [...response.body.results.map((x) => x.variants).flat(), ...response.body.results.map((x) => x.masterVariant).flat()];
     for (const p of payload) {
-      const foundSku = allReturnedVariants.find((v) => v.sku === p.sku.key);
+      const foundSku = allReturnedVariants.find((v) => v.sku === p.variant.sku);
       if (!foundSku) {
-        result.push(this.createEmptyPriceResult(p.sku.key, reqCtx.languageContext.currencyCode));
+        result.push(this.createEmptyPriceResult(p.variant.sku, reqCtx.languageContext.currencyCode));
       } else {
         result.push(this.parseSingle(foundSku, reqCtx));
       }
@@ -66,8 +66,8 @@ class CommercetoolsPriceProvider extends PriceProvider {
       base.tieredPrices = p;
     }
     base.identifier = {
-      sku: {
-        key: body.sku
+      variant: {
+        sku: body.sku
       }
     };
     base.meta = {

package/providers/product-search.provider.js

@@ -0,0 +1,123 @@
+import { createPaginatedResponseSchema, FacetIdentifierSchema, FacetValueIdentifierSchema, ImageSchema, ProductOptionIdentifierSchema, ProductSearchProvider, ProductSearchResultFacetSchema, ProductSearchResultFacetValueSchema, ProductSearchResultItemVariantSchema, ProductVariantIdentifierSchema, ProductVariantOptionSchema } from "@reactionary/core";
+import { CommercetoolsClient } from "../core/client.js";
+import createDebug from "debug";
+const debug = createDebug("reactionary:commercetools:search");
+class CommercetoolsSearchProvider extends ProductSearchProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async getClient(reqCtx) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  }
+  async queryByTerm(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const response = await client.search().get({
+      queryArgs: {
+        limit: payload.search.paginationOptions.pageSize,
+        offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize,
+        [`text.${reqCtx.languageContext.locale}`]: payload.search.term
+      }
+    }).execute();
+    const responseBody = response.body;
+    const result = this.parsePaginatedResult(responseBody, reqCtx);
+    if (debug.enabled) {
+      debug(`Search for term "${payload.search.term}" returned ${responseBody.results.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`);
+    }
+    result.identifier = {
+      ...payload.search
+    };
+    result.meta = {
+      cache: { hit: false, key: "" },
+      placeholder: false
+    };
+    return result;
+  }
+  parseSingle(body, reqCtx) {
+    const product = this.newModel();
+    product.identifier = { key: body.id };
+    product.name = body.name[reqCtx.languageContext.locale] || body.id;
+    product.slug = body.slug?.[reqCtx.languageContext.locale] || body.id;
+    product.variants = [body.masterVariant, ...body.variants].map((variant) => this.parseVariant(variant, body, reqCtx));
+    return product;
+  }
+  parsePaginatedResult(body, reqCtx) {
+    const products = body.results.map((p) => this.parseSingle(p, reqCtx));
+    const facets = [];
+    for (const id in body.facets) {
+      const f = body.facets[id];
+      const facetId = FacetIdentifierSchema.parse({
+        key: id
+      });
+      const facet = this.parseFacet(facetId, f, reqCtx);
+      facets.push(facet);
+    }
+    const result = createPaginatedResponseSchema(this.schema).parse({
+      meta: {
+        cache: { hit: false, key: "unknown" },
+        placeholder: false
+      },
+      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
+      pageSize: body.limit,
+      totalCount: body.total,
+      totalPages: Math.ceil((body.total || 0) / body.limit || 0) + 1,
+      items: products
+    });
+    result.facets = facets;
+    return result;
+  }
+  parseFacet(facetIdentifier, facetValue, reqCtx) {
+    const result = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facetIdentifier.key,
+      values: []
+    });
+    if (facetValue.type === "terms") {
+      for (const ft of facetValue.terms) {
+        const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+          facet: facetIdentifier,
+          key: ft.term
+        });
+        result.values.push(this.parseFacetValue(facetValueIdentifier, ft.term, ft.count, reqCtx));
+      }
+    }
+    return result;
+  }
+  parseFacetValue(facetValueIdentifier, label, count, reqCtx) {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false
+    });
+  }
+  parseVariant(variant, product, reqCtx) {
+    const sourceImage = variant.images?.[0];
+    const img = ImageSchema.parse({
+      sourceUrl: sourceImage?.url || "",
+      height: sourceImage?.dimensions.h || void 0,
+      width: sourceImage?.dimensions.w || void 0,
+      altText: sourceImage?.label || product.name[reqCtx.languageContext.locale] || void 0
+    });
+    const mappedOptions = variant.attributes?.filter((x) => x.name === "Color").map(
+      (opt) => ProductVariantOptionSchema.parse(
+        {
+          identifier: ProductOptionIdentifierSchema.parse({
+            key: opt.name
+          }),
+          name: opt.value || ""
+        }
+      )
+    ) || [];
+    const mappedOption = mappedOptions?.[0];
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({ sku: variant.sku || "" }),
+      image: img,
+      option: mappedOption
+    });
+  }
+}
+export {
+  CommercetoolsSearchProvider
+};

package/providers/product.provider.js

@@ -1,5 +1,12 @@
 import {
-  ProductProvider
+  ImageSchema,
+  ProductAttributeIdentifierSchema,
+  ProductAttributeSchema,
+  ProductAttributeValueIdentifierSchema,
+  ProductAttributeValueSchema,
+  ProductProvider,
+  ProductVariantIdentifierSchema,
+  ProductVariantSchema
 } from "@reactionary/core";
 import { CommercetoolsClient } from "../core/client.js";
 class CommercetoolsProductProvider extends ProductProvider {
@@ -40,13 +47,12 @@ class CommercetoolsProductProvider extends ProductProvider {
         staged: false,
         limit: 1,
         where: "variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ",
-        "var.skus": [payload].map((p) => p.sku.key)
+        "var.skus": [payload].map((p) => p.variant.sku)
       }
     }).execute();
     return this.parseSingle(remote.body.results[0], reqCtx);
   }
-  parseSingle(dataIn, reqCtx) {
-    const data = dataIn;
+  parseSingle(data, reqCtx) {
     const base = this.newModel();
     base.identifier = { key: data.id };
     base.name = data.name[reqCtx.languageContext.locale];
@@ -54,26 +60,64 @@ class CommercetoolsProductProvider extends ProductProvider {
     if (data.description) {
       base.description = data.description[reqCtx.languageContext.locale];
     }
-    if (data.masterVariant.images && data.masterVariant.images.length > 0) {
-      base.image = data.masterVariant.images[0].url;
-    }
-    base.images = [];
-    base.attributes = [];
-    base.skus = [];
-    const variants = [data.masterVariant, ...data.variants];
-    for (const variant of variants) {
-      if (variant.sku) {
-        base.skus.push({
-          identifier: { key: variant.sku }
-        });
-      }
-    }
+    base.sharedAttributes = data.masterVariant.attributes?.map((x) => this.parseAttribute(x, reqCtx)) || [];
+    base.mainVariant = this.parseVariant(data.masterVariant, data, reqCtx);
     base.meta = {
       cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, reqCtx) },
       placeholder: false
     };
     return this.assert(base);
   }
+  parseVariant(variant, product, reqCtx) {
+    const result = ProductVariantSchema.parse({
+      identifier: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku
+      }),
+      images: [
+        ...(variant.images || []).map((img) => ImageSchema.parse({
+          sourceUrl: img.url,
+          altText: img.label || "",
+          width: img.dimensions?.w,
+          height: img.dimensions?.h
+        }))
+      ]
+    });
+    return result;
+  }
+  parseAttribute(attr, reqCtx) {
+    const result = ProductAttributeSchema.parse({
+      identifier: ProductAttributeIdentifierSchema.parse({
+        key: attr.name
+      }),
+      group: "",
+      name: attr.name,
+      values: [
+        this.parseAttributeValue(attr, reqCtx)
+      ]
+    });
+    return result;
+  }
+  parseAttributeValue(attr, reqCtx) {
+    let attrValue = "";
+    if (attr.value && Array.isArray(attr.value)) {
+      attrValue = attr.value[0];
+    }
+    if (attrValue && typeof attrValue === "object") {
+      if (reqCtx.languageContext.locale in attrValue) {
+        attrValue = attrValue[reqCtx.languageContext.locale];
+      } else {
+        attrValue = "-";
+      }
+    }
+    const attrVal = ProductAttributeValueSchema.parse({
+      identifier: ProductAttributeValueIdentifierSchema.parse({
+        key: attrValue
+      }),
+      value: String(attrValue),
+      label: String(attrValue)
+    });
+    return attrVal;
+  }
 }
 export {
   CommercetoolsProductProvider

package/schema/capabilities.schema.js

@@ -1,7 +1,7 @@
 import { CapabilitiesSchema } from "@reactionary/core";
 const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
-  search: true,
+  productSearch: true,
   identity: true,
   cart: true,
   checkout: true,

package/src/core/initialize.d.ts

@@ -1,12 +1,12 @@
-import type { Cache, ProductProvider, SearchProvider, IdentityProvider, CartProvider, InventoryProvider, PriceProvider, CategoryProvider, StoreProvider, CheckoutProvider, OrderProvider } from "@reactionary/core";
+import type { Cache, ProductProvider, ProductSearchProvider, IdentityProvider, CartProvider, InventoryProvider, PriceProvider, CategoryProvider, StoreProvider, CheckoutProvider, OrderProvider } from "@reactionary/core";
 import type { CommercetoolsCapabilities } from "../schema/capabilities.schema.js";
 import type { CommercetoolsConfiguration } from "../schema/configuration.schema.js";
 type CommercetoolsClient<T extends CommercetoolsCapabilities> = (T['cart'] extends true ? {
     cart: CartProvider;
 } : object) & (T['product'] extends true ? {
     product: ProductProvider;
-} : object) & (T['search'] extends true ? {
-    search: SearchProvider;
+} : object) & (T['productSearch'] extends true ? {
+    productSearch: ProductSearchProvider;
 } : object) & (T['identity'] extends true ? {
     identity: IdentityProvider;
 } : object) & (T['category'] extends true ? {

package/src/index.d.ts

@@ -5,6 +5,6 @@ export * from './providers/identity.provider.js';
 export * from './providers/inventory.provider.js';
 export * from './providers/price.provider.js';
 export * from './providers/product.provider.js';
-export * from './providers/search.provider.js';
+export * from './providers/product-search.provider.js';
 export * from './schema/capabilities.schema.js';
 export * from './schema/configuration.schema.js';

package/src/providers/index.d.ts

@@ -5,7 +5,7 @@ export * from './inventory.provider.js';
 export * from './price.provider.js';
 export * from './product.provider.js';
 export * from './profile.provider.js';
-export * from './search.provider.js';
+export * from './product-search.provider.js';
 export * from './store.provider.js';
 export * from './order.provider.js';
 export * from './checkout.provider.js';

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

@@ -0,0 +1,31 @@
+import { ProductSearchProvider } from '@reactionary/core';
+import type { Cache, ProductSearchQueryByTerm, RequestContext, ProductSearchResultItem, ProductSearchResult, ProductSearchResultItemVariant, FacetIdentifier, ProductSearchResultFacet, FacetValueIdentifier, ProductSearchResultFacetValue } from '@reactionary/core';
+import type z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { ProductVariant as CTProductVariant, FacetResult, ProductProjection, ProductProjectionPagedSearchResponse } from '@commercetools/platform-sdk';
+export declare class CommercetoolsSearchProvider<T extends ProductSearchResultItem = ProductSearchResultItem> extends ProductSearchProvider<T> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    protected getClient(reqCtx: RequestContext): Promise<import("@commercetools/platform-sdk").ByProjectKeyProductProjectionsRequestBuilder>;
+    queryByTerm(payload: ProductSearchQueryByTerm, reqCtx: RequestContext): Promise<ProductSearchResult>;
+    protected parseSingle(body: ProductProjection, reqCtx: RequestContext): T;
+    protected parsePaginatedResult(body: ProductProjectionPagedSearchResponse, reqCtx: RequestContext): {
+        meta: {
+            [x: string]: unknown;
+            cache: {
+                [x: string]: unknown;
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: T[];
+    };
+    protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: FacetResult, reqCtx: RequestContext): ProductSearchResultFacet;
+    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number, reqCtx: RequestContext): ProductSearchResultFacetValue;
+    protected parseVariant(variant: CTProductVariant, product: ProductProjection, reqCtx: RequestContext): ProductSearchResultItemVariant;
+}

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

@@ -1,7 +1,8 @@
 import { ProductProvider } from '@reactionary/core';
 import type { z } from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { Product, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext } from '@reactionary/core';
+import type { ProductProjection, ProductVariant as CTProductVariant, Attribute as CTAttribute } from '@commercetools/platform-sdk';
+import type { Product, ProductVariant, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext, ProductAttribute, ProductAttributeValue } from '@reactionary/core';
 import type { Cache } from '@reactionary/core';
 export declare class CommercetoolsProductProvider<T extends Product = Product> extends ProductProvider<T> {
     protected config: CommercetoolsConfiguration;
@@ -10,5 +11,8 @@ export declare class CommercetoolsProductProvider<T extends Product = Product> e
     getById(payload: ProductQueryById, reqCtx: RequestContext): Promise<T>;
     getBySlug(payload: ProductQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
     getBySKU(payload: ProductQueryBySKU, reqCtx: RequestContext): Promise<T>;
-    protected parseSingle(dataIn: unknown, reqCtx: RequestContext): T;
+    protected parseSingle(data: ProductProjection, reqCtx: RequestContext): T;
+    protected parseVariant(variant: CTProductVariant, product: ProductProjection, reqCtx: RequestContext): ProductVariant;
+    protected parseAttribute(attr: CTAttribute, reqCtx: RequestContext): ProductAttribute;
+    protected parseAttributeValue(attr: CTAttribute, reqCtx: RequestContext): ProductAttributeValue;
 }

package/src/schema/capabilities.schema.d.ts

@@ -3,12 +3,12 @@ export declare const CommercetoolsCapabilitiesSchema: z.ZodObject<{
     price: z.ZodOptional<z.ZodBoolean>;
     product: z.ZodOptional<z.ZodBoolean>;
     identity: z.ZodOptional<z.ZodBoolean>;
-    search: z.ZodOptional<z.ZodBoolean>;
     cart: z.ZodOptional<z.ZodBoolean>;
     inventory: z.ZodOptional<z.ZodBoolean>;
     category: z.ZodOptional<z.ZodBoolean>;
     checkout: z.ZodOptional<z.ZodBoolean>;
     order: z.ZodOptional<z.ZodBoolean>;
     store: z.ZodOptional<z.ZodBoolean>;
+    productSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

package/providers/search.provider.js

@@ -1,48 +0,0 @@
-import { SearchProvider } from "@reactionary/core";
-import { CommercetoolsClient } from "../core/client.js";
-class CommercetoolsSearchProvider extends SearchProvider {
-  constructor(config, schema, cache) {
-    super(schema, cache);
-    this.config = config;
-  }
-  async getClient(reqCtx) {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
-    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
-  }
-  async queryByTerm(payload, reqCtx) {
-    const client = await this.getClient(reqCtx);
-    const remote = await client.search().get({
-      queryArgs: {
-        limit: payload.search.pageSize,
-        offset: (payload.search.page - 1) * payload.search.pageSize,
-        [`text.${reqCtx.languageContext.locale}`]: payload.search.term
-      }
-    }).execute();
-    return this.parseSearchResult(remote, payload, reqCtx);
-  }
-  parseSearchResult(remote, payload, reqCtx) {
-    const result = this.newModel();
-    const remoteData = remote;
-    result.identifier = payload.search;
-    for (const p of remoteData.body.results) {
-      const product = {
-        identifier: { key: p.id },
-        name: p.name[reqCtx.languageContext.locale] || p.id,
-        slug: p.slug?.[reqCtx.languageContext.locale] || p.id,
-        image: p.masterVariant.images?.[0]?.url || "https://placehold.co/400"
-      };
-      result.products.push(product);
-    }
-    result.pages = Math.ceil(
-      (remoteData.body.total || 0) / payload.search.pageSize
-    );
-    result.meta = {
-      cache: { hit: false, key: payload.search.term },
-      placeholder: false
-    };
-    return this.assert(result);
-  }
-}
-export {
-  CommercetoolsSearchProvider
-};

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

@@ -1,11 +0,0 @@
-import { SearchProvider } from '@reactionary/core';
-import type { SearchResult, Cache, SearchQueryByTerm, RequestContext } from '@reactionary/core';
-import type z from 'zod';
-import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-export declare class CommercetoolsSearchProvider<T extends SearchResult = SearchResult> extends SearchProvider<T> {
-    protected config: CommercetoolsConfiguration;
-    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
-    protected getClient(reqCtx: RequestContext): Promise<import("@commercetools/platform-sdk").ByProjectKeyProductProjectionsRequestBuilder>;
-    queryByTerm(payload: SearchQueryByTerm, reqCtx: RequestContext): Promise<T>;
-    protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm, reqCtx: RequestContext): T;
-}