@reactionary/examples-node 0.2.14 → 0.2.16

package/package.json

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

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