@reactionary/provider-fake 0.3.18 → 0.6.2

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

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

package/src/providers/cart.provider.d.ts

@@ -1,20 +1,22 @@
-import type { Cart, CartQueryById, CartMutationItemAdd, CartMutationItemRemove, CartMutationItemQuantityChange, RequestContext, Cache, CartIdentifier, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationRemoveCoupon, Result, NotFoundError } from '@reactionary/core';
+import type { Cart, CartFactory, CartFactoryCartOutput, CartFactoryWithOutput, CartQueryById, CartMutationItemAdd, CartMutationItemRemove, CartMutationItemQuantityChange, RequestContext, Cache, CartIdentifier, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationRemoveCoupon, Result, NotFoundError } from '@reactionary/core';
 import { CartProvider } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeCartProvider extends CartProvider {
+import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
+export declare class FakeCartProvider<TFactory extends CartFactory = FakeCartFactory> extends CartProvider<CartFactoryCartOutput<TFactory>, CartIdentifier> {
     protected config: FakeConfiguration;
+    protected factory: CartFactoryWithOutput<TFactory>;
     private carts;
     private generator;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
-    add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
-    remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
-    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: CartFactoryWithOutput<TFactory>);
+    getById(payload: CartQueryById): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>>;
+    add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<CartFactoryCartOutput<TFactory>>>;
     getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
     deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
-    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
-    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
-    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<CartFactoryCartOutput<TFactory>>>;
     protected recalculateCart(cart: Cart): void;
     protected createEmptyCart(): Cart;
 }

package/src/providers/category.provider.d.ts

@@ -1,19 +1,20 @@
-import type { Result, NotFoundError, Category, CategoryPaginatedResult, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext } from "@reactionary/core";
-import { CategoryProvider } from "@reactionary/core";
-import type { FakeConfiguration } from "../schema/configuration.schema.js";
-import type { Cache as ReactionaryCache } from "@reactionary/core";
+import type { Cache, Category, CategoryFactory, CategoryFactoryCategoryOutput, CategoryFactoryPaginatedOutput, CategoryFactoryWithOutput, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import { CategoryProvider } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker } from '@faker-js/faker';
-export declare class FakeCategoryProvider extends CategoryProvider {
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+export declare class FakeCategoryProvider<TFactory extends CategoryFactory = FakeCategoryFactory> extends CategoryProvider<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
     protected config: FakeConfiguration;
+    protected factory: CategoryFactoryWithOutput<TFactory>;
     protected topCategories: Category[];
     protected childCategories: Map<string, Category[]>;
     protected allCategories: Map<string, Category>;
     protected categoryGenerator: Faker;
     protected generateFakeCategory(parent: Category | undefined, index: number): Category;
-    constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext);
-    getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
-    getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
-    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
-    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryPaginatedResult>>;
-    findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryPaginatedResult>>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: CategoryFactoryWithOutput<TFactory>);
+    getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>>;
+    findTopCategories(_payload: CategoryQueryForTopCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
 }

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

