@reactionary/source 0.0.37 → 0.0.39

package/providers/fake/src/providers/cart.provider.ts

@@ -10,16 +10,22 @@ import {
 } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
+import { Faker, en, base } from '@faker-js/faker';
 
 export class FakeCartProvider<
   T extends Cart = Cart
 > extends CartProvider<T> {
   protected config: FakeConfiguration;
   private carts: Map<string, T> = new Map();
+  private generator: Faker;
+
 
   constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
     super(schema, cache);
-
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product
+    });
     this.config = config;
   }
 
@@ -28,7 +34,16 @@ export class FakeCartProvider<
     _session: Session
   ): Promise<T> {
     const cartId = payload.cart.key;
-    
+
+    if (payload.cart.key === '') {
+      const result = this.newModel();
+      result.meta = {
+        cache: { hit: false, key: 'empty' },
+        placeholder: true
+      };
+      return this.assert(result);
+    }
+
     if (!this.carts.has(cartId)) {
       const model = this.newModel();
       Object.assign(model, {
@@ -44,7 +59,7 @@ export class FakeCartProvider<
       });
       this.carts.set(cartId, this.assert(model));
     }
-    
+
     const cart = this.carts.get(cartId);
     if (!cart) {
       throw new Error(`Cart with id ${cartId} not found`);
@@ -56,22 +71,46 @@ export class FakeCartProvider<
     payload: CartMutationItemAdd,
     session: Session
   ): Promise<T> {
-    const cart = await this.getById({ cart: payload.cart }, session);
-    
+
+    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
+    const cart = await this.getById({ cart: { key: cartId } }, session);
+
     const existingItemIndex = cart.items.findIndex(
       item => item.product.key === payload.product.key
     );
-    
+
     if (existingItemIndex >= 0) {
       cart.items[existingItemIndex].quantity += payload.quantity;
     } else {
+      const price = this.generator.number.int({ min: 100, max: 100000 }) / 100;
+
       cart.items.push({
         identifier: { key: `item-${Date.now()}` },
         product: payload.product,
         quantity: payload.quantity,
+        price: {
+          unitPrice: {
+            value: price,
+            currency: session.languageContext.currencyCode,
+          },
+          totalPrice: {
+            value: 0, // Will be calculated below
+            currency: session.languageContext.currencyCode,
+          },
+          totalDiscount: {
+            value: 0,
+            currency: session.languageContext.currencyCode,
+          },
+          unitDiscount: {
+            value: 0,
+            currency: session.languageContext.currencyCode,
+          },
+        },
       });
     }
-    
+
+    this.recalculateCart(cart);
+
     return this.assert(cart);
   }
 
@@ -79,12 +118,13 @@ export class FakeCartProvider<
     payload: CartMutationItemRemove,
     session: Session
   ): Promise<T> {
-    const cart = await this.getById({ cart: payload.cart }, session);
-    
+    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
+    const cart = await this.getById({ cart: { key: cartId } }, session);
+
     cart.items = cart.items.filter(
       item => item.identifier.key !== payload.item.key
     );
-    
+    this.recalculateCart(cart);
     return this.assert(cart);
   }
 
@@ -92,16 +132,35 @@ export class FakeCartProvider<
     payload: CartMutationItemQuantityChange,
     session: Session
   ): Promise<T> {
-    const cart = await this.getById({ cart: payload.cart }, session);
-    
+    const cartId = payload.cart.key || `cart-${this.generator.string.uuid()}`;
+    const cart = await this.getById({ cart: { key: cartId } }, session);
+
     const item = cart.items.find(
       item => item.identifier.key === payload.item.key
     );
-    
+
     if (item) {
       item.quantity = payload.quantity;
     }
-    
+    this.recalculateCart(cart);
     return this.assert(cart);
   }
-}
+
+
+
+  protected recalculateCart(cart: T) {
+    cart.items.forEach(item => {
+      item.price.totalPrice.value = item.price.unitPrice.value * item.quantity;
+    });
+
+    cart.price.totalProductPrice = {
+      value: cart.items.reduce((sum, item) => sum + item.price.totalPrice.value, 0),
+      currency: cart.items[0]?.price.unitPrice.currency || 'USD',
+    }
+
+    cart.price.grandTotal = {
+      value: cart.items.reduce((sum, item) => sum + item.price.totalPrice.value, 0),
+      currency: cart.items[0]?.price.unitPrice.currency || 'USD',
+    };
+  }
+}

