@reactionary/source 0.3.18 → 0.6.2

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

@@ -1,7 +1,9 @@
 import { base, en, Faker } from '@faker-js/faker';
 import type {
   Cache,
-  Inventory,
+  InventoryFactory,
+  InventoryFactoryOutput,
+  InventoryFactoryWithOutput,
   InventoryIdentifier,
   InventoryQueryBySKU,
   InventoryStatus,
@@ -17,31 +19,37 @@ import {
   success,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
 
-export class FakeInventoryProvider extends InventoryProvider {
+export class FakeInventoryProvider<
+  TFactory extends InventoryFactory = FakeInventoryFactory,
+> extends InventoryProvider<InventoryFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: InventoryFactoryWithOutput<TFactory>;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: InventoryFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: InventoryQueryBySKUSchema,
-    outputSchema: InventorySchema
+    outputSchema: InventorySchema,
   })
-  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>> {
-    // Generate a simple hash from the SKU string for seeding
+  public override async getBySKU(
+    payload: InventoryQueryBySKU,
+  ): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>> {
     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
+    for (let i = 0; i < payload.variant.sku.length; i++) {
+      hash = (hash << 5) - hash + payload.variant.sku.charCodeAt(i);
+      hash &= hash;
     }
 
     const generator = new Faker({
@@ -49,24 +57,18 @@ export class FakeInventoryProvider extends InventoryProvider {
       locale: [en, base],
     });
 
-    const identifier = {
-      variant: payload.variant,
-      fulfillmentCenter: payload.fulfilmentCenter,
-    } satisfies InventoryIdentifier;
-
     const quantity = generator.number.int({ min: 0, max: 100 });
-
-    let status: InventoryStatus = 'outOfStock';
-    if (quantity > 0) {
-      status = 'inStock';
-    }
+    const status: InventoryStatus = quantity > 0 ? 'inStock' : 'outOfStock';
 
     const result = {
-      identifier,
+      identifier: {
+        variant: payload.variant,
+        fulfillmentCenter: payload.fulfilmentCenter,
+      } satisfies InventoryIdentifier,
       quantity,
-      status
-    } satisfies Inventory;
+      status,
+    };
 
-    return success(result);
+    return success(this.factory.parseInventory(this.context, result));
   }
 }

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

@@ -4,33 +4,41 @@ import {
   OrderSearchResultSchema,
   Reactionary,
   type Cache,
+  type OrderSearchFactory,
+  type OrderSearchFactoryOutput,
+  type OrderSearchFactoryWithOutput,
   type OrderSearchQueryByTerm,
   type OrderSearchResult,
+  type OrderSearchResultItem,
   type RequestContext,
   type Result,
   success,
-  type OrderSearchResultItem,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker, en, base } from '@faker-js/faker';
+import type { FakeOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
 
-export class FakeOrderSearchProvider extends OrderSearchProvider {
+export class FakeOrderSearchProvider<
+  TFactory extends OrderSearchFactory = FakeOrderSearchFactory,
+> extends OrderSearchProvider<OrderSearchFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
   protected generator: Faker;
+  protected factory: OrderSearchFactoryWithOutput<TFactory>;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: OrderSearchFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
-
     this.generator = new Faker({
       locale: [en, base],
       seed: config.seeds.product,
     });
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -38,41 +46,41 @@ export class FakeOrderSearchProvider extends OrderSearchProvider {
     outputSchema: OrderSearchResultSchema,
   })
   public override async queryByTerm(
-    payload: OrderSearchQueryByTerm
-  ): Promise<Result<OrderSearchResult>> {
-    const items = new Array<OrderSearchResultItem>();
+    payload: OrderSearchQueryByTerm,
+  ): Promise<Result<OrderSearchFactoryOutput<TFactory>>> {
+    const items: OrderSearchResultItem[] = [];
 
     for (let i = 0; i < payload.search.paginationOptions.pageSize; i++) {
-        items.push({
-            customerName: this.generator.company.name(),
-            identifier: {
-                key: this.generator.string.uuid()
-            },
-            inventoryStatus: 'Allocated',
-            orderDate: this.generator.date.past().toString(),
-            orderStatus: 'Shipped',
-            totalAmount: {
-                currency: 'USD',
-                value: this.generator.number.int({ multipleOf: 100 })
-            },
-            userId: {
-                userId: '1234'
-            }
-        });
+      items.push({
+        customerName: this.generator.company.name(),
+        identifier: {
+          key: this.generator.string.uuid(),
+        },
+        inventoryStatus: 'Allocated',
+        orderDate: this.generator.date.past().toString(),
+        orderStatus: 'Shipped',
+        totalAmount: {
+          currency: 'USD',
+          value: this.generator.number.int({ multipleOf: 100 }),
+        },
+        userId: {
+          userId: '1234',
+        },
+      });
     }
 
     const totalCount = this.generator.number.int({ min: items.length, max: 200 });
     const totalPages = Math.ceil(totalCount / payload.search.paginationOptions.pageSize);
 
     const result = {
-        identifier: payload.search,
-        items,
-        pageNumber: payload.search.paginationOptions.pageNumber,
-        pageSize: payload.search.paginationOptions.pageSize,
-        totalCount,
-        totalPages
+      identifier: payload.search,
+      items,
+      pageNumber: payload.search.paginationOptions.pageNumber,
+      pageSize: payload.search.paginationOptions.pageSize,
+      totalCount,
+      totalPages,
     } satisfies OrderSearchResult;
 
-    return success(result);
+    return success(this.factory.parseOrderSearchResult(this.context, result, payload));
   }
 }

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

@@ -7,30 +7,38 @@ import {
   type Cache,
   type NotFoundError,
   type Order,
+  type OrderFactory,
+  type OrderFactoryOutput,
+  type OrderFactoryWithOutput,
   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';
+import type { FakeOrderFactory } from '../factories/order/order.factory.js';
 
-export class FakeOrderProvider extends OrderProvider {
+export class FakeOrderProvider<
+  TFactory extends OrderFactory = FakeOrderFactory,
+> extends OrderProvider<OrderFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
   protected generator: Faker;
+  protected factory: OrderFactoryWithOutput<TFactory>;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: OrderFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
-
     this.generator = new Faker({
       locale: [en, base],
       seed: config.seeds.product,
     });
+    this.factory = factory;
   }
 
   @Reactionary({
@@ -38,8 +46,8 @@ export class FakeOrderProvider extends OrderProvider {
     outputSchema: OrderSchema,
   })
   public override async getById(
-    payload: OrderQueryById
-  ): Promise<Result<Order, NotFoundError>> {
+    payload: OrderQueryById,
+  ): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>> {
     const order = {
       identifier: payload.order,
       inventoryStatus: 'Allocated',
@@ -47,60 +55,36 @@ export class FakeOrderProvider extends OrderProvider {
       orderStatus: 'Shipped',
       paymentInstructions: [],
       userId: {
-        userId: '1234'
+        userId: '1234',
       },
       price: {
         grandTotal: {
           currency: 'USD',
-          value: this.generator.number.float({
-            min: 100,
-            max: 10000,
-            multipleOf: 25,
-          }),
+          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,
-          }),
+          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,
-          }),
+          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,
-          }),
+          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,
-          }),
+          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,
-          }),
+          value: this.generator.number.float({ min: 100, max: 10000, multipleOf: 25 }),
         },
       },
     } satisfies Order;
 
