@reactionary/fake 0.6.3

package/src/core/initialize.types.d.ts

@@ -0,0 +1,113 @@
+import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, IdentityFactory, InventoryFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductReviewsFactory, ProductSearchFactory, ProfileFactory, StoreFactory } from '@reactionary/core';
+import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+import type { FakeCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { FakeOrderFactory } from '../factories/order/order.factory.js';
+import type { FakeOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { FakePriceFactory } from '../factories/price/price.factory.js';
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { FakeProductFactory } from '../factories/product/product.factory.js';
+import type { FakeProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+import type { FakeCartCapability } from '../capabilities/cart.capability.js';
+import type { FakeCategoryCapability } from '../capabilities/category.capability.js';
+import type { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { FakeIdentityCapability } from '../capabilities/identity.capability.js';
+import type { FakeInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { FakeOrderCapability } from '../capabilities/order.capability.js';
+import type { FakeOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { FakePriceCapability } from '../capabilities/price.capability.js';
+import type { FakeProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import type { FakeProductCapability } from '../capabilities/product.capability.js';
+import type { FakeProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import type { FakeProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { FakeProfileCapability } from '../capabilities/profile.capability.js';
+import type { FakeStoreCapability } from '../capabilities/store.capability.js';
+type FakeCapabilityKey = keyof FakeCapabilities;
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends FakeCapabilities> = {
+    [K in FakeCapabilityKey]?: EnabledCapability<T[K]>;
+};
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends TContract ? TFactory : TDefaultFactory : TDefaultFactory;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability ? TResolvedCapability : TDefaultCapability : TDefaultCapability;
+type FactoryContractMap = {
+    product: ProductFactory;
+    productSearch: ProductSearchFactory;
+    identity: IdentityFactory;
+    category: CategoryFactory;
+    cart: CartFactory;
+    inventory: InventoryFactory;
+    store: StoreFactory;
+    price: PriceFactory;
+    checkout: CheckoutFactory;
+    order: OrderFactory;
+    orderSearch: OrderSearchFactory;
+    profile: ProfileFactory;
+    productReviews: ProductReviewsFactory;
+    productAssociations: ProductAssociationsFactory;
+};
+type DefaultFactoryMap = {
+    product: FakeProductFactory;
+    productSearch: FakeProductSearchFactory;
+    identity: FakeIdentityFactory;
+    category: FakeCategoryFactory;
+    cart: FakeCartFactory;
+    inventory: FakeInventoryFactory;
+    store: FakeStoreFactory;
+    price: FakePriceFactory;
+    checkout: FakeCheckoutFactory;
+    order: FakeOrderFactory;
+    orderSearch: FakeOrderSearchFactory;
+    profile: FakeProfileFactory;
+    productReviews: FakeProductReviewsFactory;
+    productAssociations: FakeProductAssociationsFactory;
+};
+type ResolvedFactoryMap<T extends FakeCapabilities> = {
+    [K in FakeCapabilityKey]: ExtractCapabilityFactory<T[K], FactoryContractMap[K], DefaultFactoryMap[K]>;
+};
+type DefaultCapabilityMap<T extends FakeCapabilities> = {
+    product: FakeProductCapability<ResolvedFactoryMap<T>['product']>;
+    productSearch: FakeProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+    identity: FakeIdentityCapability<ResolvedFactoryMap<T>['identity']>;
+    category: FakeCategoryCapability<ResolvedFactoryMap<T>['category']>;
+    cart: FakeCartCapability<ResolvedFactoryMap<T>['cart']>;
+    inventory: FakeInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+    store: FakeStoreCapability<ResolvedFactoryMap<T>['store']>;
+    price: FakePriceCapability<ResolvedFactoryMap<T>['price']>;
+    checkout: FakeCheckoutCapability<ResolvedFactoryMap<T>['checkout']>;
+    order: FakeOrderCapability<ResolvedFactoryMap<T>['order']>;
+    orderSearch: FakeOrderSearchCapability<ResolvedFactoryMap<T>['orderSearch']>;
+    profile: FakeProfileCapability<ResolvedFactoryMap<T>['profile']>;
+    productReviews: FakeProductReviewsCapability<ResolvedFactoryMap<T>['productReviews']>;
+    productAssociations: FakeProductAssociationsCapability<ResolvedFactoryMap<T>['productAssociations']>;
+};
+type CapabilityImplementationMap<T extends FakeCapabilities> = {
+    [K in FakeCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap<T>[K]>;
+};
+type EnabledCapabilityOverrideMap<T extends FakeCapabilities> = {
+    [K in FakeCapabilityKey as T[K] extends {
+        enabled: true;
+    } ? K : never]: CapabilityImplementationMap<T>[K];
+};
+export type FakeClientFromCapabilities<T extends FakeCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, FakeCapabilityKey> & EnabledCapabilityOverrideMap<T>;
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+}, buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs): TResolvedCapability;
+export {};

package/src/factories/cart/cart.factory.d.ts

@@ -0,0 +1,9 @@
+import type { AnyCartIdentifierSchema, AnyCartSchema, CartFactory, CartIdentifierSchema, CartSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema> {
+    readonly cartSchema: TCartSchema;
+    readonly cartIdentifierSchema: TCartIdentifierSchema;
+    constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema);
+    parseCart(_context: RequestContext, data: unknown): z.output<TCartSchema>;
+    parseCartIdentifier(_context: RequestContext, data: unknown): z.output<TCartIdentifierSchema>;
+}

package/src/factories/category/category.factory.d.ts

@@ -0,0 +1,9 @@
+import type { AnyCategoryPaginatedResultSchema, AnyCategorySchema, CategoryFactory, CategoryPaginatedResultSchema, CategorySchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeCategoryFactory<TCategorySchema extends AnyCategorySchema = typeof CategorySchema, TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema> {
+    readonly categorySchema: TCategorySchema;
+    readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+    constructor(categorySchema: TCategorySchema, categoryPaginatedResultSchema: TCategoryPaginatedSchema);
+    parseCategory(_context: RequestContext, data: unknown): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(_context: RequestContext, data: unknown): z.output<TCategoryPaginatedSchema>;
+}

package/src/factories/checkout/checkout.factory.d.ts

@@ -0,0 +1,11 @@
+import type { AnyCheckoutSchema, AnyPaymentMethodSchema, AnyShippingMethodSchema, CheckoutFactory, CheckoutSchema, PaymentMethodSchema, RequestContext, ShippingMethodSchema } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeCheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema> {
+    readonly checkoutSchema: TCheckoutSchema;
+    readonly shippingMethodSchema: TShippingMethodSchema;
+    readonly paymentMethodSchema: TPaymentMethodSchema;
+    constructor(checkoutSchema: TCheckoutSchema, shippingMethodSchema: TShippingMethodSchema, paymentMethodSchema: TPaymentMethodSchema);
+    parseCheckout(_context: RequestContext, data: unknown): z.output<TCheckoutSchema>;
+    parseShippingMethod(_context: RequestContext, data: unknown): z.output<TShippingMethodSchema>;
+    parsePaymentMethod(_context: RequestContext, data: unknown): z.output<TPaymentMethodSchema>;
+}

package/src/factories/identity/identity.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyIdentitySchema, IdentityFactory, IdentitySchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeIdentityFactory<TIdentitySchema extends AnyIdentitySchema = typeof IdentitySchema> implements IdentityFactory<TIdentitySchema> {
+    readonly identitySchema: TIdentitySchema;
+    constructor(identitySchema: TIdentitySchema);
+    parseIdentity(_context: RequestContext, data: unknown): z.output<TIdentitySchema>;
+}

package/src/factories/index.d.ts

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

package/src/factories/inventory/inventory.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyInventorySchema, InventoryFactory, InventorySchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeInventoryFactory<TInventorySchema extends AnyInventorySchema = typeof InventorySchema> implements InventoryFactory<TInventorySchema> {
+    readonly inventorySchema: TInventorySchema;
+    constructor(inventorySchema: TInventorySchema);
+    parseInventory(_context: RequestContext, data: unknown): z.output<TInventorySchema>;
+}

package/src/factories/order/order.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyOrderSchema, OrderFactory, OrderSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeOrderFactory<TOrderSchema extends AnyOrderSchema = typeof OrderSchema> implements OrderFactory<TOrderSchema> {
+    readonly orderSchema: TOrderSchema;
+    constructor(orderSchema: TOrderSchema);
+    parseOrder(_context: RequestContext, data: unknown): z.output<TOrderSchema>;
+}

package/src/factories/order-search/order-search.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyOrderSearchResultSchema, OrderSearchFactory, OrderSearchQueryByTerm, OrderSearchResultSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeOrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema> implements OrderSearchFactory<TOrderSearchResultSchema> {
+    readonly orderSearchResultSchema: TOrderSearchResultSchema;
+    constructor(orderSearchResultSchema: TOrderSearchResultSchema);
+    parseOrderSearchResult(_context: RequestContext, data: unknown, _query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+}

package/src/factories/price/price.factory.d.ts

@@ -0,0 +1,9 @@
+import type { AnyPriceSchema, PriceFactory, PriceSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakePriceFactory<TPriceSchema extends AnyPriceSchema = typeof PriceSchema> implements PriceFactory<TPriceSchema> {
+    readonly priceSchema: TPriceSchema;
+    constructor(priceSchema: TPriceSchema);
+    parsePrice(_context: RequestContext, data: unknown, _options?: {
+        includeDiscounts: boolean;
+    }): z.output<TPriceSchema>;
+}

package/src/factories/product/product.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyProductSchema, ProductFactory, ProductSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeProductFactory<TProductSchema extends AnyProductSchema = typeof ProductSchema> implements ProductFactory<TProductSchema> {
+    readonly productSchema: TProductSchema;
+    constructor(productSchema: TProductSchema);
+    parseProduct(_context: RequestContext, data: unknown): z.output<TProductSchema>;
+}

package/src/factories/product-associations/product-associations.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyProductAssociationSchema, ProductAssociationSchema, ProductAssociationsFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema> implements ProductAssociationsFactory<TProductAssociationSchema> {
+    readonly productAssociationSchema: TProductAssociationSchema;
+    constructor(productAssociationSchema: TProductAssociationSchema);
+    parseAssociation(_context: RequestContext, data: unknown): z.output<TProductAssociationSchema>;
+}

package/src/factories/product-reviews/product-reviews.factory.d.ts

@@ -0,0 +1,11 @@
+import type { AnyProductRatingSummarySchema, AnyProductReviewPaginatedSchema, AnyProductReviewSchema, ProductRatingSummarySchema, ProductReviewPaginatedResultSchema, ProductReviewSchema, ProductReviewsFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeProductReviewsFactory<TRatingSummarySchema extends AnyProductRatingSummarySchema = typeof ProductRatingSummarySchema, TReviewSchema extends AnyProductReviewSchema = typeof ProductReviewSchema, TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = typeof ProductReviewPaginatedResultSchema> implements ProductReviewsFactory<TRatingSummarySchema, TReviewSchema, TReviewPaginatedSchema> {
+    readonly ratingSummarySchema: TRatingSummarySchema;
+    readonly reviewSchema: TReviewSchema;
+    readonly reviewPaginatedSchema: TReviewPaginatedSchema;
+    constructor(ratingSummarySchema: TRatingSummarySchema, reviewSchema: TReviewSchema, reviewPaginatedSchema: TReviewPaginatedSchema);
+    parseRatingSummary(_context: RequestContext, data: unknown): z.output<TRatingSummarySchema>;
+    parseReview(_context: RequestContext, data: unknown): z.output<TReviewSchema>;
+    parseReviewPaginatedResult(_context: RequestContext, data: unknown): z.output<TReviewPaginatedSchema>;
+}

package/src/factories/product-search/product-search.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyProductSearchResultSchema, ProductSearchFactory, ProductSearchQueryByTerm, ProductSearchResultSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
+    readonly productSearchResultSchema: TProductSearchResultSchema;
+    constructor(productSearchResultSchema: TProductSearchResultSchema);
+    parseSearchResult(_context: RequestContext, data: unknown, _query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+}

package/src/factories/profile/profile.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyProfileSchema, ProfileFactory, ProfileSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeProfileFactory<TProfileSchema extends AnyProfileSchema = typeof ProfileSchema> implements ProfileFactory<TProfileSchema> {
+    readonly profileSchema: TProfileSchema;
+    constructor(profileSchema: TProfileSchema);
+    parseProfile(_context: RequestContext, data: unknown): z.output<TProfileSchema>;
+}

package/src/factories/store/store.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyStoreSchema, RequestContext, StoreFactory, StoreSchema } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeStoreFactory<TStoreSchema extends AnyStoreSchema = typeof StoreSchema> implements StoreFactory<TStoreSchema> {
+    readonly storeSchema: TStoreSchema;
+    constructor(storeSchema: TStoreSchema);
+    parseStore(_context: RequestContext, data: unknown): z.output<TStoreSchema>;
+}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './capabilities/index.js';
+export * from './factories/index.js';
+export * from './schema/capabilities.schema.js';
+export * from './schema/configuration.schema.js';

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,117 @@
+import type { Cache, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductReviewsFactory, ProductReviewsFactoryWithOutput, ProductReviewsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, StoreFactory, StoreFactoryWithOutput, StoreCapability } from '@reactionary/core';
+import type { FakeConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+export declare const FakeCapabilitiesSchema: z.ZodObject<{
+    product: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    identity: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    category: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    cart: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    inventory: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    store: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    checkout: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    order: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    orderSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    profile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productReviews: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productAssociations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export interface FakeCapabilityFactoryArgs<TFactory> {
+    cache: Cache;
+    context: RequestContext;
+    config: FakeConfiguration;
+    factory: TFactory;
+}
+export interface FakeCapabilityConfig<TFactory, TCapability> {
+    enabled: boolean;
+    factory?: TFactory;
+    capability?: (args: FakeCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+export type FakeProductCapabilityConfig = FakeCapabilityConfig<ProductFactoryWithOutput<ProductFactory>, ProductCapability>;
+export type FakeProductSearchCapabilityConfig = FakeCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
+export type FakeIdentityCapabilityConfig = FakeCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityCapability>;
+export type FakeCategoryCapabilityConfig = FakeCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
+export type FakeCartCapabilityConfig = FakeCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+export type FakeInventoryCapabilityConfig = FakeCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryCapability>;
+export type FakeStoreCapabilityConfig = FakeCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
+export type FakePriceCapabilityConfig = FakeCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+export type FakeCheckoutCapabilityConfig = FakeCapabilityConfig<CheckoutFactoryWithOutput<CheckoutFactory>, CheckoutCapability>;
+export type FakeOrderCapabilityConfig = FakeCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
+export type FakeOrderSearchCapabilityConfig = FakeCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchCapability>;
+export type FakeProfileCapabilityConfig = FakeCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
+export type FakeProductReviewsCapabilityConfig = FakeCapabilityConfig<ProductReviewsFactoryWithOutput<ProductReviewsFactory>, ProductReviewsCapability>;
+export type FakeProductAssociationsCapabilityConfig = FakeCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
+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 ParsedFakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+export declare const FakeConfigurationSchema: z.ZodObject<{
+    jitter: z.ZodDefault<z.ZodObject<{
+        mean: z.ZodNumber;
+        deviation: z.ZodNumber;
+    }, z.core.$loose>>;
+    seeds: z.ZodObject<{
+        product: z.ZodDefault<z.ZodNumber>;
+        search: z.ZodDefault<z.ZodNumber>;
+        category: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type FakeConfiguration = z.infer<typeof FakeConfigurationSchema>;

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

@@ -0,0 +1 @@
+export {};

package/src/test/test-utils.d.ts

@@ -0,0 +1,2 @@
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+export declare function getFakerTestConfiguration(): FakeConfiguration;

package/src/utilities/jitter.d.ts

@@ -0,0 +1 @@
+export declare function jitter(duration: number, deviation: number): Promise<unknown>;

package/src/utilities/seed.d.ts

@@ -0,0 +1 @@
+export declare function calcSeed(input: string): number;

package/test/client-builder-product-extension.example.js

@@ -0,0 +1,57 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  ProductSchema,
+  createInitialRequestContext
+} from "@reactionary/core";
+import * as z from "zod";
+import { withFakeCapabilities } from "../core/initialize.js";
+import { FakeProductFactory } from "../factories/product/product.factory.js";
+const assertType = (_value) => {
+};
+const assertNotAny = (_value) => {
+};
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string()
+});
+class ExtendedFakeProductFactory extends FakeProductFactory {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+  parseProduct(context, data) {
+    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
+  }
+};
+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(result.value.extendedValue);
+  }
+});

package/test/test-utils.js

@@ -0,0 +1,16 @@
+function getFakerTestConfiguration() {
+  return {
+    jitter: {
+      mean: 0,
+      deviation: 0
+    },
+    seeds: {
+      product: 1,
+      search: 1,
+      category: 1
+    }
+  };
+}
+export {
+  getFakerTestConfiguration
+};

package/utilities/jitter.js

@@ -0,0 +1,13 @@
+async function jitter(duration, deviation) {
+  const j = gaussianRandom(duration, deviation);
+  return new Promise((resolve) => setTimeout(resolve, j));
+}
+function gaussianRandom(mean, deviation) {
+  const u = 1 - Math.random();
+  const v = Math.random();
+  const z = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  return z * deviation + mean;
+}
+export {
+  jitter
+};

package/utilities/seed.js

@@ -0,0 +1,11 @@
+function calcSeed(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) - hash + input.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return hash;
+}
+export {
+  calcSeed
+};