@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,122 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+const testData = {
+  product: {
+    id: 'product_10959528',
+    name: 'Manhattan 170703 cable accessory Cable kit',
+    image: 'https://images.icecat.biz/img/norm/high/10959528-2837.jpg',
+    sku: '0766623170703',
+    slug: 'manhattan-170703-cable-accessory-cable-kit-10959528',
+  },
+  productWithMultiVariants: {
+    slug: 'hp-gk859aa-mouse-office-bluetooth-laser-1600-dpi-1377612',
+  },
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])(
+  'Product Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    it('should be able to get a product by id', async () => {
+      const response = await client.product.getById({
+        identifier: { key: testData.product.id },
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBe(testData.product.id);
+      expect(response.value.name).toBe(testData.product.name);
+      expect(response.value.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+      expect(response.value.mainVariant.name).toBeTruthy();
+    });
+
+    it('should be able to get a product by slug', async () => {
+      const response = await client.product.getBySlug({
+        slug: testData.product.slug,
+      });
+      
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBe(testData.product.id);
+      expect(response.value.name).toBe(testData.product.name);
+      expect(response.value.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+    });
+
+    it('should be able to get a multivariant product by slug', async () => {
+      const response = await client.product.getBySlug({
+        slug: testData.productWithMultiVariants.slug,
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBeTruthy();
+      expect(response.value.slug).toBe(testData.productWithMultiVariants.slug);
+      expect(response.value.mainVariant).toBeDefined();
+      expect(response.value.variants.length).toBeGreaterThan(0);
+      expect(response.value.variants[0].identifier.sku).toBeTruthy();
+      expect(response.value.variants[0].identifier.sku).not.toBe(
+        response.value.mainVariant.identifier.sku
+      );
+      expect(response.value.sharedAttributes.length).toBeGreaterThan(1);
+      expect(response.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+      expect(response.value.sharedAttributes[1].values[0].value).toBeTruthy();
+    });
+
+    it('should be able to get a product by sku', async () => {
+      const response = await client.product.getBySKU({
+        variant: { sku: testData.product.sku },
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.identifier.key).toBe(testData.product.id);
+      expect(response.value.name).toBe(testData.product.name);
+      expect(response.value.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+    });
+
+    it('should contain both product level and variant level attributes', async () => {
+      const response = await client.product.getBySKU({
+        variant: { sku: testData.product.sku },
+      });
+
+      if (!response.success) {
+        assert.fail();
+      }
+
+      expect(response.value.sharedAttributes.length).toBeGreaterThan(1);
+      expect(response.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+      expect(response.value.sharedAttributes[1].values[0].value).toBeTruthy();
+    });
+
+    it('should return an error of NotFound for unknown slug', async () => {
+      const response = await client.product.getBySlug({ slug: 'unknown-slug' });
+      
+      if (response.success) {
+        assert.fail();
+      }
+
+      expect(response.error.type).toBe('NotFound');
+    });
+  }
+);

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

@@ -0,0 +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.MEDUSA, PrimaryProvider.COMMERCETOOLS])(
+  'Profile Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+    let identity: Identity | null = null;
+    let identityIdentifier: IdentityIdentifier | null = null;
+
+    beforeEach(async () => {
+      client = createClient(provider);
+      const time = new Date().getTime();
+
+      const identityResponse = 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();
+    });
+
+    it('should be able to set the billing address on the profile', async () => {
+      if (!identity) {
+        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,
+      });
+
+      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/examples/node/src/capabilities/store.spec.ts

@@ -0,0 +1,26 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Store Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  it.skip('should be able to query stores by longitude and latitude', async () => {
+    const stores = await client.store.queryByProximity({
+      distance: 1000,
+      latitude: 15,
+      longitude: 15,
+      limit: 10,
+    });
+
+    if (!stores.success) {
+      assert.fail();
+    }
+
+    expect(stores.value.length).toBe(2);
+  });
+});

package/examples/node/src/utils.ts

@@ -0,0 +1,147 @@
+import {
+  createInitialRequestContext,
+  ClientBuilder,
+  NoOpCache,
+} from '@reactionary/core';
+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';
+import { withMeilisearchCapabilities } from '@reactionary/provider-meilisearch';
+
+export function getAlgoliaTestConfiguration() {
+  return {
+    apiKey: process.env['ALGOLIA_API_KEY'] || '',
+    appId: process.env['ALGOLIA_APP_ID'] || '',
+    indexName: process.env['ALGOLIA_INDEX'] || '',
+  };
+}
+
+export function getMeilisearchTestConfiguration() {
+  return {
+    apiKey: process.env['MEILISEARCH_API_KEY'] || '',
+    apiUrl: process.env['MEILISEARCH_API_URL'] || '',
+    indexName: process.env['MEILISEARCH_INDEX'] || '',
+    useAIEmbedding: process.env['MEILISEARCH_USE_AI_EMBEDDING'] || undefined,
+    orderIndexName: process.env['MEILISEARCH_ORDER_INDEX'] || 'order',
+  };
+}
+
+
+export function getMedusaTestConfiguration() {
+  return {
+        publishable_key: process.env['MEDUSA_PUBLISHABLE_KEY'] || '',
+        adminApiKey: process.env['MEDUSA_ADMIN_KEY'] || '',
+        apiUrl: process.env['MEDUSA_API_URL'] || '',
+        defaultCurrency: process.env['MEDUSA_DEFAULT_CURRENCY'] || '',
+        allCurrencies: []
+    };
+}
+
+
+export function getCommercetoolsTestConfiguration() {
+  return {
+    apiUrl: process.env['CTP_API_URL'] || '',
+    authUrl: process.env['CTP_AUTH_URL'] || '',
+    clientId: process.env['CTP_CLIENT_ID'] || '',
+    clientSecret: process.env['CTP_CLIENT_SECRET'] || '',
+    projectKey: process.env['CTP_PROJECT_KEY'] || '',
+    scopes: (process.env['CTP_SCOPES'] || '')
+      .split(',')
+      .map((x) => x.trim())
+      .filter((x) => x && x.length > 0),
+
+    paymentMethods: [
+      {
+        identifier: {
+          method: 'stripe',
+          name: 'Stripe',
+          paymentProcessor: 'stripe'
+        },
+        isPunchOut: false,
+        description: 'Stripe payment gateway',
+
+      },
+    ],
+    facetFieldsForSearch: (process.env['CTP_FACET_FIELDS_FOR_SEARCH'] || '').split(',') || ['category.id' ]
+  } satisfies CommercetoolsConfiguration;
+}
+
+export enum PrimaryProvider {
+  ALGOLIA = 'Algolia',
+  COMMERCETOOLS = 'Commercetools',
+  MEDUSA = 'Medusa',
+  MEILISEARCH = 'Meilisearch'
+}
+
+export function createClient(provider: PrimaryProvider) {
+  const context = createInitialRequestContext();
+  let builder = new ClientBuilder(context)
+    .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,
+          orderSearch: 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,
+          orderSearch: true,
+          store: true,
+          profile: true,
+        })
+      );
+    }
+
+
+  if (provider === PrimaryProvider.ALGOLIA) {
+    builder = builder.withCapability(
+      withAlgoliaCapabilities(getAlgoliaTestConfiguration(), {
+        productSearch: true,
+      })
+    );
+  }
+
+  if (provider === PrimaryProvider.MEILISEARCH) {
+    builder = builder.withCapability(
+      withMeilisearchCapabilities(getMeilisearchTestConfiguration(), {
+        productSearch: true,
+        orderSearch: true,
+      }),
+    );
+    builder = builder.withCapability(
+      withMedusaCapabilities(getMedusaTestConfiguration(), {
+        cart: true,
+        identity: true,
+      })
+    );
+  }
+
+  return builder.build();
+}

package/examples/node/tsconfig.json

@@ -1,24 +1,21 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "importHelpers": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noPropertyAccessFromIndexSignature": true
+      "module": "NodeNext",
+      "moduleResolution": "nodenext",
+      "forceConsistentCasingInFileNames": true,
+      "strict": true,
+      "importHelpers": true,
+      "noImplicitOverride": true,
+      "noImplicitReturns": true,
+      "noFallthroughCasesInSwitch": true,
+      "noPropertyAccessFromIndexSignature": true
   },
   "files": [],
   "include": [],
   "references": [
     {
       "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
     }
   ]
 }

package/examples/node/tsconfig.lib.json

@@ -5,6 +5,5 @@
     "declaration": true,
     "types": ["node"]
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+  "include": ["src/**/*.ts"]
 }

package/examples/node/tsconfig.spec.json

@@ -1,16 +1,4 @@
 {
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "verbatimModuleSyntax": false,
-    "outDir": "../../dist/out-tsc",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-, "src/initialize-algolia.ts"  ]
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
 }

package/examples/node/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig, defineProject } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { resolve } from 'path';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+
+export default defineProject({
+  plugins: [nxViteTsPaths()],
+  test: {
+    root: resolve(__dirname),
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.spec.ts', 'src/**/*.test.ts']
+  },
+});