@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,106 @@
+import {
+  OrderProvider,
+  OrderQueryByIdSchema,
+  OrderSchema,
+  Reactionary,
+  success,
+  type Cache,
+  type NotFoundError,
+  type Order,
+  type OrderQueryById,
+  type RequestContext,
+  type Result,
+} from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker, en, base } from '@faker-js/faker';
+
+export class FakeOrderProvider extends OrderProvider {
+  protected config: FakeConfiguration;
+  protected generator: Faker;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext
+  ) {
+    super(cache, context);
+
+    this.config = config;
+
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product,
+    });
+  }
+
+  @Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema,
+  })
+  public override async getById(
+    payload: OrderQueryById
+  ): Promise<Result<Order, NotFoundError>> {
+    const order = {
+      identifier: payload.order,
+      inventoryStatus: 'Allocated',
+      items: [],
+      orderStatus: 'Shipped',
+      paymentInstructions: [],
+      userId: {
+        userId: '1234'
+      },
+      price: {
+        grandTotal: {
+          currency: 'USD',
+          value: this.generator.number.float({
+            min: 100,
+            max: 10000,
+            multipleOf: 25,
+          }),
+        },
+        totalDiscount: {
+          currency: 'USD',
+          value: this.generator.number.float({
+            min: 100,
+            max: 10000,
+            multipleOf: 25,
+          }),
+        },
+        totalProductPrice: {
+          currency: 'USD',
+          value: this.generator.number.float({
+            min: 100,
+            max: 10000,
+            multipleOf: 25,
+          }),
+        },
+        totalShipping: {
+          currency: 'USD',
+          value: this.generator.number.float({
+            min: 100,
+            max: 10000,
+            multipleOf: 25,
+          }),
+        },
+        totalSurcharge: {
+          currency: 'USD',
+          value: this.generator.number.float({
+            min: 100,
+            max: 10000,
+            multipleOf: 25,
+          }),
+        },
+        totalTax: {
+          currency: 'USD',
+          value: this.generator.number.float({
+            min: 100,
+            max: 10000,
+            multipleOf: 25,
+          }),
+        },
+      },
+    } satisfies Order;
+
+    return success(order);
+  }
+}

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

@@ -1,46 +1,109 @@
 import {
-  type Price,
-  type PriceQueryBySku,
   type RequestContext,
   type Cache,
   PriceProvider,
+  type CustomerPriceQuery,
+  type ListPriceQuery,
+  type Price,
+  Reactionary,
+  CustomerPriceQuerySchema,
+  PriceSchema,
+  ListPriceQuerySchema,
+  error,
+  success,
+  type Result,
 } from '@reactionary/core';
 import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 
