@reactionary/source 0.2.15 → 0.2.17

package/core/src/schemas/models/identifiers.model.ts

@@ -131,7 +131,7 @@ export const OrderSearchIdentifierSchema = z.looseObject({
   term: z.string().describe('The search term used to find orders. Not all providers may support term-based search for orders.'),
   partNumber: z.array(z.string()).optional().describe('An optional list part number to filter orders by specific products. Will be ANDed together.'),
   orderStatus: z.array(OrderStatusSchema).optional().describe('An optional list of order statuses to filter the search results.'),
-  userId: IdentityIdentifierSchema.optional().describe('An optional user ID to filter orders by specific users. Mostly for b2b usecases with hierachial order access'),
+  user: IdentityIdentifierSchema.optional().describe('An optional user ID to filter orders by specific users. Mostly for b2b usecases with hierachial order access.'),
   startDate: z.string().optional().describe('An optional start date to filter orders from a specific date onwards. ISO8601'),
   endDate: z.string().optional().describe('An optional end date to filter orders up to a specific date. ISO8601'),
   filters: z.array(z.string()).describe('Additional filters applied to the search results.'),

package/examples/node/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@reactionary/examples-node",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.2.15",
-    "@reactionary/provider-commercetools": "0.2.15",
-    "@reactionary/provider-algolia": "0.2.15",
-    "@reactionary/provider-medusa": "0.2.15",
-    "@reactionary/provider-meilisearch": "0.2.15"
+    "@reactionary/core": "0.2.17",
+    "@reactionary/provider-commercetools": "0.2.17",
+    "@reactionary/provider-algolia": "0.2.17",
+    "@reactionary/provider-medusa": "0.2.17",
+    "@reactionary/provider-meilisearch": "0.2.17"
   },
   "type": "module"
 }

package/examples/node/src/capabilities/order-search.spec.ts

@@ -5,10 +5,12 @@ import type { ProductSearchQueryCreateNavigationFilter } from '@reactionary/core
 
 const testData = {
   searchTerm: '',
-  sku: '0766623301831'
+  sku: '0766623301831',
+  customerName: 'Eileen Harvey',
+  email: 'eileen.harvey@example.com',
 };
 
