@reactionary/source 0.3.18 → 0.6.2

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

@@ -17,6 +17,9 @@ import {
   type ProductSearchResultItemVariant,
   type FacetIdentifier,
   type FacetValueIdentifier,
+  type ProductSearchFactory,
+  type ProductSearchFactoryOutput,
+  type ProductSearchFactoryWithOutput,
   type ProductSearchResultFacet,
   type ProductSearchResultFacetValue,
   Reactionary,
@@ -37,20 +40,26 @@ import type {
   StoreProductListResponse,
   StoreProductVariant,
 } from '@medusajs/types';
+import type { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 const debug = createDebug('reactionary:medusa:search');
 
-export class MedusaSearchProvider extends ProductSearchProvider {
+export class MedusaSearchProvider<
+  TFactory extends ProductSearchFactory = MedusaProductSearchFactory,
+> extends ProductSearchProvider<ProductSearchFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
+  protected factory: ProductSearchFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: ProductSearchFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected async resolveCategoryIdByExternalId(
@@ -114,7 +123,7 @@ export class MedusaSearchProvider extends ProductSearchProvider {
   })
   public override async queryByTerm(
     payload: ProductSearchQueryByTerm
-  ): Promise<Result<ProductSearchResult>> {
+  ): Promise<Result<ProductSearchFactoryOutput<TFactory>>> {
     const client = await this.medusaApi.getClient();
 
     let categoryIdToFind: string | null = null;
@@ -141,22 +150,20 @@ export class MedusaSearchProvider extends ProductSearchProvider {
 
     const response = await client.store.product.list(this.queryByTermPayload(payload, categoryIdToFind));
 
-    const result = this.parsePaginatedResult(response) as ProductSearchResult;
+    const result = this.parsePaginatedResult(response, payload);
     if (debug.enabled) {
       debug(
         `Search for term "${payload.search.term}" returned ${response.products.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
       );
     }
 
-    // Set result metadata
-    result.identifier = {
-      ...payload.search,
-    };
-
-    return success(result);
+    return success(this.factory.parseSearchResult(this.context, result, payload));
   }
 
-  protected parsePaginatedResult(remote: StoreProductListResponse) {
+  protected parsePaginatedResult(
+    remote: StoreProductListResponse,
+    query: ProductSearchQueryByTerm,
+  ) {
     // Parse facets
     // no facets available from Medusa at the moment
 
@@ -166,13 +173,7 @@ export class MedusaSearchProvider extends ProductSearchProvider {
 
     const result = {
       identifier: {
-        facets: [],
-        filters: [],
-        paginationOptions: {
-          pageNumber: 1,
-          pageSize: 0,
-        },
-        term: '',
+        ...query.search,
       },
       pageNumber: (Math.ceil(remote.offset / remote.limit) || 0) + 1,
       pageSize: remote.limit,
@@ -237,17 +238,4 @@ export class MedusaSearchProvider extends ProductSearchProvider {
     return success(facetValueIdentifier);
   }
 
-  protected override parseFacetValue(
-    facetValueIdentifier: FacetValueIdentifier,
-    label: string,
-    count: number
-  ): ProductSearchResultFacetValue {
-    throw new Error('Method not implemented.');
-  }
-  protected override parseFacet(
-    facetIdentifier: FacetIdentifier,
-    facetValue: unknown
-  ): ProductSearchResultFacet {
-    throw new Error('Method not implemented.');
-  }
 }

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

@@ -1,4 +1,24 @@
-import type { Cache, Image, NotFoundError, Product, ProductAttribute, ProductAttributeIdentifier, ProductAttributeValueIdentifier, ProductOptionIdentifier, ProductOptionValueIdentifier, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, ProductVariant, ProductVariantOption, RequestContext, Result } from '@reactionary/core';
+import type {
+  Cache,
+  Image,
+  NotFoundError,
+  Product,
+  ProductAttribute,
+  ProductAttributeIdentifier,
+  ProductAttributeValueIdentifier,
+  ProductFactory,
+  ProductFactoryOutput,
+  ProductFactoryWithOutput,
+  ProductOptionIdentifier,
+  ProductOptionValueIdentifier,
+  ProductQueryById,
+  ProductQueryBySKU,
+  ProductQueryBySlug,
+  ProductVariant,
+  ProductVariantOption,
+  RequestContext,
+  Result,
+} from '@reactionary/core';
 import {
   CategoryIdentifierSchema,
   ProductIdentifierSchema,
@@ -16,16 +36,27 @@ import type { MedusaAPI } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 
 import type { StoreProduct, StoreProductImage, StoreProductVariant } from '@medusajs/types';
+import type { MedusaProductFactory } from '../factories/product/product.factory.js';
 
 const debug = createDebug('reactionary:medusa:product');
 
-export class MedusaProductProvider extends ProductProvider {
+export class MedusaProductProvider<
+  TFactory extends ProductFactory = MedusaProductFactory,
+> extends ProductProvider<ProductFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
-  protected alwaysIncludedFields = ["+metadata.*","+categories.metadata.*","+external_id"]
-
-  constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, public medusaApi: MedusaAPI) {
+  protected alwaysIncludedFields = ["+metadata.*","+categories.metadata.*","+external_id"];
+  protected factory: ProductFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI,
+    factory: ProductFactoryWithOutput<TFactory>,
+  ) {
   super(cache, context);
    this.config = config;
+   this.factory = factory;
   }
 
   protected getByIdPayload(payload: ProductQueryById) {
@@ -45,7 +76,9 @@ export class MedusaProductProvider extends ProductProvider {
     currencyDependentCaching: false,
     localeDependentCaching: true
   })
-  public override async getById(payload: ProductQueryById): Promise<Result<Product>> {
+  public override async getById(
+    payload: ProductQueryById,
+  ): Promise<Result<ProductFactoryOutput<TFactory>>> {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
       debug(`Fetching product by ID: ${payload.identifier.key}`);
@@ -81,7 +114,9 @@ export class MedusaProductProvider extends ProductProvider {
     currencyDependentCaching: false,
     localeDependentCaching: true
   })
-  public override async getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>> {
+  public override async getBySlug(
+    payload: ProductQueryBySlug,
+  ): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>> {
     const client = await this.medusaApi.getClient();
     if (debug.enabled) {
       debug(`Fetching product by slug: ${payload.slug}`);
@@ -111,7 +146,9 @@ export class MedusaProductProvider extends ProductProvider {
     currencyDependentCaching: false,
     localeDependentCaching: true
   })
-  public override async getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>> {
+  public override async getBySKU(
+    payload: ProductQueryBySKU,
+  ): Promise<Result<ProductFactoryOutput<TFactory>>> {
     if (debug.enabled) {
       debug(`Fetching product by SKU: ${Array.isArray(payload) ? payload.join(', ') : payload}`);
     }
@@ -129,7 +166,7 @@ export class MedusaProductProvider extends ProductProvider {
     return success(this.parseSingle(product));
   }
 
-  protected parseSingle(_body: StoreProduct): Product {
+  protected parseSingle(_body: StoreProduct): ProductFactoryOutput<TFactory> {
     const identifier = ProductIdentifierSchema.parse({ key: _body.external_id || _body.id });
     const name = _body.title;
     const slug = _body.handle;
@@ -171,7 +208,7 @@ export class MedusaProductProvider extends ProductProvider {
       variants: otherVariants,
     } satisfies Product;
 
-    return result;
+    return this.factory.parseProduct(this.context, result);
   }
 
   protected parseVariant(variant: StoreProductVariant, product: StoreProduct) {
@@ -275,4 +312,3 @@ export class MedusaProductProvider extends ProductProvider {
     return sharedAttributes;
   }
 }
-

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

@@ -24,6 +24,9 @@ import {
   ProfileMutationSetBillingAddressSchema,
   success,
   type Address,
+  type ProfileFactory,
+  type ProfileFactoryOutput,
+  type ProfileFactoryWithOutput,
   ProfileQueryByIdSchema,
   error
 } from '@reactionary/core';
@@ -31,6 +34,7 @@ import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import type { MedusaAPI } from '../core/client.js';
 import createDebug from 'debug';
 import type { StoreCreateCustomerAddress, StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
+import type { MedusaProfileFactory } from '../factories/profile/profile.factory.js';
 
 const debug = createDebug('reactionary:medusa:profile');
 /**
@@ -43,26 +47,33 @@ const debug = createDebug('reactionary:medusa:profile');
  * - handle guest user scenarios (if applicable).
  * - improve error handling and edge cases.
  */
-export class MedusaProfileProvider extends ProfileProvider {
+export class MedusaProfileProvider<
+  TFactory extends ProfileFactory = MedusaProfileFactory,
+> extends ProfileProvider<ProfileFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
   protected includedFields = ['+metadata.*'];
+  protected factory: ProfileFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: ProfileFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: ProfileQueryByIdSchema,
     outputSchema: ProfileSchema,
   })
-  public async getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>> {
+  public async getById(
+    payload: ProfileQueryById,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('getById', payload);
 
     const client = await this.medusaApi.getClient();
@@ -91,7 +102,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationUpdateSchema,
     outputSchema: ProfileSchema,
   })
-  public async update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>> {
+  public async update(
+    payload: ProfileMutationUpdate,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('update', payload);
 
     const client = await this.medusaApi.getClient();
@@ -120,7 +133,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationAddShippingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public async addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>> {
+  public async addShippingAddress(
+    payload: ProfileMutationAddShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('addShippingAddress', payload);
 
     const client = await this.medusaApi.getClient();
@@ -162,7 +177,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationUpdateShippingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public async updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>> {
+  public async updateShippingAddress(
+    payload: ProfileMutationUpdateShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('updateShippingAddress', payload);
 
     const client = await this.medusaApi.getClient();
@@ -203,7 +220,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationRemoveShippingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public async removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>> {
+  public async removeShippingAddress(
+    payload: ProfileMutationRemoveShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('removeShippingAddress', payload);
     const client = await this.medusaApi.getClient();
 
@@ -247,7 +266,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
     outputSchema: ProfileSchema,
   })
-  public async makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>> {
+  public async makeShippingAddressDefault(
+    payload: ProfileMutationMakeShippingAddressDefault,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('makeShippingAddressDefault', payload);
 
     const client = await this.medusaApi.getClient();
@@ -289,7 +310,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     inputSchema: ProfileMutationSetBillingAddressSchema,
     outputSchema: ProfileSchema,
   })
-  public async setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>> {
+  public async setBillingAddress(
+    payload: ProfileMutationSetBillingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
     debug('setBillingAddress', payload);
 
 
@@ -361,7 +384,7 @@ export class MedusaProfileProvider extends ProfileProvider {
     }
   }
 
-  protected parseSingle(customer: StoreCustomer): Profile {
+  protected parseSingle(customer: StoreCustomer): ProfileFactoryOutput<TFactory> {
     const email = customer.email;
     const emailVerified = customer.metadata?.['email_verified'] === 'true';
 
@@ -386,7 +409,7 @@ export class MedusaProfileProvider extends ProfileProvider {
 
     alternateShippingAddresses.push(...addresses.filter(x => ! (x.is_default_billing || x.is_default_shipping)).map( addr => this.parseAddress(addr)));
 
-    return {
+    const result = {
       identifier: {
         userId: customer.id,
       },
@@ -400,6 +423,7 @@ export class MedusaProfileProvider extends ProfileProvider {
       createdAt: new Date(customer.created_at || '').toISOString(),
       updatedAt: new Date(customer.updated_at || '').toISOString()
     } satisfies Profile;
+    return this.factory.parseProfile(this.context, result);
   }
 
 

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

@@ -1,20 +1,231 @@
-import { CapabilitiesSchema } from "@reactionary/core";
-import type * as z from 'zod';
+import type {
+  CartFactory,
+  CartFactoryWithOutput,
+  CartProvider,
+  CategoryFactory,
+  CategoryFactoryWithOutput,
+  CategoryProvider,
+  CheckoutFactory,
+  CheckoutFactoryWithOutput,
+  CheckoutProvider,
+  IdentityProvider,
+  InventoryFactory,
+  InventoryFactoryWithOutput,
+  InventoryProvider,
+  OrderFactory,
+  OrderFactoryWithOutput,
+  OrderProvider,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchProvider,
+  PriceFactory,
+  PriceFactoryWithOutput,
+  PriceProvider,
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryWithOutput,
+  ProductAssociationsProvider,
+  ProductFactory,
+  ProductFactoryWithOutput,
+  ProductProvider,
+  ProductRecommendationsProvider,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchProvider,
+  ProfileFactory,
+  ProfileFactoryWithOutput,
+  ProfileProvider,
+  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(),
+  provider: z.unknown().optional(),
+});
+
+const ProviderCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  provider: 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
-}).partial();
-
-export type MedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;
+  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: ProviderCapabilitySchema.optional(),
+    profile: OverridableCapabilitySchema.optional(),
+    productAssociations: OverridableCapabilitySchema.optional(),
+    productRecommendations: ProviderCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface MedusaProviderFactoryArgs {
+  cache: Cache;
+  context: RequestContext;
+  config: MedusaConfiguration;
+  medusaApi: MedusaAPI;
+}
+
+export interface MedusaFactoryProviderArgs<TFactory>
+  extends MedusaProviderFactoryArgs {
+  factory: TFactory;
+}
+
+export interface MedusaCapabilityConfig<TFactory, TProvider> {
+  enabled: boolean;
+  factory?: TFactory;
+  provider?: (args: MedusaFactoryProviderArgs<TFactory>) => TProvider;
+}
+
+export interface MedusaProviderOnlyCapabilityConfig<TProvider> {
+  enabled: boolean;
+  provider?: (args: MedusaProviderFactoryArgs) => TProvider;
+}
+
+export type MedusaProductCapabilityConfig = MedusaCapabilityConfig<
+  ProductFactoryWithOutput<ProductFactory>,
+  ProductProvider
+>;
+
+export type MedusaProductSearchCapabilityConfig = MedusaCapabilityConfig<
+  ProductSearchFactoryWithOutput<ProductSearchFactory>,
+  ProductSearchProvider
+>;
+
+export type MedusaCartCapabilityConfig = MedusaCapabilityConfig<
+  CartFactoryWithOutput<CartFactory>,
+  CartProvider
+>;
+
+export type MedusaCheckoutCapabilityConfig = MedusaCapabilityConfig<
+  CheckoutFactoryWithOutput<CheckoutFactory>,
+  CheckoutProvider
+>;
+
+export type MedusaCategoryCapabilityConfig = MedusaCapabilityConfig<
+  CategoryFactoryWithOutput<CategoryFactory>,
+  CategoryProvider
+>;
+
+export type MedusaPriceCapabilityConfig = MedusaCapabilityConfig<
+  PriceFactoryWithOutput<PriceFactory>,
+  PriceProvider
+>;
+
+export type MedusaOrderCapabilityConfig = MedusaCapabilityConfig<
+  OrderFactoryWithOutput<OrderFactory>,
+  OrderProvider
+>;
+
+export type MedusaOrderSearchCapabilityConfig = MedusaCapabilityConfig<
+  OrderSearchFactoryWithOutput<OrderSearchFactory>,
+  OrderSearchProvider
+>;
+
+export type MedusaInventoryCapabilityConfig = MedusaCapabilityConfig<
+  InventoryFactoryWithOutput<InventoryFactory>,
+  InventoryProvider
+>;
+
+export type MedusaIdentityCapabilityConfig =
+  MedusaProviderOnlyCapabilityConfig<IdentityProvider>;
+
+export type MedusaProfileCapabilityConfig = MedusaCapabilityConfig<
+  ProfileFactoryWithOutput<ProfileFactory>,
+  ProfileProvider
+>;
+
+export type MedusaProductAssociationsCapabilityConfig = MedusaCapabilityConfig<
+  ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+  ProductAssociationsProvider
+>;
+
+export type MedusaProductRecommendationsCapabilityConfig =
+  MedusaProviderOnlyCapabilityConfig<ProductRecommendationsProvider>;
+
+export type MedusaCapabilities<
+  TProductFactory extends ProductFactory = ProductFactory,
+  TProductProvider extends ProductProvider = ProductProvider,
+  TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
+  TProductSearchProvider extends ProductSearchProvider = ProductSearchProvider,
+  TCartFactory extends CartFactory = CartFactory,
+  TCartProvider extends CartProvider = CartProvider,
+  TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
+  TCheckoutProvider extends CheckoutProvider = CheckoutProvider,
+  TCategoryFactory extends CategoryFactory = CategoryFactory,
+  TCategoryProvider extends CategoryProvider = CategoryProvider,
+  TPriceFactory extends PriceFactory = PriceFactory,
+  TPriceProvider extends PriceProvider = PriceProvider,
+  TOrderFactory extends OrderFactory = OrderFactory,
+  TOrderProvider extends OrderProvider = OrderProvider,
+  TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory,
+  TOrderSearchProvider extends OrderSearchProvider = OrderSearchProvider,
+  TInventoryFactory extends InventoryFactory = InventoryFactory,
+  TInventoryProvider extends InventoryProvider = InventoryProvider,
+  TIdentityProvider extends IdentityProvider = IdentityProvider,
+  TProfileFactory extends ProfileFactory = ProfileFactory,
+  TProfileProvider extends ProfileProvider = ProfileProvider,
+  TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory,
+  TProductAssociationsProvider extends ProductAssociationsProvider = ProductAssociationsProvider,
+  TProductRecommendationsProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider,
+> = {
+  product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductProvider>;
+  productSearch?: MedusaCapabilityConfig<
+    ProductSearchFactoryWithOutput<TProductSearchFactory>,
+    TProductSearchProvider
+  >;
+  cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartProvider>;
+  checkout?: MedusaCapabilityConfig<
+    CheckoutFactoryWithOutput<TCheckoutFactory>,
+    TCheckoutProvider
+  >;
+  category?: MedusaCapabilityConfig<
+    CategoryFactoryWithOutput<TCategoryFactory>,
+    TCategoryProvider
+  >;
+  price?: MedusaCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceProvider>;
+  order?: MedusaCapabilityConfig<OrderFactoryWithOutput<TOrderFactory>, TOrderProvider>;
+  orderSearch?: MedusaCapabilityConfig<
+    OrderSearchFactoryWithOutput<TOrderSearchFactory>,
+    TOrderSearchProvider
+  >;
+  inventory?: MedusaCapabilityConfig<
+    InventoryFactoryWithOutput<TInventoryFactory>,
+    TInventoryProvider
+  >;
+  identity?: MedusaProviderOnlyCapabilityConfig<TIdentityProvider>;
+  profile?: MedusaCapabilityConfig<ProfileFactoryWithOutput<TProfileFactory>, TProfileProvider>;
+  productAssociations?: MedusaCapabilityConfig<
+    ProductAssociationsFactoryWithOutput<TProductAssociationsFactory>,
+    TProductAssociationsProvider
+  >;
+  productRecommendations?: MedusaProviderOnlyCapabilityConfig<TProductRecommendationsProvider>;
+};
+
+export type ParsedMedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/providers/medusa/src/test/cart.provider.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 { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 
 
@@ -19,7 +29,13 @@ describe('Medusa Cart Provider', () => {
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaCartProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
+    provider = new MedusaCartProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client,
+      new MedusaCartFactory(CartSchema, CartIdentifierSchema),
+    );
   });
 
   describe('anonymous sessions', () => {

package/providers/medusa/src/test/category.provider.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 { 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';
@@ -46,7 +48,8 @@ describe('Medusa Category Provider', () => {
       config,
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
     );
   });