@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,265 @@
+import 'dotenv/config';
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+import type { ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+
+const testData = {
+  searchTerm: '',
+  sku: '0766623301831',
+  customerName: 'Eileen Harvey',
+  email: 'eileen.harvey@example.com',
+};
+
+describe.each([PrimaryProvider.MEILISEARCH])(
+  'Order Search Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    // Technically, i should create a bunch of orders first, but a) that would make the test way longer, and b) they would all be on the same day with same statuses.
+    it('can be called by anonymous users', async () => {
+      const result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+    });
+
+    it('can be called by guest users', async () => {
+      const updatedCart = await client.cart.add({
+        quantity: 1,
+        variant: {
+          sku: testData.sku,
+        },
+      });
+      const identity = await client.identity.getSelf({});
+
+      if (!identity.success) {
+        assert.fail();
+      }
+
+      expect(identity.value.type).toBe('Guest');
+
+      const result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+    });
+
+    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',
+      });
+
+      if (!identity.success) {
+
+        assert.fail();
+      }
+
+      expect(identity.value.type).toBe('Registered');
+      const result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+    });
+
+    describe('filters', () => {
+
+
+      beforeEach(async () => {
+        const time = new Date().getTime();
+        const identity = await client.identity.login({ username: testData.email,
+          password: 'Test1234!'
+        });
+
+        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: [],
+          },
+        });
+
+        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: [],
+          },
+        });
+
+        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);
+      });
+
+      it('can filter by search term', async () => {
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: 'cable',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
+
+        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: [],
+          },
+        });
+
+        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
+        );
+      });
+
+      it('can filter by order status', async () => {
+        const result = await client.orderSearch.queryByTerm({
+          search: {
+            term: '',
+            orderStatus: ['Shipped'],
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 10,
+            },
+            filters: [],
+          },
+        });
+
+        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/capabilities/order.spec.ts

@@ -0,0 +1,91 @@
+import 'dotenv/config';
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+import type { OrderIdentifier, ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+
+const testData = {
+  searchTerm: '',
+  sku: '0766623301831',
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])(
+  'Order Search Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    it.skip('can be called by guest users', async () => {
+      const updatedCart = await client.cart.add(
+              {
+                quantity: 1,
+                variant: {
+                  sku: testData.sku
+                },
+              }
+            );
+      // create order....somehow.....
+
+      const orderId: OrderIdentifier = { key: '123456'};
+      const identity = await client.identity.getSelf({});
+      if (!identity.success) {
+        assert.fail();
+      }
+
+      expect(identity.value.type).toBe('Guest');
+      const result = await client.order.getById({ order: orderId });
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+
+      const order = result.value;
+      expect(order.identifier.key).toBe(orderId.key);
+      expect(order.items.length).toBeGreaterThan(0);
+      expect(order.price.grandTotal.value).toBeGreaterThan(0);
+
+    });
+
+    it.skip('can be called by registered users', async () => {
+      const time = new Date().getTime();
+      const identity = await client.identity.register(
+        {
+          username: `test-user+${time}@example.com`,
+          password: 'love2test',
+        }
+      );
+
+      if (!identity.success) {
+        assert.fail();
+      }
+
+      expect(identity.value.type).toBe('Registered');
+
+      const updatedCart = await client.cart.add(
+              {
+                quantity: 1,
+                variant: {
+                  sku: testData.sku
+                },
+              }
+            );
+      // create order....somehow.....
+
+      const orderId: OrderIdentifier = { key: '456789'};
+
+
+      expect(identity.value.type).toBe('Guest');
+      const result = await client.order.getById({ order: orderId });
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+
+      const order = result.value;
+      expect(order.identifier.key).toBe(orderId.key);
+      expect(order.items.length).toBeGreaterThan(0);
+      expect(order.price.grandTotal.value).toBeGreaterThan(0);
+    });
+
+
+});

package/examples/node/src/capabilities/price.spec.ts

@@ -0,0 +1,51 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+const testData = {
+  skuWithoutTiers: '4049699458101',
+};
+
+// FIXME: Currently broken in terms of actually looking up anything...
+describe.each([PrimaryProvider.COMMERCETOOLS])(
+  'Price Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    it('should be able to get an offer price for a sku', async () => {
+      const result = await client.price.getCustomerPrice({
+        variant: { sku: testData.skuWithoutTiers },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.variant.sku).toBe(
+        testData.skuWithoutTiers
+      );
+      expect(result.value.unitPrice.value).toBe(155.1);
+      expect(result.value.unitPrice.currency).toBe('USD');
+      expect(result.value.tieredPrices.length).toBe(0);
+    });
+
+    it('should be able to get a list price for a sku', async () => {
+      const result = await client.price.getListPrice({
+        variant: { sku: testData.skuWithoutTiers },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+      expect(result.value.unitPrice.value).toBeGreaterThan(200);
+      expect(result.value.unitPrice.currency).toBe('USD');
+      expect(result.value.tieredPrices.length).toBe(0);
+    });
+  }
+);

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