-export class FakePriceProvider<
-  T extends Price = Price
-> extends PriceProvider<T> {
+export class FakePriceProvider extends PriceProvider {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext
+  ) {
+    super(cache, context);
 
     this.config = config;
   }
 
-  public override async getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]> {
+  @Reactionary({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+  public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
+    if (payload.variant.sku === 'unknown-sku') {
+      return success(this.createEmptyPriceResult(payload.variant.sku));
+    }
 
-    const promises = payload.map(p => this.getBySKU(p, reqCtx));
-    const result = await Promise.all(promises);
-    return result;
-  }
+    // Generate a simple hash from the SKU key string for seeding
+    let hash = 0;
+    const skuString = payload.variant.sku;
+    for (let i = 0; i < skuString.length; i++) {
+      hash = (hash << 5) - hash + skuString.charCodeAt(i);
+      hash = hash & hash; // Convert to 32bit integer
+    }
 
-  public override async getBySKU(
-    payload: PriceQueryBySku,
-    _reqCtx: RequestContext
-  ): Promise<T> {
+    const generator = new Faker({
+      seed: hash || 42,
+      locale: [en, base],
+    });
 
-    if (payload.sku.key === 'unknown-sku') {
-      return this.createEmptyPriceResult(payload.sku.key, _reqCtx.languageContext.currencyCode);
+    const model = {
+      identifier: {
+        variant: payload.variant,
+      },
+      unitPrice: {
+        value: generator.number.int({ min: 300, max: 100000 }) / 100,
+        currency: this.context.languageContext.currencyCode,
+      },
+    } as Price;
+
+    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: this.context.languageContext.currencyCode,
+          },
+        },
+        {
+          minimumQuantity: generator.number.int({ min: 6, max: 10 }),
+          price: {
+            value: tier2Price,
+            currency: this.context.languageContext.currencyCode,
+          },
+        },
+      ];
+    } else {
+      model.tieredPrices = [];
+    }
+
+    return success(model);
+  }
+
+  @Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+  public override async getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>> {
+    if (payload.variant.sku === 'unknown-sku') {
+      return success(this.createEmptyPriceResult(payload.variant.sku));
     }
 
     // Generate a simple hash from the SKU key string for seeding
     let hash = 0;
-    const skuString = payload.sku.key;
+    const skuString = payload.variant.sku;
     for (let i = 0; i < skuString.length; i++) {
-      hash = ((hash << 5) - hash) + skuString.charCodeAt(i);
+      hash = (hash << 5) - hash + skuString.charCodeAt(i);
       hash = hash & hash; // Convert to 32bit integer
     }
 
@@ -49,24 +112,15 @@ export class FakePriceProvider<
       locale: [en, base],
     });
 
-
-    const model = this.newModel();
-    Object.assign(model, {
+    const model = {
       identifier: {
-        sku: payload.sku,
+        variant: payload.variant,
       },
       unitPrice: {
         value: generator.number.int({ min: 300, max: 100000 }) / 100,
-        currency: _reqCtx.languageContext.currencyCode,
+        currency: this.context.languageContext.currencyCode,
       },
-      meta: {
-        cache: {
-          hit: false,
-          key: payload.sku.key,
-        },
-        placeholder: false,
-      },
-    });
+    } as Price;
 
     if (skuString.includes('with-tiers')) {
       const unitPrice = model.unitPrice?.value || 0;
@@ -78,23 +132,21 @@ export class FakePriceProvider<
           minimumQuantity: generator.number.int({ min: 2, max: 5 }),
           price: {
             value: tier1Price,
-            currency: _reqCtx.languageContext.currencyCode,
-          }
+            currency: this.context.languageContext.currencyCode,
+          },
         },
         {
           minimumQuantity: generator.number.int({ min: 6, max: 10 }),
           price: {
             value: tier2Price,
-            currency: _reqCtx.languageContext.currencyCode,
-          }
-        }
+            currency: this.context.languageContext.currencyCode,
+          },
+        },
       ];
     } else {
       model.tieredPrices = [];
     }
 
-
-
-    return this.assert(model);
+    return success(model);
   }
 }

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

