@reactionary/source 0.6.1 → 0.6.3

package/{providers/fake/src/providers/identity.provider.ts → packages/fake/src/capabilities/identity.capability.ts}

@@ -1,102 +1,108 @@
 import {
+  type AnonymousIdentity,
+  type Cache,
   type Identity,
-  type IdentityQuerySelf,
+  type IdentityFactory,
+  type IdentityFactoryOutput,
+  type IdentityFactoryWithOutput,
   type IdentityMutationLogin,
+  IdentityMutationLoginSchema,
   type IdentityMutationLogout,
-  type RequestContext,
-  type Cache,
-  IdentityProvider,
+  IdentityMutationLogoutSchema,
   type IdentityMutationRegister,
-  type AnonymousIdentity,
-  type RegisteredIdentity,
-  Reactionary,
   IdentityMutationRegisterSchema,
-  IdentitySchema,
-  IdentityMutationLogoutSchema,
-  IdentityMutationLoginSchema,
+  type IdentityQuerySelf,
   IdentityQuerySelfSchema,
+  IdentityCapability,
+  IdentitySchema,
+  type RegisteredIdentity,
+  type RequestContext,
   type Result,
+  Reactionary,
   success,
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
 
-export class FakeIdentityProvider extends IdentityProvider {
+export class FakeIdentityCapability<
+  TFactory extends IdentityFactory = FakeIdentityFactory,
+> extends IdentityCapability<IdentityFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: IdentityFactoryWithOutput<TFactory>;
   private currentIdentity: Identity | null = null;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: IdentityFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: IdentityQuerySelfSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
   public override async getSelf(
-    _payload: IdentityQuerySelf
-  ): Promise<Result<Identity>> {
+    _payload: IdentityQuerySelf,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
     if (!this.currentIdentity) {
-      const model = {
+      this.currentIdentity = {
         type: 'Anonymous',
       } satisfies AnonymousIdentity;
-
-      this.currentIdentity = model;
     }
 
-    return success(this.currentIdentity);
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
   }
 
   @Reactionary({
     inputSchema: IdentityMutationLoginSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
   public override async login(
-    payload: IdentityMutationLogin
-  ): Promise<Result<Identity>> {
+    _payload: IdentityMutationLogin,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const model = {
+    this.currentIdentity = {
       type: 'Registered',
       id: {
         userId: generator.string.alphanumeric(32),
       },
     } satisfies RegisteredIdentity;
 
-    this.currentIdentity = model;
-
-    return success(this.currentIdentity);
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
   }
 
   @Reactionary({
     inputSchema: IdentityMutationLogoutSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
   public override async logout(
-    _payload: IdentityMutationLogout
-  ): Promise<Result<Identity>> {
-    const model = {
+    _payload: IdentityMutationLogout,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
+    this.currentIdentity = {
       type: 'Anonymous',
     } satisfies AnonymousIdentity;
 
-    this.currentIdentity = model;
-    return success(this.currentIdentity);
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
   }
 
   @Reactionary({
     inputSchema: IdentityMutationRegisterSchema,
-    outputSchema: IdentitySchema
+    outputSchema: IdentitySchema,
   })
-  public override register(payload: IdentityMutationRegister): Promise<Result<Identity>> {
+  public override register(
+    _payload: IdentityMutationRegister,
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
     throw new Error('Method not implemented.');
   }
 }

package/packages/fake/src/capabilities/index.ts

@@ -0,0 +1,15 @@
+export * from './analytics.capability.js';
+export * from './cart.capability.js';
+export * from './category.capability.js';
+export * from './checkout.capability.js';
+export * from './identity.capability.js';
+export * from './inventory.capability.js';
+export * from './order-search.capability.js';
+export * from './order.capability.js';
+export * from './price.capability.js';
+export * from './product.capability.js';
+export * from './product-associations.capability.js';
+export * from './product-reviews.capability.js';
+export * from './product-search.capability.js';
+export * from './profile.capability.js';
+export * from './store.capability.js';

package/packages/fake/src/capabilities/inventory.capability.ts

@@ -0,0 +1,74 @@
+import { base, en, Faker } from '@faker-js/faker';
+import type {
+  Cache,
+  InventoryFactory,
+  InventoryFactoryOutput,
+  InventoryFactoryWithOutput,
+  InventoryIdentifier,
+  InventoryQueryBySKU,
+  InventoryStatus,
+  NotFoundError,
+  RequestContext,
+  Result,
+} from '@reactionary/core';
+import {
+  InventoryCapability,
+  InventoryQueryBySKUSchema,
+  InventorySchema,
+  Reactionary,
+  success,
+} from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
+
+export class FakeInventoryCapability<
+  TFactory extends InventoryFactory = FakeInventoryFactory,
+> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
+  protected config: FakeConfiguration;
+  protected factory: InventoryFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: InventoryFactoryWithOutput<TFactory>,
+  ) {
+    super(cache, context);
+
+    this.config = config;
+    this.factory = factory;
+  }
+
+  @Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema,
+  })
+  public override async getBySKU(
+    payload: InventoryQueryBySKU,
+  ): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>> {
+    let hash = 0;
+    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({
+      seed: hash || 42,
+      locale: [en, base],
+    });
+
+    const quantity = generator.number.int({ min: 0, max: 100 });
+    const status: InventoryStatus = quantity > 0 ? 'inStock' : 'outOfStock';
+
+    const result = {
+      identifier: {
+        variant: payload.variant,
+        fulfillmentCenter: payload.fulfilmentCenter,
+      } satisfies InventoryIdentifier,
+      quantity,
+      status,
+    };
+
+    return success(this.factory.parseInventory(this.context, result));
+  }
+}

package/packages/fake/src/capabilities/order-search.capability.ts

@@ -0,0 +1,86 @@
+import {
+  OrderSearchCapability,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  type Cache,
+  type OrderSearchFactory,
+  type OrderSearchFactoryOutput,
+  type OrderSearchFactoryWithOutput,
+  type OrderSearchQueryByTerm,
+  type OrderSearchResult,
+  type OrderSearchResultItem,
+  type RequestContext,
+  type Result,
+  success,
+} 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 FakeOrderSearchCapability<
+  TFactory extends OrderSearchFactory = FakeOrderSearchFactory,
+> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
+  protected config: FakeConfiguration;
+  protected generator: Faker;
+  protected factory: OrderSearchFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    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({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public override async queryByTerm(
+    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',
+        },
+      });
+    }
+
+    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,
+    } satisfies OrderSearchResult;
+
+    return success(this.factory.parseOrderSearchResult(this.context, result, payload));
+  }
+}

package/{providers/fake/src/providers/order.provider.ts → packages/fake/src/capabilities/order.capability.ts}

@@ -1,5 +1,5 @@
 import {
-  OrderProvider,
+  OrderCapability,
   OrderQueryByIdSchema,
   OrderSchema,
   Reactionary,
@@ -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 FakeOrderCapability<
+  TFactory extends OrderFactory = FakeOrderFactory,
+> extends OrderCapability<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 → packages/fake/src/capabilities/price.capability.ts}

@@ -1,30 +1,37 @@
 import {
-  type RequestContext,
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
+  PriceCapability,
+  PriceSchema,
+  Reactionary,
+  success,
   type Cache,
-  PriceProvider,
   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 FakePriceCapability<
+  TFactory extends PriceFactory = FakePriceFactory,
+> extends PriceCapability<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));
   }
 }