@@ -1,19 +1,21 @@
-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, type CheckoutIdentifier } from '@reactionary/core';
+import { CheckoutProvider, type CheckoutMutationAddPaymentInstruction, type CheckoutMutationFinalizeCheckout, type CheckoutMutationInitiateCheckout, type CheckoutMutationRemovePaymentInstruction, type CheckoutMutationSetShippingAddress, type CheckoutMutationSetShippingInstruction, type CheckoutQueryById, type CheckoutQueryForAvailablePaymentMethods, type CheckoutQueryForAvailableShippingMethods, type NotFoundError, type RequestContext, type Result, type Cache, type CheckoutIdentifier, type CheckoutFactory, type CheckoutFactoryCheckoutOutput, type CheckoutFactoryPaymentMethodOutput, type CheckoutFactoryShippingMethodOutput, type CheckoutFactoryWithOutput } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker } from '@faker-js/faker';
-export declare class FakeCheckoutProvider extends CheckoutProvider {
+import type { FakeCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+export declare class FakeCheckoutProvider<TFactory extends CheckoutFactory = FakeCheckoutFactory> extends CheckoutProvider<CheckoutFactoryCheckoutOutput<TFactory>, CheckoutFactoryShippingMethodOutput<TFactory>, CheckoutFactoryPaymentMethodOutput<TFactory>> {
     protected config: FakeConfiguration;
     protected generator: Faker;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<Checkout>>;
-    getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>>;
-    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<Checkout>>;
-    getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<ShippingMethod[]>>;
-    getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<PaymentMethod[]>>;
-    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<Checkout>>;
-    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<Checkout>>;
-    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<Checkout>>;
-    finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<Checkout>>;
+    protected factory: CheckoutFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: CheckoutFactoryWithOutput<TFactory>);
+    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    getById(payload: CheckoutQueryById): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>>;
+    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>>;
+    getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<CheckoutFactoryPaymentMethodOutput<TFactory>[]>>;
+    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
     protected composeBaseCheckout(identifier?: CheckoutIdentifier): {
         description: string;
         identifier: CheckoutIdentifier;

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

@@ -1,11 +1,13 @@
-import { type Identity, type IdentityQuerySelf, type IdentityMutationLogin, type IdentityMutationLogout, type RequestContext, type Cache, IdentityProvider, type IdentityMutationRegister, type Result } from '@reactionary/core';
+import { type Cache, type IdentityFactory, type IdentityFactoryOutput, type IdentityFactoryWithOutput, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, IdentityProvider, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeIdentityProvider extends IdentityProvider {
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
+export declare class FakeIdentityProvider<TFactory extends IdentityFactory = FakeIdentityFactory> extends IdentityProvider<IdentityFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
+    protected factory: IdentityFactoryWithOutput<TFactory>;
     private currentIdentity;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    getSelf(_payload: IdentityQuerySelf): Promise<Result<Identity>>;
-    login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
-    logout(_payload: IdentityMutationLogout): Promise<Result<Identity>>;
-    register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: IdentityFactoryWithOutput<TFactory>);
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    login(_payload: IdentityMutationLogin): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    register(_payload: IdentityMutationRegister): Promise<Result<IdentityFactoryOutput<TFactory>>>;
 }

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

@@ -1,8 +1,10 @@
-import type { Cache, Inventory, InventoryQueryBySKU, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import type { Cache, InventoryFactory, InventoryFactoryOutput, InventoryFactoryWithOutput, InventoryQueryBySKU, NotFoundError, RequestContext, Result } from '@reactionary/core';
 import { InventoryProvider } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeInventoryProvider extends InventoryProvider {
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class FakeInventoryProvider<TFactory extends InventoryFactory = FakeInventoryFactory> extends InventoryProvider<InventoryFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>>;
+    protected factory: InventoryFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: InventoryFactoryWithOutput<TFactory>);
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>>;
 }

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

@@ -1,9 +1,11 @@
-import { OrderSearchProvider, type Cache, type OrderSearchQueryByTerm, type OrderSearchResult, type RequestContext, type Result } from '@reactionary/core';
+import { OrderSearchProvider, type Cache, type OrderSearchFactory, type OrderSearchFactoryOutput, type OrderSearchFactoryWithOutput, type OrderSearchQueryByTerm, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker } from '@faker-js/faker';
-export declare class FakeOrderSearchProvider extends OrderSearchProvider {
+import type { FakeOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+export declare class FakeOrderSearchProvider<TFactory extends OrderSearchFactory = FakeOrderSearchFactory> extends OrderSearchProvider<OrderSearchFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
     protected generator: Faker;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>>;
+    protected factory: OrderSearchFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: OrderSearchFactoryWithOutput<TFactory>);
+    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>>;
 }

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

@@ -1,9 +1,11 @@
-import { OrderProvider, type Cache, type NotFoundError, type Order, type OrderQueryById, type RequestContext, type Result } from '@reactionary/core';
+import { OrderProvider, type Cache, type NotFoundError, 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 } from '@faker-js/faker';
-export declare class FakeOrderProvider extends OrderProvider {
+import type { FakeOrderFactory } from '../factories/order/order.factory.js';
+export declare class FakeOrderProvider<TFactory extends OrderFactory = FakeOrderFactory> extends OrderProvider<OrderFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
     protected generator: Faker;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>>;
+    protected factory: OrderFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: OrderFactoryWithOutput<TFactory>);
+    getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>>;
 }

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

@@ -1,11 +1,13 @@
-import { type RequestContext, type Cache, PriceProvider, type CustomerPriceQuery, type ListPriceQuery, type Price, type Result } from '@reactionary/core';
+import { PriceProvider, type Cache, type CustomerPriceQuery, type ListPriceQuery, type Price, type PriceFactory, type PriceFactoryOutput, type PriceFactoryWithOutput, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker } from '@faker-js/faker';
-export declare class FakePriceProvider extends PriceProvider {
+import type { FakePriceFactory } from '../factories/price/price.factory.js';
+export declare class FakePriceProvider<TFactory extends PriceFactory = FakePriceFactory> extends PriceProvider<PriceFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
     protected faker: Faker;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    protected factory: PriceFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: PriceFactoryWithOutput<TFactory>);
     protected createPrice(variantSku: string, mode: 'list' | 'customer'): Price;
-    getListPrice(payload: ListPriceQuery): Promise<Result<Price>>;
-    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>>;
+    getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
 }

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

@@ -1,12 +1,15 @@
-import { ProductAssociationsProvider, type ProductAssociationsGetAccessoriesQuery, type ProductAssociationsGetSparepartsQuery, type ProductAssociationsGetReplacementsQuery, type Result, type ProductAssociation } from '@reactionary/core';
+import { ProductAssociationsProvider, type ProductAssociationsGetAccessoriesQuery, type ProductAssociationsGetSparepartsQuery, type ProductAssociationsGetReplacementsQuery, type Result, type Cache, type RequestContext } from '@reactionary/core';
+import type { ProductAssociationsFactory, ProductAssociationsFactoryOutput, ProductAssociationsFactoryWithOutput } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker } from '@faker-js/faker';
-export declare class FakeProductAssociationsProvider extends ProductAssociationsProvider {
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+export declare 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);
-    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociation[]>>;
-    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociation[]>>;
-    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociation[]>>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductAssociationsFactoryWithOutput<TFactory>);
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
     private generateFakeAssociatedProducts;
 }