-describe.each([PrimaryProvider.COMMERCETOOLS])(
+describe.each([PrimaryProvider.MEILISEARCH])(
   'Order Search Capability - %s',
   (provider) => {
     let client: ReturnType<typeof createClient>;
@@ -36,14 +38,12 @@ describe.each([PrimaryProvider.COMMERCETOOLS])(
     });
 
     it('can be called by guest users', async () => {
-      const updatedCart = await client.cart.add(
-              {
-                quantity: 1,
-                variant: {
-                  sku: testData.sku
-                },
-              }
-            );
+      const updatedCart = await client.cart.add({
+        quantity: 1,
+        variant: {
+          sku: testData.sku,
+        },
+      });
       const identity = await client.identity.getSelf({});
 
       if (!identity.success) {
@@ -70,14 +70,13 @@ describe.each([PrimaryProvider.COMMERCETOOLS])(
 
     it('can be called by an authenticated user', async () => {
       const time = new Date().getTime();
-      const identity = await client.identity.register(
-        {
-          username: `test-user+${time}@example.com`,
-          password: 'love2test',
-        }
-      );
+      const identity = await client.identity.register({
+        username: `test-user+${time}@example.com`,
+        password: 'love2test',
+      });
 
       if (!identity.success) {
+
         assert.fail();
       }
 
@@ -96,64 +95,171 @@ describe.each([PrimaryProvider.COMMERCETOOLS])(
       if (!result.success) {
         assert.fail(JSON.stringify(result.error));
       }
-
-    });
-    it.skip('can filter by startDate', async () => {
-      /** TODO */
     });
 
-    it.skip('can filter by endDate', async () => {
-      /** TODO */
-    });
+    describe('filters', () => {
 
-    it.skip('can filter by orderStatus', async () => {
-      /** TODO */
-    });
 
-    it.skip('can filter by multiple orderStatuses', async () => {
-      /** TODO */
-    });
+      beforeEach(async () => {
+        const time = new Date().getTime();
+        const identity = await client.identity.login({ username: testData.email,
+          password: 'Test1234!'
+        });
 
-    it.skip('can filter by partNumber', async () => {
-      /** TODO */
-    });
+        if (!identity.success) {
+          assert.fail();
+        }
+        expect(identity.value.type).toBe('Registered');
+      });
 
+      it('has some test orders', async () => {
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
 
-    it.skip('can page the resultset', async () => {
-      const result = await client.orderSearch.queryByTerm({
-        search: {
-          term: testData.searchTerm,
-          paginationOptions: {
-            pageNumber: 1,
-            pageSize: 2,
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.items.length).toBeGreaterThan(0);
+      });
+
+      it('can filter by part number', async () => {
+
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
           },
-          filters: [],
-        },
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+
+        const result2 = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            partNumber: [testData.sku],
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
+
+        if (!result2.success) {
+          assert.fail(JSON.stringify(result2.error));
+        }
+        expect(result2.value.items.length).toBeGreaterThan(0);
+        expect(result2.value.totalCount).toBeLessThanOrEqual(result.value.totalCount);
       });
 
-      if (!result.success) {
-        assert.fail(JSON.stringify(result.error));
-      }
+      it('can filter by search term', async () => {
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: 'cable',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
 
-      const result2 = await client.orderSearch.queryByTerm({
-        search: {
-          term: testData.searchTerm,
-          paginationOptions: {
-            pageNumber: 2,
-            pageSize: 2,
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+        expect(result.value.items.length).toBeGreaterThan(0);
+      });
+
+
+
+      it('can paginate results', async () => {
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 1,
+            },
+            filters: [],
           },
-          filters: [],
-        },
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+        expect(result.value.items.length).toBe(1);
+
+        const result2 = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            paginationOptions: {
+              pageNumber: 2,
+              pageSize: 1,
+            },
+            filters: [],
+          },
+        });
+
+        if (!result2.success) {
+          assert.fail(JSON.stringify(result2.error));
+        }
+        expect(result2.value.items.length).toBe(1);
+        expect(result2.value.items[0].identifier.key).not.toBe(
+          result.value.items[0].identifier.key
+        );
       });
 
-      if (!result2.success) {
-        assert.fail(JSON.stringify(result2.error));
-      }
+      it('can filter by order status', async () => {
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            orderStatus: ['Shipped'],
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
 
-      expect(result.value.items[0].identifier).not.toBe(
-        result2.value.items[0].identifier
-      );
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+        expect(result.value.items.length).toBeGreaterThan(0);
+
+        const result2 = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            orderStatus: ['Cancelled'],
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
+
+        if (!result2.success) {
+          assert.fail(JSON.stringify(result2.error));
+        }
+        expect(result2.value.items.length).toBe(0);
+      });
     });
   }
-
 );

package/examples/node/src/utils.ts

@@ -23,6 +23,7 @@ export function getMeilisearchTestConfiguration() {
     apiUrl: process.env['MEILISEARCH_API_URL'] || '',
     indexName: process.env['MEILISEARCH_INDEX'] || '',
     useAIEmbedding: process.env['MEILISEARCH_USE_AI_EMBEDDING'] || undefined,
+    orderIndexName: process.env['MEILISEARCH_ORDER_INDEX'] || 'order',
   };
 }
 
@@ -90,6 +91,7 @@ export function createClient(provider: PrimaryProvider) {
           order: true,
           price: true,
           productSearch: true,
+          orderSearch: true,
           store: true,
           profile: true
         })
@@ -110,6 +112,7 @@ export function createClient(provider: PrimaryProvider) {
           order: true,
           price: true,
           productSearch: true,
+          orderSearch: true,
           store: true,
           profile: true,
         })
@@ -129,6 +132,13 @@ export function createClient(provider: PrimaryProvider) {
     builder = builder.withCapability(
       withMeilisearchCapabilities(getMeilisearchTestConfiguration(), {
         productSearch: true,
+        orderSearch: true,
+      }),
+    );
+    builder = builder.withCapability(
+      withMedusaCapabilities(getMedusaTestConfiguration(), {
+        cart: true,
+        identity: true,
       })
     );
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "license": "MIT",
   "private": false,
   "dependencies": {

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

@@ -70,8 +70,8 @@ export class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
         }
       }
 
-      if (payload.search.userId) {
-        where.push(`customerId="${payload.search.userId}"`);
+      if (payload.search.user && payload.search.user.userId) {
+        where.push(`customerId="${payload.search.user.userId}"`);
       }
 
       if (payload.search.orderStatus) {

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

@@ -67,9 +67,10 @@ export class MedusaOrderSearchProvider extends OrderSearchProvider {
     if (payload.search.endDate) {
       debug('Searching orders by end date is not supported in Medusa');
     }
-    if (payload.search.userId) {
+    /*
+    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') {

package/providers/meilisearch/src/core/initialize.ts

@@ -1,5 +1,6 @@
 import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
 import { MeilisearchSearchProvider } from "../providers/product-search.provider.js";
+import { MeilisearchOrderSearchProvider } from "../providers/order-search.provider.js";
 import type { MeilisearchCapabilities } from "../schema/capabilities.schema.js";
 import type { MeilisearchConfiguration } from "../schema/configuration.schema.js";
 
@@ -11,6 +12,10 @@ export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(c
             client.productSearch = new MeilisearchSearchProvider(configuration, cache, context);
         }
 
+        if (capabilities.orderSearch) {
+            client.orderSearch = new MeilisearchOrderSearchProvider(configuration, cache, context);
+        }
+
         return client;
     };
 }

package/providers/meilisearch/src/index.ts

@@ -1,5 +1,6 @@
 export * from './core/initialize.js';
 export * from './providers/product-search.provider.js';
+export * from './providers/order-search.provider.js';
 
 export * from './schema/configuration.schema.js';
 export * from './schema/capabilities.schema.js';

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

@@ -0,0 +1,224 @@
+import {
+  type Cache,
+  type OrderSearchQueryByTerm,
+  OrderSearchQueryByTermSchema,
+  type OrderSearchResult,
+  type OrderSearchResultItem,
+  OrderSearchResultSchema,
+  OrderSearchProvider,
+  Reactionary,
+  type RequestContext,
+  type Result,
+  success,
+  type OrderStatus,
+  type Address,
+  type IdentityIdentifier,
+  type MonetaryAmount,
+  type Currency,
+  type OrderSearchIdentifier,
+  AddressIdentifierSchema,
+  type AddressIdentifier,
+  type OrderInventoryStatus,
+} from '@reactionary/core';
+import { MeiliSearch, type SearchParams, type SearchResponse } from 'meilisearch';
+import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
+
+interface MeilisearchNativeOrderAddress {
+  address1: string;
+  address2: string;
+  city: string;
+  postalCode: string;
+  country: string;
+}
+
+interface MeilisearchNativeOrderRecord {
+  orderIdentifier: string;
+  userIdentifier: string;
+  customerName: string;
+  shippingAddress: MeilisearchNativeOrderAddress;
+  orderDate: string;
+  orderDateTimestamp: number;
+  orderStatus: string;
+  inventoryStatus: string;
+  totalAmount: number;
+  currency: string;
+}
+
+export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
+  protected config: MeilisearchConfiguration;
+
+  constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {
+    super(cache, context);
+    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);
+
+    const filters: string[] = [];
+
+    // Add status filter
+    if (payload.search.orderStatus && payload.search.orderStatus.length > 0) {
+      const statusFilters = payload.search.orderStatus
+        .map((status) => `orderStatus = "${this.mapOrderStatus(status)}"`)
+        .join(' OR ');
+      filters.push(`(${statusFilters})`);
+    }
+
+    // Add user ID filter for B2B use cases with hierarchical order access
+    if (payload.search.user) {
+      filters.push(`userIdentifier = "${payload.search.user.userId}"`);
+    }
+
+    // Add date range filters
+    if (payload.search.startDate) {
+      filters.push(`orderDateTimestamp >= ${new Date(payload.search.startDate).getTime()}`);
+    }
+    if (payload.search.endDate) {
+      filters.push(`orderDateTimestamp <= ${new Date(payload.search.endDate).getTime()}`);
+    }
+
+
+    if (payload.search.partNumber && payload.search.partNumber.length > 0) {
+      const partNumberFilters = payload.search.partNumber
+        .map((partNumber) => `items.sku = "${partNumber}"`)
+        .join(' OR ');
+      filters.push(`(${partNumberFilters})`);
+    }
+
+    const searchOptions: SearchParams = {
+      offset:
+        (payload.search.paginationOptions.pageNumber - 1) *
+        payload.search.paginationOptions.pageSize,
+      limit: payload.search.paginationOptions.pageSize,
+      filter: filters.length > 0 ? filters.join(' AND ') : undefined,
+      sort: ['orderDateTimestamp:desc'],
+    };
+
+    const remote = await index.search<MeilisearchNativeOrderRecord>(
+      payload.search.term || '',
+      searchOptions
+    );
+
+    const result = this.parsePaginatedResult(remote, payload) as OrderSearchResult;
+
+    return success(result);
+  }
+
+  protected mapOrderStatus(status: OrderStatus): string {
+    // Map from Reactionary OrderStatus to Meilisearch native status
+    const statusMap: Record<OrderStatus, string> = {
+      AwaitingPayment: 'awaiting_payment',
+      ReleasedToFulfillment: 'released_to_fulfillment',
+      Shipped: 'shipped',
+      Cancelled: 'cancelled',
+    };
+    return statusMap[status] || status;
+  }
+
+  protected mapFromNativeOrderStatus(nativeStatus: string): OrderStatus {
+    // Map from Meilisearch native status to Reactionary OrderStatus
+    const statusMap: Record<string, OrderStatus> = {
+      awaiting_payment: 'AwaitingPayment',
+      released_to_fulfillment: 'ReleasedToFulfillment',
+      shipped: 'Shipped',
+      cancelled: 'Cancelled',
+    };
+    return statusMap[nativeStatus] || 'AwaitingPayment';
+  }
+
+  protected mapFromNativeInventoryStatus(nativeStatus: string): OrderInventoryStatus {
+    // Map from Meilisearch native status to Reactionary OrderInventoryStatus
+    const statusMap: Record<string, OrderInventoryStatus> = {
+      not_allocated: 'NotAllocated',
+      allocated: 'Allocated',
+      preordered: 'Preordered',
+      backordered: 'Backordered',
+    };
+    return statusMap[nativeStatus] || 'NotAllocated';
+  }
+
+  protected composeAddressFromNativeAddress(
+    nativeAddress: MeilisearchNativeOrderAddress
+  ): Address {
+    return {
+      identifier: AddressIdentifierSchema.parse({
+        nickName: 'shipping',
+      } satisfies AddressIdentifier),
+      firstName: '',
+      lastName: '',
+      streetAddress: nativeAddress.address1,
+      streetNumber: nativeAddress.address2,
+      city: nativeAddress.city,
+      postalCode: nativeAddress.postalCode,
+      countryCode: nativeAddress.country,
+      region: '',
+    };
+  }
+
+  protected parseSingle(body: MeilisearchNativeOrderRecord): OrderSearchResultItem {
+    const identifier = { key: body.orderIdentifier };
+    const userId: IdentityIdentifier = {
+      userId: body.userIdentifier,
+    };
+    const customerName = body.customerName;
+    const shippingAddress = this.composeAddressFromNativeAddress(body.shippingAddress);
+    const orderDate = body.orderDate;
+    const orderStatus = this.mapFromNativeOrderStatus(body.orderStatus);
+    const inventoryStatus = this.mapFromNativeInventoryStatus(body.inventoryStatus);
+
+    const totalAmount: MonetaryAmount = {
+      currency: (body.currency || this.context.languageContext.currencyCode)  as Currency,
+      value: body.totalAmount,
+    };
+
+    const order = {
+      identifier,
+      userId,
+      customerName,
+      shippingAddress,
+      orderDate,
+      orderStatus,
+      inventoryStatus,
+      totalAmount,
+    } satisfies OrderSearchResultItem;
+
+    return order;
+  }
+
+  protected parsePaginatedResult(
+    body: SearchResponse<MeilisearchNativeOrderRecord>,
+    query: OrderSearchQueryByTerm
+  ): OrderSearchResult {
+    const identifier = {
+      ...query.search,
+    } satisfies OrderSearchIdentifier;
+
+    const orders: OrderSearchResultItem[] = body.hits.map((hit) => {
+      return this.parseSingle(hit);
+    });
+
+    const totalCount = body.estimatedTotalHits || body.hits.length;
+    const totalPages = Math.ceil(totalCount / (body.limit || 1));
+
+    const result = {
+      identifier,
+      pageNumber: Math.floor((body.offset || 0) / (body.limit || 1)  ) + 1,
+      pageSize: body.limit || orders.length,
+      totalCount,
+      totalPages,
+      items: orders,
+    } satisfies OrderSearchResult;
+
+    return result;
+  }
+}

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

@@ -3,6 +3,7 @@ import type { z } from 'zod';
 
 export const MeilisearchCapabilitiesSchema = CapabilitiesSchema.pick({
     productSearch: true,
+    orderSearch: true,
     analytics: true
 }).partial();
 

package/providers/meilisearch/src/schema/configuration.schema.ts

@@ -4,6 +4,7 @@ export const MeilisearchConfigurationSchema = z.looseObject({
     apiUrl: z.string(),
     apiKey: z.string(),
     indexName: z.string(),
+    orderIndexName: z.string(),
     useAIEmbedding: z.string().optional()
 });