-    return success(order);
+    return success(this.factory.parseOrder(this.context, order));
   }
 }

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

@@ -1,30 +1,37 @@
 import {
-  type RequestContext,
-  type Cache,
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
   PriceProvider,
+  PriceSchema,
+  Reactionary,
+  success,
+  type Cache,
   type CustomerPriceQuery,
   type ListPriceQuery,
   type Price,
-  Reactionary,
-  CustomerPriceQuerySchema,
-  PriceSchema,
-  ListPriceQuerySchema,
-  error,
-  success,
+  type PriceFactory,
+  type PriceFactoryOutput,
+  type PriceFactoryWithOutput,
+  type RequestContext,
   type Result,
 } from '@reactionary/core';
-import type * as z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 import { calcSeed } from '../utilities/seed.js';
+import type { FakePriceFactory } from '../factories/price/price.factory.js';
 
-export class FakePriceProvider extends PriceProvider {
+export class FakePriceProvider<
+  TFactory extends PriceFactory = FakePriceFactory,
+> extends PriceProvider<PriceFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
   protected faker: Faker;
+  protected factory: PriceFactoryWithOutput<TFactory>;
+
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: PriceFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
@@ -32,6 +39,7 @@ export class FakePriceProvider extends PriceProvider {
     this.faker = new Faker({
       locale: [en, base],
     });
+    this.factory = factory;
   }
 
   protected createPrice(variantSku: string, mode: 'list' | 'customer'): Price {
@@ -40,34 +48,30 @@ export class FakePriceProvider extends PriceProvider {
     let price = this.faker.number.int({ min: 300, max: 100000 }) / 100;
     let onSale = false;
     if (mode === 'customer') {
-      // For customer price, randomly decide if the product is on sale
-      onSale = this.faker.datatype.boolean({ probability: 0.1 }); // 10% chance of being on sale
-
+      onSale = this.faker.datatype.boolean({ probability: 0.1 });
       if (onSale) {
-        price = price * this.faker.number.float({ min: 0.5, max: 0.9 }); // Apply a random discount between 10% and 50%
+        price = price * this.faker.number.float({ min: 0.5, max: 0.9 });
       }
     }
 
     const tiers = [];
     if (variantSku.includes('with-tiers')) {
-      // Add tiered pricing for SKUs that include "with-tiers"
       tiers.push({
         minimumQuantity: this.faker.number.int({ min: 2, max: 5 }),
         price: {
-          value: price * 0.8, // 20% discount for tier 1
+          value: price * 0.8,
           currency: this.context.languageContext.currencyCode,
         },
       });
       tiers.push({
         minimumQuantity: this.faker.number.int({ min: 6, max: 10 }),
         price: {
-          value: price * 0.6, // 40% discount for tier 2
+          value: price * 0.6,
           currency: this.context.languageContext.currencyCode,
         },
       });
     }
 
-
     return {
       identifier: {
         variant: {
@@ -80,32 +84,36 @@ export class FakePriceProvider extends PriceProvider {
       },
       onSale,
       tieredPrices: tiers,
-    }
+    };
   }
 
-
-
   @Reactionary({
     inputSchema: ListPriceQuerySchema,
-    outputSchema: PriceSchema
+    outputSchema: PriceSchema,
   })
-  public override async getListPrice(payload: ListPriceQuery): Promise<Result<Price>> {
-    if (payload.variant.sku === 'unknown-sku') {
-      return success(this.createEmptyPriceResult(payload.variant.sku));
-    }
+  public override async getListPrice(
+    payload: ListPriceQuery,
+  ): Promise<Result<PriceFactoryOutput<TFactory>>> {
+    const base =
+      payload.variant.sku === 'unknown-sku'
+        ? this.createEmptyPriceResult(payload.variant.sku)
+        : this.createPrice(payload.variant.sku, 'list');
 
-    return success(this.createPrice(payload.variant.sku, 'list'));
+    return success(this.factory.parsePrice(this.context, base));
   }
 
   @Reactionary({
     inputSchema: CustomerPriceQuerySchema,
-    outputSchema: PriceSchema
+    outputSchema: PriceSchema,
   })
-  public override async getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>> {
-    if (payload.variant.sku === 'unknown-sku') {
-      return success(this.createEmptyPriceResult(payload.variant.sku));
-    }
+  public override async getCustomerPrice(
+    payload: CustomerPriceQuery,
+  ): Promise<Result<PriceFactoryOutput<TFactory>>> {
+    const base =
+      payload.variant.sku === 'unknown-sku'
+        ? this.createEmptyPriceResult(payload.variant.sku)
+        : this.createPrice(payload.variant.sku, 'customer');
 
-    return success(this.createPrice(payload.variant.sku, 'customer'));
+    return success(this.factory.parsePrice(this.context, base));
   }
 }

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

@@ -7,23 +7,36 @@ import {
   type Result,
   success,
   type ProductAssociation,
+  type Cache,
   type ProductSearchResultItem,
+  type RequestContext,
+} from '@reactionary/core';
+import type {
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryOutput,
+  ProductAssociationsFactoryWithOutput,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-import { base, en, Faker } from '@faker-js/faker';
+import { en, Faker } from '@faker-js/faker';
 import { calcSeed } from '../utilities/seed.js';
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
 
-export class FakeProductAssociationsProvider extends ProductAssociationsProvider {
+export class FakeProductAssociationsProvider<
+  TFactory extends ProductAssociationsFactory = FakeProductAssociationsFactory,
+> extends ProductAssociationsProvider<ProductAssociationsFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
   protected faker: Faker;
 
   constructor(
     config: FakeConfiguration,
-    cache: any,
-    context: any
+    cache: Cache,
+    context: RequestContext,
+    factory: ProductAssociationsFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
     this.faker = new Faker({ locale: [en] });
   }
 
@@ -35,7 +48,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
   })
   public override async getAccessories(
     query: ProductAssociationsGetAccessoriesQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfAccessories || 4, 'accessory');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -46,7 +59,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   @Reactionary({
@@ -57,7 +70,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
   })
   public override async getSpareparts(
     query: ProductAssociationsGetSparepartsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfSpareparts || 4, 'sparepart');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -68,7 +81,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   @Reactionary({
@@ -79,7 +92,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
   })
   public override async getReplacements(
     query: ProductAssociationsGetReplacementsQuery
-  ): Promise<Result<ProductAssociation[]>> {
+  ): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>> {
     const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfReplacements || 4, 'replacement');
 
     const result: ProductAssociation[] = associatedProducts.map(product => ({
@@ -90,7 +103,7 @@ export class FakeProductAssociationsProvider extends ProductAssociationsProvider
       product,
     } satisfies ProductAssociation));
 
-    return success(result);
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
   }
 
   private generateFakeAssociatedProducts(baseProductKey: string, count: number, type: string): ProductSearchResultItem[] {