@reactionary/source 0.0.51 → 0.2.15

package/otel/tsconfig.lib.json

@@ -1,23 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx"
-  ]
-}

package/otel/tsconfig.spec.json

@@ -1,28 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/out-tsc",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ]
-}

package/otel/vite.config.ts

@@ -1,24 +0,0 @@
-import { defineConfig } from 'vite';
-import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
-import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
-
-export default defineConfig(() => ({
-  root: __dirname,
-  cacheDir: '../node_modules/.vite/otel',
-  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
-  // Uncomment this if you are using workers.
-  // worker: {
-  //  plugins: [ nxViteTsPaths() ],
-  // },
-  test: {
-    watch: false,
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    reporters: ['default'],
-    coverage: {
-      reportsDirectory: '../coverage/otel',
-      provider: 'v8' as const,
-    },
-  },
-}));

package/providers/algolia/jest.config.ts

@@ -1,10 +0,0 @@
-export default {
-  displayName: 'provider-algolia',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/providers/algolia',
-};

package/providers/algolia/src/providers/product.provider.ts

@@ -1,66 +0,0 @@
-import type {
-  Product,
-  ProductQueryById,
-  ProductQueryBySlug,
-  RequestContext,
-  Cache,
-  ProductQueryBySKU
-} from '@reactionary/core';
-import {
-  ProductProvider
-} from '@reactionary/core';
-import type { z } from 'zod';
-import type { AlgoliaConfiguration } from '../schema/configuration.schema';
-
-export class AlgoliaProductProvider<
-  T extends Product = Product
-> extends ProductProvider<T> {
-  protected config: AlgoliaConfiguration;
-
-  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
-
-    this.config = config;
-  }
-
-  public override async getById(
-    payload: ProductQueryById,
-    _reqCtx: RequestContext
-  ): Promise<T> {
-    // TODO: Implement Algolia product fetch by ID
-    const result = this.newModel();
-    result.identifier = { key: payload.id };
-    result.name = `Algolia Product ${payload.id}`;
-    result.slug = payload.id;
-    result.description = 'Product from Algolia';
-    result.meta = {
-      cache: { hit: false, key: payload.id },
-      placeholder: true
-    };
-
-    return this.assert(result);
-  }
-
-  public override async getBySlug(
-    payload: ProductQueryBySlug,
-    _reqCtx: RequestContext
-  ): Promise<T> {
-    // TODO: Implement Algolia product fetch by slug
-    const result = this.newModel();
-    result.identifier = { key: payload.slug };
-    result.name = `Algolia Product ${payload.slug}`;
-    result.slug = payload.slug;
-    result.description = 'Product from Algolia';
-    result.meta = {
-      cache: { hit: false, key: payload.slug },
-      placeholder: true
-    };
-
-    return this.assert(result);
-  }
-
-    public override getBySKU(payload: ProductQueryBySKU, reqCtx: RequestContext): Promise<T> {
-      throw new Error('Method not implemented.');
-    }
-
-}

package/providers/algolia/src/providers/search.provider.ts