@@ -0,0 +1,206 @@
+import {
+  ImageSchema,
+  ProductSearchProvider,
+  ProductSearchQueryByTermSchema,
+  ProductSearchResultItemSchema,
+  ProductSearchResultSchema,
+  Reactionary,
+  success,
+  error,
+} from '@reactionary/core';
+import type {
+  ProductSearchResult,
+  ProductSearchResultFacet,
+  ProductSearchResultItem,
+  Cache as ReactionaryCache,
+  Image,
+  FacetIdentifier,
+  FacetValueIdentifier,
+  ProductSearchResultFacetValue,
+  ProductSearchResultItemVariant,
+  ProductSearchQueryCreateNavigationFilter,
+  Result,
+} from '@reactionary/core';
+import type {
+  RequestContext,
+  ProductSearchQueryByTerm,
+} from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker, en, base } from '@faker-js/faker';
+import { jitter } from '../utilities/jitter.js';
+
+export class FakeSearchProvider extends ProductSearchProvider {
+  protected config: FakeConfiguration;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: ReactionaryCache,
+    context: RequestContext
+  ) {
+    super(cache, context);
+
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema,
+  })
+  public override async queryByTerm(
+    payload: ProductSearchQueryByTerm
+  ): Promise<Result<ProductSearchResult>> {
+    await jitter(this.config.jitter.mean, this.config.jitter.deviation);
+
+    const query = payload.search;
+
+    const querySpecificity =
+      20 -
+      query.term.length -
+      query.paginationOptions.pageNumber -
+      query.facets.length;
+    const totalProducts = 10 * querySpecificity;
+    const totalPages = Math.ceil(
+      totalProducts / query.paginationOptions.pageSize
+    );
+    const productsOnPage = Math.min(
+      totalProducts,
+      query.paginationOptions.pageSize
+    );
+
+    const productGenerator = new Faker({
+      seed: querySpecificity,
+      locale: [en, base],
+    });
+
+    const facetGenerator = new Faker({
+      seed: 100,
+      locale: [en, base],
+    });
+
+    const products = new Array<ProductSearchResultItem>();
+    const facets = new Array<ProductSearchResultFacet>();
+
+    for (let i = 0; i < productsOnPage; i++) {
+      const srcUrl = productGenerator.image.urlPicsumPhotos({
+        height: 300,
+        width: 300,
+        grayscale: true,
+        blur: 8,
+      });
+
+      const img = ImageSchema.parse({
+        sourceUrl: srcUrl,
+        altText: 'Fake product image',
+        height: 300,
+        width: 300,
+      } satisfies Partial<Image>);
+
+      products.push(
+        ProductSearchResultItemSchema.parse({
+          identifier: {
+            key: 'product_' + productGenerator.commerce.isbn(),
+          },
+          name: productGenerator.commerce.productName(),
+          slug: productGenerator.lorem.slug(),
+          variants: [
+            {
+              variant: {
+                sku: productGenerator.commerce.isbn(),
+              },
+              image: img,
+              options: undefined,
+            } satisfies Partial<ProductSearchResultItemVariant>,
+          ],
+        } satisfies Partial<ProductSearchResultItem>)
+      );
+    }
+
+    const facetBase = ['color', 'size'];
+
+    for (const base of facetBase) {
+      const facet: ProductSearchResultFacet = {
+        identifier: {
+          key: base,
+        },
+        name: base,
+        values: [],
+      };
+
+      for (let i = 0; i < 10; i++) {
+        const valueKey = i.toString();
+        const isActive =
+          query.facets.find(
+            (x) => x.facet.key === facet.identifier.key && x.key === valueKey
+          ) !== undefined;
+
+        facet.values.push({
+          active: isActive,
+          count: facetGenerator.number.int({ min: 1, max: 50 }),
+          identifier: {
+            facet: {
+              key: facet.identifier.key,
+            },
+            key: valueKey,
+          },
+          name: facetGenerator.color.human(),
+        });
+      }
+
+      facets.push(facet);
+    }
+
+    const result = ProductSearchResultSchema.parse({
+      identifier: {
+        term: query.term,
+        paginationOptions: {
+          pageNumber: query.paginationOptions.pageNumber,
+          pageSize: query.paginationOptions.pageSize,
+        },
+        facets: query.facets,
+        filters: [],
+      },
+      facets: facets,
+      items: products,
+      pageNumber: query.paginationOptions.pageNumber,
+      pageSize: query.paginationOptions.pageSize,
+      totalCount: totalProducts,
+      totalPages: totalPages,
+    } satisfies ProductSearchResult);
+
+    return success(result);
+  }
+
+  public override async createCategoryNavigationFilter(
+    payload: ProductSearchQueryCreateNavigationFilter
+  ): Promise<Result<FacetValueIdentifier>> {
+    const facetIdentifier = {
+      key: 'category',
+    } satisfies FacetIdentifier;
+    const facetValueIdentifier = {
+      facet: facetIdentifier,
+      key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key,
+    } satisfies FacetValueIdentifier;
+
+    return success(facetValueIdentifier);
+  }
+
+  protected override parseFacetValue(
+    facetValueIdentifier: FacetValueIdentifier,
+    label: string,
+    count: number
+  ): ProductSearchResultFacetValue {
+    throw new Error('Method not implemented.');
+  }
+  protected override parseFacet(
+    facetIdentifier: FacetIdentifier,
+    facetValue: unknown
+  ): ProductSearchResultFacet {
+    throw new Error('Method not implemented.');
+  }
+  protected override parseVariant(
+    variant: unknown,
+    product: unknown
+  ): ProductSearchResultItemVariant {
+    throw new Error('Method not implemented.');
+  }
+}

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

