@reactionary/examples-node 0.2.1 → 0.2.3

package/package.json

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

package/src/capabilities/order-search.spec.ts

@@ -0,0 +1,159 @@
+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: '',
+  sku: '0766623301831'
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])(
+  'Order Search Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    // Technically, i should create a bunch of orders first, but a) that would make the test way longer, and b) they would all be on the same day with same statuses.
+    it('can be called by anonymous users', async () => {
+      const result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+    });
+
+    it('can be called by guest users', async () => {
+      const updatedCart = await client.cart.add(
+              {
+                quantity: 1,
+                variant: {
+                  sku: testData.sku
+                },
+              }
+            );
+      const identity = await client.identity.getSelf({});
+
+      if (!identity.success) {
+        assert.fail();
+      }
+
+      expect(identity.value.type).toBe('Guest');
+
+      const result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+    });
+
+    it('can be called by an authenticated user', 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 result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+
+    });
+    it.skip('can filter by startDate', async () => {
+      /** TODO */
+    });
+
+    it.skip('can filter by endDate', async () => {
+      /** TODO */
+    });
+
+    it.skip('can filter by orderStatus', async () => {
+      /** TODO */
+    });
+
+    it.skip('can filter by multiple orderStatuses', async () => {
+      /** TODO */
+    });
+
+    it.skip('can filter by partNumber', async () => {
+      /** TODO */
+    });
+
+
+    it.skip('can page the resultset', async () => {
+      const result = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+
+      const result2 = await client.orderSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 2,
+            pageSize: 2,
+          },
+          filters: [],
+        },
+      });
+
+      if (!result2.success) {
+        assert.fail(JSON.stringify(result2.error));
+      }
+
+      expect(result.value.items[0].identifier).not.toBe(
+        result2.value.items[0].identifier
+      );
+    });
+  }
+
+);

package/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/src/capabilities/profile.spec.ts

@@ -1,28 +1,316 @@
 import 'dotenv/config';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { createClient, PrimaryProvider } from '../utils.js';
+import { IdentityIdentifierSchema, type Address, type Identity, type IdentityIdentifier, type Profile } from '@reactionary/core';
 
