@reactionary/examples-node 0.1.13 → 0.2.1

package/src/capabilities/checkout.spec.ts

@@ -4,7 +4,7 @@ import {
   PaymentInstructionSchema,
   ShippingInstructionSchema,
 } from '@reactionary/core';
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { createClient, PrimaryProvider } from '../utils.js';
 
 const testData = {
@@ -12,34 +12,38 @@ const testData = {
   skuWithTiers: '0766623360203',
 };
 
-describe.each([PrimaryProvider.COMMERCETOOLS])('Checkout Capability - %s', (provider) => {
-  let client: ReturnType<typeof createClient>;
+describe.each([PrimaryProvider.COMMERCETOOLS])(
+  'Checkout Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
 
-  beforeEach(() => {
-    client = createClient(provider);
-  });
+    beforeEach(() => {
+      client = createClient(provider);
+    });
 
-  describe('anonymous sessions', () => {
-    let cart: Cart;
+    describe('anonymous sessions', () => {
+      let cart: Cart;
 
-    beforeEach(async () => {
-      cart = await client.cart.add(
-        {
-          cart: { key: '' },
+      beforeEach(async () => {
+        const c = await client.cart.add({
           variant: {
             sku: testData.skuWithoutTiers,
           },
           quantity: 1,
-        },
-      );
-    });
+        });
+
+        if (!c.success) {
+          assert.fail();
+        }
 
-    it('can create a checkout session from a cart', async () => {
-      //  we have either an anonymous user, or an authenticated user.
-      // if it is anonymous, we assume you will have collected some basic info by now ?
+        cart = c.value;
+      });
+
+      it('can create a checkout session from a cart', async () => {
+        //  we have either an anonymous user, or an authenticated user.
+        // if it is anonymous, we assume you will have collected some basic info by now ?
 
-      const checkout = await client.checkout.initiateCheckoutForCart(
-        {
+        const checkout = await client.checkout.initiateCheckoutForCart({
           cart: cart,
           billingAddress: {
             countryCode: 'US',
@@ -53,21 +57,27 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Checkout Capability - %s', (prov
           },
           notificationEmail: 'sample@example.com',
           notificationPhone: '+4512345678',
+        });
+
+        if (!checkout.success) {
+          assert.fail();
         }
-      );
 
-      expect(checkout.identifier.key).toBeDefined();
-      expect(checkout.originalCartReference.key).toBe(cart.identifier.key);
-      expect(checkout.billingAddress?.firstName).toBe('John');
-      expect(checkout.items.length).toBe(1);
-      expect(checkout.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-    });
+        expect(checkout.value.identifier.key).toBeDefined();
+        expect(checkout.value.originalCartReference.key).toBe(
+          cart.identifier.key
+        );
+        expect(checkout.value.billingAddress?.firstName).toBe('John');
+        expect(checkout.value.items.length).toBe(1);
+        expect(checkout.value.items[0].variant.sku).toBe(
+          testData.skuWithoutTiers
+        );
+      });
 
-    describe('checkout actions', () => {
-      let checkout: Checkout;
-      beforeEach(async () => {
-        checkout = await client.checkout.initiateCheckoutForCart(
-          {
+      describe('checkout actions', () => {
+        let checkout: Checkout;
+        beforeEach(async () => {
+          const cc = await client.checkout.initiateCheckoutForCart({
             cart: cart,
             billingAddress: {
               countryCode: 'US',
@@ -81,192 +91,251 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Checkout Capability - %s', (prov
             },
             notificationEmail: 'sample@example.com',
             notificationPhone: '+4512345678',
+          });
+
+          if (!cc.success) {
+            console.log(cc);
+
+            assert.fail();
           }
-        );
-      });
 
-      it('can list payment methods', async () => {
-        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier,
+          checkout = cc.value;
+        });
+
+        it('can list payment methods', async () => {
+          const paymentMethods =
+            await client.checkout.getAvailablePaymentMethods({
+              checkout: checkout.identifier,
+            });
+
+          if (!paymentMethods.success) {
+            assert.fail();
           }
-        );
-        expect(paymentMethods.length).toBeGreaterThan(0);
-        expect(
-          paymentMethods.find((x) => x.identifier.method === 'stripe')
-        ).toBeDefined();
-      });
 
-      it('can list shipping methods', async () => {
-        const shippingMethods = await client.checkout.getAvailableShippingMethods(
-          {
-            checkout: checkout.identifier,
+          expect(paymentMethods.value.length).toBeGreaterThan(0);
+          expect(
+            paymentMethods.value.find((x) => x.identifier.method === 'stripe')
+          ).toBeDefined();
+        });
+
+        it('can list shipping methods', async () => {
+          const shippingMethods =
+            await client.checkout.getAvailableShippingMethods({
+              checkout: checkout.identifier,
+            });
+
+          if (!shippingMethods.success) {
+            assert.fail();
           }
-        );
-        expect(shippingMethods.length).toBeGreaterThan(0);
-        expect(
-          shippingMethods.find((x) => x.identifier.key === 'us-delivery')
-        ).toBeDefined();
-      });
 
-      it('can add a payment instruction', async () => {
-        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier,
+          expect(shippingMethods.value.length).toBeGreaterThan(0);
+          expect(
+            shippingMethods.value.find(
+              (x) => x.identifier.key === 'us-delivery'
+            )
+          ).toBeDefined();
+        });
+
+        it('can add a payment instruction', async () => {
+          const paymentMethods =
+            await client.checkout.getAvailablePaymentMethods({
+              checkout: checkout.identifier,
+            });
+
+          if (!paymentMethods.success) {
+            assert.fail();
           }
-        );
-        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
-        expect(pm).toBeDefined();
 
-        const checkoutWithPi = await client.checkout.addPaymentInstruction(
-          {
+          const pm = paymentMethods.value.find(
+            (x) => x.identifier.method === 'stripe'
+          );
+          expect(pm).toBeDefined();
+
+          const checkoutWithPi = await client.checkout.addPaymentInstruction({
             checkout: checkout.identifier,
             paymentInstruction: PaymentInstructionSchema.parse({
               paymentMethod: pm!.identifier,
               amount: checkout.price.grandTotal,
               protocolData: [{ key: 'test-key', value: 'test-value' }],
               identifier: {
-                key: 'pm1'
+                key: 'pm1',
               },
-              status: 'pending'
-            } satisfies Omit<PaymentInstruction, 'meta'>),
+              status: 'pending',
+            } satisfies PaymentInstruction),
+          });
+
+          if (!checkoutWithPi.success) {
+            assert.fail();
           }
-        );
 
-        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
-        expect(checkoutWithPi.paymentInstructions[0].paymentMethod.method).toBe(
-          'stripe'
-        );
-        expect(checkoutWithPi.paymentInstructions[0].protocolData.find(x => x.key === 'stripe_clientSecret')?.value).toBeDefined();
+          expect(checkoutWithPi.value.paymentInstructions.length).toBe(1);
+          expect(
+            checkoutWithPi.value.paymentInstructions[0].paymentMethod.method
+          ).toBe('stripe');
+          expect(
+            checkoutWithPi.value.paymentInstructions[0].protocolData.find(
+              (x) => x.key === 'stripe_clientSecret'
+            )?.value
+          ).toBeDefined();
+        });
 
-      });
+        it.skip('can cancel an in-progress payment', async () => {
+          const paymentMethods =
+            await client.checkout.getAvailablePaymentMethods({
+              checkout: checkout.identifier,
+            });
 
-      it.skip('can cancel an in-progress payment', async () => {
-        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier,
+          if (!paymentMethods.success) {
+            assert.fail();
           }
-        );
-        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
-        expect(pm).toBeDefined();
 
-        const checkoutWithPi = await client.checkout.addPaymentInstruction(
-          {
+          const pm = paymentMethods.value.find(
+            (x) => x.identifier.method === 'stripe'
+          );
+          expect(pm).toBeDefined();
+
+          const checkoutWithPi = await client.checkout.addPaymentInstruction({
             checkout: checkout.identifier,
             paymentInstruction: {
               paymentMethod: pm!.identifier,
               amount: checkout.price.grandTotal,
               protocolData: [{ key: 'test-key', value: 'test-value' }],
             },
+          });
+
+          if (!checkoutWithPi.success) {
+            assert.fail();
           }
-        );
 
-        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+          expect(checkoutWithPi.value.paymentInstructions.length).toBe(1);
 
-        const checkoutAfterCancel = await client.checkout.removePaymentInstruction(
-          {
-            checkout: checkout.identifier,
-            paymentInstruction:
-              checkoutWithPi.paymentInstructions[0].identifier,
+          const checkoutAfterCancel =
+            await client.checkout.removePaymentInstruction({
+              checkout: checkout.identifier,
+              paymentInstruction:
+                checkoutWithPi.value.paymentInstructions[0].identifier,
+            });
+
+          if (!checkoutAfterCancel.success) {
+            assert.fail();
           }
-        );
 
-        expect(checkoutAfterCancel.paymentInstructions.length).toBe(0);
-      });
+          expect(checkoutAfterCancel.value.paymentInstructions.length).toBe(0);
+        });
 
-      it('can set shipping address', async () => {
-        const checkoutWithShipping = await client.checkout.setShippingAddress(
-          {
-            checkout: checkout.identifier,
-            shippingAddress: {
-              countryCode: 'US',
-              firstName: 'Jane',
-              lastName: 'Doe',
-              streetAddress: '456 Other St',
-              streetNumber: '2B',
-              postalCode: '54321',
-              city: 'Othertown',
-              region: '',
-            },
+        it('can set shipping address', async () => {
+          const checkoutWithShipping = await client.checkout.setShippingAddress(
+            {
+              checkout: checkout.identifier,
+              shippingAddress: {
+                countryCode: 'US',
+                firstName: 'Jane',
+                lastName: 'Doe',
+                streetAddress: '456 Other St',
+                streetNumber: '2B',
+                postalCode: '54321',
+                city: 'Othertown',
+                region: '',
+              },
+            }
+          );
+
+          if (!checkoutWithShipping.success) {
+            assert.fail();
           }
-        );
 
-        expect(checkoutWithShipping.shippingAddress).toBeDefined();
-        expect(checkoutWithShipping.shippingAddress?.firstName).toBe('Jane');
-      });
+          expect(checkoutWithShipping.value.shippingAddress).toBeDefined();
+          expect(checkoutWithShipping.value.shippingAddress?.firstName).toBe('Jane');
+        });
 
-      it('can set shipping instructions', async () => {
-        const shippingMethods = await client.checkout.getAvailableShippingMethods(
-          {
-            checkout: checkout.identifier,
+        it('can set shipping instructions', async () => {
+          const shippingMethods =
+            await client.checkout.getAvailableShippingMethods({
+              checkout: checkout.identifier,
+            });
+
+          if (!shippingMethods.success) {
+            assert.fail();
           }
-        );
-        const sm = shippingMethods.find((x) => x.identifier.key === 'us-delivery');
-        expect(sm).toBeDefined();
-
-        const shippingInstruction = ShippingInstructionSchema.parse({
-          shippingMethod: sm?.identifier || { key: '' },
-          amount: checkout.price.totalShipping,
-          instructions: 'Leave at front door if not home',
-          consentForUnattendedDelivery: true,
-          pickupPoint: '4190asx141', // this would be a real pickup point ID in a real scenario
+
+          const sm = shippingMethods.value.find(
+            (x) => x.identifier.key === 'us-delivery'
+          );
+          expect(sm).toBeDefined();
+
+          const shippingInstruction = ShippingInstructionSchema.parse({
+            shippingMethod: sm?.identifier || { key: '' },
+            amount: checkout.price.totalShipping,
+            instructions: 'Leave at front door if not home',
+            consentForUnattendedDelivery: true,
+            pickupPoint: '4190asx141', // this would be a real pickup point ID in a real scenario
+          });
+
+          const checkoutWithShipping =
+            await client.checkout.setShippingInstruction({
+              checkout: checkout.identifier,
+              shippingInstruction,
+            });
+
+          if (!checkoutWithShipping.success) {
+            assert.fail();
+          }
+
+          expect(checkout.price.totalShipping.value).toBe(0);
+          expect(
+            checkoutWithShipping.value.price.totalShipping.value
+          ).toBeGreaterThan(0);
+          expect(checkoutWithShipping.value.shippingInstruction).toBeDefined();
+          expect(
+            checkoutWithShipping.value.shippingInstruction?.shippingMethod.key
+          ).toBe('us-delivery');
+          expect(checkoutWithShipping.value.shippingInstruction?.instructions).toBe(
+            'Leave at front door if not home'
+          );
+          expect(checkoutWithShipping.value.shippingInstruction?.pickupPoint).toBe(
+            '4190asx141'
+          );
+          expect(
+            checkoutWithShipping.value.shippingInstruction
+              ?.consentForUnattendedDelivery
+          ).toBe(true);
         });
 
-        const checkoutWithShipping = await client.checkout.setShippingInstruction(
-          {
+        it.skip('wont report it finalizable until everything is paid/authorized', async () => {
+          expect(checkout.readyForFinalization).toBe(false);
+          const r = await client.checkout.getAvailablePaymentMethods({
             checkout: checkout.identifier,
-            shippingInstruction,
+          });
+          
+          if (!r.success) {
+            assert.fail();
           }
-        );
 
-        expect(checkout.price.totalShipping.value).toBe(0);
-        expect(checkoutWithShipping.price.totalShipping.value).toBeGreaterThan(0);
-        expect(checkoutWithShipping.shippingInstruction).toBeDefined();
-        expect(
-          checkoutWithShipping.shippingInstruction?.shippingMethod.key
-        ).toBe('us-delivery');
-        expect(checkoutWithShipping.shippingInstruction?.instructions).toBe(
-          'Leave at front door if not home'
-        );
-        expect(checkoutWithShipping.shippingInstruction?.pickupPoint).toBe(
-          '4190asx141'
-        );
-        expect(
-          checkoutWithShipping.shippingInstruction?.consentForUnattendedDelivery
-        ).toBe(true);
-      });
-
-      it.skip('wont report it finalizable until everything is paid/authorized', async () => {
-        expect(checkout.readyForFinalization).toBe(false);
-        const pm = (
-          await client.checkout.getAvailablePaymentMethods(
-            {
-              checkout: checkout.identifier,
-            }
-          )
-        ).find((x) => x.identifier.method === 'stripe');
-        expect(pm).toBeDefined();
+          const pm = r.value.find((x) => x.identifier.method === 'stripe');
 
-        const checkoutWithPi = await client.checkout.addPaymentInstruction(
-          {
+          const checkoutWithPi = await client.checkout.addPaymentInstruction({
             checkout: checkout.identifier,
             paymentInstruction: {
               paymentMethod: pm!.identifier,
               amount: checkout.price.grandTotal,
               protocolData: [{ key: 'test-key', value: 'test-value' }],
             },
+          });
+
+          if (!checkoutWithPi.success) {
+            assert.fail();
           }
-        );
 
-        // do something to simulate payment authorization ?
-        const checkoutReady = await client.checkout.getById(
-          { identifier: checkoutWithPi.identifier },
-        );
-        if (!checkoutReady) {
-          expect.fail('checkout not found');
-        }
-        expect(checkoutReady.readyForFinalization).toBe(true);
+          // do something to simulate payment authorization ?
+          const checkoutReady = await client.checkout.getById({
+            identifier: checkoutWithPi.value.identifier,
+          });
+          if (!checkoutReady.success) {
+            expect.fail('checkout not found');
+          }
+          expect(checkoutReady.value.readyForFinalization).toBe(true);
+        });
       });
     });
-  });
-});
+  }
+);

package/src/capabilities/identity.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';
 
 describe.each([PrimaryProvider.COMMERCETOOLS])('Identity Capability - %s', (provider) => {
@@ -12,14 +12,16 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Identity Capability - %s', (prov
   it('should default to an anonymous identity if no operations have been performed', async () => {
     const identity = await client.identity.getSelf({});
 
-    expect(identity.type).toBe('Anonymous');
+    if (!identity.success) {
+      assert.fail();
+    }
+
+    expect(identity.value.type).toBe('Anonymous');
   });
 
   it('should automatically upgrade to guest the moment an operation is performed', async () => {
-    const cart = await client.cart.getActiveCartId();
     const updatedCart = await client.cart.add(
       {
-        cart,
         quantity: 1,
         variant: {
           sku: '0766623301831'
@@ -29,7 +31,11 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Identity Capability - %s', (prov
 
     const identity = await client.identity.getSelf({});
 
-    expect(identity.type).toBe('Guest');
+    if (!identity.success) {
+      assert.fail();
+    }
+
+    expect(identity.value.type).toBe('Guest');
   });
 
   it('should be able to register a new customer', async () => {
@@ -41,10 +47,18 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Identity Capability - %s', (prov
       }
     );
 
-    expect(identity.type).toBe('Registered');
+    if (!identity.success) {
+      assert.fail();
+    }
+
+    expect(identity.value.type).toBe('Registered');
 
     const refreshedIdentity = await client.identity.getSelf({});
-    expect(refreshedIdentity.type).toBe('Registered');
+
+    if (!refreshedIdentity.success) {
+      assert.fail();
+    }
+    expect(refreshedIdentity.value.type).toBe('Registered');
   });
 
   it('should be able to log out from a Registered identity', async () => {
@@ -56,12 +70,24 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Identity Capability - %s', (prov
       }
     );
 
-    expect(identity.type).toBe('Registered');
+    if (!identity.success) {
+      assert.fail();
+    }
+
+    expect(identity.value.type).toBe('Registered');
 
     const loggedOutIdentity = await client.identity.logout({});
-    expect(loggedOutIdentity.type).toBe('Anonymous');
+
+    if (!loggedOutIdentity.success) {
+      assert.fail();
+    }
+    expect(loggedOutIdentity.value.type).toBe('Anonymous');
 
     const refreshedIdentity = await client.identity.getSelf({});
-    expect(refreshedIdentity.type).toBe('Anonymous');
+
+    if (!refreshedIdentity.success) {
+      assert.fail();
+    }
+    expect(refreshedIdentity.value.type).toBe('Anonymous');
   });
 });

package/src/capabilities/inventory.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';
 
 describe.each([PrimaryProvider.COMMERCETOOLS])('Inventory Capability', (provider) => {
@@ -9,7 +9,7 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Inventory Capability', (provider
     client = createClient(provider);
   });
 
-  it('should return unavailable for unknown SKU', async () => {
+  it('should return NotFound for unknown SKU', async () => {
     const inventory = await client.inventory.getBySKU({
       variant: {
         sku: 'GMCT-01x',
@@ -19,16 +19,14 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Inventory Capability', (provider
       },
     });
 
-    expect(inventory.identifier.variant.sku).toBe('GMCT-01x');
-    expect(inventory.identifier.fulfillmentCenter.key).toBe(
-      'solteqPhysicalStore'
-    );
-    expect(inventory.status).toBe('outOfStock');
-    expect(inventory.quantity).toBe(0);
-    expect(inventory.meta.placeholder).toBe(true);
+    if (inventory.success) {
+      assert.fail();
+    }
+
+    expect(inventory.error.type).toBe('NotFound');
   });
 
-  it('should return unavailable for unknown ffmcenter', async () => {
+  it('should return NotFound for unknown ffmcenter', async () => {
     const inventory = await client.inventory.getBySKU({
       variant: {
         sku: 'GMCT-01',
@@ -38,15 +36,13 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Inventory Capability', (provider
       },
     });
 
-    expect(inventory.identifier.variant.sku).toBe('GMCT-01');
-    expect(inventory.identifier.fulfillmentCenter.key).toBe(
-      'unknown-ffmcenter'
-    );
-    expect(inventory.status).toBe('outOfStock');
-    expect(inventory.quantity).toBe(0);
-    expect(inventory.meta.placeholder).toBe(true);
+    if (inventory.success) {
+      assert.fail();
+    }
 
+    expect(inventory.error.type).toBe('NotFound');
   });
+
   it('should be able to fetch inventory for a given SKU and Fulfillment Center', async () => {
     const inventory = await client.inventory.getBySKU({
       variant: {
@@ -57,10 +53,14 @@ describe.each([PrimaryProvider.COMMERCETOOLS])('Inventory Capability', (provider
       },
     });
 
-    expect(inventory.identifier.variant.sku).toBe('GMCT-01');
-    expect(inventory.identifier.fulfillmentCenter.key).toBe(
+    if (!inventory.success) {
+      assert.fail();
+    }
+
+    expect(inventory.value.identifier.variant.sku).toBe('GMCT-01');
+    expect(inventory.value.identifier.fulfillmentCenter.key).toBe(
       'solteqPhysicalStore'
     );
-    expect(inventory.quantity).toBe(42);
+    expect(inventory.value.quantity).toBe(42);
   });
 });