@reactionary/source 0.0.52 → 0.2.16

package/examples/node/src/basic/basic-node-setup.spec.ts

@@ -1,42 +1,58 @@
-import { buildClient, createInitialRequestContext, NoOpCache } from '@reactionary/core';
+import 'dotenv/config';
+import {
+  ClientBuilder,
+  createInitialRequestContext,
+  NoOpCache,
+  type Client,
+  type RequestContext,
+} from '@reactionary/core';
 import { withFakeCapabilities } from '@reactionary/provider-fake';
+import { assert, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
 describe('basic node setup', () => {
-  const client = buildClient(
-    [
-      withFakeCapabilities(
-        {
-          jitter: {
-            mean: 0,
-            deviation: 0,
-          },
-          seeds: {
-            category: 1,
-            product: 1,
-            search: 1
-          }
-        },
-        { search: true, product: true, identity: false }
-      ),
-    ],
-    {
-      cache: new NoOpCache(),
-    }
-  );
+  let client: Partial<Client>;
+  let reqCtx: RequestContext;
 
-  const reqCtx = createInitialRequestContext();
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    client = new ClientBuilder(reqCtx)
+      .withCapability(
+        withFakeCapabilities(
+          {
+            jitter: {
+              mean: 0,
+              deviation: 0,
+            },
+            seeds: {
+              category: 1,
+              product: 1,
+              search: 1,
+            },
+          },
+          { productSearch: true, product: true, identity: false }
+        )
+      )
+      .withCache(new NoOpCache())
+      .build();
+  });
 
   it('should only get back the enabled capabilities', async () => {
     expect(client.product).toBeDefined();
-    expect(client.search).toBeDefined();
+    expect(client.productSearch).toBeDefined();
   });
 
   it('should be able to call the enabled capabilities', async () => {
-    const product = await client.product.getBySlug({
-        slug: '1234'
-    }, reqCtx);
+    const product = await client.product!.getBySlug(
+      {
+        slug: '1234',
+      }
+    );
+    
+    if (!product.success) {
+      assert.fail();
+    }
 
     expect(product).toBeDefined();
-    expect(product!.slug).toBe('1234');
+    expect(product.value.slug).toBe('1234');
   });
 });

package/examples/node/src/basic/client-creation.spec.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { ClientBuilder, createInitialRequestContext, NoOpCache } from '@reactionary/core';
+import { FakeProductProvider, withFakeCapabilities  } from '@reactionary/provider-fake';
+import { CommercetoolsCartProvider, withCommercetoolsCapabilities } from '@reactionary/provider-commercetools';
+import { AlgoliaSearchProvider, withAlgoliaCapabilities } from '@reactionary/provider-algolia';
+
+describe('client creation', () => {
+  it('should be able to mix providers and get a valid, typed client', async () => {
+    const reqCtx = createInitialRequestContext();
+    const client = new ClientBuilder(reqCtx)
+      .withCapability(
+        withFakeCapabilities(
+          {
+            jitter: {
+              mean: 0,
+              deviation: 0,
+            },
+            seeds: {
+              category: 1,
+              product: 1,
+              search: 1,
+            },
+          },
+          { product: true }
+        )
+      )
+      .withCapability(
+        withCommercetoolsCapabilities({
+         apiUrl: '',
+         authUrl: '',
+         clientId: '',
+         clientSecret: '',
+         paymentMethods: [],
+         projectKey: '',
+         scopes: [],
+         facetFieldsForSearch: []
+        }, { cart: true })
+      )
+      .withCapability(
+        withAlgoliaCapabilities({
+            apiKey: '',
+            appId: '',
+            indexName: ''
+        }, { productSearch: true })
+      )
+      .withCache(new NoOpCache())
+      .build();
+
+    expect(client.cart).toBeInstanceOf(CommercetoolsCartProvider);
+    expect(client.product).toBeInstanceOf(FakeProductProvider);
+    expect(client.productSearch).toBeInstanceOf(AlgoliaSearchProvider);
+  });
+});

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

