@reactionary/source 0.6.1 → 0.6.3

package/packages/commercetools/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,182 @@
+import type {
+  ProductPagedSearchResponse,
+  ProductProjection,
+  ProductSearchFacetResult as CTProductSearchFacetResult,
+  ProductSearchFacetResultBucket as CTProductSearchFacetResultBucket,
+  ProductVariant as CTProductVariant,
+} from '@commercetools/platform-sdk';
+import type {
+  ProductSearchResultSchema} from '@reactionary/core';
+import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  ProductVariantOptionSchema,
+  type AnyProductSearchResultSchema,
+  type FacetIdentifier,
+  type FacetValueIdentifier,
+  type ProductOptionIdentifier,
+  type ProductSearchFactory,
+  type ProductSearchQueryByTerm,
+  type ProductSearchResult,
+  type ProductSearchResultFacet,
+  type ProductSearchResultFacetValue,
+  type ProductSearchResultItem,
+  type ProductSearchResultItemVariant,
+  type ProductVariantIdentifier,
+  type ProductVariantOption,
+  type RequestContext,
+  type SearchIdentifier,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    context: RequestContext,
+    data: ProductPagedSearchResponse,
+    query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    const identifier = {
+      ...query.search,
+    } satisfies SearchIdentifier;
+
+    const items: ProductSearchResultItem[] = data.results.map((product) =>
+      this.parseSingle(context, product.productProjection!),
+    );
+    const facets: ProductSearchResultFacet[] = [];
+
+    for (const facet of data.facets) {
+      const facetIdentifier = FacetIdentifierSchema.parse({
+        key: facet.name,
+      } satisfies Partial<FacetIdentifier>);
+
+      const candidateFacet = this.parseFacet(facetIdentifier, facet);
+      if (candidateFacet.values.length > 0) {
+        facets.push(candidateFacet);
+      }
+    }
+
+    const result = {
+      identifier,
+      pageNumber: (Math.ceil(data.offset / data.limit) || 0) + 1,
+      pageSize: data.limit,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total || 0) / data.limit || 0) + 1,
+      items,
+      facets,
+    } satisfies ProductSearchResult;
+
+    return this.productSearchResultSchema.parse(result);
+  }
+
+  protected parseSingle(
+    context: RequestContext,
+    data: ProductProjection,
+  ): ProductSearchResultItem {
+    const identifier = { key: data.id };
+    const name = data.name[context.languageContext.locale] || data.id;
+    const slug = data.slug?.[context.languageContext.locale] || data.id;
+    const variants = [data.masterVariant, ...data.variants].map((variant) =>
+      this.parseVariant(context, variant, data),
+    );
+
+    const result = {
+      identifier,
+      name,
+      slug,
+      variants,
+    } satisfies ProductSearchResultItem;
+
+    return result;
+  }
+
+  protected parseFacet(
+    facetIdentifier: FacetIdentifier,
+    facet: CTProductSearchFacetResult,
+  ): ProductSearchResultFacet {
+    const result: ProductSearchResultFacet = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facet.name,
+      values: [],
+    });
+
+    const distinctFacet = facet as CTProductSearchFacetResultBucket;
+    for (const bucket of distinctFacet.buckets || []) {
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: bucket.key,
+      } satisfies Partial<FacetValueIdentifier>);
+
+      result.values.push(
+        this.parseFacetValue(facetValueIdentifier, bucket.key, bucket.count),
+      );
+    }
+
+    return result;
+  }
+
+  protected parseFacetValue(
+    facetValueIdentifier: FacetValueIdentifier,
+    label: string,
+    count: number,
+  ): ProductSearchResultFacetValue {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false,
+    } satisfies Partial<ProductSearchResultFacetValue>);
+  }
+
+  protected parseVariant(
+    context: RequestContext,
+    variant: CTProductVariant,
+    product: ProductProjection,
+  ): ProductSearchResultItemVariant {
+    const sourceImage = variant.images?.[0];
+
+    const image = ImageSchema.parse({
+      sourceUrl: sourceImage?.url || '',
+      height: sourceImage?.dimensions.h || undefined,
+      width: sourceImage?.dimensions.w || undefined,
+      altText:
+        sourceImage?.label || product.name[context.languageContext.locale] || undefined,
+    });
+
+    const mappedOptions =
+      variant.attributes
+        ?.filter((attribute) => attribute.name === 'Color')
+        .map((option) =>
+          ProductVariantOptionSchema.parse({
+            identifier: ProductOptionIdentifierSchema.parse({
+              key: option.name,
+            } satisfies Partial<ProductOptionIdentifier>),
+            name: option.value || '',
+          } satisfies Partial<ProductVariantOption>),
+        ) || [];
+
+    const mappedOption = mappedOptions?.[0];
+
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || '',
+      } satisfies ProductVariantIdentifier),
+      image,
+      options: mappedOption,
+    } satisfies Partial<ProductSearchResultItemVariant>);
+  }
+}

