@reactionary/provider-fake 0.0.36 → 0.0.38

package/core/initialize.js

@@ -1,6 +1,8 @@
-import { ProductSchema, SearchResultSchema } from "@reactionary/core";
+import { ProductSchema, SearchResultSchema, CategorySchema, CartSchema } from "@reactionary/core";
 import { FakeProductProvider } from "../providers/product.provider";
 import { FakeSearchProvider } from "../providers/search.provider";
+import { FakeCategoryProvider } from "../providers/category.provider";
+import { FakeCartProvider } from "../providers";
 function withFakeCapabilities(configuration, capabilities) {
   return (cache) => {
     const client = {};
@@ -10,6 +12,12 @@ function withFakeCapabilities(configuration, capabilities) {
     if (capabilities.search) {
       client.search = new FakeSearchProvider(configuration, SearchResultSchema, cache);
     }
+    if (capabilities.category) {
+      client.category = new FakeCategoryProvider(configuration, CategorySchema, cache);
+    }
+    if (capabilities.cart) {
+      client.cart = new FakeCartProvider(configuration, CartSchema, cache);
+    }
     return client;
   };
 }

package/index.js

@@ -1,10 +1,4 @@
 export * from "./core/initialize";
-export * from "./providers/analytics.provider";
-export * from "./providers/cart.provider";
-export * from "./providers/identity.provider";
-export * from "./providers/inventory.provider";
-export * from "./providers/price.provider";
-export * from "./providers/product.provider";
-export * from "./providers/search.provider";
+export * from "./providers/";
 export * from "./schema/capabilities.schema";
 export * from "./schema/configuration.schema";

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@reactionary/provider-fake",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.36",
-    "@reactionary/otel": "0.0.36",
+    "@reactionary/core": "0.0.38",
+    "@reactionary/otel": "0.0.38",
     "zod": "4.0.0-beta.20250430T185432",
     "@faker-js/faker": "^9.8.0"
   }

package/providers/cart.provider.js

@@ -1,14 +1,27 @@
 import {
   CartProvider
 } from "@reactionary/core";
+import { Faker, en, base } from "@faker-js/faker/.";
 class FakeCartProvider extends CartProvider {
   constructor(config, schema, cache) {
     super(schema, cache);
     this.carts = /* @__PURE__ */ new Map();
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product
+    });
     this.config = config;
   }
   async getById(payload, _session) {
     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, {
@@ -31,38 +44,77 @@ class FakeCartProvider extends CartProvider {
     return cart;
   }
   async add(payload, session) {
-    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: 1e5 }) / 100;
       cart.items.push({
         identifier: { key: `item-${Date.now()}` },
         product: payload.product,
-        quantity: payload.quantity
+        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);
   }
   async remove(payload, session) {
-    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);
   }
   async changeQuantity(payload, session) {
-    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(
       (item2) => item2.identifier.key === payload.item.key
     );
     if (item) {
       item.quantity = payload.quantity;
     }
+    this.recalculateCart(cart);
     return this.assert(cart);
   }
+  recalculateCart(cart) {
+    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"
+    };
+  }
 }
 export {
   FakeCartProvider

package/providers/category.provider.js

@@ -0,0 +1,122 @@
+import { CategoryProvider } from "@reactionary/core";
+import { Faker, en, base } from "@faker-js/faker";
+class FakeCategoryProvider extends CategoryProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.topCategories = new Array();
+    this.childCategories = /* @__PURE__ */ new Map();
+    this.allCategories = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.categoryGenerator = new Faker({
+      seed: this.config.seeds.category,
+      locale: [en, base]
+    });
+    for (let i = 0; i < 6; i++) {
+      const category = this.generateFakeCategory(void 0, i);
+      this.topCategories.push(category);
+    }
+    this.topCategories.forEach((parentCategory) => {
+      const children = new Array();
+      for (let j = 0; j < 5; j++) {
+        const childCategory = this.generateFakeCategory(parentCategory, j);
+        children.push(childCategory);
+        const subCategoryChildren = new Array();
+        for (let k = 0; k < 5; k++) {
+          const subChildCategory = this.generateFakeCategory(childCategory, k);
+          subCategoryChildren.push(subChildCategory);
+        }
+        this.childCategories.set(childCategory.identifier.key, subCategoryChildren);
+      }
+      this.childCategories.set(parentCategory.identifier.key, children);
+    });
+  }
+  generateFakeCategory(parent, index) {
+    let name;
+    if (!parent) {
+      name = this.categoryGenerator.commerce.department();
+    } else {
+      name = `${parent.name}-${index}`;
+    }
+    const category = 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;
+  }
+  async getById(payload, session) {
+    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;
+  }
+  getBySlug(payload, session) {
+    for (const p of this.allCategories.values()) {
+      if (p.slug === payload.slug) {
+        return Promise.resolve(p);
+      }
+    }
+    return Promise.resolve(null);
+  }
+  getBreadcrumbPathToCategory(payload, session) {
+    const path = new Array();
+    let category = this.allCategories.get(payload.id.key);
+    path.push(category);
+    while (category?.parentCategory) {
+      category = this.allCategories.get(category.parentCategory.key);
+      if (category) {
+        path.unshift(category);
+      }
+    }
+    return Promise.resolve(path);
+  }
+  async findChildCategories(payload, session) {
+    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 : [],
+      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);
+  }
+  findTopCategories(payload, session) {
+    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 : [],
+      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);
+  }
+}
+export {
+  FakeCategoryProvider
+};