@@ -1,106 +0,0 @@
-import {
-  type SearchQueryByTerm,
-  type SearchResult,
-  type SearchResultFacet,
-  type SearchResultProduct,
-  type RequestContext,
-  type Cache,
-  SearchProvider,
-} from '@reactionary/core';
-import { algoliasearch } from 'algoliasearch';
-import type { z } from 'zod';
-import type { AlgoliaConfiguration } from '../schema/configuration.schema';
-
-export class AlgoliaSearchProvider<
-  T extends SearchResult = SearchResult
-> extends SearchProvider<T> {
-  protected config: AlgoliaConfiguration;
-
-  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
-
-    this.config = config;
-  }
-
-  public override async queryByTerm(
-    payload: SearchQueryByTerm,
-    _reqCtx: RequestContext
-  ): Promise<SearchResult> {
-    const client = algoliasearch(this.config.appId, this.config.apiKey);
-    const remote = await client.search<unknown>({
-      requests: [
-        {
-          indexName: this.config.indexName,
-          query: payload.search.term,
-          page: payload.search.page,
-          hitsPerPage: payload.search.pageSize,
-          facets: ['*'],
-          analytics: true,
-          clickAnalytics: true,
-          facetFilters: payload.search.facets.map(
-            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
-          ),
-        },
-      ],
-    });
-
-    return this.parseSearchResult(remote, payload);
-  }
-
-  protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T {
-    const result = this.newModel();
-    const remoteData = remote as { results: Array<{ facets: Record<string, Record<string, number>>; hits: Array<{ objectID: string; slug?: string; name?: string; image?: string }>; index: string; queryID: string; nbPages: number }> };
-    const remoteProducts = remoteData.results[0];
-
-    // Parse facets
-    for (const id in remoteProducts.facets) {
-      const f = remoteProducts.facets[id];
-
-      const facet = {
-        identifier: { key: id },
-        name: id,
-        values: []
-      } as SearchResultFacet;
-
-      for (const vid in f) {
-        const fv = f[vid];
-        const isActive = payload.search.facets.find(
-          (x) => x.facet.key === id && x.key === vid
-        );
-
-        facet.values.push({
-          identifier: { key: vid, facet: { key: id } },
-          count: fv,
-          name: vid,
-          active: !!isActive
-        });
-      }
-
-      result.facets.push(facet);
-    }
-
-    // Parse products
-    for (const p of remoteProducts.hits) {
-      result.products.push({
-        identifier: { key: p.objectID },
-        slug: p.slug,
-        name: p.name,
-        image: p.image
-      } as SearchResultProduct);
-    }
-
-    // Set result metadata
-    result.identifier = {
-      ...payload.search,
-      index: remoteProducts.index,
-      key: remoteProducts.queryID
-    };
-    result.pages = remoteProducts.nbPages;
-    result.meta = {
-      cache: { hit: false, key: payload.search.term },
-      placeholder: false
-    };
-
-    return this.assert(result);
-  }
-}

package/providers/algolia/src/test/search.provider.spec.ts

@@ -1,91 +0,0 @@
-import 'dotenv/config';
-import { createInitialRequestContext, NoOpCache, SearchResultSchema } from '@reactionary/core';
-import { AlgoliaSearchProvider } from '../providers/search.provider';
-
-describe('Algolia Search Provider', () => {
-  const provider = new AlgoliaSearchProvider(
-    {
-      apiKey: process.env['ALGOLIA_API_KEY'] || '',
-      appId: process.env['ALGOLIA_APP_ID'] || '',
-      indexName: process.env['ALGOLIA_INDEX'] || '',
-    },
-    SearchResultSchema,
-    new NoOpCache()
-  );
-
-  const reqCtx = createInitialRequestContext();
-
-  it('should be able to get a result by term', async () => {
-    const result = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 0,
-      pageSize: 20,
-      facets: [],
-    }}, reqCtx);
-
-    expect(result.products.length).toBeGreaterThan(0);
-    expect(result.facets.length).toBe(2);
-    expect(result.facets[0].values.length).toBeGreaterThan(0);
-    expect(result.facets[1].values.length).toBeGreaterThan(0);
-  });
-
-  it('should be able to paginate', async () => {
-    const firstPage = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 0,
-      pageSize: 20,
-      facets: [],
-    }}, reqCtx);
-
-    const secondPage = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 1,
-      pageSize: 20,
-      facets: [],
-    }}, reqCtx);
-
-    expect(firstPage.identifier.page).toBe(0);
-    expect(secondPage.identifier.page).toBe(1);
-    expect(firstPage.products[0].identifier.key).not.toEqual(
-      secondPage.products[0].identifier.key
-    );
-  });
-
-  it('should be able to change page size', async () => {
-    const smallPage = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 0,
-      pageSize: 2,
-      facets: [],
-    }}, reqCtx);
-    const largePage = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 0,
-      pageSize: 30,
-      facets: [],
-    }}, reqCtx);
-
-    expect(smallPage.products.length).toBe(2);
-    expect(smallPage.identifier.pageSize).toBe(2);
-    expect(largePage.products.length).toBe(30);
-    expect(largePage.identifier.pageSize).toBe(30);
-  });
-
-  it('should be able to apply facets', async () => {
-    const initial = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 0,
-      pageSize: 2,
-      facets: [],
-    }}, reqCtx);
-
-    const filtered = await provider.queryByTerm({ search: {
-      term: 'glass',
-      page: 0,
-      pageSize: 2,
-      facets: [initial.facets[0].values[0].identifier],
-    }}, reqCtx);
-
-    expect(initial.pages).toBeGreaterThan(filtered.pages);
-  });
-});

