@reactionary/examples-node 0.1.5

package/src/capabilities/category.spec.ts

@@ -0,0 +1,158 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } 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 },
+    });
+
+    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);
+
+    expect(result.items[1].identifier.key).toBe(testData.topCategories[1].key);
+    expect(result.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 },
+    });
+
+    expect(result.items.length).toBeGreaterThan(0);
+    expect(result.items[0].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].key
+    );
+    expect(result.items[0].name).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].name
+    );
+
+    expect(result.items[1].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[1].key
+    );
+    expect(result.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 },
+    });
+
+    expect(result.items.length).toBeGreaterThan(0);
+    expect(result.items[0].identifier.key).toBe(
+      testData.childCategoriesOfFirstTopcategory[0].key
+    );
+    expect(result.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);
+
+    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(
+      testData.childCategoriesOfFirstTopcategory[1].key
+    );
+    expect(result.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);
+  });
+
+  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! },
+    });
+
+    expect(result.length).toBe(testData.breadCrumb.length);
+    for (let i = 0; i < testData.breadCrumb.length; i++) {
+      expect(result[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!,
+    });
+    expect(result).toBeTruthy();
+    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);
+    }
+  });
+
+  it('returns null if looking for slug that does not exist', async () => {
+    const result = await client.category.getBySlug({ slug: 'non-existent-slug' });
+    expect(result).toBeNull();
+  });
+
+  it('should be able to get a category by id', async () => {
+    const result = await client.category.getById({
+      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();
+
+    expect(result.text).toBe(testData.topCategories[0].text);
+    expect(result.meta.placeholder).toBe(false);
+  });
+
+  it('returns a placeholder 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);
+  });
+});

package/src/capabilities/checkout.spec.ts

@@ -0,0 +1,272 @@
+import 'dotenv/config';
+import type { Cart, Checkout, PaymentInstruction } from '@reactionary/core';
+import {
+  PaymentInstructionSchema,
+  ShippingInstructionSchema,
+} from '@reactionary/core';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+const testData = {
+  skuWithoutTiers: '0766623301831',
+  skuWithTiers: '0766623360203',
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Checkout Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  describe('anonymous sessions', () => {
+    let cart: Cart;
+
+    beforeEach(async () => {
+      cart = await client.cart.add(
+        {
+          cart: { key: '' },
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1,
+        },
+      );
+    });
+
+    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(
+        {
+          cart: cart,
+          billingAddress: {
+            countryCode: 'US',
+            firstName: 'John',
+            lastName: 'Doe',
+            streetAddress: '123 Main St',
+            streetNumber: '1A',
+            postalCode: '12345',
+            city: 'Anytown',
+            region: '',
+          },
+          notificationEmail: 'sample@example.com',
+          notificationPhone: '+4512345678',
+        }
+      );
+
+      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);
+    });
+
+    describe('checkout actions', () => {
+      let checkout: Checkout;
+      beforeEach(async () => {
+        checkout = await client.checkout.initiateCheckoutForCart(
+          {
+            cart: cart,
+            billingAddress: {
+              countryCode: 'US',
+              firstName: 'John',
+              lastName: 'Doe',
+              streetAddress: '123 Main St',
+              streetNumber: '1A',
+              postalCode: '12345',
+              city: 'Anytown',
+              region: '',
+            },
+            notificationEmail: 'sample@example.com',
+            notificationPhone: '+4512345678',
+          }
+        );
+      });
+
+      it('can list payment methods', async () => {
+        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+        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(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,
+          }
+        );
+        const pm = paymentMethods.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'
+              },
+              status: 'pending'
+            } satisfies Omit<PaymentInstruction, 'meta'>),
+          }
+        );
+
+        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();
+
+      });
+
+      it.skip('can cancel an in-progress payment', async () => {
+        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+        const pm = paymentMethods.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' }],
+            },
+          }
+        );
+
+        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+
+        const checkoutAfterCancel = await client.checkout.removePaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction:
+              checkoutWithPi.paymentInstructions[0].identifier,
+          }
+        );
+
+        expect(checkoutAfterCancel.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: '',
+            },
+          }
+        );
+
+        expect(checkoutWithShipping.shippingAddress).toBeDefined();
+        expect(checkoutWithShipping.shippingAddress?.firstName).toBe('Jane');
+      });
+
+      it('can set shipping instructions', async () => {
+        const shippingMethods = await client.checkout.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+        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 checkoutWithShipping = await client.checkout.setShippingInstruction(
+          {
+            checkout: checkout.identifier,
+            shippingInstruction,
+          }
+        );
+
+        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 checkoutWithPi = await client.checkout.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: {
+              paymentMethod: pm!.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            },
+          }
+        );
+
+        // 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);
+      });
+    });
+  });
+});

