@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,96 +0,0 @@
-import { SearchProvider } from '@reactionary/core';
-import type {
-  SearchResult,
-  SearchResultProduct,
-  Cache,
-  SearchQueryByTerm,
-  RequestContext,
-} from '@reactionary/core';
-
-import { CommercetoolsClient } from '../core/client.js';
-import type z from 'zod';
-import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-
-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;
-  }
-
-  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.js';
-import { CommercetoolsCartProvider } from '../providers/cart.provider.js';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
-import { CommercetoolsProductProvider } from '../providers/product.provider.js';
-
-
-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 () => { });
-    */
-
-  });
-
-});

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

@@ -1,168 +0,0 @@
-import 'dotenv/config'
-import type { RequestContext} from '@reactionary/core';
-import { CategorySchema, NoOpCache , createInitialRequestContext} from '@reactionary/core';
-import { CommercetoolsCategoryProvider } from '../providers/category.provider.js';
-import { getCommercetoolsTestConfiguration } from './test-utils.js';
-
-const testData = {
-  topCategories: [
-    {
-      key: 'home-decor', name: 'Home Decor', slug: 'home-decor'
-    },
-    {
-      key: 'furniture', name: 'Furniture'
-    }
-  ],
-
-  childCategoriesOfFirstTopcategory: [
-    { key: 'bedding', name: 'Bedding' },
-    { key: 'room-decor', name: 'Room Decor' }
-  ],
-
-  breadCrumb: [ 'home-decor', 'room-decor', 'home-accents' ],
-}
-
-
-describe('Commercetools Category Provider', () => {
-  let provider: CommercetoolsCategoryProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll( () => {
-    provider = new CommercetoolsCategoryProvider(getCommercetoolsTestConfiguration(), CategorySchema, new NoOpCache());
-  });
-
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext()
-  })
-
-  it('should be able to get top-categories', async () => {
-    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.items[0].name).toBe(testData.topCategories[0].name);
-
-    expect(result.items[1].identifier.key).toBe(testData.topCategories[1].key);
-    expect(result.items[1].name).toBe(testData.topCategories[1].name);
-  });
-
-  it('should be able to get child categories for a category', async () => {
-    const result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[0].key);
-    expect(result.items[0].name).toBe(testData.childCategoriesOfFirstTopcategory[0].name);
-
-    expect(result.items[1].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[1].key);
-    expect(result.items[1].name).toBe(testData.childCategoriesOfFirstTopcategory[1].name);
-
-  });
-
-
-  it('should be able to get child categories for a category, paged', async () => {
-    let result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 1, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[0].key);
-    expect(result.items[0].name).toBe(testData.childCategoriesOfFirstTopcategory[0].name);
-    expect(result.totalCount).toBe(2);
-    expect(result.totalPages).toBe(2);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(1);
-
-    result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 1, pageNumber: 2 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[1].key);
-    expect(result.items[0].name).toBe(testData.childCategoriesOfFirstTopcategory[1].name);
-    expect(result.totalCount).toBe(2);
-    expect(result.totalPages).toBe(2);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(2);
-  });
-
-
-  it('can load all breadcrumbs for a category', async () => {
-    const leaf = testData.breadCrumb[testData.breadCrumb.length -1];
-    const result = await provider.getBreadcrumbPathToCategory({ id: { key: leaf! } }, reqCtx);
-
-    expect(result.length).toBe(testData.breadCrumb.length);
-    for(let i = 0 ; i < testData.breadCrumb.length; i++) {
-      expect(result[i].identifier.key).toBe(testData.breadCrumb[i]);
-    }
-  });
-
-
-  it('should be able to get a category by slug', async () => {
-
-    const result = await provider.getBySlug({ slug: testData.topCategories[0].slug! }, reqCtx);
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.key).toBe(testData.topCategories[0].key);
-      expect(result.name).toBe(testData.topCategories[0].name);
-      expect(result.slug).toBe(testData.topCategories[0].slug);
-      expect(result.parentCategory).toBeUndefined();
-      expect(result.text).not.toBe("");
-      expect(result.meta.placeholder).toBe(false);
-    }
-  });
-
-  it('returns null if looking for slug that does not exist', async () => {
-    const result = await provider.getBySlug({ slug: 'non-existent-slug' }, reqCtx);
-    expect(result).toBeNull();
-  });
-
-
-
-  it('should be able to get a category by id', async () => {
-    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
-
-    expect(result.identifier.key).toBe('home-decor');
-    expect(result.name).toBe('Home Decor');
-    expect(result.slug).toBe('home-decor');
-    expect(result.parentCategory).toBeUndefined();
-
-    expect(result.text).toBe('A test description');
-    expect(result.meta.placeholder).toBe(false);
-
-  });
-
- it('should be able to get a category by id in alternate language', async () => {
-
-    reqCtx.languageContext.locale = 'de-DE';
-    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
-
-    expect(result.identifier.key).toBe('home-decor');
-    expect(result.name).toBe('Dekoration');
-    expect(result.slug).toBe('home-decor');
-    expect(result.parentCategory).toBeUndefined();
-
-    expect(result.text).toBe('Eine Testbeschreibung');
-    expect(result.meta.placeholder).toBe(false);
-
-  });
-
-
-  it('returns empty values if you choose a language that is not available', async () => {
-
-    reqCtx.languageContext.locale = 'fr-FR';
-    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
-
-    expect(result.identifier.key).toBe('home-decor');
-    expect(result.name).toBe('No Name');
-    expect(result.slug).toBe('');
-    expect(result.parentCategory).toBeUndefined();
-
-    expect(result.meta.placeholder).toBe(false);
-
-  });
-
-
-
-  it('returns a placeholder if you search for a category that does not exist', async () => {
-    const result = await provider.getById({ id: { key: 'non-existent-category'}}, reqCtx);
-    expect(result.identifier.key).toBe('non-existent-category');
-    expect(result.meta.placeholder).toBe(true);
-
-  });
-});