@reactionary/source 0.6.1 → 0.6.3

package/packages/medusa/src/factories/order/order.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyOrderSchema,
+  OrderFactory,
+  OrderSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaOrderFactory<
+  TOrderSchema extends AnyOrderSchema = typeof OrderSchema,
+> implements OrderFactory<TOrderSchema>
+{
+  public readonly orderSchema: TOrderSchema;
+
+  constructor(orderSchema: TOrderSchema) {
+    this.orderSchema = orderSchema;
+  }
+
+  public parseOrder(_context: RequestContext, data: unknown): z.output<TOrderSchema> {
+    return this.orderSchema.parse(data);
+  }
+}

package/packages/medusa/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyOrderSearchResultSchema,
+  OrderSearchFactory,
+  OrderSearchQueryByTerm,
+  OrderSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}

package/packages/medusa/src/factories/price/price.factory.ts

@@ -0,0 +1,26 @@
+import type {
+  AnyPriceSchema,
+  PriceFactory,
+  PriceSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaPriceFactory<
+  TPriceSchema extends AnyPriceSchema = typeof PriceSchema,
+> implements PriceFactory<TPriceSchema>
+{
+  public readonly priceSchema: TPriceSchema;
+
+  constructor(priceSchema: TPriceSchema) {
+    this.priceSchema = priceSchema;
+  }
+
+  public parsePrice(
+    _context: RequestContext,
+    data: unknown,
+    _options?: { includeDiscounts: boolean },
+  ): z.output<TPriceSchema> {
+    return this.priceSchema.parse(data);
+  }
+}

package/packages/medusa/src/factories/product/product.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyProductSchema,
+  ProductFactory,
+  ProductSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProductFactory<
+  TProductSchema extends AnyProductSchema = typeof ProductSchema,
+> implements ProductFactory<TProductSchema>
+{
+  public readonly productSchema: TProductSchema;
+
+  constructor(productSchema: TProductSchema) {
+    this.productSchema = productSchema;
+  }
+
+  public parseProduct(_context: RequestContext, data: unknown): z.output<TProductSchema> {
+    return this.productSchema.parse(data);
+  }
+}

package/packages/medusa/src/factories/product-associations/product-associations.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyProductAssociationSchema,
+  ProductAssociationSchema,
+  ProductAssociationsFactory,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProductAssociationsFactory<
+  TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema,
+> implements ProductAssociationsFactory<TProductAssociationSchema>
+{
+  public readonly productAssociationSchema: TProductAssociationSchema;
+
+  constructor(productAssociationSchema: TProductAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+
+  public parseAssociation(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TProductAssociationSchema> {
+    return this.productAssociationSchema.parse(data);
+  }
+}

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

@@ -0,0 +1,27 @@
+import type {
+  AnyProductSearchResultSchema,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    return this.productSearchResultSchema.parse(data);
+  }
+}

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

@@ -0,0 +1,22 @@
+import type {
+  AnyProfileSchema,
+  ProfileFactory,
+  ProfileSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaProfileFactory<
+  TProfileSchema extends AnyProfileSchema = typeof ProfileSchema,
+> implements ProfileFactory<TProfileSchema>
+{
+  public readonly profileSchema: TProfileSchema;
+
+  constructor(profileSchema: TProfileSchema) {
+    this.profileSchema = profileSchema;
+  }
+
+  public parseProfile(_context: RequestContext, data: unknown): z.output<TProfileSchema> {
+    return this.profileSchema.parse(data);
+  }
+}

package/packages/medusa/src/index.ts

@@ -0,0 +1,17 @@
+export * from './schema/configuration.schema.js';
+export * from './schema/medusa.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './core/client.js';
+export * from './factories/index.js';
+export * from './capabilities/cart.capability.js';
+export * from './capabilities/identity.capability.js';
+export * from './capabilities/inventory.capability.js';
+export * from './capabilities/order.capability.js';
+export * from './capabilities/order-search.capability.js';
+export * from './capabilities/price.capability.js';
+export * from './capabilities/product-search.capability.js';
+export * from './capabilities/product-recommendations.capability.js';
+export * from './capabilities/product-associations.capability.js';
+export * from './capabilities/profile.capability.js';

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

@@ -0,0 +1,231 @@
+import type {
+  CartFactory,
+  CartFactoryWithOutput,
+  CartCapability,
+  CategoryFactory,
+  CategoryFactoryWithOutput,
+  CategoryCapability,
+  CheckoutFactory,
+  CheckoutFactoryWithOutput,
+  CheckoutCapability,
+  IdentityCapability,
+  InventoryFactory,
+  InventoryFactoryWithOutput,
+  InventoryCapability,
+  OrderFactory,
+  OrderFactoryWithOutput,
+  OrderCapability,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchCapability,
+  PriceFactory,
+  PriceFactoryWithOutput,
+  PriceCapability,
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryWithOutput,
+  ProductAssociationsCapability,
+  ProductFactory,
+  ProductFactoryWithOutput,
+  ProductCapability,
+  ProductRecommendationsCapability,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchCapability,
+  ProfileFactory,
+  ProfileFactoryWithOutput,
+  ProfileCapability,
+  RequestContext,
+  Cache,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { MedusaConfiguration } from './configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import * as z from 'zod';
+
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional(),
+});
+
+const DirectCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  capability: z.unknown().optional(),
+});
+
+export const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
+  productSearch: true,
+  productRecommendations: true,
+  cart: true,
+  checkout: true,
+  category: true,
+  product: true,
+  price: true,
+  order: true,
+  orderSearch: true,
+  inventory: true,
+  identity: true,
+  profile: true,
+  productAssociations: true,
+})
+  .extend({
+    product: OverridableCapabilitySchema.optional(),
+    productSearch: OverridableCapabilitySchema.optional(),
+    cart: OverridableCapabilitySchema.optional(),
+    checkout: OverridableCapabilitySchema.optional(),
+    category: OverridableCapabilitySchema.optional(),
+    price: OverridableCapabilitySchema.optional(),
+    order: OverridableCapabilitySchema.optional(),
+    orderSearch: OverridableCapabilitySchema.optional(),
+    inventory: OverridableCapabilitySchema.optional(),
+    identity: DirectCapabilitySchema.optional(),
+    profile: OverridableCapabilitySchema.optional(),
+    productAssociations: OverridableCapabilitySchema.optional(),
+    productRecommendations: DirectCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface MedusaCapabilityFactoryArgs {
+  cache: Cache;
+  context: RequestContext;
+  config: MedusaConfiguration;
+  medusaApi: MedusaAPI;
+}
+
+export interface MedusaFactoryCapabilityArgs<TFactory>
+  extends MedusaCapabilityFactoryArgs {
+  factory: TFactory;
+}
+
+export interface MedusaCapabilityConfig<TFactory, TCapability> {
+  enabled: boolean;
+  factory?: TFactory;
+  capability?: (args: MedusaFactoryCapabilityArgs<TFactory>) => TCapability;
+}
+
+export interface MedusaDirectCapabilityConfig<TCapability> {
+  enabled: boolean;
+  capability?: (args: MedusaCapabilityFactoryArgs) => TCapability;
+}
+
+export type MedusaProductCapabilityConfig = MedusaCapabilityConfig<
+  ProductFactoryWithOutput<ProductFactory>,
+  ProductCapability
+>;
+
+export type MedusaProductSearchCapabilityConfig = MedusaCapabilityConfig<
+  ProductSearchFactoryWithOutput<ProductSearchFactory>,
+  ProductSearchCapability
+>;
+
+export type MedusaCartCapabilityConfig = MedusaCapabilityConfig<
+  CartFactoryWithOutput<CartFactory>,
+  CartCapability
+>;
+
+export type MedusaCheckoutCapabilityConfig = MedusaCapabilityConfig<
+  CheckoutFactoryWithOutput<CheckoutFactory>,
+  CheckoutCapability
+>;
+
+export type MedusaCategoryCapabilityConfig = MedusaCapabilityConfig<
+  CategoryFactoryWithOutput<CategoryFactory>,
+  CategoryCapability
+>;
+
+export type MedusaPriceCapabilityConfig = MedusaCapabilityConfig<
+  PriceFactoryWithOutput<PriceFactory>,
+  PriceCapability
+>;
+
+export type MedusaOrderCapabilityConfig = MedusaCapabilityConfig<
+  OrderFactoryWithOutput<OrderFactory>,
+  OrderCapability
+>;
+
+export type MedusaOrderSearchCapabilityConfig = MedusaCapabilityConfig<
+  OrderSearchFactoryWithOutput<OrderSearchFactory>,
+  OrderSearchCapability
+>;
+
+export type MedusaInventoryCapabilityConfig = MedusaCapabilityConfig<
+  InventoryFactoryWithOutput<InventoryFactory>,
+  InventoryCapability
+>;
+
+export type MedusaIdentityCapabilityConfig =
+  MedusaDirectCapabilityConfig<IdentityCapability>;
+
+export type MedusaProfileCapabilityConfig = MedusaCapabilityConfig<
+  ProfileFactoryWithOutput<ProfileFactory>,
+  ProfileCapability
+>;
+
+export type MedusaProductAssociationsCapabilityConfig = MedusaCapabilityConfig<
+  ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+  ProductAssociationsCapability
+>;
+
+export type MedusaProductRecommendationsCapabilityConfig =
+  MedusaDirectCapabilityConfig<ProductRecommendationsCapability>;
+
+export type MedusaCapabilities<
+  TProductFactory extends ProductFactory = ProductFactory,
+  TProductCapability extends ProductCapability = ProductCapability,
+  TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
+  TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability,
+  TCartFactory extends CartFactory = CartFactory,
+  TCartCapability extends CartCapability = CartCapability,
+  TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
+  TCheckoutCapability extends CheckoutCapability = CheckoutCapability,
+  TCategoryFactory extends CategoryFactory = CategoryFactory,
+  TCategoryCapability extends CategoryCapability = CategoryCapability,
+  TPriceFactory extends PriceFactory = PriceFactory,
+  TPriceCapability extends PriceCapability = PriceCapability,
+  TOrderFactory extends OrderFactory = OrderFactory,
+  TOrderCapability extends OrderCapability = OrderCapability,
+  TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory,
+  TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability,
+  TInventoryFactory extends InventoryFactory = InventoryFactory,
+  TInventoryCapability extends InventoryCapability = InventoryCapability,
+  TIdentityCapability extends IdentityCapability = IdentityCapability,
+  TProfileFactory extends ProfileFactory = ProfileFactory,
+  TProfileCapability extends ProfileCapability = ProfileCapability,
+  TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory,
+  TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability,
+  TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
+> = {
+  product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
+  productSearch?: MedusaCapabilityConfig<
+    ProductSearchFactoryWithOutput<TProductSearchFactory>,
+    TProductSearchCapability
+  >;
+  cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartCapability>;
+  checkout?: MedusaCapabilityConfig<
+    CheckoutFactoryWithOutput<TCheckoutFactory>,
+    TCheckoutCapability
+  >;
+  category?: MedusaCapabilityConfig<
+    CategoryFactoryWithOutput<TCategoryFactory>,
+    TCategoryCapability
+  >;
+  price?: MedusaCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceCapability>;
+  order?: MedusaCapabilityConfig<OrderFactoryWithOutput<TOrderFactory>, TOrderCapability>;
+  orderSearch?: MedusaCapabilityConfig<
+    OrderSearchFactoryWithOutput<TOrderSearchFactory>,
+    TOrderSearchCapability
+  >;
+  inventory?: MedusaCapabilityConfig<
+    InventoryFactoryWithOutput<TInventoryFactory>,
+    TInventoryCapability
+  >;
+  identity?: MedusaDirectCapabilityConfig<TIdentityCapability>;
+  profile?: MedusaCapabilityConfig<ProfileFactoryWithOutput<TProfileFactory>, TProfileCapability>;
+  productAssociations?: MedusaCapabilityConfig<
+    ProductAssociationsFactoryWithOutput<TProductAssociationsFactory>,
+    TProductAssociationsCapability
+  >;
+  productRecommendations?: MedusaDirectCapabilityConfig<TProductRecommendationsCapability>;
+};
+
+export type ParsedMedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/{providers/medusa/src/test/cart.provider.spec.ts → packages/medusa/src/test/cart.capability.spec.ts}

@@ -1,8 +1,18 @@
 
-import { NoOpCache, createInitialRequestContext, unwrapValue, type Cart, type CartMutationItemAdd, type RequestContext } from '@reactionary/core';
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  NoOpCache,
+  createInitialRequestContext,
+  unwrapValue,
+  type Cart,
+  type CartMutationItemAdd,
+  type RequestContext,
+} from '@reactionary/core';
 import { assert, beforeEach, describe, expect, it } from 'vitest';
 import { MedusaAPI } from '../core/client.js';
-import { MedusaCartProvider } from '../providers/cart.provider.js';
+import { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 
 
@@ -13,13 +23,19 @@ const testData = {
 
 
 describe('Medusa Cart Provider', () => {
-  let provider: MedusaCartProvider;
+  let provider: MedusaCartCapability;
   let reqCtx: RequestContext;
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaCartProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
+    provider = new MedusaCartCapability(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client,
+      new MedusaCartFactory(CartSchema, CartIdentifierSchema),
+    );
   });
 
   describe('anonymous sessions', () => {

package/{providers/medusa/src/test/category.provider.spec.ts → packages/medusa/src/test/category.capability.spec.ts}

@@ -1,11 +1,13 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
+  CategoryPaginatedResultSchema,
   CategorySchema,
   NoOpCache,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { MedusaCategoryProvider } from '../providers/category.provider.js';
+import { MedusaCategoryCapability } from '../capabilities/category.capability.js';
+import { MedusaCategoryFactory } from '../factories/category/category.factory.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { MedusaAPI } from '../core/client.js';
@@ -34,7 +36,7 @@ const testData = {
 };
 
 describe('Medusa Category Provider', () => {
-  let provider: MedusaCategoryProvider;
+  let provider: MedusaCategoryCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -42,11 +44,12 @@ describe('Medusa Category Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaCategoryProvider(
+    provider = new MedusaCategoryCapability(
       config,
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
     );
   });
 

package/{providers → packages}/medusa/src/test/checkout.spec.ts

@@ -23,15 +23,15 @@ function createMedusaClient(config: MedusaConfiguration, reqCtx: RequestContext)
     .withCache(new NoOpCache())
     .withCapability(
       withMedusaCapabilities(config, {
-        cart: true,
-        product: true,
-        category: true,
-        checkout: true,
-        identity: true,
-        inventory: true,
-        order: true,
-        price: true,
-        productSearch: true,
+        cart: { enabled: true },
+        product: { enabled: true },
+        category: { enabled: true },
+        checkout: { enabled: true },
+        identity: { enabled: true },
+        inventory: { enabled: true },
+        order: { enabled: true },
+        price: { enabled: true },
+        productSearch: { enabled: true },
       })
     );
 

package/{providers/medusa/src/test/identity.provider.spec.ts → packages/medusa/src/test/identity.capability.spec.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, assert } from 'vitest';
-import { MedusaIdentityProvider } from '../providers/identity.provider.js';
+import { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
 import { IdentitySchema, NoOpCache, createInitialRequestContext, type RequestContext } from '@reactionary/core';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
@@ -12,7 +12,7 @@ const testData = {
 };
 
 describe('Medusa Identity Provider', () => {
-  let provider: MedusaIdentityProvider;
+  let provider: MedusaIdentityCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -20,7 +20,7 @@ describe('Medusa Identity Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaIdentityProvider(config, new NoOpCache(), reqCtx, client);
+    provider = new MedusaIdentityCapability(config, new NoOpCache(), reqCtx, client);
   });
 
   it('should return anonymous identity when not authenticated', async () => {

package/{providers/medusa/src/test/inventory.provider.spec.ts → packages/medusa/src/test/inventory.capability.spec.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, assert } from 'vitest';
-import { MedusaInventoryProvider } from '../providers/inventory.provider.js';
+import { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
 import {
   InventorySchema,
   NoOpCache,
@@ -8,6 +8,7 @@ import {
 } from '@reactionary/core';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
+import { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
 
 const testData = {
   skuInStock: '	4007249524126',
@@ -17,7 +18,7 @@ const testData = {
 
 // FIXME: Currently broken in terms of actually looking up anything...
 describe('Medusa Inventory Provider', () => {
-  let provider: MedusaInventoryProvider;
+  let provider: MedusaInventoryCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -25,11 +26,12 @@ describe('Medusa Inventory Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaInventoryProvider(
+    provider = new MedusaInventoryCapability(
       config,
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaInventoryFactory(InventorySchema),
     );
   });
 

package/{providers/medusa/src/test/large-cart.provider.spec.ts → packages/medusa/src/test/large-cart.capability.spec.ts}

@@ -1,6 +1,8 @@
 import {
+  CartIdentifierSchema,
   CartSchema,
   NoOpCache,
+  ProductSearchResultSchema,
   ProductSearchQueryByTermSchema,
   ProductSearchResultItemSchema,
   createInitialRequestContext,
@@ -8,10 +10,12 @@ import {
   type RequestContext,
 } from '@reactionary/core';
 import { assert, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { MedusaCartProvider } from '../providers/cart.provider.js';
-import { MedusaSearchProvider } from '../providers/product-search.provider.js';
+import { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
+import { MedusaCartFactory } from '../factories/cart/cart.factory.js';
+import { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 /**
 const testData = {
@@ -21,24 +25,26 @@ const testData = {
 */
 
 describe('Medusa Cart Provider - Large Scenarios', () => {
-  let provider: MedusaCartProvider;
-  let searchProvider: MedusaSearchProvider;
+  let provider: MedusaCartCapability;
+  let searchProvider: MedusaProductSearchCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaCartProvider(
+    provider = new MedusaCartCapability(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaCartFactory(CartSchema, CartIdentifierSchema),
     );
-    searchProvider = new MedusaSearchProvider(
+    searchProvider = new MedusaProductSearchCapability(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaProductSearchFactory(ProductSearchResultSchema),
     );
   });