package/src/providers/product-reviews.provider.d.ts

@@ -1,12 +1,13 @@
-import { ProductReviewsProvider } from '@reactionary/core';
-import type { ProductReview, ProductRatingSummary, ProductReviewPaginatedResult, ProductReviewsListQuery, ProductReviewsGetRatingSummaryQuery, ProductReviewMutationSubmit, Result, RequestContext, Cache, ProductIdentifier } from '@reactionary/core';
+import { ProductReviewsProvider, type Cache, type ProductIdentifier, type ProductReviewsFactory, type ProductReviewsFactoryRatingOutput, type ProductReviewsFactoryReviewOutput, type ProductReviewsFactoryReviewPaginatedOutput, type ProductReviewsFactoryWithOutput, type ProductReviewsGetRatingSummaryQuery, type ProductReviewsListQuery, type ProductReview, type ProductReviewMutationSubmit, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeProductReviewsProvider extends ProductReviewsProvider {
+import type { FakeProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+export declare class FakeProductReviewsProvider<TFactory extends ProductReviewsFactory = FakeProductReviewsFactory> extends ProductReviewsProvider<ProductReviewsFactoryRatingOutput<TFactory>, ProductReviewsFactoryReviewPaginatedOutput<TFactory>, ProductReviewsFactoryReviewOutput<TFactory>> {
     protected config: FakeConfiguration;
+    protected factory: ProductReviewsFactoryWithOutput<TFactory>;
     private faker;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductReviewsFactoryWithOutput<TFactory>);
     protected createReviewsForProduct(productIdentifier: ProductIdentifier): ProductReview[];
-    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductRatingSummary>>;
-    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewPaginatedResult>>;
-    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReview>>;
+    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>>;
+    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>>;
+    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>>;
 }

package/src/providers/product-search.provider.d.ts

@@ -1,13 +1,10 @@
-import { ProductSearchProvider } from '@reactionary/core';
-import type { ProductSearchResult, ProductSearchResultFacet, Cache as ReactionaryCache, FacetIdentifier, FacetValueIdentifier, ProductSearchResultFacetValue, ProductSearchResultItemVariant, ProductSearchQueryCreateNavigationFilter, Result } from '@reactionary/core';
-import type { RequestContext, ProductSearchQueryByTerm } from '@reactionary/core';
+import { ProductSearchProvider, type Cache, type FacetValueIdentifier, type ProductSearchFactory, type ProductSearchFactoryOutput, type ProductSearchFactoryWithOutput, type ProductSearchQueryByTerm, type ProductSearchQueryCreateNavigationFilter, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeSearchProvider extends ProductSearchProvider {
+import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class FakeSearchProvider<TFactory extends ProductSearchFactory = FakeProductSearchFactory> extends ProductSearchProvider<ProductSearchFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, cache: ReactionaryCache, context: RequestContext);
-    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
+    protected factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductSearchFactoryWithOutput<TFactory>);
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
     createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
-    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
-    protected parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown): ProductSearchResultFacet;
-    protected parseVariant(variant: unknown, product: unknown): ProductSearchResultItemVariant;
 }