package/providers/fake/src/providers/category.provider.ts

@@ -0,0 +1,152 @@
+import { Category, CategoryProvider, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, Session } from "@reactionary/core";
+import { FakeConfiguration } from "../schema/configuration.schema";
+import { Cache as ReactionaryCache } from "@reactionary/core";
+import z from "zod";
+import { Faker, en, base } from '@faker-js/faker';
+export class FakeCategoryProvider<
+  T extends Category = Category
+> extends CategoryProvider<T> {
+
+  protected config: FakeConfiguration;
+
+  protected topCategories = new Array<T>();
+  protected childCategories = new Map<string, Array<T>>();
+  protected allCategories = new Map<string, T>();
+
+  protected categoryGenerator: Faker;
+
+  protected generateFakeCategory(parent: Category | undefined, index: number): T {
+
+    let name: string;
+    if (!parent) {
+      name = this.categoryGenerator.commerce.department();
+    } else {
+      name = `${parent.name}-${index}`;
+    }
+
+    const category: T = this.newModel();
+    category.identifier = { key: name.toLowerCase().replace(/\s+/g, '-') };
+    category.name = name;
+    category.text = this.categoryGenerator.lorem.sentences(3);
+    category.slug = category.identifier.key + '-slug';
+    if (parent) {
+      category.parentCategory = parent.identifier;
+    }
+    this.allCategories.set(category.identifier.key, category);
+    return category;
+  }
+
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache) {
+    super(schema, cache);
+    this.config = config;
+    this.categoryGenerator = new Faker({
+      seed: this.config.seeds.category,
+      locale: [en, base],
+    });
+
+    // Generate some top-level categories
+    for (let i = 0; i < 6; i++) {
+      const category: T = this.generateFakeCategory(undefined, i);
+      this.topCategories.push(category);
+    }
+
+    // Generate two levels of child categories
+    this.topCategories.forEach((parentCategory) => {
+      const children = new Array<T>();
+      for (let j = 0; j < 5; j++) {
+        const childCategory: T = this.generateFakeCategory(parentCategory, j);
+        children.push(childCategory);
+
+
+        const subCategoryChildren = new Array<T>();
+        for(let k = 0; k < 5; k++) {
+          const subChildCategory: T = this.generateFakeCategory(childCategory, k);
+          subCategoryChildren.push(subChildCategory);
+        }
+        this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
+      }
+      this.childCategories.set(parentCategory.identifier.key, children);
+    });
+  }
+
+
+
+  public override async getById(payload: CategoryQueryById, session: Session): Promise<T> {
+    const category = this.allCategories.get(payload.id.key);
+    if(!category) {
+      const dummyCategory = this.newModel();
+      dummyCategory.meta.placeholder = true;
+      dummyCategory.identifier = { key: payload.id.key };
+      return dummyCategory;
+    }
+    return  category;
+  }
+  public override getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null> {
+    for(const p of this.allCategories.values()) {
+      if(p.slug === payload.slug) {
+        return Promise.resolve(p as T);
+      }
+    }
+    return Promise.resolve(null);
+  }
+
+  public override getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]> {
+    const path = new Array<T>();
+    let category = this.allCategories.get(payload.id.key);
+    path.push(category as T);
+    while(category?.parentCategory) {
+      category = this.allCategories.get(category.parentCategory.key);
+      if(category) {
+        path.unshift(category as T);
+      }
+    }
+    return Promise.resolve(path);
+  }
+
+  public override async findChildCategories(payload: CategoryQueryForChildCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>> {
+    const children = this.childCategories.get(payload.parentId.key);
+    const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
+
+
+    const res = {
+      meta: {
+        placeholder: false,
+        cache: {
+          hit: false,
+          key: 'child-categories-' + payload.parentId.key + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
+        },
+      },
+      items: page ? page as T[] : [],
+      totalCount: children ? children.length : 0,
+      pageNumber: payload.paginationOptions.pageNumber,
+      pageSize: payload.paginationOptions.pageSize,
+      totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1,
+    };
+
+    return Promise.resolve(res);
+  }
+  public override findTopCategories(payload: CategoryQueryForTopCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>> {
+    const children = this.topCategories;
+    const page = children?.slice((payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize, payload.paginationOptions.pageNumber * payload.paginationOptions.pageSize);
+
+
+    const res = {
+      meta: {
+        placeholder: false,
+        cache: {
+          hit: false,
+          key: 'top' + '-' + payload.paginationOptions.pageNumber + '-' + payload.paginationOptions.pageSize,
+        },
+      },
+      items: page ? page as T[] : [],
+      totalCount: children ? children.length : 0,
+      pageNumber: payload.paginationOptions.pageNumber,
+      pageSize: payload.paginationOptions.pageSize,
+      totalPages: children ? Math.ceil(children.length / payload.paginationOptions.pageSize) : 1,
+    };
+
+    return Promise.resolve(res);
+  }
+
+}

package/providers/fake/src/providers/index.ts

@@ -0,0 +1,8 @@
+export * from './analytics.provider';
+export * from './cart.provider';
+export * from './category.provider';
+export * from './identity.provider';
+export * from './inventory.provider';
+export * from './price.provider';
+export * from './product.provider';
+export * from './search.provider';

package/providers/fake/src/providers/inventory.provider.ts

@@ -26,29 +26,43 @@ export class FakeInventoryProvider<
   ): Promise<T> {
     // Generate a simple hash from the SKU string for seeding
     let hash = 0;
-    const skuString = payload.sku;
+    const skuString = payload.sku.key;
     for (let i = 0; i < skuString.length; i++) {
       hash = ((hash << 5) - hash) + skuString.charCodeAt(i);
       hash = hash & hash; // Convert to 32bit integer
     }
-    
+
     const generator = new Faker({
       seed: hash || 42,
       locale: [en, base],
     });
 
     const model = this.newModel();
-    Object.assign(model, {
-      quantity: generator.number.int({ min: 0, max: 100 }),
-      meta: {
+
+    model.identifier = {
+      sku: { key: skuString},
+      channelId: {
+        key: 'online'
+      },
+    };
+    model.sku = skuString;
+
+    model.quantity = generator.number.int({ min: 0, max: 100 });
+    if (model.quantity > 0 ) {
+      model.status = 'inStock';
+    } else {
+      model.status = 'outOfStock';
+    }
+
+
+    model.meta = {
         cache: {
           hit: false,
-          key: payload.sku,
+          key: this.generateCacheKeySingle(model.identifier, _session)
         },
         placeholder: false,
-      },
-    });
+      };
 
     return this.assert(model);
   }
-}
+}

