@reactionary/source 0.6.1 → 0.6.3

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

@@ -2,10 +2,18 @@ import type {
   StoreProductCategory,
   StoreProductCategoryListResponse,
 } from '@medusajs/types';
-import type { Category, Cache, CategoryPaginatedResult } from '@reactionary/core';
+import type {
+  Category,
+  Cache,
+  CategoryFactory,
+  CategoryFactoryCategoryOutput,
+  CategoryFactoryPaginatedOutput,
+  CategoryFactoryWithOutput,
+  CategoryPaginatedResult,
+} from '@reactionary/core';
 import {
   CategoryIdentifierSchema,
-  CategoryProvider,
+  CategoryCapability,
   CategorySchema,
   CategoryQueryByIdSchema,
   CategoryQueryBySlugSchema,
@@ -28,18 +36,27 @@ import {
 } from '@reactionary/core';
 import type { MedusaAPI, MedusaConfiguration } from '../index.js';
 import * as z from 'zod';
+import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
 
-export class MedusaCategoryProvider extends CategoryProvider {
+export class MedusaCategoryCapability<
+  TFactory extends CategoryFactory = MedusaCategoryFactory,
+> extends CategoryCapability<
+  CategoryFactoryCategoryOutput<TFactory>,
+  CategoryFactoryPaginatedOutput<TFactory>
+> {
   protected config: MedusaConfiguration;
+  protected factory: CategoryFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: CategoryFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected async resolveCategoryIdByExternalId(
@@ -82,7 +99,9 @@ export class MedusaCategoryProvider extends CategoryProvider {
     inputSchema: CategoryQueryByIdSchema,
     outputSchema: CategorySchema,
   })
-  public override async getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>> {
+  public override async getById(
+    payload: CategoryQueryById,
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
     const candidate = await this.resolveCategoryIdByExternalId(payload.id.key);
     if (!candidate) {
       return error<NotFoundError>({
@@ -107,7 +126,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
   })
   public override async getBySlug(
     payload: CategoryQueryBySlug
-  ): Promise<Result<Category, NotFoundError>> {
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>> {
     const sdk = await this.medusaApi.getClient();
 
     const categoryResult = await sdk.store.category.list(this.getBySlugPayload(payload));
@@ -126,7 +145,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
   })
   public override async getBreadcrumbPathToCategory(
     payload: CategoryQueryForBreadcrumb
-  ): Promise<Result<Category[]>> {
+  ): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>> {
     const actualCategoryId = await this.resolveCategoryIdByExternalId(
       payload.id.key
     );
@@ -140,7 +159,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
       include_ancestors_tree: true,
     });
 
-    let results = new Array<Category>();
+    let results = new Array<CategoryFactoryCategoryOutput<TFactory>>();
     let current: StoreProductCategory | null = path.product_category;
     while (current) {
       results.push(this.parseSingle(current));
@@ -209,7 +228,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
     return success(result);
   }
 
-  protected parseSingle(_body: StoreProductCategory): Category {
+  protected parseSingle(_body: StoreProductCategory): CategoryFactoryCategoryOutput<TFactory> {
     const identifier = CategoryIdentifierSchema.parse({
       key: _body.metadata?.['external_id'] || '',
     });
@@ -230,12 +249,12 @@ export class MedusaCategoryProvider extends CategoryProvider {
       images: [],
     } satisfies Category;
 
-    return result;
+    return this.factory.parseCategory(this.context, result);
   }
 
   protected parsePaginatedResult(
     body: StoreProductCategoryListResponse
-  ) {
+  ): CategoryFactoryPaginatedOutput<TFactory> {
     const items = body.product_categories.map((x) => this.parseSingle(x));
 
     const totalPages = Math.ceil(
@@ -254,7 +273,6 @@ export class MedusaCategoryProvider extends CategoryProvider {
       items: items,
     } satisfies CategoryPaginatedResult;
 
-    return result;
+    return this.factory.parseCategoryPaginatedResult(this.context, result);
   }
 }
-

package/{providers/medusa/src/providers/checkout.provider.ts → packages/medusa/src/capabilities/checkout.capability.ts}

@@ -12,6 +12,11 @@ import type {
   CheckoutMutationRemovePaymentInstruction,
   CheckoutMutationSetShippingAddress,
   CheckoutMutationSetShippingInstruction,
+  CheckoutFactory,
+  CheckoutFactoryCheckoutOutput,
+  CheckoutFactoryPaymentMethodOutput,
+  CheckoutFactoryShippingMethodOutput,
+  CheckoutFactoryWithOutput,
   CheckoutQueryById,
   CheckoutQueryForAvailablePaymentMethods,
   CheckoutQueryForAvailableShippingMethods,
@@ -35,7 +40,7 @@ import {
   CheckoutMutationRemovePaymentInstructionSchema,
   CheckoutMutationSetShippingAddressSchema,
   CheckoutMutationSetShippingInstructionSchema,
-  CheckoutProvider,
+  CheckoutCapability,
   CheckoutQueryByIdSchema,
   CheckoutQueryForAvailablePaymentMethodsSchema,
   CheckoutQueryForAvailableShippingMethodsSchema,
@@ -57,6 +62,7 @@ import {
   type MedusaCartIdentifier,
   type MedusaOrderIdentifier
 } from '../schema/medusa.schema.js';
+import type { MedusaCheckoutFactory } from '../factories/checkout/checkout.factory.js';
 const debug = createDebug('reactionary:medusa:checkout');
 
 export class CheckoutNotReadyForFinalizationError extends Error {
@@ -74,8 +80,15 @@ export class CheckoutNotReadyForFinalizationError extends Error {
   }
 }
 
-export class MedusaCheckoutProvider extends CheckoutProvider {
+export class MedusaCheckoutCapability<
+  TFactory extends CheckoutFactory = MedusaCheckoutFactory,
+> extends CheckoutCapability<
+  CheckoutFactoryCheckoutOutput<TFactory>,
+  CheckoutFactoryShippingMethodOutput<TFactory>,
+  CheckoutFactoryPaymentMethodOutput<TFactory>
+> {
   protected config: MedusaConfiguration;
+  protected factory: CheckoutFactoryWithOutput<TFactory>;
 
   /**
    * This controls which fields are always included when fetching a cart
@@ -91,10 +104,12 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: CheckoutFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected initiateCheckoutForCartPayload(payload: CheckoutMutationInitiateCheckout): StoreUpdateCart {
@@ -118,7 +133,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async initiateCheckoutForCart(
     payload: CheckoutMutationInitiateCheckout
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const client = await this.medusaApi.getClient();
     // we should eventually copy the cart.... but for now we just continue with the existing one.
     if (debug.enabled) {
@@ -144,7 +159,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async getById(
     payload: CheckoutQueryById
-  ): Promise<Result<Checkout, NotFoundError>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>> {
     const client = await this.medusaApi.getClient();
     const response = await client.store.cart.retrieve(payload.identifier.key, {
       fields: this.includedFields,
@@ -165,7 +180,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async setShippingAddress(
     payload: CheckoutMutationSetShippingAddress
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const client = await this.medusaApi.getClient();
 
     const response = await client.store.cart.update(
@@ -191,7 +206,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async getAvailableShippingMethods(
     payload: CheckoutQueryForAvailableShippingMethods
-  ): Promise<Result<ShippingMethod[]>> {
+  ): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>> {
     const client = await this.medusaApi.getClient();
 
     if (debug.enabled) {
@@ -229,7 +244,9 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
         shippingMethods
       );
     }
-    return success(shippingMethods);
+    return success(
+      shippingMethods.map((x) => this.factory.parseShippingMethod(this.context, x)),
+    );
   }
 
   protected getAvailablePaymentMethodsPayload(payload: CheckoutQueryForAvailablePaymentMethods, regionId: string) {
@@ -244,7 +261,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async getAvailablePaymentMethods(
     payload: CheckoutQueryForAvailablePaymentMethods
-  ): Promise<Result<PaymentMethod[]>> {
+  ): Promise<Result<CheckoutFactoryPaymentMethodOutput<TFactory>[]>> {
     const client = await this.medusaApi.getClient();
 
     if (debug.enabled) {
@@ -286,7 +303,9 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
       );
     }
 
-    return success(paymentMethods);
+    return success(
+      paymentMethods.map((x) => this.factory.parsePaymentMethod(this.context, x)),
+    );
   }
 
 
@@ -307,7 +326,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async addPaymentInstruction(
     payload: CheckoutMutationAddPaymentInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const client = await this.medusaApi.getClient();
 
     if (debug.enabled) {
@@ -347,7 +366,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override removePaymentInstruction(
     payload: CheckoutMutationRemovePaymentInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     throw new Error('Method not implemented.');
   }
 
@@ -368,7 +387,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async setShippingInstruction(
     payload: CheckoutMutationSetShippingInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const client = await this.medusaApi.getClient();
     const medusaId = payload.checkout as MedusaCartIdentifier;
     try {
@@ -412,7 +431,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
   })
   public override async finalizeCheckout(
     payload: CheckoutMutationFinalizeCheckout
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = await this.getById({ identifier: payload.checkout });
     if (!checkout.success || !checkout.value.readyForFinalization) {
       throw new CheckoutNotReadyForFinalizationError(payload.checkout);
@@ -432,9 +451,15 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
           order_display_id: response.order?.display_id ? +'' : '',
         },
       });
-      return this.getById({
+      const refreshedCheckout = await this.getById({
         identifier: payload.checkout,
-      }) as Promise<Result<Checkout>>;
+      });
+
+      if (!refreshedCheckout.success) {
+        throw new Error(`Unable to reload checkout ${payload.checkout.key} after completion`);
+      }
+
+      return success(refreshedCheckout.value);
     }
 
     throw new Error('Something failed during order creation');
@@ -534,7 +559,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
    * @param remote
    * @returns
    */
-  protected parseSingle(remote: StoreCart): Checkout {
+  protected parseSingle(remote: StoreCart): CheckoutFactoryCheckoutOutput<TFactory> {
     const identifier = {
       key: remote.id,
       //        region_id: remote.region_id,
@@ -668,6 +693,6 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
       shippingInstruction
     };
 
-    return result;
+    return this.factory.parseCheckout(this.context, result);
   }
 }

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

@@ -6,7 +6,7 @@ import {
   type IdentityQuerySelf,
   type RequestContext,
   type Cache,
-  IdentityProvider,
+  IdentityCapability,
   Reactionary,
   IdentityQuerySelfSchema,
   IdentitySchema,
@@ -24,7 +24,7 @@ import createDebug from 'debug';
 
 const debug = createDebug('reactionary:medusa:identity');
 
-export class MedusaIdentityProvider extends IdentityProvider {
+export class MedusaIdentityCapability extends IdentityCapability {
   protected config: MedusaConfiguration;
   protected medusaApi: MedusaAPI;
 
@@ -32,7 +32,7 @@ export class MedusaIdentityProvider extends IdentityProvider {
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    medusaApi: MedusaAPI
+    medusaApi: MedusaAPI,
   ) {
     super(cache, context);
 

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

@@ -3,11 +3,14 @@ import {
   type InventoryQueryBySKU,
   type RequestContext,
   type Cache,
-  InventoryProvider,
+  InventoryCapability,
   InventorySchema,
   InventoryQueryBySKUSchema,
   Reactionary,
   type InventoryIdentifier,
+  type InventoryFactory,
+  type InventoryFactoryOutput,
+  type InventoryFactoryWithOutput,
   type InventoryStatus,
   type NotFoundError,
   type Result,
@@ -17,27 +20,35 @@ import type * as z from 'zod';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import { MedusaAdminAPI, type MedusaAPI } from '../core/client.js';
 import createDebug from 'debug';
+import type { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
 
 const debug = createDebug('reactionary:medusa:inventory');
 
-export class MedusaInventoryProvider extends InventoryProvider {
+export class MedusaInventoryCapability<
+  TFactory extends InventoryFactory = MedusaInventoryFactory,
+> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
+  protected factory: InventoryFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: InventoryFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: InventoryQueryBySKUSchema,
     outputSchema: InventorySchema,
   })
-  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>> {
+  public override async getBySKU(
+    payload: InventoryQueryBySKU,
+  ): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>> {
     const sku = payload.variant.sku;
     const fulfillmentCenterKey = payload.fulfilmentCenter.key;
 
@@ -112,7 +123,7 @@ export class MedusaInventoryProvider extends InventoryProvider {
     }
   }
 
-  protected parseSingle(_body: unknown): Inventory {
+  protected parseSingle(_body: unknown): InventoryFactoryOutput<TFactory> {
     const { sku, fulfillmentCenterKey, quantity } = _body as {
       sku: string;
       fulfillmentCenterKey: string;
@@ -140,7 +151,7 @@ export class MedusaInventoryProvider extends InventoryProvider {
       status
     } satisfies Inventory;
 
-    return result;
+    return this.factory.parseInventory(this.context, result);
   }
 
   /**
@@ -150,7 +161,10 @@ export class MedusaInventoryProvider extends InventoryProvider {
    * @param fulfillmentCenterKey
    * @returns
    */
-  protected createEmptyInventoryResult(sku: string, fulfillmentCenterKey: string): Inventory {
+  protected createEmptyInventoryResult(
+    sku: string,
+    fulfillmentCenterKey: string,
+  ): InventoryFactoryOutput<TFactory> {
     const identifier = {
       variant: { sku },
       fulfillmentCenter: { key: fulfillmentCenterKey },
@@ -164,7 +178,7 @@ export class MedusaInventoryProvider extends InventoryProvider {
       status
     } satisfies Inventory;
 
-    return result;
+    return this.factory.parseInventory(this.context, result);
   }
 
   protected override getResourceName(): string {

package/{providers/medusa/src/providers/order-search.provider.ts → packages/medusa/src/capabilities/order-search.capability.ts}

@@ -13,10 +13,13 @@ import type {
   OrderSearchIdentifier,
   AddressIdentifier,
   OrderInventoryStatus,
+  OrderSearchFactory,
+  OrderSearchFactoryOutput,
+  OrderSearchFactoryWithOutput,
 } from '@reactionary/core';
 import {
   AddressIdentifierSchema,
-  OrderSearchProvider,
+  OrderSearchCapability,
   OrderSearchQueryByTermSchema,
   OrderSearchResultSchema,
   Reactionary,
@@ -26,21 +29,27 @@ import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import type { MedusaAPI } from '../core/client.js';
 import createDebug from 'debug';
 import type { OrderStatus as MedusaOrderStatus, StoreOrder, StoreOrderAddress,  StoreOrderListResponse } from '@medusajs/types';
+import type { MedusaOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
 
 const debug = createDebug('reactionary:medusa:order-search');
 
-export class MedusaOrderSearchProvider extends OrderSearchProvider {
+export class MedusaOrderSearchCapability<
+  TFactory extends OrderSearchFactory = MedusaOrderSearchFactory,
+> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
+  protected factory: OrderSearchFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: OrderSearchFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
 
   }
 
@@ -99,7 +108,9 @@ export class MedusaOrderSearchProvider extends OrderSearchProvider {
     inputSchema: OrderSearchQueryByTermSchema,
     outputSchema: OrderSearchResultSchema,
   })
-  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+  public async queryByTerm(
+    payload: OrderSearchQueryByTerm,
+  ): Promise<Result<OrderSearchFactoryOutput<TFactory>>> {
     debug('queryByTerm', payload);
 
     const medusa = await this.medusaApi.getClient();
@@ -109,14 +120,14 @@ export class MedusaOrderSearchProvider extends OrderSearchProvider {
 
     const response = await medusa.store.order.list(this.queryByTermPayload(payload));
 
-    const result = this.parsePaginatedResult(response, payload) as OrderSearchResult;
+    const result = this.parsePaginatedResult(response, payload);
     if (debug.enabled) {
       debug(
         `Search for term "${payload.search.term}" returned ${response.orders.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
       );
     }
 
-    return success(result);
+    return success(this.factory.parseOrderSearchResult(this.context, result, payload));
   }
 
   protected composeAddressFromStoreAddress(storeAddress: StoreOrderAddress): Address {

package/{providers/medusa/src/providers/order.provider.ts → packages/medusa/src/capabilities/order.capability.ts}

@@ -17,9 +17,12 @@ import type {
   OrderInventoryStatus,
   PaymentMethodIdentifier,
   PaymentInstruction,
+  OrderFactory,
+  OrderFactoryOutput,
+  OrderFactoryWithOutput,
 } from '@reactionary/core';
 import {
-  OrderProvider,
+  OrderCapability,
   OrderQueryByIdSchema,
   OrderSchema,
   Reactionary,
@@ -33,27 +36,35 @@ import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import { handleProviderError } from '../utils/medusa-helpers.js';
 import type { StoreOrder, StoreOrderLineItem, StorePaymentCollection } from '@medusajs/types';
 import { parseMedusaItemPrice, parseMedusaCostBreakdown } from '../utils/medusa-helpers.js'
+import type { MedusaOrderFactory } from '../factories/order/order.factory.js';
 const debug = createDebug('reactionary:medusa:order');
 
-export class MedusaOrderProvider extends OrderProvider {
+export class MedusaOrderCapability<
+  TFactory extends OrderFactory = MedusaOrderFactory,
+> extends OrderCapability<OrderFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
+  protected factory: OrderFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: OrderFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: OrderQueryByIdSchema,
     outputSchema: OrderSchema,
   })
-  public async getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>> {
+  public async getById(
+    payload: OrderQueryById,
+  ): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>> {
     debug('getById', payload);
 
     const medusa = await this.medusaApi.getClient();
@@ -175,7 +186,7 @@ export class MedusaOrderProvider extends OrderProvider {
 
 
 
-  protected parseSingle(body: StoreOrder): Order {
+  protected parseSingle(body: StoreOrder): OrderFactoryOutput<TFactory> {
 
     const identifier = { key: body.id };
     const userId: IdentityIdentifier = {
@@ -213,7 +224,7 @@ export class MedusaOrderProvider extends OrderProvider {
       return this.parsePaymentInstruction(pc, body);
     }) || [];
 
-    return {
+    const result = {
       identifier,
       userId,
       items,
@@ -222,5 +233,6 @@ export class MedusaOrderProvider extends OrderProvider {
       inventoryStatus,
       paymentInstructions
     } satisfies Order;
+    return this.factory.parseOrder(this.context, result);
   }
 }

package/{providers/medusa/src/providers/price.provider.ts → packages/medusa/src/capabilities/price.capability.ts}

@@ -1,6 +1,6 @@
 import type { StoreProductVariant } from '@medusajs/types';
 import {
-  PriceProvider,
+  PriceCapability,
   PriceSchema,
   CustomerPriceQuerySchema,
   ListPriceQuerySchema,
@@ -11,6 +11,9 @@ import {
   type CustomerPriceQuery,
   type ListPriceQuery,
   type Price,
+  type PriceFactory,
+  type PriceFactoryOutput,
+  type PriceFactoryWithOutput,
   type RequestContext,
   type PriceIdentifier,
   type MonetaryAmount,
@@ -20,27 +23,35 @@ import createDebug from 'debug';
 import type * as z from 'zod';
 import type { MedusaAPI } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaPriceFactory } from '../factories/price/price.factory.js';
 
 const debug = createDebug('reactionary:medusa:price');
 
-export class MedusaPriceProvider extends PriceProvider {
+export class MedusaPriceCapability<
+  TFactory extends PriceFactory = MedusaPriceFactory,
+> extends PriceCapability<PriceFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
+  protected factory: PriceFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    public medusaApi: MedusaAPI
+    public medusaApi: MedusaAPI,
+    factory: PriceFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: ListPriceQuerySchema,
     outputSchema: PriceSchema,
   })
-  public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
+  public override async getListPrice(
+    payload: ListPriceQuery,
+  ): Promise<Result<PriceFactoryOutput<TFactory>>> {
     const result = await this.getBySKU(payload, 'list');
 
     return success(result);
@@ -50,14 +61,19 @@ export class MedusaPriceProvider extends PriceProvider {
     inputSchema: CustomerPriceQuerySchema,
     outputSchema: PriceSchema,
   })
-  public override async getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>> {
+  public override async getCustomerPrice(
+    payload: CustomerPriceQuery,
+  ): Promise<Result<PriceFactoryOutput<TFactory>>> {
     const result = await this.getBySKU(payload, 'customer');
 
     return success(result);
   }
 
 
-  protected async getBySKU(payload: ListPriceQuery | CustomerPriceQuery, mode: 'list' | 'customer' ): Promise<Price> {
+  protected async getBySKU(
+    payload: ListPriceQuery | CustomerPriceQuery,
+    mode: 'list' | 'customer',
+  ): Promise<PriceFactoryOutput<TFactory>> {
     const sku = payload.variant.sku;
 
     if (debug.enabled) {
@@ -98,7 +114,10 @@ export class MedusaPriceProvider extends PriceProvider {
     }
   }
 
-  protected parseSingle(variant: StoreProductVariant, mode: 'list' | 'customer'): Price {
+  protected parseSingle(
+    variant: StoreProductVariant,
+    mode: 'list' | 'customer',
+  ): PriceFactoryOutput<TFactory> {
     const identifier = {
       variant: {
         sku: variant.sku || '',
@@ -139,7 +158,7 @@ export class MedusaPriceProvider extends PriceProvider {
       onSale: isOnSale,
     } satisfies Price;
 
-    return result;
+    return this.factory.parsePrice(this.context, result);
   }