@reactionary/examples-node 0.1.12 → 0.2.1

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@reactionary/examples-node",
-  "version": "0.1.12",
+  "version": "0.2.1",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.1.12",
-    "@reactionary/provider-commercetools": "0.1.12",
-    "@reactionary/provider-algolia": "0.1.12",
-    "@reactionary/provider-medusa": "0.1.12"
+    "@reactionary/core": "0.2.1",
+    "@reactionary/provider-commercetools": "0.2.1",
+    "@reactionary/provider-algolia": "0.2.1"
   },
   "type": "module"
 }

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

@@ -7,7 +7,7 @@ import {
   type RequestContext,
 } from '@reactionary/core';
 import { withFakeCapabilities } from '@reactionary/provider-fake';
-import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { assert, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
 describe('basic node setup', () => {
   let client: Partial<Client>;
@@ -47,8 +47,12 @@ describe('basic node setup', () => {
         slug: '1234',
       }
     );
+    
+    if (!product.success) {
+      assert.fail();
+    }
 
     expect(product).toBeDefined();
-    expect(product!.slug).toBe('1234');
+    expect(product.value.slug).toBe('1234');
   });
 });

package/src/capabilities/cart.spec.ts

@@ -1,6 +1,6 @@
 import 'dotenv/config';
 import { createClient, PrimaryProvider } from '../utils.js';
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { ProductSearchQueryByTermSchema, type ProductSearchQueryByTerm } from '@reactionary/core';
 
 const testData = {
@@ -16,161 +16,192 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Cart Capability - %s', (provider
   });
 
   describe('anonymous sessions', () => {
-    it('should be able to get an empty cart', async () => {
+    it('should get a NotFound for an unknown cart ID', async () => {
       const cart = await client.cart.getById({
         cart: { key: '' },
       });
 
-      expect(cart.identifier.key).toBeFalsy();
-      expect(cart.items.length).toBe(0);
-      expect(cart.meta?.placeholder).toBe(true);
+      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({
-        cart: { key: '' },
         variant: {
           sku: testData.skuWithoutTiers,
         },
         quantity: 1,
       });
 
-      expect(cart.identifier.key).toBeDefined();
-      expect(cart.items.length).toBe(1);
-      expect(cart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-      expect(cart.items[0].quantity).toBe(1);
+      if (!cart.success) {
+        assert.fail();
+      }
 
-      expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
+      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.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
 
-      expect(cart.price.grandTotal.value).toBe(
-        cart.items[0].price.totalPrice.value
-      );
+      expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
 
-      expect(cart.meta?.placeholder).toBeFalsy();
+      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({
-        cart: { key: '' },
         variant: {
           sku: testData.skuWithoutTiers,
         },
         quantity: 1,
       });
+      
+      if (!cart.success) {
+        assert.fail();
+      }
 
       const updatedCart = await client.cart.add({
-        cart: cart.identifier,
+        cart: cart.value.identifier,
         variant: {
           sku: testData.skuWithTiers,
         },
         quantity: 2,
       });
 
-      expect(updatedCart.items.length).toBe(2);
-      expect(updatedCart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(1);
-      expect(updatedCart.items[1].variant.sku).toBe(testData.skuWithTiers);
-      expect(updatedCart.items[1].quantity).toBe(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({
-        cart: { key: '' },
         variant: {
           sku: testData.skuWithoutTiers,
         },
         quantity: 1,
       });
 
+      if (!cart.success) {
+        assert.fail();
+      }
+
       const updatedCart = await client.cart.changeQuantity({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
         quantity: 3,
       });
 
-      expect(updatedCart.items.length).toBe(1);
-      expect(updatedCart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(3);
+      if (!updatedCart.success) {
+        assert.fail();
+      }
 
-      expect(updatedCart.items[0].price.totalPrice.value).toBeGreaterThan(
-        cart.items[0].price.totalPrice.value
+      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.items[0].price.unitPrice.value).toBe(
-        cart.items[0].price.unitPrice.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({
-        cart: { key: '' },
         variant: {
           sku: testData.skuWithoutTiers,
         },
         quantity: 1,
       });
 
+      if (!cart.success) {
+        assert.fail();
+      }
+
       const updatedCart = await client.cart.remove({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
       });
 
-      expect(updatedCart.items.length).toBe(0);
+      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({
-        cart: { key: '' },
         variant: {
           sku: testData.skuWithoutTiers,
         },
         quantity: 1,
       });
 
-      expect(cart.items.length).toBe(1);
-      expect(cart.identifier.key).toBeTruthy();
+      if (!cart.success) {
+        assert.fail();
+      }
 
-      const deletedCart = await client.cart.deleteCart({
-        cart: cart.identifier,
-      });
+      expect(cart.value.items.length).toBe(1);
+      expect(cart.value.identifier.key).toBeTruthy();
 
-      expect(deletedCart.items.length).toBe(0);
-      expect(deletedCart.identifier.key).toBe('');
+      await client.cart.deleteCart({
+        cart: cart.value.identifier,
+      });
 
       const originalCart = await client.cart.getById({
-        cart: cart.identifier,
+        cart: cart.value.identifier,
       });
 
-      expect(originalCart.items.length).toBe(0);
+      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({
-        cart: { key: '' },
         variant: {
           sku: testData.skuWithoutTiers,
         },
         quantity: 1,
       });
-      expect(cart.items[0].variant).toBeDefined();
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      expect(cart.value.items[0].variant).toBeDefined();
 
       const product = await client.product.getBySKU({
-        variant: cart.items[0].variant,
+        variant: cart.value.items[0].variant,
       });
+
+      if (!product.success) {
+        assert.fail();
+      }
+
       expect(product).toBeTruthy();
       if (product) {
-        expect(product.mainVariant.identifier.sku).toEqual(
-          cart.items[0].variant.sku
+        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 () => {
-      let cart = await client.cart.getById({
-        cart: { key: '' },
-      });
-
       const searchResult = await client.productSearch.queryByTerm(
         ProductSearchQueryByTermSchema.parse({
           search: {
@@ -184,25 +215,38 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Cart Capability - %s', (provider
           },
         } satisfies ProductSearchQueryByTerm)
       );
-      expect(searchResult.items.length).toBeGreaterThanOrEqual(8);
 
-      for (const product of searchResult.items) {
-        cart = await client.cart.add({
-          cart: cart.identifier,
+      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.identifier.key).toBeDefined();
-        expect(cart.items.length).toBe(8);
+        expect(cart.value.identifier.key).toBeDefined();
+        expect(cart.value.items.length).toBe(8);
 
-        expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
-        expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-        expect(cart.meta?.placeholder).toBeFalsy();
+        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');
       }

package/src/capabilities/category.spec.ts

@@ -1,5 +1,5 @@
 import 'dotenv/config';
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { createClient, PrimaryProvider } from '../utils.js';
 
 const testData = {
@@ -36,12 +36,16 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (prov
       paginationOptions: { pageSize: 10, pageNumber: 1 },
     });
 
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.items[0].name).toBe(testData.topCategories[0].name);
+    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.items[1].identifier.key).toBe(testData.topCategories[1].key);
-    expect(result.items[1].name).toBe(testData.topCategories[1].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 () => {
@@ -50,18 +54,22 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (prov
       paginationOptions: { pageSize: 10, pageNumber: 1 },
     });
 
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(
+    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.items[0].name).toBe(
+    expect(result.value.items[0].name).toBe(
       testData.childCategoriesOfFirstTopcategory[0].name
     );
 
-    expect(result.items[1].identifier.key).toBe(
+    expect(result.value.items[1].identifier.key).toBe(
       testData.childCategoriesOfFirstTopcategory[1].key
     );
-    expect(result.items[1].name).toBe(
+    expect(result.value.items[1].name).toBe(
       testData.childCategoriesOfFirstTopcategory[1].name
     );
   });
@@ -71,35 +79,43 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (prov
       parentId: { key: testData.topCategories[0].key },
       paginationOptions: { pageSize: 1, pageNumber: 1 },
     });
+    
+    if (!result.success) {
+      assert.fail();
+    }
 
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe(
       testData.childCategoriesOfFirstTopcategory[0].key
     );
-    expect(result.items[0].name).toBe(
+    expect(result.value.items[0].name).toBe(
       testData.childCategoriesOfFirstTopcategory[0].name
     );
-    expect(result.totalCount).toBe(3);
-    expect(result.totalPages).toBe(3);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(1);
+    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 },
     });
 
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(
+    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.items[0].name).toBe(
+    expect(result.value.items[0].name).toBe(
       testData.childCategoriesOfFirstTopcategory[1].name
     );
-    expect(result.totalCount).toBe(3);
-    expect(result.totalPages).toBe(3);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(2);
+    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 () => {
@@ -108,9 +124,13 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (prov
       id: { key: leaf! },
     });
 
-    expect(result.length).toBe(testData.breadCrumb.length);
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.length).toBe(testData.breadCrumb.length);
     for (let i = 0; i < testData.breadCrumb.length; i++) {
-      expect(result[i].identifier.key).toBe(testData.breadCrumb[i]);
+      expect(result.value[i].identifier.key).toBe(testData.breadCrumb[i]);
     }
   });
 
@@ -118,20 +138,28 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (prov
     const result = await client.category.getBySlug({
       slug: testData.topCategories[0].slug!,
     });
-    expect(result).toBeTruthy();
+    
+    if (!result.success) {
+      assert.fail();
+    }
+
     if (result) {
-      expect(result.identifier.key).toBe(testData.topCategories[0].key);
-      expect(result.name).toBe(testData.topCategories[0].name);
-      expect(result.slug).toBe(testData.topCategories[0].slug);
-      expect(result.parentCategory).toBeUndefined();
-      expect(result.text).not.toBe('');
-      expect(result.meta.placeholder).toBe(false);
+      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 null if looking for slug that does not exist', async () => {
+  it('returns NotFound if looking for slug that does not exist', async () => {
     const result = await client.category.getBySlug({ slug: 'non-existent-slug' });
-    expect(result).toBeNull();
+    
+    if (result.success) {
+      assert.fail();
+    }
+
+    expect(result.error.type).toBe('NotFound');
   });
 
   it('should be able to get a category by id', async () => {
@@ -139,20 +167,27 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Category Capability - %s', (prov
       id: { key: testData.topCategories[0].key },
     });
 
-    expect(result.identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.name).toBe(testData.topCategories[0].name);
-    expect(result.slug).toBe(testData.topCategories[0].slug);
-    expect(result.parentCategory).toBeUndefined();
+    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.text).toBe(testData.topCategories[0].text);
-    expect(result.meta.placeholder).toBe(false);
+    expect(result.value.text).toBe(testData.topCategories[0].text);
   });
 
-  it('returns a placeholder if you search for a category that does not exist', async () => {
+  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' },
     });
-    expect(result.identifier.key).toBe('non-existent-category');
-    expect(result.meta.placeholder).toBe(true);
+    
+    if (result.success) {
+      assert.fail();
+    }
+
+    expect(result.error.type).toBe('NotFound');
   });
 });