@reactionary/source 0.3.16 → 0.3.18

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

@@ -93,6 +93,14 @@ export class MedusaCategoryProvider extends CategoryProvider {
     return success(this.parseSingle(candidate));
   }
 
+  protected getBySlugPayload(payload: CategoryQueryBySlug) {
+    return {
+      handle: payload.slug,
+      limit: 1,
+      offset: 0,
+    }
+  }
+
   @Reactionary({
     inputSchema: CategoryQueryBySlugSchema,
     outputSchema: CategorySchema.nullable(),
@@ -102,11 +110,7 @@ export class MedusaCategoryProvider extends CategoryProvider {
   ): Promise<Result<Category, NotFoundError>> {
     const sdk = await this.medusaApi.getClient();
 
-    const categoryResult = await sdk.store.category.list({
-      handle: payload.slug,
-      limit: 1,
-      offset: 0,
-    });
+    const categoryResult = await sdk.store.category.list(this.getBySlugPayload(payload));
     if (categoryResult.count === 0) {
       return error<NotFoundError>({
         type: 'NotFound',
@@ -146,6 +150,17 @@ export class MedusaCategoryProvider extends CategoryProvider {
     return success(results);
   }
 
+
+  protected findChildCategoriesPayload(payload: CategoryQueryForChildCategories, actualParent: StoreProductCategory) {
+    return {
+      fields: '+metadata,+parent_category.metadata',
+      parent_category_id: actualParent.id,
+      limit: payload.paginationOptions.pageSize,
+      offset:
+        (payload.paginationOptions.pageNumber - 1) *
+        payload.paginationOptions.pageSize,
+    }
+  }
   @Reactionary({
     inputSchema: CategoryQueryForChildCategoriesSchema,
     outputSchema: CategoryPaginatedResultSchema,
@@ -155,24 +170,28 @@ export class MedusaCategoryProvider extends CategoryProvider {
   ) {
     const sdk = await this.medusaApi.getClient();
 
-    const actualParentId = await this.resolveCategoryIdByExternalId(
+    const actualParent = await this.resolveCategoryIdByExternalId(
       payload.parentId.key
     );
-    if (!actualParentId) {
+    if (!actualParent) {
       throw new Error('Parent category not found ' + payload.parentId.key);
     }
 
-    const response = await sdk.store.category.list({
-      fields: '+metadata,+parent_category.metadata',
-      parent_category_id: actualParentId.id,
+    const response = await sdk.store.category.list(this.findChildCategoriesPayload(payload, actualParent));
+
+    const result = this.parsePaginatedResult(response);
+    return success(result);
+  }
+
+  protected findTopCategoriesPayload(payload: CategoryQueryForTopCategories) {
+    return {
+      fields: '+metadata',
+      parent_category_id: 'null',
       limit: payload.paginationOptions.pageSize,
       offset:
         (payload.paginationOptions.pageNumber - 1) *
         payload.paginationOptions.pageSize,
-    });
-
-    const result = this.parsePaginatedResult(response);
-    return success(result);
+    }
   }
 
   @Reactionary({
@@ -184,17 +203,9 @@ export class MedusaCategoryProvider extends CategoryProvider {
   ) {
     const sdk = await this.medusaApi.getClient();
 
-    const response = await sdk.store.category.list({
-      fields: '+metadata',
-      parent_category_id: 'null',
-      limit: payload.paginationOptions.pageSize,
-      offset:
-        (payload.paginationOptions.pageNumber - 1) *
-        payload.paginationOptions.pageSize,
-    });
+    const response = await sdk.store.category.list(this.findTopCategoriesPayload(payload));
 
     const result = this.parsePaginatedResult(response);
-
     return success(result);
   }
 
@@ -246,3 +257,4 @@ export class MedusaCategoryProvider extends CategoryProvider {
     return result;
   }
 }
+

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

@@ -1,4 +1,4 @@
-import type { StoreCart, StoreCartAddress, StoreCartLineItem } from '@medusajs/types';
+import type { StoreAddCartShippingMethods, StoreCart, StoreCartAddress, StoreCartLineItem, StoreInitializePaymentSession, StoreUpdateCart } from '@medusajs/types';
 import type {
   Address,
   AddressIdentifier,
@@ -97,6 +97,21 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     this.config = config;
   }
 
+  protected initiateCheckoutForCartPayload(payload: CheckoutMutationInitiateCheckout): StoreUpdateCart {
+    return {
+        billing_address: payload.billingAddress
+          ? this.mapAddressToStoreAddress(payload.billingAddress)
+          : undefined,
+        shipping_address: payload.billingAddress
+          ? this.mapAddressToStoreAddress(payload.billingAddress)
+          : undefined,
+        email: payload.notificationEmail,
+        metadata: {
+          sms_notification: payload.notificationPhone,
+        },
+      }
+  }
+
   @Reactionary({
     inputSchema: CheckoutMutationInitiateCheckoutSchema,
     outputSchema: CheckoutSchema,
@@ -114,18 +129,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     // zero out existing checkout data?
     const response = await client.store.cart.update(
       payload.cart.identifier.key,
-      {
-        billing_address: payload.billingAddress
-          ? this.mapAddressToStoreAddress(payload.billingAddress)
-          : undefined,
-        shipping_address: payload.billingAddress
-          ? this.mapAddressToStoreAddress(payload.billingAddress)
-          : undefined,
-        email: payload.notificationEmail,
-        metadata: {
-          sms_notification: payload.notificationPhone,
-        },
-      },
+      this.initiateCheckoutForCartPayload(payload),
       {
         fields: this.includedFields,
       }
@@ -148,6 +152,13 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     return success(this.parseSingle(response.cart));
   }
 
+
+  protected setShippingAddressPayload(payload: CheckoutMutationSetShippingAddress): StoreUpdateCart {
+    return {
+      shipping_address: this.mapAddressToStoreAddress(payload.shippingAddress),
+    }
+  }
+
   @Reactionary({
     inputSchema: CheckoutMutationSetShippingAddressSchema,
     outputSchema: CheckoutSchema,
@@ -159,18 +170,21 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
 
     const response = await client.store.cart.update(
       payload.checkout.key,
-      {
-        shipping_address: this.mapAddressToStoreAddress(
-          payload.shippingAddress
-        ),
-      },
+      this.setShippingAddressPayload(payload),
       {
         fields: this.includedFields,
-      }
+      },
     );
     return success(this.parseSingle(response.cart));
   }
 
+
+  protected getAvailableShippingMethodsPayload(payload: CheckoutQueryForAvailableShippingMethods) {
+    return {
+      cart_id: payload.checkout.key,
+    }
+  }
+
   @Reactionary({
     inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
     outputSchema: z.array(ShippingMethodSchema),
@@ -187,9 +201,9 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     }
 
     const shippingMethodResponse =
-      await client.store.fulfillment.listCartOptions({
-        cart_id: payload.checkout.key,
-      });
+      await client.store.fulfillment.listCartOptions(
+        this.getAvailableShippingMethodsPayload(payload)
+      );
 
     const shippingMethods: ShippingMethod[] = [];
 
@@ -218,6 +232,12 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     return success(shippingMethods);
   }
 
+  protected getAvailablePaymentMethodsPayload(payload: CheckoutQueryForAvailablePaymentMethods, regionId: string) {
+    return {
+      region_id: regionId,
+    }
+  }
+
   @Reactionary({
     inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
     outputSchema: z.array(PaymentMethodSchema),
@@ -234,10 +254,12 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     }
     const checkout = await client.store.cart.retrieve(payload.checkout.key);
     const paymentMethodResponse =
-      await client.store.payment.listPaymentProviders({
-        region_id:
-          checkout.cart.region_id || (await this.medusaApi.getActiveRegion()).id,
-      });
+      await client.store.payment.listPaymentProviders(
+        this.getAvailablePaymentMethodsPayload(
+          payload,
+          checkout.cart.region_id || (await this.medusaApi.getActiveRegion()).id
+        )
+      );
 
     const paymentMethods: PaymentMethod[] = [];
 
@@ -267,6 +289,18 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     return success(paymentMethods);
   }
 
+
+  protected addPaymentInstructionPayload(payload: CheckoutMutationAddPaymentInstruction): StoreInitializePaymentSession {
+    return {
+          provider_id: payload.paymentInstruction.paymentMethod.method,
+          data: payload.paymentInstruction.protocolData.reduce((acc, curr) => {
+            acc[curr.key] = curr.value;
+            return acc;
+          }, {} as Record<string, string>),
+        };
+  }
+
+
   @Reactionary({
     inputSchema: CheckoutMutationAddPaymentInstructionSchema,
     outputSchema: CheckoutSchema,
@@ -287,13 +321,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
       );
 
       const paymentSessionResponse =
-        await client.store.payment.initiatePaymentSession(cartResponse.cart, {
-          provider_id: payload.paymentInstruction.paymentMethod.method,
-          data: payload.paymentInstruction.protocolData.reduce((acc, curr) => {
-            acc[curr.key] = curr.value;
-            return acc;
-          }, {} as Record<string, string>),
-        });
+        await client.store.payment.initiatePaymentSession(cartResponse.cart, this.addPaymentInstructionPayload(payload));
 
       const updatedCartResponse = await client.store.cart.retrieve(
         payload.checkout.key,
@@ -323,6 +351,17 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     throw new Error('Method not implemented.');
   }
 
+  protected setShippingInstructionPayload(payload: CheckoutMutationSetShippingInstruction): StoreAddCartShippingMethods {
+    return {
+          option_id: payload.shippingInstruction.shippingMethod.key,
+          data: {
+            consent_for_unattended_delivery:
+              payload.shippingInstruction.consentForUnattendedDelivery + '',
+            instructions: payload.shippingInstruction.instructions || '',
+          },
+        };
+  }
+
   @Reactionary({
     inputSchema: CheckoutMutationSetShippingInstructionSchema,
     outputSchema: CheckoutSchema,
@@ -335,14 +374,7 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
     try {
       // Set shipping method
       if (payload.shippingInstruction.shippingMethod) {
-        await client.store.cart.addShippingMethod(medusaId.key, {
-          option_id: payload.shippingInstruction.shippingMethod.key,
-          data: {
-            consent_for_unattended_delivery:
-              payload.shippingInstruction.consentForUnattendedDelivery + '',
-            instructions: payload.shippingInstruction.instructions || '',
-          },
-        });
+        await client.store.cart.addShippingMethod(medusaId.key, this.setShippingInstructionPayload(payload));
       }
 
       // for now, we store a backup of the shipping instruction in metadata
@@ -369,6 +401,11 @@ export class MedusaCheckoutProvider extends CheckoutProvider {
       handleProviderError('set shipping method', error);
     }
   }
+
+
+
+
+
   @Reactionary({
     inputSchema: CheckoutMutationFinalizeCheckoutSchema,
     outputSchema: CheckoutSchema,

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

@@ -44,14 +44,9 @@ export class MedusaOrderSearchProvider extends OrderSearchProvider {
 
   }
 
-  @Reactionary({
-    inputSchema: OrderSearchQueryByTermSchema,
-    outputSchema: OrderSearchResultSchema,
-  })
-  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
-    debug('queryByTerm', payload);
+  protected queryByTermPayload(payload: OrderSearchQueryByTerm): any {
+    const filters: any = {};
 
-    const medusa = await this.medusaApi.getClient();
 
     if (payload.search.term) {
       debug('Searching orders by term is not supported in Medusa');
@@ -67,10 +62,12 @@ export class MedusaOrderSearchProvider extends OrderSearchProvider {
     if (payload.search.endDate) {
       debug('Searching orders by end date is not supported in Medusa');
     }
+
     /*
     if (payload.search.user && payload.search.user.userId) {
       debug('Searching orders by customer ID is not supported in Medusa');
     } */
+
     const statusFilter: MedusaOrderStatus[] = (payload.search.orderStatus ?? []).map((status) => {
       let retStatus: MedusaOrderStatus = 'draft';
       if (status === 'AwaitingPayment') {
@@ -88,15 +85,29 @@ export class MedusaOrderSearchProvider extends OrderSearchProvider {
       return retStatus;
     });
 
-
-    const response = await medusa.store.order.list({
+    return {
       status: statusFilter,
       limit: payload.search.paginationOptions.pageSize,
       offset:
         (payload.search.paginationOptions.pageNumber - 1) *
         payload.search.paginationOptions.pageSize,
 
-    });
+    }
+  }
+
+  @Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+    debug('queryByTerm', payload);
+
+    const medusa = await this.medusaApi.getClient();
+
+
+
+
+    const response = await medusa.store.order.list(this.queryByTermPayload(payload));
 
     const result = this.parsePaginatedResult(response, payload) as OrderSearchResult;
     if (debug.enabled) {

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

@@ -41,7 +41,7 @@ export class MedusaPriceProvider extends PriceProvider {
     outputSchema: PriceSchema,
   })
   public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
-    const result = await this.getBySKU(payload);
+    const result = await this.getBySKU(payload, 'list');
 
     return success(result);
   }
@@ -51,13 +51,13 @@ export class MedusaPriceProvider extends PriceProvider {
     outputSchema: PriceSchema,
   })
   public override async getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>> {
-    const result = await this.getBySKU(payload);
+    const result = await this.getBySKU(payload, 'customer');
 
     return success(result);
   }
 
 
-  protected async getBySKU(payload: ListPriceQuery | CustomerPriceQuery ): Promise<Price> {
+  protected async getBySKU(payload: ListPriceQuery | CustomerPriceQuery, mode: 'list' | 'customer' ): Promise<Price> {
     const sku = payload.variant.sku;
 
     if (debug.enabled) {
@@ -71,7 +71,7 @@ export class MedusaPriceProvider extends PriceProvider {
       const product = (
         await client.store.product.retrieve(
           productForSKU.id || '',
-          { region_id: (await this.medusaApi.getActiveRegion()).id }
+          { region_id: (await this.medusaApi.getActiveRegion()).id },
         )
       ).product;
 
@@ -87,7 +87,7 @@ export class MedusaPriceProvider extends PriceProvider {
       }
 
       // For simplicity, return the first matched product
-      return this.parseSingle(variant);
+      return this.parseSingle(variant, mode);
     } catch (error) {
       if (debug.enabled) {
         debug(
@@ -98,7 +98,7 @@ export class MedusaPriceProvider extends PriceProvider {
     }
   }
 
-  protected parseSingle(variant: StoreProductVariant): Price {
+  protected parseSingle(variant: StoreProductVariant, mode: 'list' | 'customer'): Price {
     const identifier = {
       variant: {
         sku: variant.sku || '',
@@ -108,11 +108,19 @@ export class MedusaPriceProvider extends PriceProvider {
     // In Medusa v2, calculated_price contains the final price for the variant
     // based on the region, currency, and any applicable price lists
     const calculatedPrice = variant.calculated_price;
-
     let unitPrice;
+    let isOnSale = false;
     if (calculatedPrice) {
+
+
+      const priceToUse = mode === 'customer' ? calculatedPrice.calculated_amount : calculatedPrice.original_amount;
+
+      if (mode === 'customer') {
+        isOnSale = calculatedPrice.calculated_price?.price_list_type === 'sale'
+      }
+
       unitPrice = {
-        value: calculatedPrice.calculated_amount || 0,
+        value: priceToUse || 0,
         currency: (calculatedPrice.currency_code?.toUpperCase() ||
           this.context.languageContext.currencyCode) as Currency,
       } satisfies MonetaryAmount;
@@ -127,7 +135,8 @@ export class MedusaPriceProvider extends PriceProvider {
     const result = {
       identifier,
       tieredPrices: [],
-      unitPrice
+      unitPrice,
+      onSale: isOnSale,
     } satisfies Price;
 
     return result;

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

@@ -1,4 +1,4 @@
-import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import type { StoreCollection, StoreProduct, StoreProductVariant } from '@medusajs/types';
 import {
   error,
   ImageSchema,
@@ -42,6 +42,14 @@ export class MedusaProductRecommendationsProvider extends ProductRecommendations
     this.medusaApi = medusaApi;
   }
 
+
+  protected getCollectionPayload(query: ProductRecommendationsByCollectionQuery, collection: StoreCollection) {
+    return {
+        collection_id: [collection.id],
+        limit: query.numberOfRecommendations,
+        fields: '+variants.id,+variants.sku,+external_id',
+      }
+  }
   /**
    * Get product recommendations from a Medusa collection
    *
@@ -82,11 +90,7 @@ export class MedusaProductRecommendationsProvider extends ProductRecommendations
       }
 
       // Fetch products from the collection
-      const productsResponse = await client.store.product.list({
-        collection_id: [collection.id],
-        limit: query.numberOfRecommendations,
-        fields: '+variants.id,+variants.sku,+external_id',
-      });
+      const productsResponse = await client.store.product.list(this.getCollectionPayload(query, collection));
 
       if (debug.enabled) {
         debug(`Found ${productsResponse.products.length} products in collection`);

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

@@ -88,6 +88,22 @@ export class MedusaSearchProvider extends ProductSearchProvider {
     return candidate || null;
   }
 
+
+  protected queryByTermPayload(payload: ProductSearchQueryByTerm, categoryIdToFind: string | null): any {
+
+    const finalSearch = (payload.search.term || '').trim().replace('*', '');
+
+    return {
+      q: finalSearch,
+      ...(categoryIdToFind ? { category_id: categoryIdToFind } : {}),
+      limit: payload.search.paginationOptions.pageSize,
+      fields: '+metadata.*,+external_id',
+      offset:
+        (payload.search.paginationOptions.pageNumber - 1) *
+        payload.search.paginationOptions.pageSize,
+    }
+  }
+
   @Reactionary({
     inputSchema: ProductSearchQueryByTermSchema,
     outputSchema: ProductSearchResultSchema,
@@ -121,16 +137,9 @@ export class MedusaSearchProvider extends ProductSearchProvider {
         );
       }
     }
-    const finalSearch = (payload.search.term || '').trim().replace('*', '');
-    const response = await client.store.product.list({
-      q: finalSearch,
-      ...(categoryIdToFind ? { category_id: categoryIdToFind } : {}),
-      limit: payload.search.paginationOptions.pageSize,
-      fields: '+metadata.*,+external_id',
-      offset:
-        (payload.search.paginationOptions.pageNumber - 1) *
-        payload.search.paginationOptions.pageSize,
-    });
+
+
+    const response = await client.store.product.list(this.queryByTermPayload(payload, categoryIdToFind));
 
     const result = this.parsePaginatedResult(response) as ProductSearchResult;
     if (debug.enabled) {

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

@@ -28,6 +28,15 @@ export class MedusaProductProvider extends ProductProvider {
    this.config = config;
   }
 
+  protected getByIdPayload(payload: ProductQueryById) {
+    return {
+      external_id: payload.identifier.key,
+      limit: 1,
+      offset: 0,
+      fields: this.alwaysIncludedFields.join(','),
+    }
+  }
+
   @Reactionary({
     inputSchema: ProductQueryByIdSchema,
     outputSchema: ProductSchema,
@@ -42,12 +51,7 @@ export class MedusaProductProvider extends ProductProvider {
       debug(`Fetching product by ID: ${payload.identifier.key}`);
     }
     const response = await client.store.product.list(
-      {
-        external_id: payload.identifier.key,
-        limit: 1,
-        offset: 0,
-        fields: this.alwaysIncludedFields.join(','),
-      },
+      this.getByIdPayload(payload)
     );
 
     if (response.count === 0) {
@@ -59,6 +63,15 @@ export class MedusaProductProvider extends ProductProvider {
     return success(this.parseSingle(response.products[0]));
   }
 
+  protected getBySlugPayload(payload: ProductQueryBySlug) {
+    return {
+      handle: payload.slug,
+      limit: 1,
+      offset: 0,
+      fields: this.alwaysIncludedFields.join(','),
+    }
+   }
+
 
   @Reactionary({
     inputSchema: ProductQueryBySlugSchema,
@@ -74,12 +87,7 @@ export class MedusaProductProvider extends ProductProvider {
       debug(`Fetching product by slug: ${payload.slug}`);
     }
 
-    const response = await client.store.product.list({
-      handle: payload.slug,
-      limit: 1,
-      offset: 0,
-      fields: this.alwaysIncludedFields.join(','),
-    });
+    const response = await client.store.product.list(this.getBySlugPayload(payload));
 
     if (debug.enabled) {
       debug(`Found ${response.count} products for slug: ${payload.slug}`);