@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,254 @@
+import {
+  CheckoutProvider,
+  type Checkout,
+  type CheckoutMutationAddPaymentInstruction,
+  type CheckoutMutationFinalizeCheckout,
+  type CheckoutMutationInitiateCheckout,
+  type CheckoutMutationRemovePaymentInstruction,
+  type CheckoutMutationSetShippingAddress,
+  type CheckoutMutationSetShippingInstruction,
+  type CheckoutQueryById,
+  type CheckoutQueryForAvailablePaymentMethods,
+  type CheckoutQueryForAvailableShippingMethods,
+  type NotFoundError,
+  type PaymentMethod,
+  type RequestContext,
+  type Result,
+  type ShippingMethod,
+  type Cache,
+  Reactionary,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutSchema,
+  CheckoutQueryByIdSchema,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutMutationAddPaymentInstructionSchema,
+  CheckoutMutationRemovePaymentInstructionSchema,
+  CheckoutMutationSetShippingInstructionSchema,
+  CheckoutMutationFinalizeCheckoutSchema,
+  success,
+  type CheckoutIdentifier,
+} from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { base, en, Faker } from '@faker-js/faker';
+
+export class FakeCheckoutProvider extends CheckoutProvider {
+  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: CheckoutMutationInitiateCheckoutSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async initiateCheckoutForCart(
+    payload: CheckoutMutationInitiateCheckout
+  ): Promise<Result<Checkout>> {
+    const checkout = this.composeBaseCheckout(payload.cart.identifier);
+
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutQueryByIdSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async getById(
+    payload: CheckoutQueryById
+  ): Promise<Result<Checkout, NotFoundError>> {
+    const checkout = this.composeBaseCheckout(payload.identifier);
+
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutMutationSetShippingAddressSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async setShippingAddress(
+    payload: CheckoutMutationSetShippingAddress
+  ): Promise<Result<Checkout>> {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async getAvailableShippingMethods(
+    payload: CheckoutQueryForAvailableShippingMethods
+  ): Promise<Result<ShippingMethod[]>> {
+    const methods = [
+      {
+        name: 'Fake',
+        deliveryTime: '3 days',
+        description: 'A fake delivery by fake mail',
+        identifier: {
+          key: 'fake-001',
+        },
+        price: {
+          currency: 'USD',
+          value: 500,
+        },
+        carrier: 'Faker',
+      },
+    ] satisfies Array<ShippingMethod>;
+
+    return success(methods);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async getAvailablePaymentMethods(
+    payload: CheckoutQueryForAvailablePaymentMethods
+  ): Promise<Result<PaymentMethod[]>> {
+    const methods = [
+      {
+        description: 'A fake payment method for paying at some point',
+        identifier: {
+          method: 'PayLater',
+          name: 'Pay Later',
+          paymentProcessor: 'Faker',
+        },
+        isPunchOut: false,
+      },
+    ] satisfies Array<PaymentMethod>;
+
+    return success(methods);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutMutationAddPaymentInstructionSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async addPaymentInstruction(
+    payload: CheckoutMutationAddPaymentInstruction
+  ): Promise<Result<Checkout>> {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutMutationRemovePaymentInstructionSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async removePaymentInstruction(
+    payload: CheckoutMutationRemovePaymentInstruction
+  ): Promise<Result<Checkout>> {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutMutationSetShippingInstructionSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async setShippingInstruction(
+    payload: CheckoutMutationSetShippingInstruction
+  ): Promise<Result<Checkout>> {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutMutationFinalizeCheckoutSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public override async finalizeCheckout(
+    payload: CheckoutMutationFinalizeCheckout
+  ): Promise<Result<Checkout>> {
+    const checkout = this.composeBaseCheckout(payload.checkout);
+
+    return success(checkout);
+  }
+
+  protected composeBaseCheckout(identifier?: CheckoutIdentifier) {
+    const checkout = {
+      description: 'Fake Checkout',
+      identifier: identifier || {
+        key: this.generator.string.uuid(),
+      },
+      items: [],
+      name: 'Fake Checkout',
+      originalCartReference: {
+        key: this.generator.string.uuid(),
+      },
+      paymentInstructions: [],
+      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
+          }),
+        },
+      },
+      readyForFinalization: false,
+    } satisfies Checkout;
+
+    return checkout;
+  }
+}

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

@@ -7,104 +7,96 @@ import {
   type Cache,
   IdentityProvider,
   type IdentityMutationRegister,
+  type AnonymousIdentity,
+  type RegisteredIdentity,
+  Reactionary,
+  IdentityMutationRegisterSchema,
+  IdentitySchema,
+  IdentityMutationLogoutSchema,
+  IdentityMutationLoginSchema,
+  IdentityQuerySelfSchema,
+  type Result,
+  success,
 } 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 FakeIdentityProvider<
-  T extends Identity = Identity
-> extends IdentityProvider<T> {
+export class FakeIdentityProvider extends IdentityProvider {
   protected config: FakeConfiguration;
-  private currentIdentity: T | null = null;
+  private currentIdentity: Identity | null = null;
 
-  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;
   }
 
+  @Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
   public override async getSelf(
-    _payload: IdentityQuerySelf,
-    _reqCtx: RequestContext
-  ): Promise<T> {
+    _payload: IdentityQuerySelf
+  ): Promise<Result<Identity>> {
     if (!this.currentIdentity) {
-      const model = this.newModel();
-      Object.assign(model, {
-        id: 'anonymous',
+      const model = {
         type: 'Anonymous',
-        issued: new Date(),
-        expiry: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
-        meta: {
-          cache: {
-            hit: false,
-            key: 'anonymous',
-          },
-          placeholder: false,
-        },
-      });
-      this.currentIdentity = this.assert(model);
+      } satisfies AnonymousIdentity;
+
+      this.currentIdentity = model;
     }
 
-    return this.currentIdentity;
+    return success(this.currentIdentity);
   }
 
+  @Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
   public override async login(
-    payload: IdentityMutationLogin,
-    _reqCtx: RequestContext
-  ): Promise<T> {
+    payload: IdentityMutationLogin
+  ): Promise<Result<Identity>> {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const model = this.newModel();
-    Object.assign(model, {
-      id: generator.string.uuid(),
+    const model = {
       type: 'Registered',
-      token: generator.string.alphanumeric(32),
-      issued: new Date(),
-      expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days from now
-      meta: {
-        cache: {
-          hit: false,
-          key: payload.username,
-        },
-        placeholder: false,
+      id: {
+        userId: generator.string.alphanumeric(32),
       },
-    });
+    } satisfies RegisteredIdentity;
+
+    this.currentIdentity = model;
 
-    this.currentIdentity = this.assert(model);
-    return this.currentIdentity;
+    return success(this.currentIdentity);
   }
 
+  @Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema
+  })
   public override async logout(
-    _payload: IdentityMutationLogout,
-    _reqCtx: RequestContext
-  ): Promise<T> {
-    const model = this.newModel();
-    Object.assign(model, {
-      id: 'anonymous',
+    _payload: IdentityMutationLogout
+  ): Promise<Result<Identity>> {
+    const model = {
       type: 'Anonymous',
-      issued: new Date(),
-      expiry: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
-      meta: {
-        cache: {
-          hit: false,
-          key: 'anonymous',
-        },
-        placeholder: false,
-      },
-    });
+    } satisfies AnonymousIdentity;
 
-    this.currentIdentity = this.assert(model);
-    return this.currentIdentity;
+    this.currentIdentity = model;
+    return success(this.currentIdentity);
   }
 
-  public override register(
-    payload: IdentityMutationRegister,
-    reqCtx: RequestContext
-  ): Promise<T> {
+  @Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+  public override register(payload: IdentityMutationRegister): Promise<Result<Identity>> {
     throw new Error('Method not implemented.');
   }
 }

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

@@ -1,9 +1,13 @@
 export * from './analytics.provider.js';
 export * from './cart.provider.js';
 export * from './category.provider.js';
+export * from './checkout.provider.js';
 export * from './identity.provider.js';
 export * from './inventory.provider.js';
+export * from './order-search.provider.js';
+export * from './order.provider.js';
 export * from './price.provider.js';
 export * from './product.provider.js';
-export * from './search.provider.js';
-export * from './store.provider.js';
+export * from './product-search.provider.js';
+export * from './profile.provider.js';
+export * from './store.provider.js';

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

@@ -1,36 +1,46 @@
+import { base, en, Faker } from '@faker-js/faker';
 import type {
+  Cache,
   Inventory,
+  InventoryIdentifier,
+  InventoryQueryBySKU,
+  InventoryStatus,
+  NotFoundError,
   RequestContext,
-  Cache,
-  InventoryQueryBySKU
+  Result,
 } from '@reactionary/core';
 import {
-  InventoryProvider
+  InventoryProvider,
+  InventoryQueryBySKUSchema,
+  InventorySchema,
+  Reactionary,
+  success,
 } 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 FakeInventoryProvider<
-  T extends Inventory = Inventory
-> extends InventoryProvider<T> {
+export class FakeInventoryProvider extends InventoryProvider {
   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 getBySKU(
-    payload: InventoryQueryBySKU,
-    _reqCtx: RequestContext
-  ): Promise<T> {
+  @Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema
+  })
+  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>> {
     // Generate a simple hash from the SKU 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
     }
 
@@ -39,30 +49,24 @@ export class FakeInventoryProvider<
       locale: [en, base],
     });
 
-    const model = this.newModel();
+    const identifier = {
+      variant: payload.variant,
+      fulfillmentCenter: payload.fulfilmentCenter,
+    } satisfies InventoryIdentifier;
 
-    model.identifier = {
-      sku: payload.sku,
-      fulfillmentCenter: payload.fulfilmentCenter
-    };
-    model.sku = skuString;
+    const quantity = generator.number.int({ min: 0, max: 100 });
 
-    model.quantity = generator.number.int({ min: 0, max: 100 });
-    if (model.quantity > 0 ) {
-      model.status = 'inStock';
-    } else {
-      model.status = 'outOfStock';
+    let status: InventoryStatus = 'outOfStock';
+    if (quantity > 0) {
+      status = 'inStock';
     }
 
+    const result = {
+      identifier,
+      quantity,
+      status
+    } satisfies Inventory;
 
-    model.meta = {
-        cache: {
-          hit: false,
-          key: this.generateCacheKeySingle(model.identifier, _reqCtx)
-        },
-        placeholder: false,
-      };
-
-    return this.assert(model);
+    return success(result);
   }
 }

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

@@ -0,0 +1,78 @@
+import {
+  OrderSearchProvider,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  type Cache,
+  type OrderSearchQueryByTerm,
+  type OrderSearchResult,
+  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';
+
+export class FakeOrderSearchProvider extends OrderSearchProvider {
+  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: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public override async queryByTerm(
+    payload: OrderSearchQueryByTerm
+  ): Promise<Result<OrderSearchResult>> {
+    const items = new Array<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(result);
+  }
+}