package/providers/fake/src/providers/price.provider.ts

@@ -20,10 +20,22 @@ export class FakePriceProvider<
     this.config = config;
   }
 
+  public override async getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]> {
+
+    const promises = payload.map(p => this.getBySKU(p, session));
+    const result = await Promise.all(promises);
+    return result;
+  }
+
   public override async getBySKU(
     payload: PriceQueryBySku,
     _session: Session
   ): Promise<T> {
+
+    if (payload.sku.key === 'unknown-sku') {
+      return this.getEmptyPriceResult(payload.sku.key, _session.languageContext.currencyCode);
+    }
+
     // Generate a simple hash from the SKU key string for seeding
     let hash = 0;
     const skuString = payload.sku.key;
@@ -31,30 +43,58 @@ export class FakePriceProvider<
       hash = ((hash << 5) - hash) + skuString.charCodeAt(i);
       hash = hash & hash; // Convert to 32bit integer
     }
-    
+
     const generator = new Faker({
       seed: hash || 42,
       locale: [en, base],
     });
 
+
     const model = this.newModel();
     Object.assign(model, {
       identifier: {
         sku: payload.sku,
       },
-      value: {
-        cents: generator.number.int({ min: 100, max: 100000 }),
-        currency: 'USD',
+      unitPrice: {
+        value: generator.number.int({ min: 300, max: 100000 }) / 100,
+        currency: _session.languageContext.currencyCode,
       },
       meta: {
         cache: {
           hit: false,
-          key: payload.sku,
+          key: payload.sku.key,
         },
         placeholder: false,
       },
     });
 
+    if (skuString.includes('with-tiers')) {
+      const unitPrice = model.unitPrice?.value || 0;
+      // Ensure tiered prices are less than the unit price
+      const tier1Price = unitPrice * 0.8;
+      const tier2Price = tier1Price * 0.8;
+      model.tieredPrices = [
+        {
+          minimumQuantity: generator.number.int({ min: 2, max: 5 }),
+          price: {
+            value: tier1Price,
+            currency: _session.languageContext.currencyCode,
+          }
+        },
+        {
+          minimumQuantity: generator.number.int({ min: 6, max: 10 }),
+          price: {
+            value: tier2Price,
+            currency: _session.languageContext.currencyCode,
+          }
+        }
+      ];
+    } else {
+      model.tieredPrices = [];
+    }
+
+
+
     return this.assert(model);
   }