package/src/providers/product.provider.d.ts

@@ -1,10 +1,12 @@
-import { type ProductQueryById, type ProductQueryBySlug, type RequestContext, type Cache as ReactinaryCache, ProductProvider, type ProductQueryBySKU, type Product, type Result, type NotFoundError } from '@reactionary/core';
+import { type Cache, type NotFoundError, type ProductFactory, type ProductFactoryOutput, type ProductFactoryWithOutput, type ProductQueryById, type ProductQueryBySKU, type ProductQueryBySlug, ProductProvider, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeProductProvider extends ProductProvider {
+import type { FakeProductFactory } from '../factories/product/product.factory.js';
+export declare class FakeProductProvider<TFactory extends ProductFactory = FakeProductFactory> extends ProductProvider<ProductFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, cache: ReactinaryCache, context: RequestContext);
-    getById(payload: ProductQueryById): Promise<Result<Product>>;
-    getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;
-    getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>>;
-    protected parseSingle(body: string): Product;
+    protected factory: ProductFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductFactoryWithOutput<TFactory>);
+    getById(payload: ProductQueryById): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    protected composeSingle(body: string): ProductFactoryOutput<TFactory>;
 }

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

@@ -1,24 +1,18 @@
-import { ProfileProvider, type Cache, type IdentityIdentifier, type NotFoundError, type Profile, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf, type RequestContext, type Result } from '@reactionary/core';
+import { ProfileProvider, type Cache, type Address, type IdentityIdentifier, type NotFoundError, type ProfileFactory, type ProfileFactoryOutput, type ProfileFactoryWithOutput, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf, type RequestContext, type Result } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeProfileProvider extends ProfileProvider {
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
+export declare class FakeProfileProvider<TFactory extends ProfileFactory = FakeProfileFactory> extends ProfileProvider<ProfileFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
+    protected factory: ProfileFactoryWithOutput<TFactory>;
     private generator;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    getById(payload: ProfileQuerySelf): Promise<Result<Profile, NotFoundError>>;
-    update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
-    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
-    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
-    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
-    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
-    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
-    protected composeBaseProfile(identifier?: IdentityIdentifier): {
-        alternateShippingAddresses: never[];
-        createdAt: string;
-        email: string;
-        emailVerified: true;
-        identifier: IdentityIdentifier;
-        phone: string;
-        phoneVerified: true;
-        updatedAt: string;
-    };
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProfileFactoryWithOutput<TFactory>);
+    getById(payload: ProfileQuerySelf): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    update(payload: ProfileMutationUpdate): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected composeProfile(identifier: IdentityIdentifier): ProfileFactoryOutput<TFactory>;
+    protected createEmptyAddress(): Address;
 }

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

@@ -1,8 +1,10 @@
-import type { Cache, RequestContext, Store, StoreQueryByProximity, Result } from '@reactionary/core';
+import type { Cache, RequestContext, Result, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StoreQueryByProximity } from '@reactionary/core';
 import { StoreProvider } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
-export declare class FakeStoreProvider extends StoreProvider {
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+export declare class FakeStoreProvider<TFactory extends StoreFactory = FakeStoreFactory> extends StoreProvider<StoreFactoryOutput<TFactory>> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
-    queryByProximity(payload: StoreQueryByProximity): Promise<Result<Store[]>>;
+    protected factory: StoreFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: StoreFactoryWithOutput<TFactory>);
+    queryByProximity(payload: StoreQueryByProximity): Promise<Result<StoreFactoryOutput<TFactory>[]>>;
 }