@reactionary/provider-fake 0.3.18 → 0.6.2

package/providers/product-reviews.provider.js

@@ -10,37 +10,35 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
   ProductReviewsProvider,
   Reactionary,
-  success,
   error,
-  ProductReviewSchema,
-  ProductRatingSummarySchema,
-  ProductReviewPaginatedResultSchema
+  success
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 import { calcSeed } from "../utilities/seed.js";
 class FakeProductReviewsProvider extends ProductReviewsProvider {
-  constructor(config, cache, context) {
+  constructor(config, cache, context, factory) {
     super(cache, context);
     this.config = config;
-    this.faker = new Faker({ locale: [en] });
+    this.factory = factory;
+    this.faker = new Faker({ locale: [en, base] });
   }
   createReviewsForProduct(productIdentifier) {
     const seed = calcSeed(productIdentifier.key);
     this.faker.seed(seed);
     const hasAnyReviews = this.faker.datatype.boolean({ probability: 0.5 });
-    if (!hasAnyReviews) {
-      return [];
-    }
-    if (productIdentifier.key === "unknown-product-id") {
+    if (!hasAnyReviews || productIdentifier.key === "unknown-product-id") {
       return [];
     }
     const reviews = [];
     const totalReviews = this.faker.number.int({ min: 1, max: 20 });
     for (let i = 0; i < totalReviews; i++) {
       const hasReply = this.faker.datatype.boolean({ probability: 0.3 });
-      const review = {
+      reviews.push({
         identifier: {
           key: `fake-review-${productIdentifier.key}-${i}`
         },
@@ -55,53 +53,56 @@ class FakeProductReviewsProvider extends ProductReviewsProvider {
         verified: this.faker.datatype.boolean(),
         reply: hasReply ? this.faker.lorem.sentences(2) : void 0,
         repliedAt: hasReply ? this.faker.date.recent({ days: 7 }).toISOString() : void 0
-      };
-      reviews.push(review);
+      });
     }
-    return reviews.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return reviews.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
   }
   async getRatingSummary(query) {
     const reviews = this.createReviewsForProduct(query.product);
     if (reviews.length === 0) {
       const emptySummary = this.createEmptyProductRatingSummary({ product: query.product });
-      return success(emptySummary);
+      return success(this.factory.parseRatingSummary(this.context, emptySummary));
     }
     const totalRatings = reviews.length;
-    const averageRating = reviews.reduce((sum, review) => sum + review.rating, 0) / (totalRatings || 1);
-    const ratingDistribution = {
-      "1": reviews.filter((x) => x.rating === 1).length,
-      "2": reviews.filter((x) => x.rating === 2).length,
-      "3": reviews.filter((x) => x.rating === 3).length,
-      "4": reviews.filter((x) => x.rating === 4).length,
-      "5": reviews.filter((x) => x.rating === 5).length
-    };
+    const averageRating = reviews.reduce((sum, review) => sum + review.rating, 0) / totalRatings;
     const summary = {
       identifier: {
         product: query.product
       },
       averageRating,
       totalRatings,
-      ratingDistribution
+      ratingDistribution: {
+        "1": reviews.filter((x) => x.rating === 1).length,
+        "2": reviews.filter((x) => x.rating === 2).length,
+        "3": reviews.filter((x) => x.rating === 3).length,
+        "4": reviews.filter((x) => x.rating === 4).length,
+        "5": reviews.filter((x) => x.rating === 5).length
+      }
     };
-    return success(summary);
+    return success(this.factory.parseRatingSummary(this.context, summary));
   }
   async findReviews(query) {
     const pageSize = query.paginationOptions?.pageSize ?? 20;
     const pageNumber = query.paginationOptions?.pageNumber ?? 1;
     const reviews = this.createReviewsForProduct(query.product);
     const returnedReviews = reviews.slice((pageNumber - 1) * pageSize, pageNumber * pageSize);
-    const paginatedResult = {
+    const result = {
       items: returnedReviews,
       totalCount: reviews.length,
       pageSize,
       pageNumber,
       totalPages: Math.ceil(reviews.length / Math.max(pageSize, 1))
     };
-    return success(paginatedResult);
+    return success(this.factory.parseReviewPaginatedResult(this.context, result));
   }
   async submitReview(mutation) {
     if (this.context.session.identityContext.identity.type !== "Registered") {
-      return error({ type: "InvalidInput", error: "Only registered users can submit reviews." });
+      return error({
+        type: "InvalidInput",
+        error: "Only registered users can submit reviews."
+      });
     }
     const review = {
       identifier: {
@@ -115,7 +116,7 @@ class FakeProductReviewsProvider extends ProductReviewsProvider {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       verified: this.faker.datatype.boolean()
     };
-    return success(review);
+    return success(this.factory.parseReview(this.context, review));
   }
 }
 __decorateClass([

package/providers/product-search.provider.js

@@ -16,28 +16,23 @@ import {
   ProductSearchResultItemSchema,
   ProductSearchResultSchema,
   Reactionary,
-  success,
-  error
+  success
 } from "@reactionary/core";
 import { Faker, en, base } from "@faker-js/faker";
 import { jitter } from "../utilities/jitter.js";
 class FakeSearchProvider extends ProductSearchProvider {
-  constructor(config, cache, context) {
+  constructor(config, cache, context, factory) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
   async queryByTerm(payload) {
     await jitter(this.config.jitter.mean, this.config.jitter.deviation);
     const query = payload.search;
     const querySpecificity = 20 - query.term.length - query.paginationOptions.pageNumber - query.facets.length;
     const totalProducts = 10 * querySpecificity;
-    const totalPages = Math.ceil(
-      totalProducts / query.paginationOptions.pageSize
-    );
-    const productsOnPage = Math.min(
-      totalProducts,
-      query.paginationOptions.pageSize
-    );
+    const totalPages = Math.ceil(totalProducts / query.paginationOptions.pageSize);
+    const productsOnPage = Math.min(totalProducts, query.paginationOptions.pageSize);
     const productGenerator = new Faker({
       seed: querySpecificity,
       locale: [en, base]
@@ -46,8 +41,8 @@ class FakeSearchProvider extends ProductSearchProvider {
       seed: 100,
       locale: [en, base]
     });
-    const products = new Array();
-    const facets = new Array();
+    const products = [];
+    const facets = [];
     for (let i = 0; i < productsOnPage; i++) {
       const srcUrl = productGenerator.image.urlPicsumPhotos({
         height: 300,
@@ -64,7 +59,7 @@ class FakeSearchProvider extends ProductSearchProvider {
       products.push(
         ProductSearchResultItemSchema.parse({
           identifier: {
-            key: "product_" + productGenerator.commerce.isbn()
+            key: `product_${productGenerator.commerce.isbn()}`
           },
           name: productGenerator.commerce.productName(),
           slug: productGenerator.lorem.slug(),
@@ -80,13 +75,12 @@ class FakeSearchProvider extends ProductSearchProvider {
         })
       );
     }
-    const facetBase = ["color", "size"];
-    for (const base2 of facetBase) {
+    for (const baseFacet of ["color", "size"]) {
       const facet = {
         identifier: {
-          key: base2
+          key: baseFacet
         },
-        name: base2,
+        name: baseFacet,
         values: []
       };
       for (let i = 0; i < 10; i++) {
@@ -108,7 +102,7 @@ class FakeSearchProvider extends ProductSearchProvider {
       }
       facets.push(facet);
     }
-    const result = ProductSearchResultSchema.parse({
+    const result = {
       identifier: {
         term: query.term,
         paginationOptions: {
@@ -124,8 +118,8 @@ class FakeSearchProvider extends ProductSearchProvider {
       pageSize: query.paginationOptions.pageSize,
       totalCount: totalProducts,
       totalPages
-    });
-    return success(result);
+    };
+    return success(this.factory.parseSearchResult(this.context, result, payload));
   }
   async createCategoryNavigationFilter(payload) {
     const facetIdentifier = {
@@ -137,15 +131,6 @@ class FakeSearchProvider extends ProductSearchProvider {
     };
     return success(facetValueIdentifier);
   }
-  parseFacetValue(facetValueIdentifier, label, count) {
-    throw new Error("Method not implemented.");
-  }
-  parseFacet(facetIdentifier, facetValue) {
-    throw new Error("Method not implemented.");
-  }
-  parseVariant(variant, product) {
-    throw new Error("Method not implemented.");
-  }
 }
 __decorateClass([
   Reactionary({

package/providers/product.provider.js

@@ -10,42 +10,41 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
-  ProductProvider,
-  Reactionary,
   ProductQueryByIdSchema,
-  ProductSchema,
-  ProductQueryBySlugSchema,
   ProductQueryBySKUSchema,
-  error,
+  ProductQueryBySlugSchema,
+  ProductProvider,
+  ProductSchema,
+  Reactionary,
   success
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeProductProvider extends ProductProvider {
-  constructor(config, cache, context) {
+  constructor(config, cache, context, factory) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
   async getById(payload) {
-    return success(this.parseSingle(payload.identifier.key));
+    return success(this.composeSingle(payload.identifier.key));
   }
   async getBySlug(payload) {
-    return success(this.parseSingle(payload.slug));
+    return success(this.composeSingle(payload.slug));
   }
   async getBySKU(payload) {
-    return success(this.parseSingle(payload.variant.sku));
+    return success(this.composeSingle(payload.variant.sku));
   }
-  parseSingle(body) {
+  composeSingle(body) {
     const generator = new Faker({
       seed: 42,
       locale: [en, base]
     });
-    const key = body;
     const result = {
       identifier: {
-        key
+        key: body
       },
       name: generator.commerce.productName(),
-      slug: key,
+      slug: body,
       brand: "",
       longDescription: "",
       mainVariant: {
@@ -68,7 +67,7 @@ class FakeProductProvider extends ProductProvider {
       sharedAttributes: [],
       variants: []
     };
-    return result;
+    return this.factory.parseProduct(this.context, result);
   }
 }
 __decorateClass([

package/providers/profile.provider.js

@@ -10,6 +10,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
+  AddressSchema,
   ProfileMutationAddShippingAddressSchema,
   ProfileMutationMakeShippingAddressDefaultSchema,
   ProfileMutationRemoveShippingAddressSchema,
@@ -24,69 +25,72 @@ import {
 } from "@reactionary/core";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeProfileProvider extends ProfileProvider {
-  constructor(config, cache, context) {
+  constructor(config, cache, context, factory) {
     super(cache, context);
     this.generator = new Faker({
       locale: [en, base],
       seed: config.seeds.product
     });
     this.config = config;
+    this.factory = factory;
   }
   async getById(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
   async update(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
   async addShippingAddress(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
   async updateShippingAddress(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
   async removeShippingAddress(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
   async makeShippingAddressDefault(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
   async setBillingAddress(payload) {
-    const profile = this.composeBaseProfile(payload.identifier);
-    return success(profile);
+    return success(this.composeProfile(payload.identifier));
   }
-  composeBaseProfile(identifier) {
-    const profile = {
-      alternateShippingAddresses: [],
-      createdAt: this.generator.date.past().toISOString(),
+  composeProfile(identifier) {
+    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: []
     };
-    return profile;
+    return this.factory.parseProfile(this.context, baseProfile);
+  }
+  createEmptyAddress() {
+    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")
+    });
   }
 }
 __decorateClass([
-  Reactionary({
-    inputSchema: ProfileQueryByIdSchema,
-    outputSchema: ProfileSchema
-  })
+  Reactionary({ inputSchema: ProfileQueryByIdSchema, outputSchema: ProfileSchema })
 ], FakeProfileProvider.prototype, "getById", 1);
 __decorateClass([
-  Reactionary({
-    inputSchema: ProfileMutationUpdateSchema,
-    outputSchema: ProfileSchema
-  })
+  Reactionary({ inputSchema: ProfileMutationUpdateSchema, outputSchema: ProfileSchema })
 ], FakeProfileProvider.prototype, "update", 1);
 __decorateClass([
   Reactionary({

package/providers/store.provider.js

@@ -9,33 +9,39 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
-import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success } from "@reactionary/core";
+import {
+  Reactionary,
+  StoreProvider,
+  StoreQueryByProximitySchema,
+  StoreSchema,
+  success
+} from "@reactionary/core";
 import * as z from "zod";
 import { base, en, Faker } from "@faker-js/faker";
 class FakeStoreProvider extends StoreProvider {
-  constructor(config, cache, context) {
+  constructor(config, cache, context, factory) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
   async queryByProximity(payload) {
     const generator = new Faker({
       seed: 42,
       locale: [en, base]
     });
-    const results = new Array();
+    const results = [];
     for (let i = 0; i < payload.limit; i++) {
-      const name = generator.company.name();
-      const identifier = {
-        key: "" + i
-      };
-      const fulfillmentCenter = {
-        key: "" + i
-      };
-      results.push({
-        fulfillmentCenter,
-        identifier,
-        name
-      });
+      results.push(
+        this.factory.parseStore(this.context, {
+          identifier: {
+            key: `${i}`
+          },
+          fulfillmentCenter: {
+            key: `${i}`
+          },
+          name: generator.company.name()
+        })
+      );
     }
     return success(results);
   }

package/schema/capabilities.schema.js

@@ -1,4 +1,10 @@
 import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  provider: z.unknown().optional()
+});
 const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
   productSearch: true,
@@ -14,6 +20,21 @@ const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
   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 {
   FakeCapabilitiesSchema

package/src/core/initialize.d.ts

@@ -1,4 +1,5 @@
-import type { Cache as ReactinaryCache, RequestContext, ClientFromCapabilities } from '@reactionary/core';
+import type { Cache as ReactinaryCache, RequestContext } from '@reactionary/core';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import type { FakeCapabilities } from '../schema/capabilities.schema.js';
-export declare function withFakeCapabilities<T extends FakeCapabilities>(configuration: FakeConfiguration, capabilities: T): (cache: ReactinaryCache, context: RequestContext) => ClientFromCapabilities<T>;
+import { type FakeClientFromCapabilities } from './initialize.types.js';
+export declare function withFakeCapabilities<T extends FakeCapabilities>(configuration: FakeConfiguration, capabilities: T): (cache: ReactinaryCache, context: RequestContext) => FakeClientFromCapabilities<T>;

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 { FakeCartProvider } from '../providers/cart.provider.js';
+import type { FakeCategoryProvider } from '../providers/category.provider.js';
+import type { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import type { FakeIdentityProvider } from '../providers/identity.provider.js';
+import type { FakeInventoryProvider } from '../providers/inventory.provider.js';
+import type { FakeOrderProvider } from '../providers/order.provider.js';
+import type { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+import type { FakePriceProvider } from '../providers/price.provider.js';
+import type { FakeProductAssociationsProvider } from '../providers/product-associations.provider.js';
+import type { FakeProductProvider } from '../providers/product.provider.js';
+import type { FakeProductReviewsProvider } from '../providers/product-reviews.provider.js';
+import type { FakeSearchProvider } from '../providers/product-search.provider.js';
+import type { FakeProfileProvider } from '../providers/profile.provider.js';
+import type { FakeStoreProvider } from '../providers/store.provider.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 ExtractCapabilityProvider<TCapability, TDefaultProvider> = TCapability extends {
+    enabled: true;
+    provider?: infer TProviderFactory;
+} ? TProviderFactory extends (...args: unknown[]) => infer TProvider ? TProvider : TDefaultProvider : TDefaultProvider;
+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 DefaultProviderMap<T extends FakeCapabilities> = {
+    product: FakeProductProvider<ResolvedFactoryMap<T>['product']>;
+    productSearch: FakeSearchProvider<ResolvedFactoryMap<T>['productSearch']>;
+    identity: FakeIdentityProvider<ResolvedFactoryMap<T>['identity']>;
+    category: FakeCategoryProvider<ResolvedFactoryMap<T>['category']>;
+    cart: FakeCartProvider<ResolvedFactoryMap<T>['cart']>;
+    inventory: FakeInventoryProvider<ResolvedFactoryMap<T>['inventory']>;
+    store: FakeStoreProvider<ResolvedFactoryMap<T>['store']>;
+    price: FakePriceProvider<ResolvedFactoryMap<T>['price']>;
+    checkout: FakeCheckoutProvider<ResolvedFactoryMap<T>['checkout']>;
+    order: FakeOrderProvider<ResolvedFactoryMap<T>['order']>;
+    orderSearch: FakeOrderSearchProvider<ResolvedFactoryMap<T>['orderSearch']>;
+    profile: FakeProfileProvider<ResolvedFactoryMap<T>['profile']>;
+    productReviews: FakeProductReviewsProvider<ResolvedFactoryMap<T>['productReviews']>;
+    productAssociations: FakeProductAssociationsProvider<ResolvedFactoryMap<T>['productAssociations']>;
+};
+type CapabilityProviderTypeMap<T extends FakeCapabilities> = {
+    [K in FakeCapabilityKey]: ExtractCapabilityProvider<T[K], DefaultProviderMap<T>[K]>;
+};
+type EnabledCapabilityOverrideMap<T extends FakeCapabilities> = {
+    [K in FakeCapabilityKey as T[K] extends {
+        enabled: true;
+    } ? K : never]: CapabilityProviderTypeMap<T>[K];
+};
+export type FakeClientFromCapabilities<T extends FakeCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, FakeCapabilityKey> & EnabledCapabilityOverrideMap<T>;
+export declare function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(capability: {
+    factory?: TFactory;
+    provider?: (args: TProviderArgs) => TProvider;
+} | undefined, defaults: {
+    factory: TFactory;
+    provider: (args: TProviderArgs) => TProvider;
+}, buildProviderArgs: (factory: TFactory) => TProviderArgs): TProvider;
+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>;
+}