@reactionary/source 0.0.52 → 0.2.15

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);
+    });
+  }
+);

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

@@ -0,0 +1,122 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+const testData = {
+  product: {
+    id: 'product_10959528',
+    name: 'Manhattan 170703 cable accessory Cable kit',
+    image: 'https://images.icecat.biz/img/norm/high/10959528-2837.jpg',
+    sku: '0766623170703',
+    slug: 'manhattan-170703-cable-accessory-cable-kit-10959528',
+  },
+  productWithMultiVariants: {
+    slug: 'hp-gk859aa-mouse-office-bluetooth-laser-1600-dpi-1377612',
+  },
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])(
+  'Product Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    it('should be able to get a product by id', async () => {
+      const response = await client.product.getById({
+        identifier: { key: testData.product.id },
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBe(testData.product.id);
+      expect(response.value.name).toBe(testData.product.name);
+      expect(response.value.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+      expect(response.value.mainVariant.name).toBeTruthy();
+    });
+
+    it('should be able to get a product by slug', async () => {
+      const response = await client.product.getBySlug({
+        slug: testData.product.slug,
+      });
+      
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBe(testData.product.id);
+      expect(response.value.name).toBe(testData.product.name);
+      expect(response.value.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+    });
+
+    it('should be able to get a multivariant product by slug', async () => {
+      const response = await client.product.getBySlug({
+        slug: testData.productWithMultiVariants.slug,
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBeTruthy();
+      expect(response.value.slug).toBe(testData.productWithMultiVariants.slug);
+      expect(response.value.mainVariant).toBeDefined();
+      expect(response.value.variants.length).toBeGreaterThan(0);
+      expect(response.value.variants[0].identifier.sku).toBeTruthy();
+      expect(response.value.variants[0].identifier.sku).not.toBe(
+        response.value.mainVariant.identifier.sku
+      );
+      expect(response.value.sharedAttributes.length).toBeGreaterThan(1);
+      expect(response.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+      expect(response.value.sharedAttributes[1].values[0].value).toBeTruthy();
+    });
+
+    it('should be able to get a product by sku', async () => {
+      const response = await client.product.getBySKU({
+        variant: { sku: testData.product.sku },
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBe(testData.product.id);
+      expect(response.value.name).toBe(testData.product.name);
+      expect(response.value.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+    });
+
+    it('should contain both product level and variant level attributes', async () => {
+      const response = await client.product.getBySKU({
+        variant: { sku: testData.product.sku },
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.sharedAttributes.length).toBeGreaterThan(1);
+      expect(response.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+      expect(response.value.sharedAttributes[1].values[0].value).toBeTruthy();
+    });
+
+    it('should return an error of NotFound for unknown slug', async () => {
+      const response = await client.product.getBySlug({ slug: 'unknown-slug' });
+      
+      if (response.success) {
+        assert.fail();
+      }
+
+      expect(response.error.type).toBe('NotFound');
+    });
+  }
+);