@reactionary/examples-node 0.1.5

package/README.md

@@ -0,0 +1,11 @@
+# examples-node
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build examples-node` to build the library.
+
+## Running unit tests
+
+Run `nx test examples-node` to execute the unit tests via [Jest](https://jestjs.io).

package/eslint.config.mjs

@@ -0,0 +1,19 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/package.json

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

package/project.json

@@ -0,0 +1,23 @@
+{
+  "name": "examples-node",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "examples/node/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/examples/node",
+        "main": "examples/node/src/index.ts",
+        "tsConfig": "examples/node/tsconfig.lib.json",
+        "assets": ["examples/node/*.md"],
+        "format": ["esm"],
+        "bundle": false
+      }
+    }
+
+  }
+}

package/src/basic/basic-node-provider-model-extension.spec.ts

@@ -0,0 +1,104 @@
+import type {
+  Cache,
+  ProductQueryById,
+  ProductQueryBySlug,
+  RequestContext} from '@reactionary/core';
+import {
+  ClientBuilder,
+  NoOpCache,
+  ProductSchema
+} from '@reactionary/core';
+import {
+  FakeProductProvider,
+  withFakeCapabilities,
+} from '@reactionary/provider-fake';
+import { createInitialRequestContext } from '@reactionary/core'
+import { z } from 'zod';
+import { describe, expect, it } from 'vitest';
+
+describe('basic node provider extension (models)', () => {
+  const reqCtx = createInitialRequestContext();
+
+  const ExtendedProductModel = ProductSchema.extend({
+    gtin: z.string().default('gtin-default'),
+  });
+  type ExtendedProduct = z.infer<typeof ExtendedProductModel>;
+
+  class ExtendedProductProvider extends FakeProductProvider {
+    protected override parseSingle(body: string): ExtendedProduct {
+      const result = {
+        ...super.parseSingle(body),
+        gtin: 'gtin-1234'
+      } satisfies ExtendedProduct;
+
+      return result;
+    }
+  }
+
+  function withExtendedCapabilities() {
+    return (cache: Cache, context: RequestContext) => {
+      const client = {
+        product: new ExtendedProductProvider(
+          { jitter: { mean: 0, deviation: 0 },
+          seeds: {
+            category: 1,
+            product: 1,
+            search: 1
+          } },
+          cache,
+          context
+        ),
+      };
+
+      return client;
+    };
+  }
+
+  const client = new ClientBuilder(reqCtx)
+    .withCapability(
+      withFakeCapabilities(
+        {
+          jitter: {
+            mean: 0,
+            deviation: 0,
+          },
+          seeds: {
+            category: 1,
+            product: 1,
+            search: 1
+          }
+        },
+        { productSearch: true, product: false, identity: false }
+      )
+    )
+    .withCapability(withExtendedCapabilities())
+    .withCache(new NoOpCache())
+    .build();
+
+  it('should get the enabled set of capabilities across providers', async () => {
+    expect(client.product).toBeDefined();
+    expect(client.productSearch).toBeDefined();
+  });
+
+  it('should be able to call the regular methods and get the default value', async () => {
+    const product = await client.product.getBySlug(
+      {
+        slug: '1234',
+      }
+    );
+
+    expect(product).toBeDefined();
+    // FIXME: expect(product.gtin).toBe('gtin-1234');
+  });
+
+  it('should be able to get serialized value from the extended provider', async () => {
+    const product = await client.product.getById(
+      {
+        identifier: { key: '1234' },
+      }
+    );
+
+    expect(product).toBeDefined();
+    // FIXME: expect(product.gtin).toBe('gtin-1234');
+  });
+});

package/src/basic/basic-node-provider-query-extension.spec.ts

@@ -0,0 +1,99 @@
+import type {
+  Cache,
+  Product,
+  RequestContext} from '@reactionary/core';
+import {
+  ClientBuilder,
+  createInitialRequestContext,
+  NoOpCache,
+  ProductSchema
+} from '@reactionary/core';
+import {
+  FakeProductProvider,
+  withFakeCapabilities,
+} from '@reactionary/provider-fake';
+import { z } from 'zod';
+import { describe, expect, it } from 'vitest';
+
+describe('basic node provider extension (models)', () => {
+  const ExtendedProductModel = ProductSchema.extend({
+    gtin: z.string().default('gtin-default'),
+  });
+
+  class ExtendedProductProvider extends FakeProductProvider {
+
+    public async getByCustom(_custom: string): Promise<Product> {
+      // Lets say we called somewhere...
+      const data = {
+        id: 'foo',
+        name: 'bar'
+      };
+
+      const model = this.parseItem(data);
+
+      return model;
+    }
+
+    protected parseItem(data: unknown): Product {
+      // In the real world, call super
+      // super.parseItem(data);
+      // Which would start by doing
+      const item = { } as any;
+
+      if (data) {
+        item.name = (data as { name: string }).name;
+      }
+
+
+      return item;
+    }
+  }
+
+  function withExtendedCapabilities() {
+    return (cache: Cache, context: RequestContext) => {
+      const client = {
+        product: new ExtendedProductProvider(
+          { jitter: { mean: 0, deviation: 0 },
+                  seeds: {
+            category: 1,
+            product: 1,
+            search: 1
+          }},
+          cache,
+          context
+        ),
+      };
+
+      return client;
+    };
+  }
+
+  const reqCtx = createInitialRequestContext();
+  const client = new ClientBuilder(reqCtx)
+    .withCapability(
+      withFakeCapabilities(
+        {
+          jitter: {
+            mean: 0,
+            deviation: 0,
+          },
+          seeds: {
+            category: 1,
+            product: 1,
+            search: 1
+          }
+        },
+        { productSearch: true, product: false, identity: false }
+      )
+    )
+    .withCapability(withExtendedCapabilities())
+    .withCache(new NoOpCache())
+    .build();
+
+  it('should be able to call a custom query method on the provider', async () => {
+    const product = await client.product.getByCustom('1234');
+
+    expect(product.name).toBe('bar');
+  });
+
+});

package/src/basic/basic-node-setup.spec.ts

@@ -0,0 +1,54 @@
+import 'dotenv/config';
+import {
+  ClientBuilder,
+  createInitialRequestContext,
+  NoOpCache,
+  type Client,
+  type RequestContext,
+} from '@reactionary/core';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+describe('basic node setup', () => {
+  let client: Partial<Client>;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    client = new ClientBuilder(reqCtx)
+      .withCapability(
+        withFakeCapabilities(
+          {
+            jitter: {
+              mean: 0,
+              deviation: 0,
+            },
+            seeds: {
+              category: 1,
+              product: 1,
+              search: 1,
+            },
+          },
+          { productSearch: true, product: true, identity: false }
+        )
+      )
+      .withCache(new NoOpCache())
+      .build();
+  });
+
+  it('should only get back the enabled capabilities', async () => {
+    expect(client.product).toBeDefined();
+    expect(client.productSearch).toBeDefined();
+  });
+
+  it('should be able to call the enabled capabilities', async () => {
+    const product = await client.product!.getBySlug(
+      {
+        slug: '1234',
+      }
+    );
+
+    expect(product).toBeDefined();
+    expect(product!.slug).toBe('1234');
+  });
+});

package/src/basic/client-creation.spec.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { ClientBuilder, createInitialRequestContext, NoOpCache } from '@reactionary/core';
+import { FakeProductProvider, withFakeCapabilities  } from '@reactionary/provider-fake';
+import { CommercetoolsCartProvider, withCommercetoolsCapabilities } from '@reactionary/provider-commercetools';
+import { AlgoliaSearchProvider, withAlgoliaCapabilities } from '@reactionary/provider-algolia';
+
+describe('client creation', () => {
+  it('should be able to mix providers and get a valid, typed client', async () => {
+    const reqCtx = createInitialRequestContext();
+    const client = new ClientBuilder(reqCtx)
+      .withCapability(
+        withFakeCapabilities(
+          {
+            jitter: {
+              mean: 0,
+              deviation: 0,
+            },
+            seeds: {
+              category: 1,
+              product: 1,
+              search: 1,
+            },
+          },
+          { product: true }
+        )
+      )
+      .withCapability(
+        withCommercetoolsCapabilities({
+         apiUrl: '',
+         authUrl: '',
+         clientId: '',
+         clientSecret: '',
+         paymentMethods: [],
+         projectKey: '',
+         scopes: [],
+         facetFieldsForSearch: []
+        }, { cart: true })
+      )
+      .withCapability(
+        withAlgoliaCapabilities({
+            apiKey: '',
+            appId: '',
+            indexName: ''
+        }, { productSearch: true })
+      )
+      .withCache(new NoOpCache())
+      .build();
+
+    expect(client.cart).toBeInstanceOf(CommercetoolsCartProvider);
+    expect(client.product).toBeInstanceOf(FakeProductProvider);
+    expect(client.productSearch).toBeInstanceOf(AlgoliaSearchProvider);
+  });
+});

package/src/capabilities/cart.spec.ts

@@ -0,0 +1,211 @@
+import 'dotenv/config';
+import { createClient, PrimaryProvider } from '../utils.js';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { ProductSearchQueryByTermSchema, type ProductSearchQueryByTerm } from '@reactionary/core';
+
+const testData = {
+  skuWithoutTiers: '0766623301831',
+  skuWithTiers: '0766623360203',
+};
+
+describe.each([PrimaryProvider.COMMERCETOOLS])('Cart Capability - %s', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  describe('anonymous sessions', () => {
+    it('should be able to get an empty cart', async () => {
+      const cart = await client.cart.getById({
+        cart: { key: '' },
+      });
+
+      expect(cart.identifier.key).toBeFalsy();
+      expect(cart.items.length).toBe(0);
+      expect(cart.meta?.placeholder).toBe(true);
+    });
+
+    it('should be able to add an item to a cart', async () => {
+      const cart = await client.cart.add({
+        cart: { key: '' },
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      expect(cart.identifier.key).toBeDefined();
+      expect(cart.items.length).toBe(1);
+      expect(cart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(cart.items[0].quantity).toBe(1);
+
+      expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
+
+      expect(cart.price.grandTotal.value).toBeGreaterThan(0);
+
+      expect(cart.price.grandTotal.value).toBe(
+        cart.items[0].price.totalPrice.value
+      );
+
+      expect(cart.meta?.placeholder).toBeFalsy();
+    });
+
+    it('can add multiple different items to a cart', async () => {
+      const cart = await client.cart.add({
+        cart: { key: '' },
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      const updatedCart = await client.cart.add({
+        cart: cart.identifier,
+        variant: {
+          sku: testData.skuWithTiers,
+        },
+        quantity: 2,
+      });
+
+      expect(updatedCart.items.length).toBe(2);
+      expect(updatedCart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.items[0].quantity).toBe(1);
+      expect(updatedCart.items[1].variant.sku).toBe(testData.skuWithTiers);
+      expect(updatedCart.items[1].quantity).toBe(2);
+    });
+
+    it('should be able to change quantity of an item in a cart', async () => {
+      const cart = await client.cart.add({
+        cart: { key: '' },
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      const updatedCart = await client.cart.changeQuantity({
+        cart: cart.identifier,
+        item: cart.items[0].identifier,
+        quantity: 3,
+      });
+
+      expect(updatedCart.items.length).toBe(1);
+      expect(updatedCart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.items[0].quantity).toBe(3);
+
+      expect(updatedCart.items[0].price.totalPrice.value).toBeGreaterThan(
+        cart.items[0].price.totalPrice.value
+      );
+      expect(updatedCart.items[0].price.unitPrice.value).toBe(
+        cart.items[0].price.unitPrice.value
+      );
+    });
+
+    it('should be able to remove an item from a cart', async () => {
+      const cart = await client.cart.add({
+        cart: { key: '' },
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      const updatedCart = await client.cart.remove({
+        cart: cart.identifier,
+        item: cart.items[0].identifier,
+      });
+
+      expect(updatedCart.items.length).toBe(0);
+    });
+
+    it('should be able to delete a cart', async () => {
+      const cart = await client.cart.add({
+        cart: { key: '' },
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+
+      expect(cart.items.length).toBe(1);
+      expect(cart.identifier.key).toBeTruthy();
+
+      const deletedCart = await client.cart.deleteCart({
+        cart: cart.identifier,
+      });
+
+      expect(deletedCart.items.length).toBe(0);
+      expect(deletedCart.identifier.key).toBe('');
+
+      const originalCart = await client.cart.getById({
+        cart: cart.identifier,
+      });
+
+      expect(originalCart.items.length).toBe(0);
+    });
+
+    it('can load the product information for cart items', async () => {
+      const cart = await client.cart.add({
+        cart: { key: '' },
+        variant: {
+          sku: testData.skuWithoutTiers,
+        },
+        quantity: 1,
+      });
+      expect(cart.items[0].variant).toBeDefined();
+
+      const product = await client.product.getBySKU({
+        variant: cart.items[0].variant,
+      });
+      expect(product).toBeTruthy();
+      if (product) {
+        expect(product.mainVariant.identifier.sku).toEqual(
+          cart.items[0].variant.sku
+        );
+      }
+    });
+
+    it('should be able to add an 50 items to a cart in less than 30 seconds', async () => {
+      let cart = await client.cart.getById({
+        cart: { key: '' },
+      });
+
+      const searchResult = await client.productSearch.queryByTerm(
+        ProductSearchQueryByTermSchema.parse({
+          search: {
+            term: 'cable',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 8,
+            },
+            filters: [],
+            facets: [],
+          },
+        } satisfies ProductSearchQueryByTerm)
+      );
+      expect(searchResult.items.length).toBeGreaterThanOrEqual(8);
+
+      for (const product of searchResult.items) {
+        cart = await client.cart.add({
+          cart: cart.identifier,
+          variant: {
+            sku: product.variants[0].variant.sku,
+          },
+          quantity: 1,
+        });
+      }
+
+      if (cart) {
+        expect(cart.identifier.key).toBeDefined();
+        expect(cart.items.length).toBe(8);
+
+        expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
+        expect(cart.price.grandTotal.value).toBeGreaterThan(0);
+        expect(cart.meta?.placeholder).toBeFalsy();
+      } else {
+        throw new Error('Cart is undefined');
+      }
+    }, 30000);
+  });
+});