package/providers/commercetools/jest.config.ts

@@ -1,10 +0,0 @@
-export default {
-  displayName: 'provider-commercetools',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/providers/commercetools',
-};

package/providers/commercetools/src/providers/search.provider.ts

@@ -1,98 +0,0 @@
-import { SearchProvider } from '@reactionary/core';
-import type {
-  SearchResult,
-  SearchResultProduct,
-  Cache,
-  SearchQueryByTerm,
-  Session, RequestContext,
-} from '@reactionary/core';
-
-import { CommercetoolsClient } from '../core/client';
-import type z from 'zod';
-import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
-import { traced } from '@reactionary/otel';
-
-export class CommercetoolsSearchProvider<
-  T extends SearchResult = SearchResult
-> extends SearchProvider<T> {
-  protected config: CommercetoolsConfiguration;
-
-  constructor(
-    config: CommercetoolsConfiguration,
-    schema: z.ZodType<T>,
-    cache: Cache
-  ) {
-    super(schema, cache);
-
-    this.config = config;
-  }
-
-  @traced()
-  protected async getClient(reqCtx: RequestContext) {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
-    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
-  }
-
-
-  public override async queryByTerm(
-    payload: SearchQueryByTerm,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
-
-    const remote = await client
-      .search()
-      .get({
-        queryArgs: {
-          limit: payload.search.pageSize,
-          offset: (payload.search.page - 1) * payload.search.pageSize,
-          [`text.${reqCtx.languageContext.locale}`]: payload.search.term,
-        },
-      })
-      .execute();
-
-    return this.parseSearchResult(remote, payload, reqCtx);
-  }
-
-  protected parseSearchResult(
-    remote: unknown,
-    payload: SearchQueryByTerm,
-    reqCtx: RequestContext
-  ): T {
-    const result = this.newModel();
-    const remoteData = remote as {
-      body: {
-        results: Array<{
-          id: string;
-          name: Record<string, string>;
-          slug?: Record<string, string>;
-          masterVariant: { images?: Array<{ url?: string }> };
-        }>;
-        total?: number;
-      };
-    };
-
-    result.identifier = payload.search;
-
-    for (const p of remoteData.body.results) {
-      const product: SearchResultProduct = {
-        identifier: { key: p.id },
-        name: p.name[reqCtx.languageContext.locale] || p.id,
-        slug: p.slug?.[reqCtx.languageContext.locale] || p.id,
-        image: p.masterVariant.images?.[0]?.url || 'https://placehold.co/400',
-      };
-
-      result.products.push(product);
-    }
-
-    result.pages = Math.ceil(
-      (remoteData.body.total || 0) / payload.search.pageSize
-    );
-    result.meta = {
-      cache: { hit: false, key: payload.search.term },
-      placeholder: false,
-    };
-
-    return this.assert(result);
-  }
-}

package/providers/commercetools/src/test/cart.provider.spec.ts