package/src/capabilities/identity.spec.ts

@@ -0,0 +1,67 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Identity Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  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');
+  });
+
+  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'
+        },
+      }
+    );
+
+    const identity = await client.identity.getSelf({});
+
+    expect(identity.type).toBe('Guest');
+  });
+
+  it('should be able to register a new customer', async () => {
+    const time = new Date().getTime();
+    const identity = await client.identity.register(
+      {
+        username: `test-user+${time}@example.com`,
+        password: 'love2test',
+      }
+    );
+
+    expect(identity.type).toBe('Registered');
+
+    const refreshedIdentity = await client.identity.getSelf({});
+    expect(refreshedIdentity.type).toBe('Registered');
+  });
+
+  it('should be able to log out from a Registered identity', async () => {
+    const time = new Date().getTime();
+    const identity = await client.identity.register(
+      {
+        username: `test-user+${time}@example.com`,
+        password: 'love2test',
+      }
+    );
+
+    expect(identity.type).toBe('Registered');
+
+    const loggedOutIdentity = await client.identity.logout({});
+    expect(loggedOutIdentity.type).toBe('Anonymous');
+
+    const refreshedIdentity = await client.identity.getSelf({});
+    expect(refreshedIdentity.type).toBe('Anonymous');
+  });
+});

package/src/capabilities/inventory.spec.ts

@@ -0,0 +1,66 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Inventory Capability', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  it('should return unavailable for unknown SKU', async () => {
+    const inventory = await client.inventory.getBySKU({
+      variant: {
+        sku: 'GMCT-01x',
+      },
+      fulfilmentCenter: {
+        key: 'solteqPhysicalStore',
+      },
+    });
+
+    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);
+  });
+
+  it('should return unavailable for unknown ffmcenter', async () => {
+    const inventory = await client.inventory.getBySKU({
+      variant: {
+        sku: 'GMCT-01',
+      },
+      fulfilmentCenter: {
+        key: 'unknown-ffmcenter',
+      },
+    });
+
+    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);
+
+  });
+  it('should be able to fetch inventory for a given SKU and Fulfillment Center', async () => {
+    const inventory = await client.inventory.getBySKU({
+      variant: {
+        sku: 'GMCT-01',
+      },
+      fulfilmentCenter: {
+        key: 'solteqPhysicalStore',
+      },
+    });
+
+    expect(inventory.identifier.variant.sku).toBe('GMCT-01');
+    expect(inventory.identifier.fulfillmentCenter.key).toBe(
+      'solteqPhysicalStore'
+    );
+    expect(inventory.quantity).toBe(42);
+  });
+});

package/src/capabilities/price.spec.ts

@@ -0,0 +1,41 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } 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 } });
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+      expect(result.unitPrice.value).toBe(155.1);
+      expect(result.unitPrice.currency).toBe('USD');
+      expect(result.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 } });
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+      expect(result.unitPrice.value).toBeGreaterThan(200);
+      expect(result.unitPrice.currency).toBe('USD');
+      expect(result.tieredPrices.length).toBe(0);
+    }
+  });
+});