@reactionary/source 0.3.18 → 0.6.2

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

@@ -1,4 +1,5 @@
 import {
+  AddressSchema,
   ProfileMutationAddShippingAddressSchema,
   ProfileMutationMakeShippingAddressDefaultSchema,
   ProfileMutationRemoveShippingAddressSchema,
@@ -10,9 +11,13 @@ import {
   ProfileSchema,
   Reactionary,
   type Cache,
+  type Address,
   type IdentityIdentifier,
   type NotFoundError,
   type Profile,
+  type ProfileFactory,
+  type ProfileFactoryOutput,
+  type ProfileFactoryWithOutput,
   type ProfileMutationAddShippingAddress,
   type ProfileMutationMakeShippingAddressDefault,
   type ProfileMutationRemoveShippingAddress,
@@ -26,15 +31,20 @@ import {
 } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
 
-export class FakeProfileProvider extends ProfileProvider {
+export class FakeProfileProvider<
+  TFactory extends ProfileFactory = FakeProfileFactory,
+> extends ProfileProvider<ProfileFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: ProfileFactoryWithOutput<TFactory>;
   private generator: Faker;
 
   constructor(
     config: FakeConfiguration,
     cache: Cache,
-    context: RequestContext
+    context: RequestContext,
+    factory: ProfileFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
     this.generator = new Faker({
@@ -42,30 +52,21 @@ export class FakeProfileProvider extends ProfileProvider {
       seed: config.seeds.product,
     });
     this.config = config;
+    this.factory = factory;
   }
 
-  @Reactionary({
-    inputSchema: ProfileQueryByIdSchema,
-    outputSchema: ProfileSchema,
-  })
+  @Reactionary({ inputSchema: ProfileQueryByIdSchema, outputSchema: ProfileSchema })
   public override async getById(
-    payload: ProfileQuerySelf
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileQuerySelf,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
-  @Reactionary({
-    inputSchema: ProfileMutationUpdateSchema,
-    outputSchema: ProfileSchema,
-  })
+  @Reactionary({ inputSchema: ProfileMutationUpdateSchema, outputSchema: ProfileSchema })
   public override async update(
-    payload: ProfileMutationUpdate
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileMutationUpdate,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
   @Reactionary({
@@ -73,11 +74,9 @@ export class FakeProfileProvider extends ProfileProvider {
     outputSchema: ProfileSchema,
   })
   public override async addShippingAddress(
-    payload: ProfileMutationAddShippingAddress
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileMutationAddShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
   @Reactionary({
@@ -85,11 +84,9 @@ export class FakeProfileProvider extends ProfileProvider {
     outputSchema: ProfileSchema,
   })
   public override async updateShippingAddress(
-    payload: ProfileMutationUpdateShippingAddress
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileMutationUpdateShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
   @Reactionary({
@@ -97,11 +94,9 @@ export class FakeProfileProvider extends ProfileProvider {
     outputSchema: ProfileSchema,
   })
   public override async removeShippingAddress(
-    payload: ProfileMutationRemoveShippingAddress
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileMutationRemoveShippingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
   @Reactionary({
@@ -109,11 +104,9 @@ export class FakeProfileProvider extends ProfileProvider {
     outputSchema: ProfileSchema,
   })
   public override async makeShippingAddressDefault(
-    payload: ProfileMutationMakeShippingAddressDefault
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileMutationMakeShippingAddressDefault,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
   @Reactionary({
@@ -121,27 +114,41 @@ export class FakeProfileProvider extends ProfileProvider {
     outputSchema: ProfileSchema,
   })
   public override async setBillingAddress(
-    payload: ProfileMutationSetBillingAddress
-  ): Promise<Result<Profile, NotFoundError>> {
-    const profile = this.composeBaseProfile(payload.identifier);
-
-    return success(profile);
+    payload: ProfileMutationSetBillingAddress,
+  ): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>> {
+    return success(this.composeProfile(payload.identifier));
   }
 
-  protected composeBaseProfile(identifier?: IdentityIdentifier) {
-    const profile = {
-      alternateShippingAddresses: [],
-      createdAt: this.generator.date.past().toISOString(),
+  protected composeProfile(identifier: IdentityIdentifier): ProfileFactoryOutput<TFactory> {
+    const baseProfile = {
+      identifier,
       email: this.generator.internet.email(),
-      emailVerified: true,
-      identifier: identifier || {
-        userId: this.generator.string.uuid(),
-      },
       phone: this.generator.phone.number(),
+      emailVerified: true,
       phoneVerified: true,
-      updatedAt: this.generator.date.past().toISOString(),
+      createdAt: this.generator.date.past().toISOString(),
+      updatedAt: this.generator.date.recent().toISOString(),
+      billingAddress: this.createEmptyAddress(),
+      shippingAddress: this.createEmptyAddress(),
+      alternateShippingAddresses: [],
     } satisfies Profile;
 
-    return profile;
+    return this.factory.parseProfile(this.context, baseProfile);
+  }
+
+  protected createEmptyAddress(): Address {
+    return AddressSchema.parse({
+      identifier: {
+        nickName: this.generator.person.firstName().toLowerCase(),
+      },
+      firstName: this.generator.person.firstName(),
+      lastName: this.generator.person.lastName(),
+      streetAddress: this.generator.location.street(),
+      streetNumber: this.generator.location.buildingNumber(),
+      city: this.generator.location.city(),
+      region: this.generator.location.state(),
+      postalCode: this.generator.location.zipCode(),
+      countryCode: this.generator.location.countryCode('alpha-2'),
+    });
   }
 }

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

@@ -2,53 +2,69 @@ import type {
   Cache,
   FulfillmentCenterIdentifier,
   RequestContext,
-  Store,
+  Result,
+  StoreFactory,
+  StoreFactoryOutput,
+  StoreFactoryWithOutput,
   StoreIdentifier,
   StoreQueryByProximity,
-  Result
 } from '@reactionary/core';
-import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success } from '@reactionary/core';
+import {
+  Reactionary,
+  StoreProvider,
+  StoreQueryByProximitySchema,
+  StoreSchema,
+  success,
+} from '@reactionary/core';
 import * as z from 'zod';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
 
-export class FakeStoreProvider extends StoreProvider {
+export class FakeStoreProvider<
+  TFactory extends StoreFactory = FakeStoreFactory,
+> extends StoreProvider<StoreFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
+  protected factory: StoreFactoryWithOutput<TFactory>;
 
-  constructor(config: FakeConfiguration, cache: Cache, context: RequestContext) {
+  constructor(
+    config: FakeConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: StoreFactoryWithOutput<TFactory>,
+  ) {
     super(cache, context);
 
     this.config = config;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: StoreQueryByProximitySchema,
-    outputSchema: z.array(StoreSchema)
+    outputSchema: z.array(StoreSchema),
   })
   public override async queryByProximity(
-    payload: StoreQueryByProximity
-  ): Promise<Result<Store[]>> {
+    payload: StoreQueryByProximity,
+  ): Promise<Result<StoreFactoryOutput<TFactory>[]>> {
     const generator = new Faker({
       seed: 42,
       locale: [en, base],
     });
 
-    const results = new Array<Store>();
+    const results: StoreFactoryOutput<TFactory>[] = [];
 
     for (let i = 0; i < payload.limit; i++) {
-        const name = generator.company.name();
-        const identifier = {
-          key: '' + i
-        } satisfies StoreIdentifier;
-        const fulfillmentCenter = {
-          key: '' + i
-        } satisfies FulfillmentCenterIdentifier;
-
-        results.push({
-          fulfillmentCenter,
-          identifier,
-          name
-        });
+      results.push(
+        this.factory.parseStore(this.context, {
+          identifier: {
+            key: `${i}`,
+          } satisfies StoreIdentifier,
+          fulfillmentCenter: {
+            key: `${i}`,
+          } satisfies FulfillmentCenterIdentifier,
+          name: generator.company.name(),
+        }),
+      );
     }
 
     return success(results);

package/providers/fake/src/schema/capabilities.schema.ts

@@ -1,21 +1,178 @@
-import { CapabilitiesSchema } from "@reactionary/core";
-import type * as z from 'zod';
+import type {
+  Cache,
+  CartFactory,
+  CartFactoryWithOutput,
+  CartProvider,
+  CategoryFactory,
+  CategoryFactoryWithOutput,
+  CategoryProvider,
+  CheckoutFactory,
+  CheckoutFactoryWithOutput,
+  CheckoutProvider,
+  IdentityFactory,
+  IdentityFactoryWithOutput,
+  IdentityProvider,
+  InventoryFactory,
+  InventoryFactoryWithOutput,
+  InventoryProvider,
+  OrderFactory,
+  OrderFactoryWithOutput,
+  OrderProvider,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchProvider,
+  PriceFactory,
+  PriceFactoryWithOutput,
+  PriceProvider,
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryWithOutput,
+  ProductAssociationsProvider,
+  ProductFactory,
+  ProductFactoryWithOutput,
+  ProductProvider,
+  ProductReviewsFactory,
+  ProductReviewsFactoryWithOutput,
+  ProductReviewsProvider,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchProvider,
+  ProfileFactory,
+  ProfileFactoryWithOutput,
+  ProfileProvider,
+  RequestContext,
+  StoreFactory,
+  StoreFactoryWithOutput,
+  StoreProvider,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { FakeConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  provider: z.unknown().optional(),
+});
 
 export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
-    product: true,
-    productSearch: true,
-    identity: true,
-    category: true,
-    cart: true,
-    inventory: true,
-    store: true,
-    price: true,
-    checkout: true,
-    order: true,
-    orderSearch: true,
-    profile: true,
-    productReviews: true,
-    productAssociations: true,
-}).partial();
+  product: true,
+  productSearch: true,
+  identity: true,
+  category: true,
+  cart: true,
+  inventory: true,
+  store: true,
+  price: true,
+  checkout: true,
+  order: true,
+  orderSearch: true,
+  profile: true,
+  productReviews: true,
+  productAssociations: true,
+})
+  .extend({
+    product: OverridableCapabilitySchema.optional(),
+    productSearch: OverridableCapabilitySchema.optional(),
+    identity: OverridableCapabilitySchema.optional(),
+    category: OverridableCapabilitySchema.optional(),
+    cart: OverridableCapabilitySchema.optional(),
+    inventory: OverridableCapabilitySchema.optional(),
+    store: OverridableCapabilitySchema.optional(),
+    price: OverridableCapabilitySchema.optional(),
+    checkout: OverridableCapabilitySchema.optional(),
+    order: OverridableCapabilitySchema.optional(),
+    orderSearch: OverridableCapabilitySchema.optional(),
+    profile: OverridableCapabilitySchema.optional(),
+    productReviews: OverridableCapabilitySchema.optional(),
+    productAssociations: OverridableCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface FakeCapabilityProviderFactoryArgs<TFactory> {
+  cache: Cache;
+  context: RequestContext;
+  config: FakeConfiguration;
+  factory: TFactory;
+}
+
+export interface FakeCapabilityConfig<TFactory, TProvider> {
+  enabled: boolean;
+  factory?: TFactory;
+  provider?: (args: FakeCapabilityProviderFactoryArgs<TFactory>) => TProvider;
+}
+
+export type FakeProductCapabilityConfig = FakeCapabilityConfig<
+  ProductFactoryWithOutput<ProductFactory>,
+  ProductProvider
+>;
+export type FakeProductSearchCapabilityConfig = FakeCapabilityConfig<
+  ProductSearchFactoryWithOutput<ProductSearchFactory>,
+  ProductSearchProvider
+>;
+export type FakeIdentityCapabilityConfig = FakeCapabilityConfig<
+  IdentityFactoryWithOutput<IdentityFactory>,
+  IdentityProvider
+>;
+export type FakeCategoryCapabilityConfig = FakeCapabilityConfig<
+  CategoryFactoryWithOutput<CategoryFactory>,
+  CategoryProvider
+>;
+export type FakeCartCapabilityConfig = FakeCapabilityConfig<
+  CartFactoryWithOutput<CartFactory>,
+  CartProvider
+>;
+export type FakeInventoryCapabilityConfig = FakeCapabilityConfig<
+  InventoryFactoryWithOutput<InventoryFactory>,
+  InventoryProvider
+>;
+export type FakeStoreCapabilityConfig = FakeCapabilityConfig<
+  StoreFactoryWithOutput<StoreFactory>,
+  StoreProvider
+>;
+export type FakePriceCapabilityConfig = FakeCapabilityConfig<
+  PriceFactoryWithOutput<PriceFactory>,
+  PriceProvider
+>;
+export type FakeCheckoutCapabilityConfig = FakeCapabilityConfig<
+  CheckoutFactoryWithOutput<CheckoutFactory>,
+  CheckoutProvider
+>;
+export type FakeOrderCapabilityConfig = FakeCapabilityConfig<
+  OrderFactoryWithOutput<OrderFactory>,
+  OrderProvider
+>;
+export type FakeOrderSearchCapabilityConfig = FakeCapabilityConfig<
+  OrderSearchFactoryWithOutput<OrderSearchFactory>,
+  OrderSearchProvider
+>;
+export type FakeProfileCapabilityConfig = FakeCapabilityConfig<
+  ProfileFactoryWithOutput<ProfileFactory>,
+  ProfileProvider
+>;
+export type FakeProductReviewsCapabilityConfig = FakeCapabilityConfig<
+  ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
+  ProductReviewsProvider
+>;
+export type FakeProductAssociationsCapabilityConfig = FakeCapabilityConfig<
+  ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+  ProductAssociationsProvider
+>;
+
+export type FakeCapabilities = {
+  product?: FakeProductCapabilityConfig;
+  productSearch?: FakeProductSearchCapabilityConfig;
+  identity?: FakeIdentityCapabilityConfig;
+  category?: FakeCategoryCapabilityConfig;
+  cart?: FakeCartCapabilityConfig;
+  inventory?: FakeInventoryCapabilityConfig;
+  store?: FakeStoreCapabilityConfig;
+  price?: FakePriceCapabilityConfig;
+  checkout?: FakeCheckoutCapabilityConfig;
+  order?: FakeOrderCapabilityConfig;
+  orderSearch?: FakeOrderSearchCapabilityConfig;
+  profile?: FakeProfileCapabilityConfig;
+  productReviews?: FakeProductReviewsCapabilityConfig;
+  productAssociations?: FakeProductAssociationsCapabilityConfig;
+};
 
-export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;
+export type ParsedFakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/providers/fake/src/test/cart.provider.spec.ts

@@ -1,9 +1,16 @@
 import 'dotenv/config';
 import type { RequestContext} from '@reactionary/core';
-import { CartSchema, IdentitySchema, NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { FakeCartProvider } from '../providers/cart.provider.js';
 import { FakeIdentityProvider } from '../providers/index.js';
+import { FakeCartFactory, FakeIdentityFactory } from '../factories/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
 const testData = {
@@ -18,8 +25,18 @@ describe('Fake Cart Provider', () => {
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeCartProvider(getFakerTestConfiguration(), new NoOpCache(), reqCtx);
-    identityProvider = new FakeIdentityProvider(getFakerTestConfiguration(), new NoOpCache(), reqCtx);
+    provider = new FakeCartProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      new FakeCartFactory(CartSchema, CartIdentifierSchema),
+    );
+    identityProvider = new FakeIdentityProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      new FakeIdentityFactory(IdentitySchema),
+    );
   });
 
   describe('anonymous sessions', () => {

package/providers/fake/src/test/category.provider.spec.ts

@@ -1,11 +1,13 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
+  CategoryPaginatedResultSchema,
   CategorySchema,
   MemoryCache,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { FakeCategoryProvider } from '../providers/index.js';
+import { FakeCategoryFactory } from '../factories/index.js';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
@@ -21,7 +23,8 @@ describe('Faker Category Provider', () => {
     provider = new FakeCategoryProvider(
       getFakerTestConfiguration(),
       cache,
-      reqCtx
+      reqCtx,
+      new FakeCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
     );
   });
 

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

@@ -2,11 +2,15 @@ import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
   NoOpCache,
+  CheckoutSchema,
+  ShippingMethodSchema,
+  PaymentMethodSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import { FakeCheckoutFactory } from '../factories/index.js';
 
 describe('Fake Checkout Provider', () => {
   let provider: FakeCheckoutProvider;
@@ -17,7 +21,12 @@ describe('Fake Checkout Provider', () => {
     provider = new FakeCheckoutProvider(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeCheckoutFactory(
+        CheckoutSchema,
+        ShippingMethodSchema,
+        PaymentMethodSchema,
+      ),
     );
   });
 
@@ -177,7 +186,8 @@ describe('Fake Checkout Provider', () => {
         },
         userId: {
             userId: 'Fake'
-        }
+        },
+        appliedPromotions: [],
       },
     });
 

package/providers/fake/src/test/client-builder-product-extension.example.ts

@@ -0,0 +1,75 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  ProductSchema,
+  createInitialRequestContext,
+  type RequestContext,
+} from '@reactionary/core';
+import * as z from 'zod';
+import { withFakeCapabilities } from '../core/initialize.js';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { FakeProductFactory } from '../factories/product/product.factory.js';
+
+const assertType = <T>(_value: T) => {
+  void _value;
+};
+
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+const assertNotAny = <T>(_value: IsAny<T> extends true ? never : T) => {
+  void _value;
+};
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedFakeProductFactory extends FakeProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+
+  public override parseProduct(context: RequestContext, data: unknown) {
+    const base = super.parseProduct(context, data);
+    return this.productSchema.parse({
+      ...base,
+      extendedValue: 'from-fake-factory',
+    });
+  }
+}
+
+const config = {
+  jitter: {
+    mean: 0,
+    deviation: 0,
+  },
+  seeds: {
+    product: 1,
+    search: 1,
+    category: 1,
+  },
+} satisfies FakeConfiguration;
+
+const client = new ClientBuilder(createInitialRequestContext())
+  .withCache(new NoOpCache())
+  .withCapability(
+    withFakeCapabilities(config, {
+      product: {
+        enabled: true,
+        factory: new ExtendedFakeProductFactory(),
+      },
+    }),
+  )
+  .build();
+
+client.product
+  .getById({
+    identifier: { key: 'example-product-id' },
+  })
+  .then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      assertNotAny(result.value);
+      assertNotAny(result.value.extendedValue);
+      assertType<string>(result.value.extendedValue);
+    }
+  });