@@ -1,199 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext} from '@reactionary/core';
-import { CartSchema, IdentitySchema, NoOpCache, ProductSchema, createInitialRequestContext } from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsCartProvider } from '../providers/cart.provider';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
-import { CommercetoolsProductProvider } from '../providers/product.provider';
-
-
-const testData = {
-  skuWithoutTiers: 'SGB-01',
-  skuWithTiers: 'GMCT-01'
-}
-
-describe('Commercetools Cart Provider', () => {
-  let provider: CommercetoolsCartProvider;
-  let productProvider: CommercetoolsProductProvider;
-  let identityProvider: CommercetoolsIdentityProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll( () => {
-    provider = new CommercetoolsCartProvider(getCommercetoolsTestConfiguration(), CartSchema, new NoOpCache());
-    identityProvider = new CommercetoolsIdentityProvider(getCommercetoolsTestConfiguration(), IdentitySchema, new NoOpCache());
-    productProvider = new CommercetoolsProductProvider(getCommercetoolsTestConfiguration(), ProductSchema, new NoOpCache());
-  });
-
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext()
-  });
-
-  describe('anonymous sessions', () => {
-    it('should be able to get an empty cart', async () => {
-      const cart = await provider.getById({
-        cart: { key: '' },
-      }, reqCtx);
-
-      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 provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1
-      }, reqCtx);
-
-      expect(cart.identifier.key).toBeDefined();
-      expect(cart.items.length).toBe(1);
-      expect(cart.items[0].sku.key).toBe(testData.skuWithoutTiers);
-      expect(cart.items[0].quantity).toBe(1);
-
-      expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
-      expect(cart.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-
-      expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-      expect(cart.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
-
-      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 provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1
-      }, reqCtx);
-
-
-      const updatedCart = await provider.add({
-          cart: cart.identifier,
-          sku: {
-            key: testData.skuWithTiers,
-          },
-          quantity: 2
-      }, reqCtx);
-
-      expect(updatedCart.items.length).toBe(2);
-      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(1);
-      expect(updatedCart.items[1].sku.key).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 provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1
-      }, reqCtx);
-
-      const updatedCart = await provider.changeQuantity({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
-        quantity: 3
-      }, reqCtx);
-
-
-      expect(updatedCart.items.length).toBe(1);
-      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(3);
-
-      expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
-      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 provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1
-      }, reqCtx);
-
-      const updatedCart = await provider.remove({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
-      }, reqCtx);
-
-      expect(updatedCart.items.length).toBe(0);
-    });
-
-    it('should be able to delete a cart', async () => {
-
-      const cart = await provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1
-      }, reqCtx);
-
-      expect(cart.items.length).toBe(1);
-      expect(cart.identifier.key).toBeTruthy();
-
-      const deletedCart = await provider.deleteCart({
-        cart: cart.identifier,
-      }, reqCtx);
-
-      expect(deletedCart.items.length).toBe(0);
-      expect(deletedCart.identifier.key).toBe('');
-
-      const originalCart = await provider.getById({
-        cart: cart.identifier,
-      }, reqCtx);
-
-      expect(originalCart.items.length).toBe(0);
-    });
-
-    it('can load the product information for cart items', async () => {
-
-      const cart = await provider.add({
-          cart: { key: '' },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1
-      }, reqCtx);
-      expect(cart.items[0].sku).toBeDefined();
-
-      const product = await productProvider.getBySKU( { sku: cart.items[0].sku }, reqCtx);
-      expect(product).toBeTruthy();
-      if (product) {
-        expect(product.skus.some(s => s.identifier.key === cart.items[0].sku.key)).toBe(true);
-      }
-    });
-    /**
-    it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
-    });
-
-    it('should be able to create a cart for an anonymous user, then register and merge the cart', async () => {
-    });
-
-    it('should be able to clear the cart', async () => { });
-
-    it('should be able to check out the cart', async () => { });
-    */
-
-  });
-
-});