-}
+}

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

@@ -1,28 +1,29 @@
 import {
   SearchProvider,
-  SearchQueryByTerm,
   SearchResult,
   SearchResultFacet,
   SearchResultProduct,
-  Session,
-  Cache as ReactinaryCache,
+  Cache as ReactionaryCache,
 } from '@reactionary/core';
+import type { SearchQueryByTerm, Session } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 import { Faker, en, base } from '@faker-js/faker';
 import { jitter } from '../utilities/jitter';
+import { traced } from '@reactionary/otel';
 
 export class FakeSearchProvider<
   T extends SearchResult = SearchResult
 > extends SearchProvider<T> {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache) {
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache) {
     super(schema, cache);
 
     this.config = config;
   }
 
+  @traced()
   public override async queryByTerm(
     payload: SearchQueryByTerm,
     _session: Session
@@ -119,6 +120,14 @@ export class FakeSearchProvider<
       },
     } satisfies SearchResult;
 
+    const foo = this.childFunction();
+
     return this.schema.parse(result);
   }
+
+  @traced()
+  protected childFunction() {
+    const foo = 42;
+    return foo;
+  }
 }

package/providers/fake/src/schema/capabilities.schema.ts

@@ -4,7 +4,9 @@ import { z } from 'zod';
 export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
     product: true,
     search: true,
-    identity: true
+    identity: true,
+    category: true,
+    cart: true,
 }).partial();
 
-export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;
+export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/providers/fake/src/schema/configuration.schema.ts

@@ -10,6 +10,11 @@ export const FakeConfigurationSchema = z.looseInterface({
       mean: 0,
       deviation: 0,
     }),
+  seeds: z.looseInterface({
+    product: z.number().min(0).max(10000).default(1),
+    search: z.number().min(0).max(10000).default(1),
+    category: z.number().min(0).max(10000).default(1),
+  }),
 });
 
 export type FakeConfiguration = z.infer<typeof FakeConfigurationSchema>;

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

@@ -0,0 +1,126 @@
+import 'dotenv/config';
+import { CartSchema, CategorySchema, IdentitySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
+import { createAnonymousTestSession, getFakerTestConfiguration } from './test-utils';
+import { FakeCartProvider } from '../providers/cart.provider';
+import { FakeIdentityProvider } from '../providers';
+
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01-with-tiers'
+}
+
+describe('Fake Cart Provider', () => {
+  let provider: FakeCartProvider;
+  let identityProvider: FakeIdentityProvider;
+  let session: Session;
+
+  beforeAll( () => {
+    provider = new FakeCartProvider(getFakerTestConfiguration(), CartSchema, new NoOpCache());
+    identityProvider = new FakeIdentityProvider(getFakerTestConfiguration(), IdentitySchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  });
+
+  describe('anonymous sessions', () => {
+    it('should be able to get an empty cart', async () => {
+      const cart = await provider.getById({
+        cart: { key: '' },
+      }, session);
+
+      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: '' },
+          product: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, session);
+
+      expect(cart.identifier.key).toBeDefined();
+      expect(cart.items.length).toBe(1);
+      expect(cart.items[0].product.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(session.languageContext.currencyCode);
+
+      expect(cart.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.price.grandTotal.currency).toBe(session.languageContext.currencyCode);
+
+      expect(cart.price.grandTotal.value).toBe(cart.items[0].price.totalPrice.value);
+
+
+      expect(cart.meta?.placeholder).toBeFalsy();
+
+    });
+
+
+    it('should be able to change quantity of an item in a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          product: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, session);
+
+      const updatedCart = await provider.changeQuantity({
+        cart: cart.identifier,
+        item: cart.items[0].identifier,
+        quantity: 3
+      }, session);
+
+      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+      expect(updatedCart.items.length).toBe(1);
+      expect(updatedCart.items[0].product.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: '' },
+          product: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, session);
+
+      const updatedCart = await provider.remove({
+        cart: cart.identifier,
+        item: cart.items[0].identifier,
+      }, session);
+      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+      expect(updatedCart.items.length).toBe(0);
+    });
+
+    /**
+    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 () => { });
+    */
+
+  });
+
+});