-describe.each([PrimaryProvider.COMMERCETOOLS])('Profile Capability - %s', (provider) => {
-  let client: ReturnType<typeof createClient>;
+describe.each([PrimaryProvider.MEDUSA, PrimaryProvider.COMMERCETOOLS])(
+  'Profile Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+    let identity: Identity | null = null;
+    let identityIdentifier: IdentityIdentifier | null = null;
 
-  beforeEach(() => {
-    client = createClient(provider);
-  });
+    beforeEach(async () => {
+      client = createClient(provider);
+      const time = new Date().getTime();
 
-  it('should be able to fetch the profile for the current user', async () => {
-    const time = new Date().getTime();
+      const identityResponse = await client.identity.register({
+        username: `martin.rogne+test-${time}@solteq.com`,
+        password: 'love2test',
+      });
 
-    await client.identity.register({
-      username: `martin.rogne+test-${time}@solteq.com`,
-      password: 'love2test',
+      if (!identityResponse.success) {
+        assert.fail();
+      }
+
+      identity = identityResponse.value;
+      if (identity.type !== 'Registered') {
+        assert.fail();
+      }
+      identityIdentifier = identity.id;
+    });
+
+    it('should be able to fetch the profile for the current user', async () => {
+      const time = new Date().getTime();
+      if (!identity) {
+        assert.fail();
+      }
+
+      if (identity.type !== 'Registered') {
+        assert.fail();
+      }
+
+      const profile = await client.profile.getById({
+        identifier: identity.id,
+      });
+
+      if (!profile.success) {
+        console.log(profile.error);
+        assert.fail();
+      }
+
+      expect(profile.value.email).toContain('martin.rogne');
+    });
+
+    it('should be able to update the profile for the current user', async () => {
+
+      const time = new Date().getTime();
+      const updatedProfile = await client.profile.update({
+        identifier: identityIdentifier!,
+        phone: '+4712345678',
+        email: `martin.rogne+test-${time}-a@solteq.com`,
+      });
+
+      if (!updatedProfile.success) {
+        console.log(updatedProfile.error);
+        assert.fail();
+      }
+
+      expect(updatedProfile.value.email).toBe(
+        `martin.rogne+test-${time}-a@solteq.com`
+      );
+      expect(updatedProfile.value.phone).toBe('+4712345678');
+      expect(updatedProfile.value.billingAddress).toBeUndefined();
     });
 
-    const profile = await client.profile.getSelf({});
+    it('should be able to set the billing address on the profile', async () => {
+      if (!identity) {
+        assert.fail();
+      }
 
-    if (!profile.success) {
-      assert.fail();
-    }
+      if (identity.type !== 'Registered') {
+        assert.fail();
+      }
+      const newAddress: Address = {
+        identifier: {
+          nickName: 'Billing',
+        },
+        firstName: 'Jane',
+        lastName: 'Doe',
+        streetAddress: 'Second Street',
+        streetNumber: '456',
+        city: 'Gotham',
+        region: 'State',
+        postalCode: '67890',
+        countryCode: 'US',
+      };
+      const updatedProfile = await client.profile.setBillingAddress({
+        identifier: identity.id,
+        address: newAddress,
+      });
 
-    expect(profile.value.email).toContain('martin.rogne');
-  });
-});
+      if (!updatedProfile.success) {
+        console.log(updatedProfile.error);
+        assert.fail();
+      }
+      expect(updatedProfile.value.billingAddress).toMatchObject(newAddress);
+    });
+
+    it('cannot use same nickname for billing and shipping addresses', async () => {
+      if (!identity) {
+        assert.fail();
+      }
+
+      if (identity.type !== 'Registered') {
+        assert.fail();
+      }
+      const newAddress: Address = {
+        identifier: {
+          nickName: 'SameNick',
+        },
+        firstName: 'Jane',
+        lastName: 'Doe',
+        streetAddress: 'Second Street',
+        streetNumber: '456',
+        city: 'Gotham',
+        region: 'State',
+        postalCode: '67890',
+        countryCode: 'US',
+      };
+      const billingAddressResponse = await client.profile.setBillingAddress({
+        identifier: identity.id,
+        address: newAddress,
+      });
+
+      if (!billingAddressResponse.success) {
+        console.log(billingAddressResponse.error);
+        assert.fail();
+      }
+
+      const shippingAddressResponse = await client.profile.addShippingAddress({
+        identifier: identity.id,
+        address: newAddress,
+      });
+      expect(shippingAddressResponse.success).toBe(false);
+    });
+
+    it('cannot set the billing address to an existing shipping address', async () => {
+      if (!identity) {
+        assert.fail();
+      }
+
+      if (identity.type !== 'Registered') {
+        assert.fail();
+      }
+      const newAddress: Address = {
+        identifier: {
+          nickName: 'SameNick',
+        },
+        firstName: 'Jane',
+        lastName: 'Doe',
+        streetAddress: 'Second Street',
+        streetNumber: '456',
+        city: 'Gotham',
+        region: 'State',
+        postalCode: '67890',
+        countryCode: 'US',
+      };
+      const shippingAddressResponse = await client.profile.addShippingAddress({
+        identifier: identity.id,
+        address: newAddress,
+      });
+
+      if (!shippingAddressResponse.success) {
+        console.log(shippingAddressResponse.error);
+        assert.fail();
+      }
+
+      const billingAddress = await client.profile.setBillingAddress({
+        identifier: identity.id,
+        address: shippingAddressResponse.value.alternateShippingAddresses[0]
+      });
+      expect(billingAddress.success).toBe(false);
+    });
+
+
+    it('should be able to add a shipping address to the profile', async () => {
+      if (!identity) {
+        assert.fail();
+      }
+
+      if (identity.type !== 'Registered') {
+        assert.fail();
+      }
+
+      const newAddress: Address = {
+        identifier: {
+          nickName: 'Home',
+        },
+        firstName: 'John',
+        lastName: 'Doe',
+        streetAddress: 'Main Street',
+        streetNumber: '123',
+        city: 'Metropolis',
+        region: 'State',
+        postalCode: '12345',
+        countryCode: 'US',
+      };
+      const updatedProfile = await client.profile.addShippingAddress({
+        identifier: identity.id,
+        address: newAddress,
+      });
+
+      if (!updatedProfile.success) {
+        console.log(updatedProfile.error);
+        assert.fail();
+      }
+      expect(updatedProfile.value.shippingAddress).toBeUndefined();
+
+      expect(updatedProfile.value.alternateShippingAddresses.length).toBe(1);
+      expect(updatedProfile.value.alternateShippingAddresses[0]).toMatchObject(
+        newAddress
+      );
+    });
+
+    describe('Shipping Addresses', () => {
+      const newAddress: Address = {
+        identifier: {
+          nickName: 'Home',
+        },
+        firstName: 'John',
+        lastName: 'Doe',
+        streetAddress: 'Main Street',
+        streetNumber: '123',
+        city: 'Metropolis',
+        region: 'State',
+        postalCode: '12345',
+        countryCode: 'US',
+      };
+      let profile: Profile | null;
+
+      beforeEach(async () => {
+        const updatedProfile = await client.profile.addShippingAddress({
+          identifier: identityIdentifier!,
+          address: newAddress,
+        });
+
+        if (!updatedProfile.success) {
+          console.log(updatedProfile.error);
+          assert.fail();
+        }
+
+        profile = updatedProfile.value;
+      });
+
+      it('can make a shipping address the default address', async () => {
+        const addressToMakeDefault =
+          profile!.alternateShippingAddresses[0];
+
+        const updatedProfile = await client.profile.makeShippingAddressDefault({
+          identifier: identityIdentifier!,
+          addressIdentifier: addressToMakeDefault.identifier,
+        });
+
+        if (!updatedProfile.success) {
+          console.log(updatedProfile.error);
+          assert.fail();
+        }
+        expect(updatedProfile.value.shippingAddress).toBeDefined();
+        expect(updatedProfile.value.shippingAddress).toMatchObject(newAddress);
+        expect(updatedProfile.value.alternateShippingAddresses.length).toBe(0);
+      });
+
+      it('can remove a shipping address from the profile', async () => {
+        const addressToRemove =
+          profile!.alternateShippingAddresses[0];
+
+        const updatedProfile = await client.profile.removeShippingAddress({
+          identifier: identityIdentifier!,
+          addressIdentifier: addressToRemove.identifier,
+        });
+        if (!updatedProfile.success) {
+          console.log(updatedProfile.error);
+          assert.fail();
+        }
+
+        expect(updatedProfile.value.alternateShippingAddresses.length).toBe(0);
+      });
+
+      it('can remove a shipping address from the profile even if it is the default shipping address', async () => {
+        const makeDefaultResponse = await client.profile.makeShippingAddressDefault({
+          identifier: identityIdentifier!,
+          addressIdentifier: profile!.alternateShippingAddresses[0].identifier,
+        });
+        if (!makeDefaultResponse.success) {
+          console.log(makeDefaultResponse.error);
+          assert.fail();
+        }
+
+        const profileWithDefault = makeDefaultResponse.value;
+        const addressToRemove = profileWithDefault.shippingAddress!;
+
+        const updatedProfile = await client.profile.removeShippingAddress({
+          identifier: identityIdentifier!,
+          addressIdentifier: addressToRemove.identifier,
+        });
+
+        if (!updatedProfile.success) {
+          console.log(updatedProfile.error);
+          assert.fail();
+        }
+        expect(updatedProfile.value.shippingAddress).toBeUndefined();
+        expect(updatedProfile.value.alternateShippingAddresses.length).toBe(0);
+      });
+    });
+  }
+);

package/src/utils.ts

@@ -6,6 +6,7 @@ import {
 import type { CommercetoolsConfiguration } from '@reactionary/provider-commercetools';
 import { withCommercetoolsCapabilities } from '@reactionary/provider-commercetools';
 import { withAlgoliaCapabilities } from '@reactionary/provider-algolia';
+import { withMedusaCapabilities } from '@reactionary/provider-medusa';
 
 export function getAlgoliaTestConfiguration() {
   return {
@@ -63,22 +64,46 @@ export enum PrimaryProvider {
 export function createClient(provider: PrimaryProvider) {
   const context = createInitialRequestContext();
   let builder = new ClientBuilder(context)
-    .withCache(new NoOpCache())
-    .withCapability(
-      withCommercetoolsCapabilities(getCommercetoolsTestConfiguration(), {
-        cart: true,
-        product: true,
-        category: true,
-        checkout: true,
-        identity: true,
-        inventory: true,
-        order: true,
-        price: true,
-        productSearch: true,
-        store: true,
-        profile: true,
-      })
-    );
+    .withCache(new NoOpCache());
+
+    if (provider === PrimaryProvider.MEDUSA) {
+      builder = builder.withCapability(
+        withMedusaCapabilities( getMedusaTestConfiguration(), {
+          cart: true,
+          product: true,
+          category: true,
+          checkout: true,
+          identity: true,
+          inventory: true,
+          order: true,
+          price: true,
+          productSearch: true,
+          store: true,
+          profile: true
+        })
+      );
+    }
+
+
+
+    if (provider === PrimaryProvider.COMMERCETOOLS) {
+      builder = builder.withCapability(
+        withCommercetoolsCapabilities(getCommercetoolsTestConfiguration(), {
+          cart: true,
+          product: true,
+          category: true,
+          checkout: true,
+          identity: true,
+          inventory: true,
+          order: true,
+          price: true,
+          productSearch: true,
+          store: true,
+          profile: true,
+        })
+      );
+    }
+
 
   if (provider === PrimaryProvider.ALGOLIA) {
     builder = builder.withCapability(