@reactionary/source 0.3.18 → 0.6.2

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

@@ -12,6 +12,11 @@ import type {
   CheckoutMutationRemovePaymentInstruction,
   CheckoutMutationSetShippingAddress,
   CheckoutMutationSetShippingInstruction,
+  CheckoutFactory,
+  CheckoutFactoryCheckoutOutput,
+  CheckoutFactoryPaymentMethodOutput,
+  CheckoutFactoryShippingMethodOutput,
+  CheckoutFactoryWithOutput,
   CheckoutQueryById,
   CheckoutQueryForAvailablePaymentMethods,
   CheckoutQueryForAvailableShippingMethods,
@@ -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 MedusaCheckoutProvider<
+  TFactory extends CheckoutFactory = MedusaCheckoutFactory,
+> extends CheckoutProvider<
+  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

@@ -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

@@ -8,6 +8,9 @@ import {
   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 MedusaInventoryProvider<
+  TFactory extends InventoryFactory = MedusaInventoryFactory,
+> extends InventoryProvider<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

@@ -13,6 +13,9 @@ import type {
   OrderSearchIdentifier,
   AddressIdentifier,
   OrderInventoryStatus,
+  OrderSearchFactory,
+  OrderSearchFactoryOutput,
+  OrderSearchFactoryWithOutput,
 } from '@reactionary/core';
 import {
   AddressIdentifierSchema,
@@ -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 MedusaOrderSearchProvider<
+  TFactory extends OrderSearchFactory = MedusaOrderSearchFactory,
+> extends OrderSearchProvider<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

@@ -17,6 +17,9 @@ import type {
   OrderInventoryStatus,
   PaymentMethodIdentifier,
   PaymentInstruction,
+  OrderFactory,
+  OrderFactoryOutput,
+  OrderFactoryWithOutput,
 } from '@reactionary/core';
 import {
   OrderProvider,
@@ -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 MedusaOrderProvider<
+  TFactory extends OrderFactory = MedusaOrderFactory,
+> extends OrderProvider<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

@@ -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 MedusaPriceProvider<
+  TFactory extends PriceFactory = MedusaPriceFactory,
+> extends PriceProvider<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);
   }
 
 

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

@@ -6,6 +6,11 @@ import {
   ProductVariantIdentifierSchema,
   success,
 } from '@reactionary/core';
+import type {
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryOutput,
+  ProductAssociationsFactoryWithOutput,
+} from '@reactionary/core';
 import type {
   ProductVariantIdentifier,
   ProductIdentifier,
@@ -22,20 +27,26 @@ import type {
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import type { MedusaAPI } from '../core/client.js';
 import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import type { MedusaProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
 
-export class MedusaProductAssociationsProvider extends ProductAssociationsProvider {
+export class MedusaProductAssociationsProvider<
+  TFactory extends ProductAssociationsFactory = MedusaProductAssociationsFactory,
+> extends ProductAssociationsProvider<ProductAssociationsFactoryOutput<TFactory>> {
   protected config: MedusaConfiguration;
   protected medusa: MedusaAPI;
+  protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
 
   constructor(
     config: MedusaConfiguration,
     cache: Cache,
     context: RequestContext,
-    medusa: MedusaAPI
+    medusa: MedusaAPI,
+    factory: ProductAssociationsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
     this.medusa = medusa;
+    this.factory = factory;
   }
 
   protected async fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]> {
@@ -87,7 +98,7 @@ export class MedusaProductAssociationsProvider extends ProductAssociationsProvid
   })
   public override async getAccessories(
     query: ProductAssociationsGetAccessoriesQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, 'reactionaryaccessories');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -98,7 +109,7 @@ export class MedusaProductAssociationsProvider extends ProductAssociationsProvid
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   @Reactionary({
@@ -109,7 +120,7 @@ export class MedusaProductAssociationsProvider extends ProductAssociationsProvid
   })
   public override async getSpareparts(
     query: ProductAssociationsGetSparepartsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, 'reactionaryspareparts');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -120,7 +131,7 @@ export class MedusaProductAssociationsProvider extends ProductAssociationsProvid
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   @Reactionary({
@@ -131,7 +142,7 @@ export class MedusaProductAssociationsProvider extends ProductAssociationsProvid
   })
   public override async getReplacements(
     query: ProductAssociationsGetReplacementsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, 'reactionaryreplacements');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -142,7 +153,7 @@ export class MedusaProductAssociationsProvider extends ProductAssociationsProvid
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   protected parseSingle(_body: StoreProduct): ProductSearchResultItem {