@@ -0,0 +1,255 @@
+import 'dotenv/config';
+import { createClient, PrimaryProvider } from '../utils.js';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { ProductSearchQueryByTermSchema, type ProductSearchQueryByTerm } from '@reactionary/core';
+
+const testData = {
+  skuWithoutTiers: '0766623301831',
+  skuWithTiers: '0766623360203',
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Cart Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  describe('anonymous sessions', () => {
+    it('should get a NotFound for an unknown cart ID', async () => {
+      const cart = await client.cart.getById({
+        cart: { key: '' },
+      });
+
+      if (cart.success) {
+        assert.fail();
+      }
+
+      expect(cart.error.type).toBe('NotFound');
+    });
+
+    it('should be able to add an item to a cart', async () => {
+      const cart = await client.cart.add({
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      expect(cart.value.identifier.key).toBeDefined();
+      expect(cart.value.items.length).toBe(1);
+      expect(cart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(cart.value.items[0].quantity).toBe(1);
+
+      expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
+
+      expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
+
+      expect(cart.value.price.grandTotal.value).toBe(
+        cart.value.items[0].price.totalPrice.value
+      );
+    });
+
+    it('can add multiple different items to a cart', async () => {
+      const cart = await client.cart.add({
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+      
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      const updatedCart = await client.cart.add({
+        cart: cart.value.identifier,
+        variant: {
+          sku: testData.skuWithTiers,
+        },
+        quantity: 2,
+      });
+
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+
+      expect(updatedCart.value.items.length).toBe(2);
+      expect(updatedCart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.value.items[0].quantity).toBe(1);
+      expect(updatedCart.value.items[1].variant.sku).toBe(testData.skuWithTiers);
+      expect(updatedCart.value.items[1].quantity).toBe(2);
+    });
+
+    it('should be able to change quantity of an item in a cart', async () => {
+      const cart = await client.cart.add({
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      const updatedCart = await client.cart.changeQuantity({
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
+        quantity: 3,
+      });
+
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+
+      expect(updatedCart.value.items.length).toBe(1);
+      expect(updatedCart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.value.items[0].quantity).toBe(3);
+      expect(updatedCart.value.items[0].price.totalPrice.value).toBeGreaterThan(
+        cart.value.items[0].price.totalPrice.value
+      );
+      expect(updatedCart.value.items[0].price.unitPrice.value).toBe(
+        cart.value.items[0].price.unitPrice.value
+      );
+    });
+
+    it('should be able to remove an item from a cart', async () => {
+      const cart = await client.cart.add({
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      const updatedCart = await client.cart.remove({
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
+      });
+
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+
+      expect(updatedCart.value.items.length).toBe(0);
+    });
+
+    it('should be able to delete a cart', async () => {
+      const cart = await client.cart.add({
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      expect(cart.value.items.length).toBe(1);
+      expect(cart.value.identifier.key).toBeTruthy();
+
+      await client.cart.deleteCart({
+        cart: cart.value.identifier,
+      });
+
+      const originalCart = await client.cart.getById({
+        cart: cart.value.identifier,
+      });
+
+      if (originalCart.success) {
+        assert.fail();
+      }
+      expect(originalCart.error.type).toBe('NotFound');
+    });
+
+    it('can load the product information for cart items', async () => {
+      const cart = await client.cart.add({
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      expect(cart.value.items[0].variant).toBeDefined();
+
+      const product = await client.product.getBySKU({
+        variant: cart.value.items[0].variant,
+      });
+
+      if (!product.success) {
+        assert.fail();
+      }
+
+      expect(product).toBeTruthy();
+      if (product) {
+        expect(product.value.mainVariant.identifier.sku).toEqual(
+          cart.value.items[0].variant.sku
+        );
+      }
+    });
+
+    it('should be able to add an 50 items to a cart in less than 30 seconds', async () => {
+      const searchResult = await client.productSearch.queryByTerm(
+        ProductSearchQueryByTermSchema.parse({
+          search: {
+            term: 'cable',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 8,
+            },
+            filters: [],
+            facets: [],
+          },
+        } satisfies ProductSearchQueryByTerm)
+      );
+
+      if (!searchResult.success) {
+        assert.fail();
+      }
+
+      let cartIdentifier = undefined;
+      let cart = undefined;
+      expect(searchResult.value.items.length).toBeGreaterThanOrEqual(8);
+
+      for (const product of searchResult.value.items) {
+        const updated = await client.cart.add({
+          cart: cartIdentifier,
+          variant: {
+            sku: product.variants[0].variant.sku,
+          },
+          quantity: 1,
+        });
+
+        if (!updated.success) {
+          assert.fail();
+        }
+
+        cart = updated;
+        cartIdentifier = updated.value.identifier;
+      }
+
+      if (cart) {
+        expect(cart.value.identifier.key).toBeDefined();
+        expect(cart.value.items.length).toBe(8);
+
+        expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
+        expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
+      } else {
+        throw new Error('Cart is undefined');
+      }
+    }, 30000);
+  });
+});

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

@@ -0,0 +1,193 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+const testData = {
+  topCategories: [
+    {
+      key: '2833',
+      name: 'Computers & Peripherals',
+      slug: 'computers-and-peripherals',
+      text: 'Computers & Peripherals',
+    },
+    {
+      key: '9541',
+      name: 'Computer Spare Parts & Accessories',
+    },
+  ],
+
+  childCategoriesOfFirstTopcategory: [
+    { key: '225', name: 'Printers & Scanners' },
+    { key: '830', name: 'Computer Cables' },
+  ],
+
+  breadCrumb: ['2833', '225'],
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  it('should be able to get top-categories', async () => {
+    const result = await client.category.findTopCategories({
+      paginationOptions: { pageSize: 10, pageNumber: 1 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe(testData.topCategories[0].key);
+    expect(result.value.items[0].name).toBe(testData.topCategories[0].name);
+
+    expect(result.value.items[1].identifier.key).toBe(testData.topCategories[1].key);
+    expect(result.value.items[1].name).toBe(testData.topCategories[1].name);
+  });
+
+  it('should be able to get child categories for a category', async () => {
+    const result = await client.category.findChildCategories({
+      parentId: { key: testData.topCategories[0].key },
+      paginationOptions: { pageSize: 10, pageNumber: 1 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].key
+    );
+    expect(result.value.items[0].name).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].name
+    );
+
+    expect(result.value.items[1].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[1].key
+    );
+    expect(result.value.items[1].name).toBe(
+      testData.childCategoriesOfFirstTopcategory[1].name
+    );
+  });
+
+  it('should be able to get child categories for a category, paged', async () => {
+    let result = await client.category.findChildCategories({
+      parentId: { key: testData.topCategories[0].key },
+      paginationOptions: { pageSize: 1, pageNumber: 1 },
+    });
+    
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].key
+    );
+    expect(result.value.items[0].name).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].name
+    );
+    expect(result.value.totalCount).toBe(3);
+    expect(result.value.totalPages).toBe(3);
+    expect(result.value.pageSize).toBe(1);
+    expect(result.value.pageNumber).toBe(1);
+
+    result = await client.category.findChildCategories({
+      parentId: { key: testData.topCategories[0].key },
+      paginationOptions: { pageSize: 1, pageNumber: 2 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[1].key
+    );
+    expect(result.value.items[0].name).toBe(
+      testData.childCategoriesOfFirstTopcategory[1].name
+    );
+    expect(result.value.totalCount).toBe(3);
+    expect(result.value.totalPages).toBe(3);
+    expect(result.value.pageSize).toBe(1);
+    expect(result.value.pageNumber).toBe(2);
+  });
+
+  it('can load all breadcrumbs for a category', async () => {
+    const leaf = testData.breadCrumb[testData.breadCrumb.length - 1];
+    const result = await client.category.getBreadcrumbPathToCategory({
+      id: { key: leaf! },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.length).toBe(testData.breadCrumb.length);
+    for (let i = 0; i < testData.breadCrumb.length; i++) {
+      expect(result.value[i].identifier.key).toBe(testData.breadCrumb[i]);
+    }
+  });
+
+  it('should be able to get a category by slug', async () => {
+    const result = await client.category.getBySlug({
+      slug: testData.topCategories[0].slug!,
+    });
+    
+    if (!result.success) {
+      assert.fail();
+    }
+
+    if (result) {
+      expect(result.value.identifier.key).toBe(testData.topCategories[0].key);
+      expect(result.value.name).toBe(testData.topCategories[0].name);
+      expect(result.value.slug).toBe(testData.topCategories[0].slug);
+      expect(result.value.parentCategory).toBeUndefined();
+      expect(result.value.text).not.toBe('');
+    }
+  });
+
+  it('returns NotFound if looking for slug that does not exist', async () => {
+    const result = await client.category.getBySlug({ slug: 'non-existent-slug' });
+    
+    if (result.success) {
+      assert.fail();
+    }
+
+    expect(result.error.type).toBe('NotFound');
+  });
+
+  it('should be able to get a category by id', async () => {
+    const result = await client.category.getById({
+      id: { key: testData.topCategories[0].key },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe(testData.topCategories[0].key);
+    expect(result.value.name).toBe(testData.topCategories[0].name);
+    expect(result.value.slug).toBe(testData.topCategories[0].slug);
+    expect(result.value.parentCategory).toBeUndefined();
+
+    expect(result.value.text).toBe(testData.topCategories[0].text);
+  });
+
+  it('returns NotFound if you search for a category that does not exist', async () => {
+    const result = await client.category.getById({
+      id: { key: 'non-existent-category' },
+    });
+    
+    if (result.success) {
+      assert.fail();
+    }
+
+    expect(result.error.type).toBe('NotFound');
+  });
+});