@@ -0,0 +1,293 @@
+import 'dotenv/config';
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+import type { ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+
+const testData = {
+  searchTerm: 'manhattan',
+};
+
+describe.each([PrimaryProvider.ALGOLIA, PrimaryProvider.COMMERCETOOLS,PrimaryProvider.MEILISEARCH])(
+  'Product Search Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    it('should be able to get a result by term', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          facets: [],
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+
+      expect(result.value.items.length).toBeGreaterThan(0);
+    });
+
+    it('should be able to get a result by term, paged', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          facets: [],
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 1,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.items.length).toBeGreaterThan(0);
+      expect(result.value.totalPages).toBeGreaterThan(1);
+
+      const result2 = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          facets: [],
+          paginationOptions: {
+            pageNumber: 2,
+            pageSize: 1,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result2.success) {
+        assert.fail();
+      }
+
+      expect(result2.value.items.length).toBeGreaterThan(0);
+      expect(result2.value.totalPages).toBeGreaterThan(2);
+      expect(result2.value.items[0].identifier.key).not.toBe(
+        result.value.items[0].identifier.key
+      );
+    });
+
+    it('should be able to change page size', async () => {
+      const smallPage = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+      const largePage = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 30,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!smallPage.success || !largePage.success) {
+        assert.fail();
+      }
+
+      expect(smallPage.value.items.length).toBe(2);
+      expect(smallPage.value.pageSize).toBe(2);
+      expect(largePage.value.items.length).toBe(30);
+      expect(largePage.value.pageSize).toBe(30);
+    });
+
+    it('should be able to apply facets', async () => {
+      const initial = await client.productSearch.queryByTerm({
+        search: {
+          term: "",
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!initial.success) {
+        assert.fail();
+      }
+
+      expect(initial.value.facets.length).toBeGreaterThan(0);
+
+      const filtered = await client.productSearch.queryByTerm({
+        search: {
+          term: "",
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          facets: [initial.value.facets[0].values[0].identifier],
+          filters: [],
+        },
+      });
+
+      if (!filtered.success) {
+        assert.fail();
+      }
+
+      expect(initial.value.totalCount).toBeGreaterThan(filtered.value.totalCount);
+      expect(filtered.value.totalCount).toBeGreaterThan(0);
+    });
+
+    it('should not return facets with no values', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      for (const facet of result.value.facets) {
+        expect(facet.values.length).toBeGreaterThan(0);
+      }
+    });
+
+
+    it('can apply a category facet', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: "*",
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      const categoryFacet = result.value.facets.find(
+        (f) => f.identifier.key === 'categories'
+      );
+      expect(categoryFacet).toBeDefined();
+      const chosenFacet = categoryFacet!.values[0]!;
+
+      const narrowedResult = await client.productSearch.queryByTerm({
+        search: {
+          term: "*",
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          facets: [chosenFacet.identifier],
+          filters: [],
+        },
+      });
+
+      if (!narrowedResult.success) {
+        assert.fail();
+      }
+
+      expect(narrowedResult.value.totalCount).toBeLessThan(result.value.totalCount);
+      expect(narrowedResult.value.totalCount).toBeGreaterThan(0);
+      expect(narrowedResult.value.totalCount).toBe(chosenFacet.count);
+
+    });
+
+
+
+    it.skip('can apply a top level category filter', async () => {
+      // First, get a category to filter on
+      const categories = await client.category.findTopCategories({
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 2,
+        },
+      });
+
+
+      const unfilteredSearch = await client.productSearch.queryByTerm({
+        search: {
+          term: "",
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 1,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!unfilteredSearch.success || !categories.success) {
+        assert.fail();
+      }
+
+      expect(unfilteredSearch.value.totalCount).toBeGreaterThan(0);
+
+      const breadCrumb = await client.category.getBreadcrumbPathToCategory({
+        id: categories.value.items[1].identifier,
+      });
+
+      if (!breadCrumb.success) {
+        assert.fail();
+      }
+
+      expect(breadCrumb.value.length).toBeGreaterThan(0);
+
+      const categoryFilter = await client.productSearch.createCategoryNavigationFilter({
+        categoryPath: breadCrumb.value,
+      } satisfies ProductSearchQueryCreateNavigationFilter);
+
+      if (!categoryFilter.success) {
+        assert.fail();
+      }
+
+      const filteredSearch = await client.productSearch.queryByTerm({
+        search: {
+          term: "",
+          categoryFilter: categoryFilter.value,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 1,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!filteredSearch.success) {
+        assert.fail();
+      }
+
+      expect(filteredSearch.value.totalCount).toBeLessThan(unfilteredSearch.value.totalCount);
+      expect(filteredSearch.value.totalCount).toBeGreaterThan(0);
+    });
+  }
+);