@@ -1,5 +1,4 @@
 import {
-  type Product,
   type ProductQueryById,
   type ProductQueryBySlug,
   type RequestContext,
@@ -7,79 +6,95 @@ import {
   ProductProvider,
   Reactionary,
   type ProductQueryBySKU,
+  type Product,
+  ProductQueryByIdSchema,
+  ProductSchema,
+  ProductQueryBySlugSchema,
+  ProductQueryBySKUSchema,
+  type Result,
+  error,
+  success,
+  type NotFoundError
 } from '@reactionary/core';
 import type z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 
-export class FakeProductProvider<
-  T extends Product = Product
-> extends ProductProvider<T> {
+export class FakeProductProvider extends ProductProvider {
   protected config: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache) {
-    super(schema, cache);
+  constructor(config: FakeConfiguration, cache: ReactinaryCache, context: RequestContext) {
+    super(cache, context);
 
     this.config = config;
   }
 
-  @Reactionary({})
+  @Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema
+  })
   public override async getById(
-    payload: ProductQueryById,
-    _reqCtx: RequestContext
-  ): Promise<T> {
-    return this.parseSingle(payload);
+    payload: ProductQueryById
+  ): Promise<Result<Product>> {
+    return success(this.parseSingle(payload.identifier.key));
   }
 
-  @Reactionary({})
+  @Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema
+  })
   public override async getBySlug(
-    payload: ProductQueryBySlug,
-    _reqCtx: RequestContext
-  ): Promise<T> {
-    return this.parseSingle(payload);
+    payload: ProductQueryBySlug
+  ): Promise<Result<Product, NotFoundError>> {
+    return success(this.parseSingle(payload.slug));
   }
 
-  @Reactionary({})
-  public override async getBySKU(payload: ProductQueryBySKU, reqCtx: RequestContext): Promise<T> {
-    return this.parseSingle(payload);
+  @Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema,
+  })
+  public override async getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>> {
+    return success(this.parseSingle(payload.variant.sku));
   }
 
-
-  protected override parseSingle(body: ProductQueryById | ProductQueryBySlug | ProductQueryBySKU): T {
+  protected parseSingle(body: string): Product {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const key = body.slug || body.id;
-
-    // Create a model instance based on the schema
-    const model = this.newModel();
+    const key = body;
 
     // Merge the generated data into the model
-    Object.assign(model, {
+    const result = {
       identifier: {
         key: key,
       },
       name: generator.commerce.productName(),
       slug: key,
-      attributes: [],
-      description: generator.commerce.productDescription(),
-      image: generator.image.urlPicsumPhotos({
-        width: 600,
-        height: 600,
-      }),
-      images: [],
-      meta: {
-        cache: {
-          hit: false,
-          key: key,
+      brand: '',
+      longDescription: '',
+      mainVariant: {
+        barcode: '',
+        ean: '',
+        gtin: '',
+        identifier: {
+          sku: ''
         },
-        placeholder: false,
+        images: [],
+        name: '',
+        options: [],
+        upc: ''
       },
-      skus: [],
-    });
+      description: generator.commerce.productDescription(),
+      manufacturer: '',
+      options: [],
+      parentCategories: [],
+      published: true,
+      sharedAttributes: [],
+      variants: [],
+    } satisfies Product
 
-    return this.assert(model);
+    return result;
   }
 }