@reactionary/source 0.3.18 → 0.6.2

package/providers/commercetools/src/providers/profile.provider.ts

@@ -1,5 +1,7 @@
 import type {
-  Profile,
+  ProfileFactory,
+  ProfileFactoryOutput,
+  ProfileFactoryWithOutput,
   ProfileMutationAddShippingAddress,
   ProfileMutationMakeShippingAddressDefault,
   ProfileMutationRemoveShippingAddress,
@@ -10,8 +12,8 @@ import type {
   Result,
   NotFoundError,
   InvalidInputError,
+  ProfileMutationUpdateShippingAddress,
   Address,
-  ProfileMutationUpdateShippingAddress
 } from '@reactionary/core';
 import {
   ProfileMutationUpdateSchema,
@@ -27,23 +29,29 @@ import {
 import type * as z from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { Cache } from '@reactionary/core';
-import type { Customer, MyCustomerUpdateAction, Address as CTAddress } from '@commercetools/platform-sdk';
+import type { MyCustomerUpdateAction, Address as CTAddress } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
 
-export class CommercetoolsProfileProvider extends ProfileProvider {
+export class CommercetoolsProfileProvider<
+  TFactory extends ProfileFactory = CommercetoolsProfileFactory,
+> extends ProfileProvider<ProfileFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: ProfileFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: ProfileFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -51,7 +59,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
     return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
-  public override async getById(payload: ProfileQuerySelf): Promise<Result<Profile, NotFoundError>> {
+  public override async getById(payload: ProfileQuerySelf): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -63,7 +71,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
       });
     }
 
-    const model = this.parseSingle(remote.body);
+    const model = this.factory.parseProfile(this.context, remote.body);
     return success(model);
   }
 
@@ -73,7 +81,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationAddShippingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public override async addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>> {
+  public override async addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -101,11 +109,11 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
       })
       .execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
 
-  public override async updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>> {
+  public override async updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -144,7 +152,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
       })
       .execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
 
@@ -152,7 +160,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationRemoveShippingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public override async removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>> {
+  public override async removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -207,13 +215,13 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
       .execute();
     customer = updateResponse.body;
 
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
 
 
 
-  public override async makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>> {
+  public override async makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -257,7 +265,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
       })
       .execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
 
@@ -266,7 +274,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationSetBillingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public override async setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>> {
+  public override async setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -311,7 +319,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
         .execute();
       customer = updateResponse.body;
     }
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
 
@@ -319,7 +327,7 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationUpdateSchema,
     outputSchema: ProfileSchema,
   })
-  public override async update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>> {
+  public override async update(payload: ProfileMutationUpdate): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
 
     const remote = await client.me().get().execute();
@@ -381,65 +389,11 @@ export class CommercetoolsProfileProvider extends ProfileProvider {
         .execute();
       customer = updateResponse.body;
     }
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
 
   }
 
