@reactionary/source 0.3.17 → 0.6.1

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/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}`);

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

@@ -79,6 +79,14 @@ export class MedusaProfileProvider extends ProfileProvider {
     return success(model);
   }
 
+  protected updatePayload(payload: ProfileMutationUpdate) {
+    const updateData: any = {};
+    if (payload.phone !== undefined) {
+      updateData.phone = payload.phone;
+    }
+    return updateData;
+  }
+
   @Reactionary({
     inputSchema: ProfileMutationUpdateSchema,
     outputSchema: ProfileSchema,
@@ -98,14 +106,16 @@ export class MedusaProfileProvider extends ProfileProvider {
 
     const customer = customerResponse.customer;
 
-    const updatedResponse = await client.store.customer.update({
-      phone: payload.phone ?? customer.phone,
-    }, { fields: this.includedFields.join(',') });
+    const updatedResponse = await client.store.customer.update(this.updatePayload(payload), { fields: this.includedFields.join(',') });
 
     const model = this.parseSingle(updatedResponse.customer);
     return success(model);
   }
 
+  protected addShippingAddressPayload(payload: ProfileMutationAddShippingAddress) {
+    return this.createMedusaAddress(payload.address);
+  }
+
   @Reactionary({
     inputSchema: ProfileMutationAddShippingAddressSchema,
     outputSchema: ProfileSchema,
@@ -115,7 +125,6 @@ export class MedusaProfileProvider extends ProfileProvider {
 
     const client = await this.medusaApi.getClient();
 
-    const medusaAddress = this.createMedusaAddress(payload.address);
 
     // check if any address with the same nickName exists
     const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
@@ -133,7 +142,7 @@ export class MedusaProfileProvider extends ProfileProvider {
       });
     }
 
-    const response = await client.store.customer.createAddress(medusaAddress, { fields: this.includedFields.join(',') });
+    const response = await client.store.customer.createAddress(this.addShippingAddressPayload(payload), { fields: this.includedFields.join(',') });
     if (!response.customer) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
@@ -145,6 +154,10 @@ export class MedusaProfileProvider extends ProfileProvider {
     return success(model);
   }
 
+  protected updateShippingAddressPayload(payload: ProfileMutationUpdateShippingAddress) {
+    return this.createMedusaAddress(payload.address);
+  }
+
   @Reactionary({
     inputSchema: ProfileMutationUpdateShippingAddressSchema,
     outputSchema: ProfileSchema,
@@ -162,8 +175,6 @@ export class MedusaProfileProvider extends ProfileProvider {
       });
     }
 
-    const medusaAddress = this.createMedusaAddress(payload.address);
-
     const existingAddress = customer.customer.addresses.find(addr => addr.address_name === payload.address.identifier.nickName);
     if (!existingAddress) {
       return error<NotFoundError>({
@@ -172,7 +183,7 @@ export class MedusaProfileProvider extends ProfileProvider {
       });
     }
 
-    const response = await client.store.customer.updateAddress(existingAddress.id, medusaAddress , { fields: this.includedFields.join(',') });
+    const response = await client.store.customer.updateAddress(existingAddress.id, this.updateShippingAddressPayload(payload), { fields: this.includedFields.join(',') });
     if (!response.customer) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
@@ -226,6 +237,12 @@ export class MedusaProfileProvider extends ProfileProvider {
   }
 
 
+  protected makeShippingAddressDefaultPayload(payload: ProfileMutationMakeShippingAddressDefault) {
+   return  {
+      is_default_shipping: true
+    }
+  }
+
   @Reactionary({
     inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
     outputSchema: ProfileSchema,
@@ -251,15 +268,23 @@ export class MedusaProfileProvider extends ProfileProvider {
       });
     }
 
-    const response = await client.store.customer.updateAddress(existingAddress.id, {
-      is_default_shipping: true
-    }, { fields: this.includedFields.join(',') }
+    const response = await client.store.customer.updateAddress(
+      existingAddress.id,
+      this.makeShippingAddressDefaultPayload(payload),
+      { fields: this.includedFields.join(',') }
     );
 
     const model = this.parseSingle(response.customer!);
     return success(model);
   }
 
+
+  protected setBillingAddressPayload(payload: ProfileMutationSetBillingAddress) {
+    const newAddr = this.createMedusaAddress(payload.address);
+    newAddr.is_default_billing = true;
+    return newAddr;
+  }
+
   @Reactionary({
     inputSchema: ProfileMutationSetBillingAddressSchema,
     outputSchema: ProfileSchema,
@@ -289,9 +314,9 @@ export class MedusaProfileProvider extends ProfileProvider {
     }
 
 
-    const newAddr = this.createMedusaAddress(payload.address);
-    newAddr.is_default_billing = true;
 
+
+    const newAddr = this.setBillingAddressPayload(payload);
     // two scenarios: Either we already have a billing addres, in which case we update it, or we dont and we need to create it.
     const existingBillingAddress = customer.addresses.find(addr => addr.is_default_billing);
     if (existingBillingAddress) {

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

@@ -52,17 +52,7 @@ export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
     this.config = config;
   }
 
-  @Reactionary({
-    inputSchema: OrderSearchQueryByTermSchema,
-    outputSchema: OrderSearchResultSchema,
-  })
-  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
-    const client = new MeiliSearch({
-      host: this.config.apiUrl,
-      apiKey: this.config.apiKey,
-    });
-
-    const index = client.index(this.config.orderIndexName);
+  protected queryByTermPayload(payload: OrderSearchQueryByTerm): SearchParams {
 
     const filters: string[] = [];
 
@@ -103,10 +93,25 @@ export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
       filter: filters.length > 0 ? filters.join(' AND ') : undefined,
       sort: ['orderDateTimestamp:desc'],
     };
+    return searchOptions
+  }
+
+  @Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+    const client = new MeiliSearch({
+      host: this.config.apiUrl,
+      apiKey: this.config.apiKey,
+    });
+
+    const index = client.index(this.config.orderIndexName);
+
 
     const remote = await index.search<MeilisearchNativeOrderRecord>(
       payload.search.term || '',
-      searchOptions
+      this.queryByTermPayload(payload)
     );
 
     const result = this.parsePaginatedResult(remote, payload) as OrderSearchResult;