package/providers/index.js

@@ -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/inventory.provider.js

@@ -9,7 +9,7 @@ class FakeInventoryProvider extends InventoryProvider {
   }
   async getBySKU(payload, _session) {
     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;
@@ -19,16 +19,26 @@ class FakeInventoryProvider extends InventoryProvider {
       locale: [en, base]
     });
     const model = this.newModel();
-    Object.assign(model, {
-      quantity: generator.number.int({ min: 0, max: 100 }),
-      meta: {
-        cache: {
-          hit: false,
-          key: payload.sku
-        },
-        placeholder: false
+    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: this.generateCacheKeySingle(model.identifier, _session)
+      },
+      placeholder: false
+    };
     return this.assert(model);
   }
 }

package/providers/price.provider.js

@@ -7,7 +7,15 @@ class FakePriceProvider extends PriceProvider {
     super(schema, cache);
     this.config = config;
   }
+  async getBySKUs(payload, session) {
+    const promises = payload.map((p) => this.getBySKU(p, session));
+    const result = await Promise.all(promises);
+    return result;
+  }
   async getBySKU(payload, _session) {
+    if (payload.sku.key === "unknown-sku") {
+      return this.getEmptyPriceResult(payload.sku.key, _session.languageContext.currencyCode);
+    }
     let hash = 0;
     const skuString = payload.sku.key;
     for (let i = 0; i < skuString.length; i++) {
@@ -23,18 +31,41 @@ class FakePriceProvider extends PriceProvider {
       identifier: {
         sku: payload.sku
       },
-      value: {
-        cents: generator.number.int({ min: 100, max: 1e5 }),
-        currency: "USD"
+      unitPrice: {
+        value: generator.number.int({ min: 300, max: 1e5 }) / 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;
+      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/product.provider.js

@@ -2,13 +2,11 @@ import {
   ProductProvider
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
-import { traced } from "@reactionary/otel";
 class FakeProductProvider extends ProductProvider {
   constructor(config, schema, cache) {
     super(schema, cache);
     this.config = config;
   }
-  @traced()
   async getById(payload, _session) {
     return this.parseSingle(payload);
   }

package/schema/capabilities.schema.js

@@ -2,7 +2,9 @@ import { CapabilitiesSchema } from "@reactionary/core";
 const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
   search: true,
-  identity: true
+  identity: true,
+  category: true,
+  cart: true
 }).partial();
 export {
   FakeCapabilitiesSchema

package/schema/configuration.schema.js

@@ -6,6 +6,11 @@ const FakeConfigurationSchema = z.looseInterface({
   }).default({
     mean: 0,
     deviation: 0
+  }),
+  seeds: z.looseInterface({
+    product: z.number().min(0).max(1e4).default(1),
+    search: z.number().min(0).max(1e4).default(1),
+    category: z.number().min(0).max(1e4).default(1)
   })
 });
 export {

package/src/core/initialize.d.ts

@@ -1,10 +1,12 @@
-import { Cache as ReactinaryCache, ProductProvider, SearchProvider, IdentityProvider } from "@reactionary/core";
+import { Cache as ReactinaryCache, ProductProvider, SearchProvider, IdentityProvider, CategoryProvider, CartProvider } from "@reactionary/core";
 import { FakeConfiguration } from "../schema/configuration.schema";
 import { FakeCapabilities } from "../schema/capabilities.schema";
 type FakeClient<T extends FakeCapabilities> = Partial<{
+    cart: T['cart'] extends true ? CartProvider : never;
     product: T['product'] extends true ? ProductProvider : never;
     search: T['search'] extends true ? SearchProvider : never;
     identity: T['identity'] extends true ? IdentityProvider : never;
+    category: T['category'] extends true ? CategoryProvider : never;
 }>;
 export declare function withFakeCapabilities<T extends FakeCapabilities>(configuration: FakeConfiguration, capabilities: T): (cache: ReactinaryCache) => FakeClient<T>;
 export {};

package/src/index.d.ts

@@ -1,10 +1,4 @@
 export * from './core/initialize';
-export * from './providers/analytics.provider';
-export * from './providers/cart.provider';
-export * from './providers/identity.provider';
-export * from './providers/inventory.provider';
-export * from './providers/price.provider';
-export * from './providers/product.provider';
-export * from './providers/search.provider';
+export * from './providers/';
 export * from './schema/capabilities.schema';
 export * from './schema/configuration.schema';

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

@@ -4,9 +4,11 @@ import { FakeConfiguration } from '../schema/configuration.schema';
 export declare class FakeCartProvider<T extends Cart = Cart> extends CartProvider<T> {
     protected config: FakeConfiguration;
     private carts;
+    private generator;
     constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache);
     getById(payload: CartQueryById, _session: Session): Promise<T>;
     add(payload: CartMutationItemAdd, session: Session): Promise<T>;
     remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
     changeQuantity(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
+    protected recalculateCart(cart: T): void;
 }

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

@@ -0,0 +1,19 @@
+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 } from '@faker-js/faker';
+export declare class FakeCategoryProvider<T extends Category = Category> extends CategoryProvider<T> {
+    protected config: FakeConfiguration;
+    protected topCategories: T[];
+    protected childCategories: Map<string, T[]>;
+    protected allCategories: Map<string, T>;
+    protected categoryGenerator: Faker;
+    protected generateFakeCategory(parent: Category | undefined, index: number): T;
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactionaryCache);
+    getById(payload: CategoryQueryById, session: Session): Promise<T>;
+    getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]>;
+    findChildCategories(payload: CategoryQueryForChildCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+    findTopCategories(payload: CategoryQueryForTopCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+}

package/src/providers/index.d.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/src/providers/price.provider.d.ts

@@ -4,5 +4,6 @@ import { FakeConfiguration } from '../schema/configuration.schema';
 export declare class FakePriceProvider<T extends Price = Price> extends PriceProvider<T> {
     protected config: FakeConfiguration;
     constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]>;
     getBySKU(payload: PriceQueryBySku, _session: Session): Promise<T>;
 }

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

@@ -1,8 +1,8 @@
-import { SearchProvider, SearchQueryByTerm, SearchResult, Session, Cache as ReactinaryCache } from '@reactionary/core';
+import { SearchProvider, SearchQueryByTerm, SearchResult, Session, Cache as ReactionaryCache } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 export declare 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);
     queryByTerm(payload: SearchQueryByTerm, _session: Session): Promise<SearchResult>;
 }

package/src/schema/capabilities.schema.d.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 export declare const FakeCapabilitiesSchema: z.ZodInterface<{
     identity: z.ZodOptional<z.ZodBoolean>;
-    search: z.ZodOptional<z.ZodBoolean>;
     product: z.ZodOptional<z.ZodBoolean>;
+    search: z.ZodOptional<z.ZodBoolean>;
+    cart: z.ZodOptional<z.ZodBoolean>;
+    category: z.ZodOptional<z.ZodBoolean>;
 }, {
-    optional: "identity" | "search" | "product";
+    optional: "identity" | "product" | "search" | "cart" | "category";
     defaulted: never;
     extra: Record<string, unknown>;
 }>;

package/src/schema/configuration.schema.d.ts

@@ -8,6 +8,15 @@ export declare const FakeConfigurationSchema: z.ZodInterface<{
         defaulted: never;
         extra: Record<string, unknown>;
     }>>;
+    seeds: z.ZodInterface<{
+        product: z.ZodDefault<z.ZodNumber>;
+        search: z.ZodDefault<z.ZodNumber>;
+        category: z.ZodDefault<z.ZodNumber>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
 }, {
     optional: never;
     defaulted: never;