-  protected parseAddress(address: CTAddress): Address {
-    const result = {
-      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;
-
-    return result;
-  }
-
-  protected parseSingle(body: Customer): Profile {
-    const email = body.email;
-    const emailVerified = body.isEmailVerified;
-    let defaultCTBillingAddress = body.addresses.find(addr => addr.id === body.defaultBillingAddressId);
-    const phone = defaultCTBillingAddress?.phone ?? '';
-
-
-    // if we only have the phone number on the billing address, we dont really have a billing address, so we ignore it
-    if (this.isIncompleteAddress(defaultCTBillingAddress)) {
-      defaultCTBillingAddress = undefined;
-    }
-
-    const defaultCTShippingAddress = body.addresses.find(addr => addr.id === body.defaultShippingAddressId);
-
-    const alternateShippingAddresses = body.addresses.filter(x => x.id !== body.defaultBillingAddressId && x.id !== body.defaultShippingAddressId).map(addr => this.parseAddress(addr));
-    const billingAddress = defaultCTBillingAddress ? this.parseAddress(defaultCTBillingAddress) : undefined;
-    const shippingAddress = defaultCTShippingAddress ? this.parseAddress(defaultCTShippingAddress) : undefined;
-
-    const result = {
-      identifier: {
-        userId: body.id
-      },
-      email,
-      emailVerified,
-      alternateShippingAddresses,
-      billingAddress: billingAddress,
-      shippingAddress: shippingAddress,
-      createdAt: body.createdAt,
-      phone,
-      phoneVerified: false,
-      updatedAt: body.lastModifiedAt
-    } satisfies Profile;
-
-    return result;
-  }
-
   protected createCTAddressDraft( address: Address): CTAddress {
     return {
       key: address.identifier.nickName,

package/providers/commercetools/src/providers/store.provider.ts

@@ -1,32 +1,37 @@
 import type {
   RequestContext,
   Cache,
+  StoreFactory,
+  StoreFactoryOutput,
+  StoreFactoryWithOutput,
   StoreQueryByProximity,
-  Store,
-  StoreIdentifier,
-  FulfillmentCenterIdentifier,
   Result,
 } from '@reactionary/core';
 import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success, error } from '@reactionary/core';
 import * as z from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { Channel } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
 
-export class CommercetoolsStoreProvider extends StoreProvider {
+export class CommercetoolsStoreProvider<
+  TFactory extends StoreFactory = CommercetoolsStoreFactory,
+> extends StoreProvider<StoreFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: StoreFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: StoreFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -40,7 +45,7 @@ export class CommercetoolsStoreProvider extends StoreProvider {
   })
   public override async queryByProximity(
     payload: StoreQueryByProximity
-  ): Promise<Result<Array<Store>>> {
+  ): Promise<Result<Array<StoreFactoryOutput<TFactory>>>> {
     const client = await this.getClient();
 
     const remote = await client
@@ -60,33 +65,10 @@ export class CommercetoolsStoreProvider extends StoreProvider {
     const results = [];
 
     for (const r of remote.body.results) {
-      results.push(this.parseSingle(r));
+      results.push(this.factory.parseStore(this.context, r));
     }
 
     return success(results);
   }
 
-  protected parseSingle(body: Channel): Store {
-
-    let name = '';
-    if (body.name && body.name['la']) {
-      name = body.name['la'];
-    }
-
-    const identifier = {
-      key: body.key,
-    } satisfies StoreIdentifier;
-
-    const fulfillmentCenter = {
-      key: body.key,
-    } satisfies FulfillmentCenterIdentifier;
-
-    const result = {
-      identifier,
-      fulfillmentCenter,
-      name,
-    } satisfies Store;
-
-    return result;
-  }
 }

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

@@ -1,22 +1,260 @@
-import { CapabilitiesSchema } from "@reactionary/core";
-import type * as z from 'zod';
+import type {
+  Cache,
+  CartFactory,
+  CartFactoryWithOutput,
+  CartProvider,
+  CategoryFactory,
+  CategoryFactoryWithOutput,
+  CategoryProvider,
+  CheckoutFactory,
+  CheckoutFactoryWithOutput,
+  CheckoutProvider,
+  IdentityFactory,
+  IdentityFactoryWithOutput,
+  IdentityProvider,
+  InventoryFactory,
+  InventoryFactoryWithOutput,
+  InventoryProvider,
+  OrderFactory,
+  OrderFactoryWithOutput,
+  OrderProvider,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchProvider,
+  PriceFactory,
+  PriceFactoryWithOutput,
+  PriceProvider,
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryWithOutput,
+  ProductAssociationsProvider,
+  ProductFactory,
+  ProductFactoryWithOutput,
+  ProductListFactory,
+  ProductListFactoryWithOutput,
+  ProductListProvider,
+  ProductProvider,
+  ProductReviewsFactory,
+  ProductReviewsFactoryWithOutput,
+  ProductReviewsProvider,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchProvider,
+  ProfileFactory,
+  ProfileFactoryWithOutput,
+  ProfileProvider,
+  RequestContext,
+  StoreFactory,
+  StoreFactoryWithOutput,
+  StoreProvider,
+} 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(),
+  provider: 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
-}).partial();
-
-export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+  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 CommercetoolsCapabilityProviderFactoryArgs<TFactory> {
+  cache: Cache;
+  context: RequestContext;
+  config: CommercetoolsConfiguration;
+  commercetoolsApi: CommercetoolsAPI;
+  factory: TFactory;
+}
+
+export interface CommercetoolsCapabilityConfig<TFactory, TProvider> {
+  factory?: TFactory;
+  provider?: (args: CommercetoolsCapabilityProviderFactoryArgs<TFactory>) => TProvider;
+}
+
+type EnabledCapabilityConfig<TFactory, TProvider> = {
+  enabled: boolean;
+} & CommercetoolsCapabilityConfig<TFactory, TProvider>;
+
+export type CommercetoolsProductCapabilityConfig<
+  TFactory extends ProductFactory = ProductFactory,
+  TProvider extends ProductProvider = ProductProvider,
+> = CommercetoolsCapabilityConfig<ProductFactoryWithOutput<TFactory>, TProvider>;
+
+export type CommercetoolsCheckoutCapabilityConfig<
+  TFactory extends CheckoutFactory = CheckoutFactory,
+  TProvider extends CheckoutProvider = CheckoutProvider,
+> = CommercetoolsCapabilityConfig<CheckoutFactoryWithOutput<TFactory>, TProvider>;
+
+export type CommercetoolsProductSearchCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductSearchFactoryWithOutput<ProductSearchFactory>,
+  ProductSearchProvider
+>;
+export type CommercetoolsProductAssociationsCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+  ProductAssociationsProvider
+>;
+export type CommercetoolsProductReviewsCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
+  ProductReviewsProvider
+>;
+export type CommercetoolsProductListCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProductListFactoryWithOutput<ProductListFactory>,
+  ProductListProvider
+>;
+export type CommercetoolsIdentityCapabilityConfig = CommercetoolsCapabilityConfig<
+  IdentityFactoryWithOutput<IdentityFactory>,
+  IdentityProvider
+>;
+export type CommercetoolsCartCapabilityConfig = CommercetoolsCapabilityConfig<
+  CartFactoryWithOutput<CartFactory>,
+  CartProvider
+>;
+export type CommercetoolsInventoryCapabilityConfig = CommercetoolsCapabilityConfig<
+  InventoryFactoryWithOutput<InventoryFactory>,
+  InventoryProvider
+>;
+export type CommercetoolsPriceCapabilityConfig = CommercetoolsCapabilityConfig<
+  PriceFactoryWithOutput<PriceFactory>,
+  PriceProvider
+>;
+export type CommercetoolsCategoryCapabilityConfig = CommercetoolsCapabilityConfig<
+  CategoryFactoryWithOutput<CategoryFactory>,
+  CategoryProvider
+>;
+export type CommercetoolsStoreCapabilityConfig = CommercetoolsCapabilityConfig<
+  StoreFactoryWithOutput<StoreFactory>,
+  StoreProvider
+>;
+export type CommercetoolsProfileCapabilityConfig = CommercetoolsCapabilityConfig<
+  ProfileFactoryWithOutput<ProfileFactory>,
+  ProfileProvider
+>;
+export type CommercetoolsOrderCapabilityConfig = CommercetoolsCapabilityConfig<
+  OrderFactoryWithOutput<OrderFactory>,
+  OrderProvider
+>;
+export type CommercetoolsOrderSearchCapabilityConfig = CommercetoolsCapabilityConfig<
+  OrderSearchFactoryWithOutput<OrderSearchFactory>,
+  OrderSearchProvider
+>;
+
+export type CommercetoolsCapabilityConfigMap<
+  TProductFactory extends ProductFactory = ProductFactory,
+  TProductProvider extends ProductProvider = ProductProvider,
+  TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
+  TCheckoutProvider extends CheckoutProvider = CheckoutProvider,
+> = {
+  product: EnabledCapabilityConfig<
+    ProductFactoryWithOutput<TProductFactory>,
+    TProductProvider
+  >;
+  checkout: EnabledCapabilityConfig<
+    CheckoutFactoryWithOutput<TCheckoutFactory>,
+    TCheckoutProvider
+  >;
+  productSearch: EnabledCapabilityConfig<
+    ProductSearchFactoryWithOutput<ProductSearchFactory>,
+    ProductSearchProvider
+  >;
+  productAssociations: EnabledCapabilityConfig<
+    ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+    ProductAssociationsProvider
+  >;
+  productReviews: EnabledCapabilityConfig<
+    ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
+    ProductReviewsProvider
+  >;
+  productList: EnabledCapabilityConfig<
+    ProductListFactoryWithOutput<ProductListFactory>,
+    ProductListProvider
+  >;
+  identity: EnabledCapabilityConfig<
+    IdentityFactoryWithOutput<IdentityFactory>,
+    IdentityProvider
+  >;
+  cart: EnabledCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartProvider>;
+  inventory: EnabledCapabilityConfig<
+    InventoryFactoryWithOutput<InventoryFactory>,
+    InventoryProvider
+  >;
+  price: EnabledCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceProvider>;
+  category: EnabledCapabilityConfig<
+    CategoryFactoryWithOutput<CategoryFactory>,
+    CategoryProvider
+  >;
+  store: EnabledCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreProvider>;
+  profile: EnabledCapabilityConfig<
+    ProfileFactoryWithOutput<ProfileFactory>,
+    ProfileProvider
+  >;
+  order: EnabledCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderProvider>;
+  orderSearch: EnabledCapabilityConfig<
+    OrderSearchFactoryWithOutput<OrderSearchFactory>,
+    OrderSearchProvider
+  >;
+};
+
+type CommercetoolsCapabilitiesBase = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+
+export type CommercetoolsCapabilities<
+  TProductFactory extends ProductFactory = ProductFactory,
+  TProductProvider extends ProductProvider = ProductProvider,
+  TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
+  TCheckoutProvider extends CheckoutProvider = CheckoutProvider,
+> = Omit<
+  CommercetoolsCapabilitiesBase,
+  keyof CommercetoolsCapabilityConfigMap<
+    TProductFactory,
+    TProductProvider,
+    TCheckoutFactory,
+    TCheckoutProvider
+  >
+> &
+  Partial<
+    CommercetoolsCapabilityConfigMap<
+      TProductFactory,
+      TProductProvider,
+      TCheckoutFactory,
+      TCheckoutProvider
+    >
+  >;

package/providers/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 { CommercetoolsAPI } from '../core/client.js';
 import { CommercetoolsSearchProvider } from '../providers/product-search.provider.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,7 +21,13 @@ describe('Caching', () => {
     const context = createInitialRequestContext();
     const cache = new MemoryCache();
     const client = new CommercetoolsAPI(config, context);
-    const provider = new CommercetoolsProductProvider(config, cache, context, client);
+    const provider = new CommercetoolsProductProvider(
+      cache,
+      context,
+      config,
+      client,
+      new CommercetoolsProductFactory(ProductSchema)
+    );
 
     const identifier = {
         key: 'product_10959528'
@@ -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 provider = new CommercetoolsSearchProvider(
+      config,
+      cache,
+      context,
+      client,
+      new CommercetoolsProductSearchFactory(ProductSearchResultSchema),
+    );
 
     const query = {
       search: {