package/packages/commercetools/src/factories/profile/profile.factory.ts

@@ -0,0 +1,94 @@
+import type { Address as CTAddress, Customer } from '@commercetools/platform-sdk';
+import type {
+  ProfileSchema} from '@reactionary/core';
+import {
+  type Address,
+  type AnyProfileSchema,
+  type Profile,
+  type ProfileFactory,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsProfileFactory<
+  TProfileSchema extends AnyProfileSchema = typeof ProfileSchema,
+> implements ProfileFactory<TProfileSchema>
+{
+  public readonly profileSchema: TProfileSchema;
+
+  constructor(profileSchema: TProfileSchema) {
+    this.profileSchema = profileSchema;
+  }
+
+  public parseProfile(
+    _context: RequestContext,
+    data: Customer,
+  ): z.output<TProfileSchema> {
+    const email = data.email;
+    const emailVerified = data.isEmailVerified;
+    let defaultBilling = data.addresses.find((address) => address.id === data.defaultBillingAddressId);
+    const phone = defaultBilling?.phone ?? '';
+
+    if (this.isIncompleteAddress(defaultBilling)) {
+      defaultBilling = undefined;
+    }
+
+    const defaultShipping = data.addresses.find(
+      (address) => address.id === data.defaultShippingAddressId,
+    );
+
+    const alternateShippingAddresses = data.addresses
+      .filter((address) => address.id !== data.defaultBillingAddressId)
+      .filter((address) => address.id !== data.defaultShippingAddressId)
+      .map((address) => this.parseAddress(address));
+
+    const billingAddress = defaultBilling ? this.parseAddress(defaultBilling) : undefined;
+    const shippingAddress = defaultShipping ? this.parseAddress(defaultShipping) : undefined;
+
+    const result = {
+      identifier: {
+        userId: data.id,
+      },
+      email,
+      emailVerified,
+      alternateShippingAddresses,
+      billingAddress,
+      shippingAddress,
+      createdAt: data.createdAt,
+      phone,
+      phoneVerified: false,
+      updatedAt: data.lastModifiedAt,
+    } satisfies Profile;
+
+    return this.profileSchema.parse(result);
+  }
+
+  protected parseAddress(address: CTAddress): Address {
+    return {
+      identifier: {
+        nickName: address.key || '',
+      },
+      firstName: address.firstName || '',
+      lastName: address.lastName || '',
+      streetAddress: address.streetName || '',
+      streetNumber: address.streetNumber || '',
+      city: address.city || '',
+      region: address.region || '',
+      postalCode: address.postalCode || '',
+      countryCode: address.country,
+    } satisfies Address;
+  }
+
+  protected isIncompleteAddress(address: CTAddress | undefined): boolean {
+    if (!address) {
+      return false;
+    }
+    return (
+      !address.firstName &&
+      !address.lastName &&
+      !address.streetName &&
+      !address.streetNumber &&
+      !address.city
+    );
+  }
+}

package/packages/commercetools/src/factories/store/store.factory.ts

@@ -0,0 +1,49 @@
+import type { Channel } from '@commercetools/platform-sdk';
+import type {
+  StoreSchema} from '@reactionary/core';
+import {
+  type AnyStoreSchema,
+  type FulfillmentCenterIdentifier,
+  type RequestContext,
+  type Store,
+  type StoreFactory,
+  type StoreIdentifier,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsStoreFactory<
+  TStoreSchema extends AnyStoreSchema = typeof StoreSchema,
+> implements StoreFactory<TStoreSchema>
+{
+  public readonly storeSchema: TStoreSchema;
+
+  constructor(storeSchema: TStoreSchema) {
+    this.storeSchema = storeSchema;
+  }
+
+  public parseStore(
+    _context: RequestContext,
+    data: Channel,
+  ): z.output<TStoreSchema> {
+    let name = '';
+    if (data.name && data.name['la']) {
+      name = data.name['la'];
+    }
+
+    const identifier = {
+      key: data.key || '',
+    } satisfies StoreIdentifier;
+
+    const fulfillmentCenter = {
+      key: data.key || '',
+    } satisfies FulfillmentCenterIdentifier;
+
+    const result = {
+      identifier,
+      fulfillmentCenter,
+      name,
+    } satisfies Store;
+
+    return this.storeSchema.parse(result);
+  }
+}

package/packages/commercetools/src/index.ts

@@ -0,0 +1,30 @@
+export * from './core/client.js';
+export * from './core/initialize.js';
+
+export * from './capabilities/cart.capability.js';
+export * from './capabilities/identity.capability.js';
+export * from './capabilities/inventory.capability.js';
+export * from './capabilities/order-search.capability.js';
+export * from './capabilities/price.capability.js';
+export * from './capabilities/product-associations.capability.js';
+export * from './capabilities/product.capability.js';
+export * from './capabilities/product-reviews.capability.js';
+export * from './capabilities/product-search.capability.js';
+export * from './factories/product/product.factory.js';
+export * from './factories/checkout/checkout.factory.js';
+export * from './factories/product-search/product-search.factory.js';
+export * from './factories/inventory/inventory.factory.js';
+export * from './factories/price/price.factory.js';
+export * from './factories/store/store.factory.js';
+export * from './factories/order/order.factory.js';
+export * from './factories/category/category.factory.js';
+export * from './factories/cart/cart.factory.js';
+export * from './factories/profile/profile.factory.js';
+export * from './factories/order-search/order-search.factory.js';
+export * from './factories/product-associations/product-associations.factory.js';
+export * from './factories/product-reviews/product-reviews.factory.js';
+export * from './factories/product-list/product-list.factory.js';
+export * from './factories/identity/identity.factory.js';
+
+export * from './schema/capabilities.schema.js';
+export * from './schema/configuration.schema.js';

package/packages/commercetools/src/schema/capabilities.schema.ts

@@ -0,0 +1,260 @@
+import type {
+  Cache,
+  CartFactory,
+  CartFactoryWithOutput,
+  CartCapability,
+  CategoryFactory,
+  CategoryFactoryWithOutput,
+  CategoryCapability,
+  CheckoutFactory,
+  CheckoutFactoryWithOutput,
+  CheckoutCapability,
+  IdentityFactory,
+  IdentityFactoryWithOutput,
+  IdentityCapability,
+  InventoryFactory,
+  InventoryFactoryWithOutput,
+  InventoryCapability,
+  OrderFactory,
+  OrderFactoryWithOutput,
+  OrderCapability,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchCapability,
+  PriceFactory,
+  PriceFactoryWithOutput,
+  PriceCapability,
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryWithOutput,
+  ProductAssociationsCapability,
+  ProductFactory,
+  ProductFactoryWithOutput,
+  ProductListFactory,
+  ProductListFactoryWithOutput,
+  ProductListCapability,
+  ProductCapability,
+  ProductReviewsFactory,
+  ProductReviewsFactoryWithOutput,
+  ProductReviewsCapability,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchCapability,
+  ProfileFactory,
+  ProfileFactoryWithOutput,
+  ProfileCapability,
+  RequestContext,
+  StoreFactory,
+  StoreFactoryWithOutput,
+  StoreCapability,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const EnabledCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+});
+
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional(),
+});
+
+export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  productSearch: true,
+  productAssociations: true,
+  productReviews: true,
+  productList: true,
+  identity: true,
+  cart: true,
+  checkout: true,
+  order: true,
+  orderSearch: true,
+  inventory: true,
+  price: true,
+  category: true,
+  store: true,
+  profile: true,
+})
+  .extend({
+    productSearch: EnabledCapabilitySchema.optional(),
+    productAssociations: EnabledCapabilitySchema.optional(),
+    productReviews: EnabledCapabilitySchema.optional(),
+    productList: EnabledCapabilitySchema.optional(),
+    identity: EnabledCapabilitySchema.optional(),
+    cart: EnabledCapabilitySchema.optional(),
+    order: EnabledCapabilitySchema.optional(),
+    orderSearch: EnabledCapabilitySchema.optional(),
+    inventory: EnabledCapabilitySchema.optional(),
+    price: EnabledCapabilitySchema.optional(),
+    category: EnabledCapabilitySchema.optional(),
+    store: EnabledCapabilitySchema.optional(),
+    profile: EnabledCapabilitySchema.optional(),
+    product: OverridableCapabilitySchema.optional(),
+    checkout: OverridableCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface CommercetoolsCapabilityFactoryArgs<TFactory> {
+  cache: Cache;
+  context: RequestContext;
+  config: CommercetoolsConfiguration;
+  commercetoolsApi: CommercetoolsAPI;
+  factory: TFactory;
+}
+
+export interface CommercetoolsCapabilityConfig<TFactory, TCapability> {
+  factory?: TFactory;
+  capability?: (args: CommercetoolsCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+
+type EnabledCapabilityConfig<TFactory, TCapability> = {
+  enabled: boolean;
+} & CommercetoolsCapabilityConfig<TFactory, TCapability>;
+
+export type CommercetoolsProductCapabilityConfig<
+  TFactory extends ProductFactory = ProductFactory,
+  TCapability extends ProductCapability = ProductCapability,
+> = CommercetoolsCapabilityConfig<ProductFactoryWithOutput<TFactory>, TCapability>;
+
+export type CommercetoolsCheckoutCapabilityConfig<
+  TFactory extends CheckoutFactory = CheckoutFactory,
+  TCapability extends CheckoutCapability = CheckoutCapability,
+> = CommercetoolsCapabilityConfig<CheckoutFactoryWithOutput<TFactory>, TCapability>;
+
+export type CommercetoolsProductSearchCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductSearchFactoryWithOutput<ProductSearchFactory>,
+  ProductSearchCapability
+>;
+export type CommercetoolsProductAssociationsCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+  ProductAssociationsCapability
+>;
+export type CommercetoolsProductReviewsCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
+  ProductReviewsCapability
+>;
+export type CommercetoolsProductListCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductListFactoryWithOutput<ProductListFactory>,
+  ProductListCapability
+>;
+export type CommercetoolsIdentityCapabilityConfig = CommercetoolsCapabilityConfig<
+  IdentityFactoryWithOutput<IdentityFactory>,
+  IdentityCapability
+>;
+export type CommercetoolsCartCapabilityConfig = CommercetoolsCapabilityConfig<
+  CartFactoryWithOutput<CartFactory>,
+  CartCapability
+>;
+export type CommercetoolsInventoryCapabilityConfig = CommercetoolsCapabilityConfig<
+  InventoryFactoryWithOutput<InventoryFactory>,
+  InventoryCapability
+>;
+export type CommercetoolsPriceCapabilityConfig = CommercetoolsCapabilityConfig<
+  PriceFactoryWithOutput<PriceFactory>,
+  PriceCapability
+>;
+export type CommercetoolsCategoryCapabilityConfig = CommercetoolsCapabilityConfig<
+  CategoryFactoryWithOutput<CategoryFactory>,
+  CategoryCapability
+>;
+export type CommercetoolsStoreCapabilityConfig = CommercetoolsCapabilityConfig<
+  StoreFactoryWithOutput<StoreFactory>,
+  StoreCapability
+>;
+export type CommercetoolsProfileCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProfileFactoryWithOutput<ProfileFactory>,
+  ProfileCapability
+>;
+export type CommercetoolsOrderCapabilityConfig = CommercetoolsCapabilityConfig<
+  OrderFactoryWithOutput<OrderFactory>,
+  OrderCapability
+>;
+export type CommercetoolsOrderSearchCapabilityConfig = CommercetoolsCapabilityConfig<
+  OrderSearchFactoryWithOutput<OrderSearchFactory>,
+  OrderSearchCapability
+>;
+
+export type CommercetoolsCapabilityConfigMap<
+  TProductFactory extends ProductFactory = ProductFactory,
+  TProductCapability extends ProductCapability = ProductCapability,
+  TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
+  TCheckoutCapability extends CheckoutCapability = CheckoutCapability,
+> = {
+  product: EnabledCapabilityConfig<
+    ProductFactoryWithOutput<TProductFactory>,
+    TProductCapability
+  >;
+  checkout: EnabledCapabilityConfig<
+    CheckoutFactoryWithOutput<TCheckoutFactory>,
+    TCheckoutCapability
+  >;
+  productSearch: EnabledCapabilityConfig<
+    ProductSearchFactoryWithOutput<ProductSearchFactory>,
+    ProductSearchCapability
+  >;
+  productAssociations: EnabledCapabilityConfig<
+    ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+    ProductAssociationsCapability
+  >;
+  productReviews: EnabledCapabilityConfig<
+    ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
+    ProductReviewsCapability
+  >;
+  productList: EnabledCapabilityConfig<
+    ProductListFactoryWithOutput<ProductListFactory>,
+    ProductListCapability
+  >;
+  identity: EnabledCapabilityConfig<
+    IdentityFactoryWithOutput<IdentityFactory>,
+    IdentityCapability
+  >;
+  cart: EnabledCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+  inventory: EnabledCapabilityConfig<
+    InventoryFactoryWithOutput<InventoryFactory>,
+    InventoryCapability
+  >;
+  price: EnabledCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+  category: EnabledCapabilityConfig<
+    CategoryFactoryWithOutput<CategoryFactory>,
+    CategoryCapability
+  >;
+  store: EnabledCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
+  profile: EnabledCapabilityConfig<
+    ProfileFactoryWithOutput<ProfileFactory>,
+    ProfileCapability
+  >;
+  order: EnabledCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
+  orderSearch: EnabledCapabilityConfig<
+    OrderSearchFactoryWithOutput<OrderSearchFactory>,
+    OrderSearchCapability
+  >;
+};
+
+type CommercetoolsCapabilitiesBase = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+
+export type CommercetoolsCapabilities<
+  TProductFactory extends ProductFactory = ProductFactory,
+  TProductCapability extends ProductCapability = ProductCapability,
+  TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
+  TCheckoutCapability extends CheckoutCapability = CheckoutCapability,
+> = Omit<
+  CommercetoolsCapabilitiesBase,
+  keyof CommercetoolsCapabilityConfigMap<
+    TProductFactory,
+    TProductCapability,
+    TCheckoutFactory,
+    TCheckoutCapability
+  >
+> &
+  Partial<
+    CommercetoolsCapabilityConfigMap<
+      TProductFactory,
+      TProductCapability,
+      TCheckoutFactory,
+      TCheckoutCapability
+    >
+  >;

package/{providers → packages}/commercetools/src/test/caching.spec.ts

@@ -4,12 +4,16 @@ import { getCommercetoolsTestConfiguration } from './test-utils.js';
 import {
   createInitialRequestContext,
   MemoryCache,
+  ProductSchema,
+  ProductSearchResultSchema,
   type ProductIdentifier,
   type ProductSearchQueryByTerm,
 } from '@reactionary/core';
-import { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import { CommercetoolsProductCapability } from '../capabilities/product.capability.js';
 import { CommercetoolsAPI } from '../core/client.js';
-import { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
+import { CommercetoolsProductSearchCapability } from '../capabilities/product-search.capability.js';
+import { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+import { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 describe('Caching', () => {
   it('should cache repeat look-ups for products', async () => {
@@ -17,13 +21,19 @@ describe('Caching', () => {
     const context = createInitialRequestContext();
     const cache = new MemoryCache();
     const client = new CommercetoolsAPI(config, context);
-    const provider = new CommercetoolsProductProvider(config, cache, context, client);
+    const capability = new CommercetoolsProductCapability(
+      cache,
+      context,
+      config,
+      client,
+      new CommercetoolsProductFactory(ProductSchema)
+    );
 
     const identifier = {
         key: 'product_10959528'
     } satisfies ProductIdentifier;
 
-    const uncached = await provider.getById({
+    const uncached = await capability.getById({
         identifier
     });
 
@@ -33,7 +43,7 @@ describe('Caching', () => {
 
     expect(uncached.meta.cache.hit).toBe(false);
 
-    const cached = await provider.getById({
+    const cached = await capability.getById({
         identifier
     });
 
@@ -49,7 +59,13 @@ describe('Caching', () => {
     const context = createInitialRequestContext();
     const cache = new MemoryCache();
     const client = new CommercetoolsAPI(config, context);
-    const provider = new CommercetoolsSearchProvider(config, cache, context, client);
+    const capability = new CommercetoolsProductSearchCapability(
+      config,
+      cache,
+      context,
+      client,
+      new CommercetoolsProductSearchFactory(ProductSearchResultSchema),
+    );
 
     const query = {
       search: {
@@ -63,7 +79,7 @@ describe('Caching', () => {
       }
     } satisfies ProductSearchQueryByTerm;
 
-    const uncached = await provider.queryByTerm(query);
+    const uncached = await capability.queryByTerm(query);
 
     if (!uncached.success) {
       assert.fail();
@@ -71,7 +87,7 @@ describe('Caching', () => {
 
     expect(uncached.meta.cache.hit).toBe(false);
 
-    const cached = await provider.queryByTerm(query);
+    const cached = await capability.queryByTerm(query);
 
     if (!cached.success) {
       assert.fail();