@reactionary/examples-node 0.1.5

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

@@ -0,0 +1,149 @@
+import 'dotenv/config';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+const testData = {
+  searchTerm: 'manhattan',
+};
+
+describe.each([PrimaryProvider.ALGOLIA, PrimaryProvider.COMMERCETOOLS])(
+  'Product Search Capability - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    it('should be able to get a result by term', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          facets: [],
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          filters: [],
+        },
+      });
+
+      expect(result.items.length).toBeGreaterThan(0);
+    });
+
+    it('should be able to get a result by term, paged', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          facets: [],
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 1,
+          },
+          filters: [],
+        },
+      });
+
+      expect(result.items.length).toBeGreaterThan(0);
+      expect(result.totalPages).toBeGreaterThan(1);
+
+      const result2 = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          facets: [],
+          paginationOptions: {
+            pageNumber: 2,
+            pageSize: 1,
+          },
+          filters: [],
+        },
+      });
+
+      expect(result2.items.length).toBeGreaterThan(0);
+      expect(result2.totalPages).toBeGreaterThan(2);
+      expect(result2.items[0].identifier.key).not.toBe(
+        result.items[0].identifier.key
+      );
+    });
+
+    it('should be able to change page size', async () => {
+      const smallPage = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+      const largePage = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 30,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      expect(smallPage.items.length).toBe(2);
+      expect(smallPage.pageSize).toBe(2);
+      expect(largePage.items.length).toBe(30);
+      expect(largePage.pageSize).toBe(30);
+    });
+
+    it('should be able to apply facets', async () => {
+
+      const initial = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      expect(initial.facets.length).toBeGreaterThan(0);
+
+      const filtered = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 2,
+          },
+          facets: [initial.facets[0].values[0].identifier],
+          filters: [],
+        },
+      });
+
+      expect(initial.totalPages).toBeGreaterThanOrEqual(filtered.totalPages);
+    });
+
+    it('should not return facets with no values', async () => {
+      const result = await client.productSearch.queryByTerm({
+        search: {
+          term: testData.searchTerm,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      for (const facet of result.facets) {
+        expect(facet.values.length).toBeGreaterThan(0);
+      }
+    });
+  }
+);

package/src/capabilities/product.spec.ts

@@ -0,0 +1,108 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } 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 result = await client.product.getById({ identifier: { key: testData.product.id } });
+
+    expect(result).toBeTruthy();
+    expect(result.identifier.key).toBe(testData.product.id);
+    expect(result.meta.placeholder).toBe(false);
+    expect(result.name).toBe(testData.product.name);
+    expect(result.mainVariant.images[0].sourceUrl).toBe(testData.product.image);
+    expect(result.mainVariant.name).toBeTruthy();
+  });
+
+  it('should be able to get a product by slug', async () => {
+    const result = await client.product.getBySlug({ slug: testData.product.slug });
+
+    expect(result).toBeTruthy();
+
+    if (result) {
+      expect(result.meta.placeholder).toBe(false);
+      expect(result.identifier.key).toBe(testData.product.id);
+      expect(result.name).toBe(testData.product.name);
+      expect(result.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+    }
+  });
+
+  it('should be able to get a multivariant product by slug', async () => {
+    const result = await client.product.getBySlug({ slug: testData.productWithMultiVariants.slug });
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.meta.placeholder).toBe(false);
+      expect(result.identifier.key).toBeTruthy();
+      expect(result.slug).toBe(testData.productWithMultiVariants.slug);
+      expect(result.mainVariant).toBeDefined();
+      expect(result.variants.length).toBeGreaterThan(0);
+      expect(result.variants[0].identifier.sku).toBeTruthy();
+      expect(result.variants[0].identifier.sku).not.toBe(result.mainVariant.identifier.sku);
+      expect(result!.sharedAttributes.length).toBeGreaterThan(1);
+      expect(result!.sharedAttributes[1].values.length).toBeGreaterThan(0);
+      expect(result!.sharedAttributes[1].values[0].value).toBeTruthy();
+    }
+  });
+
+
+  it('should be able to get a product by sku', async () => {
+    const result = await client.product.getBySKU({
+      variant: { sku: testData.product.sku },
+    });
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.meta.placeholder).toBe(false);
+      expect(result.identifier.key).toBe(testData.product.id);
+      expect(result.name).toBe(testData.product.name);
+      expect(result.mainVariant.images[0].sourceUrl).toBe(
+        testData.product.image
+      );
+    }
+  });
+
+  it('should contain both product level and variant level attributes', async () => {
+    const result = await client.product.getBySKU({
+      variant: { sku: testData.product.sku },
+    });
+
+    expect(result).toBeTruthy();
+    expect(result.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
+  })
+
+  it('should return null for unknown slug', async () => {
+    const result = await client.product.getBySlug({ slug: 'unknown-slug' });
+
+    expect(result).toBeNull();
+  });
+
+  it('should return a placeholder product for unknown id', async () => {
+    const result = await client.product.getById({ identifier: { key: 'unknown-id' } });
+
+    expect(result).toBeTruthy();
+    expect(result.meta.placeholder).toBe(true);
+  });
+});

package/src/capabilities/profile.spec.ts

@@ -0,0 +1,25 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Profile Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  it('should be able to fetch the profile for the current user', async () => {
+    const time = new Date().getTime();
+
+    await client.identity.register({
+      username: `martin.rogne+test-${time}@solteq.com`,
+      password: 'love2test',
+    });
+
+    const profile = await client.profile.getSelf({});
+
+    expect(profile).toBeDefined();
+    expect(profile.email).toContain('martin.rogne');
+  });
+});

package/src/capabilities/store.spec.ts

@@ -0,0 +1,22 @@
+import 'dotenv/config';
+import { describe, expect, it, beforeEach } 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,
+    });
+
+    expect(stores.length).toBe(2);
+  });
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+// FIXME: Convert from a library to an application. This is required due to it being a package...
+export const FOO = 42;

package/src/utils.ts

@@ -0,0 +1,102 @@
+import {
+  createInitialRequestContext,
+  ClientBuilder,
+  NoOpCache,
+  type PaymentMethod,
+  type PaymentMethodIdentifier,
+} 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';
+
+export function getAlgoliaTestConfiguration() {
+  return {
+    apiKey: process.env['ALGOLIA_API_KEY'] || '',
+    appId: process.env['ALGOLIA_APP_ID'] || '',
+    indexName: process.env['ALGOLIA_INDEX'] || '',
+  };
+}
+
+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,
+        meta: {
+          cache: {
+            hit: false,
+            key: ''
+          },
+          placeholder: 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',
+}
+
+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,
+      })
+    );
+
+  if (provider === PrimaryProvider.ALGOLIA) {
+    builder = builder.withCapability(
+      withAlgoliaCapabilities(getAlgoliaTestConfiguration(), {
+        productSearch: true,
+      })
+    );
+  }
+
+  return builder.build();
+}

package/tsconfig.json

@@ -0,0 +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
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
+}

package/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']
+  },
+});