@reactionary/source 0.6.2 → 0.6.3

package/{providers/fake/src/providers/product.provider.ts → packages/fake/src/capabilities/product.capability.ts}

@@ -10,7 +10,7 @@ import {
   ProductQueryBySKUSchema,
   type ProductQueryBySlug,
   ProductQueryBySlugSchema,
-  ProductProvider,
+  ProductCapability,
   ProductSchema,
   type RequestContext,
   type Result,
@@ -21,9 +21,9 @@ import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 import type { FakeProductFactory } from '../factories/product/product.factory.js';
 
-export class FakeProductProvider<
+export class FakeProductCapability<
   TFactory extends ProductFactory = FakeProductFactory,
-> extends ProductProvider<ProductFactoryOutput<TFactory>> {
+> extends ProductCapability<ProductFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
   protected factory: ProductFactoryWithOutput<TFactory>;
 

package/{providers/fake/src/providers/profile.provider.ts → packages/fake/src/capabilities/profile.capability.ts}

@@ -6,7 +6,7 @@ import {
   ProfileMutationSetBillingAddressSchema,
   ProfileMutationUpdateSchema,
   ProfileMutationUpdateShippingAddressSchema,
-  ProfileProvider,
+  ProfileCapability,
   ProfileQueryByIdSchema,
   ProfileSchema,
   Reactionary,
@@ -33,9 +33,9 @@ import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
 
-export class FakeProfileProvider<
+export class FakeProfileCapability<
   TFactory extends ProfileFactory = FakeProfileFactory,
-> extends ProfileProvider<ProfileFactoryOutput<TFactory>> {
+> extends ProfileCapability<ProfileFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
   protected factory: ProfileFactoryWithOutput<TFactory>;
   private generator: Faker;

package/{providers/fake/src/providers/store.provider.ts → packages/fake/src/capabilities/store.capability.ts}

@@ -11,7 +11,7 @@ import type {
 } from '@reactionary/core';
 import {
   Reactionary,
-  StoreProvider,
+  StoreCapability,
   StoreQueryByProximitySchema,
   StoreSchema,
   success,
@@ -21,9 +21,9 @@ import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 import type { FakeStoreFactory } from '../factories/store/store.factory.js';
 
-export class FakeStoreProvider<
+export class FakeStoreCapability<
   TFactory extends StoreFactory = FakeStoreFactory,
-> extends StoreProvider<StoreFactoryOutput<TFactory>> {
+> extends StoreCapability<StoreFactoryOutput<TFactory>> {
   protected config: FakeConfiguration;
   protected factory: StoreFactoryWithOutput<TFactory>;
 

package/{providers → packages}/fake/src/core/initialize.ts

@@ -21,25 +21,25 @@ import {
   ShippingMethodSchema as CoreShippingMethodSchema,
   StoreSchema as CoreStoreSchema,
 } from '@reactionary/core';
-import { FakeProductProvider } from '../providers/product.provider.js';
-import { FakeSearchProvider } from '../providers/product-search.provider.js';
+import { FakeProductCapability } from '../capabilities/product.capability.js';
+import { FakeProductSearchCapability } from '../capabilities/product-search.capability.js';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import type { FakeCapabilities } from '../schema/capabilities.schema.js';
 import { FakeCapabilitiesSchema } from '../schema/capabilities.schema.js';
-import { FakeCategoryProvider } from '../providers/category.provider.js';
+import { FakeCategoryCapability } from '../capabilities/category.capability.js';
 import {
-  FakeCartProvider,
-  FakeIdentityProvider,
-  FakeInventoryProvider,
-  FakePriceProvider,
-  FakeStoreProvider,
-} from '../providers/index.js';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
-import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
-import { FakeOrderProvider } from '../providers/order.provider.js';
-import { FakeProfileProvider } from '../providers/profile.provider.js';
-import { FakeProductReviewsProvider } from '../providers/product-reviews.provider.js';
-import { FakeProductAssociationsProvider } from '../providers/product-associations.provider.js';
+  FakeCartCapability,
+  FakeIdentityCapability,
+  FakeInventoryCapability,
+  FakePriceCapability,
+  FakeStoreCapability,
+} from '../capabilities/index.js';
+import { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
+import { FakeOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import { FakeOrderCapability } from '../capabilities/order.capability.js';
+import { FakeProfileCapability } from '../capabilities/profile.capability.js';
+import { FakeProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import { FakeProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
 import {
   FakeCartFactory,
   FakeCategoryFactory,
@@ -58,7 +58,7 @@ import {
 } from '../factories/index.js';
 import {
   type FakeClientFromCapabilities,
-  resolveCapabilityProvider,
+  resolveCapabilityWithFactory,
 } from './initialize.types.js';
 
 export function withFakeCapabilities<T extends FakeCapabilities>(
@@ -73,7 +73,7 @@ export function withFakeCapabilities<T extends FakeCapabilities>(
     const client: any = {};
     const caps = FakeCapabilitiesSchema.parse(capabilities);
 
-    const buildProviderArgs = <TFactory,>(factory: TFactory) => ({
+    const buildCapabilityArgs = <TFactory,>(factory: TFactory) => ({
       cache,
       context,
       config: configuration,
@@ -81,106 +81,106 @@ export function withFakeCapabilities<T extends FakeCapabilities>(
     });
 
     if (caps.product?.enabled) {
-      client.product = resolveCapabilityProvider(
+      client.product = resolveCapabilityWithFactory(
         capabilities.product,
         {
           factory: new FakeProductFactory(CoreProductSchema),
-          provider: (args) =>
-            new FakeProductProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeProductCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.productSearch?.enabled) {
-      client.productSearch = resolveCapabilityProvider(
+      client.productSearch = resolveCapabilityWithFactory(
         capabilities.productSearch,
         {
           factory: new FakeProductSearchFactory(CoreProductSearchResultSchema),
-          provider: (args) =>
-            new FakeSearchProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeProductSearchCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.category?.enabled) {
-      client.category = resolveCapabilityProvider(
+      client.category = resolveCapabilityWithFactory(
         capabilities.category,
         {
           factory: new FakeCategoryFactory(
             CoreCategorySchema,
             CoreCategoryPaginatedResultSchema,
           ),
-          provider: (args) =>
-            new FakeCategoryProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeCategoryCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.cart?.enabled) {
-      client.cart = resolveCapabilityProvider(
+      client.cart = resolveCapabilityWithFactory(
         capabilities.cart,
         {
           factory: new FakeCartFactory(CoreCartSchema, CoreCartIdentifierSchema),
-          provider: (args) =>
-            new FakeCartProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeCartCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.inventory?.enabled) {
-      client.inventory = resolveCapabilityProvider(
+      client.inventory = resolveCapabilityWithFactory(
         capabilities.inventory,
         {
           factory: new FakeInventoryFactory(CoreInventorySchema),
-          provider: (args) =>
-            new FakeInventoryProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeInventoryCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.store?.enabled) {
-      client.store = resolveCapabilityProvider(
+      client.store = resolveCapabilityWithFactory(
         capabilities.store,
         {
           factory: new FakeStoreFactory(CoreStoreSchema),
-          provider: (args) =>
-            new FakeStoreProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeStoreCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.price?.enabled) {
-      client.price = resolveCapabilityProvider(
+      client.price = resolveCapabilityWithFactory(
         capabilities.price,
         {
           factory: new FakePriceFactory(CorePriceSchema),
-          provider: (args) =>
-            new FakePriceProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakePriceCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.identity?.enabled) {
-      client.identity = resolveCapabilityProvider(
+      client.identity = resolveCapabilityWithFactory(
         capabilities.identity,
         {
           factory: new FakeIdentityFactory(CoreIdentitySchema),
-          provider: (args) =>
-            new FakeIdentityProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeIdentityCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.checkout?.enabled) {
-      client.checkout = resolveCapabilityProvider(
+      client.checkout = resolveCapabilityWithFactory(
         capabilities.checkout,
         {
           factory: new FakeCheckoutFactory(
@@ -188,51 +188,51 @@ export function withFakeCapabilities<T extends FakeCapabilities>(
             CoreShippingMethodSchema,
             CorePaymentMethodSchema,
           ),
-          provider: (args) =>
-            new FakeCheckoutProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeCheckoutCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.orderSearch?.enabled) {
-      client.orderSearch = resolveCapabilityProvider(
+      client.orderSearch = resolveCapabilityWithFactory(
         capabilities.orderSearch,
         {
           factory: new FakeOrderSearchFactory(CoreOrderSearchResultSchema),
-          provider: (args) =>
-            new FakeOrderSearchProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeOrderSearchCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.order?.enabled) {
-      client.order = resolveCapabilityProvider(
+      client.order = resolveCapabilityWithFactory(
         capabilities.order,
         {
           factory: new FakeOrderFactory(CoreOrderSchema),
-          provider: (args) =>
-            new FakeOrderProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeOrderCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.profile?.enabled) {
-      client.profile = resolveCapabilityProvider(
+      client.profile = resolveCapabilityWithFactory(
         capabilities.profile,
         {
           factory: new FakeProfileFactory(CoreProfileSchema),
-          provider: (args) =>
-            new FakeProfileProvider(args.config, args.cache, args.context, args.factory),
+          capability: (args) =>
+            new FakeProfileCapability(args.config, args.cache, args.context, args.factory),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.productReviews?.enabled) {
-      client.productReviews = resolveCapabilityProvider(
+      client.productReviews = resolveCapabilityWithFactory(
         capabilities.productReviews,
         {
           factory: new FakeProductReviewsFactory(
@@ -240,32 +240,32 @@ export function withFakeCapabilities<T extends FakeCapabilities>(
             CoreProductReviewSchema,
             CoreProductReviewPaginatedResultSchema,
           ),
-          provider: (args) =>
-            new FakeProductReviewsProvider(
+          capability: (args) =>
+            new FakeProductReviewsCapability(
               args.config,
               args.cache,
               args.context,
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.productAssociations?.enabled) {
-      client.productAssociations = resolveCapabilityProvider(
+      client.productAssociations = resolveCapabilityWithFactory(
         capabilities.productAssociations,
         {
           factory: new FakeProductAssociationsFactory(CoreProductAssociationSchema),
-          provider: (args) =>
-            new FakeProductAssociationsProvider(
+          capability: (args) =>
+            new FakeProductAssociationsCapability(
               args.config,
               args.cache,
               args.context,
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 

package/{providers → packages}/fake/src/core/initialize.types.ts

@@ -30,20 +30,20 @@ import type { FakeProductReviewsFactory } from '../factories/product-reviews/pro
 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';
+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;
 
@@ -61,12 +61,12 @@ type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
       : TDefaultFactory
     : TDefaultFactory;
 
-type ExtractCapabilityProvider<TCapability, TDefaultProvider> =
-  TCapability extends { enabled: true; provider?: infer TProviderFactory }
-    ? TProviderFactory extends (...args: unknown[]) => infer TProvider
-      ? TProvider
-      : TDefaultProvider
-    : TDefaultProvider;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> =
+  TCapability extends { enabled: true; capability?: infer TCapabilityFactory }
+    ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
 
 type FactoryContractMap = {
   product: ProductFactory;
@@ -110,32 +110,32 @@ type ResolvedFactoryMap<T extends FakeCapabilities> = {
   >;
 };
 
-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<
+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 CapabilityProviderTypeMap<T extends FakeCapabilities> = {
-  [K in FakeCapabilityKey]: ExtractCapabilityProvider<T[K], DefaultProviderMap<T>[K]>;
+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]:
-    CapabilityProviderTypeMap<T>[K];
+    CapabilityImplementationMap<T>[K];
 };
 
 export type FakeClientFromCapabilities<T extends FakeCapabilities> = Omit<
@@ -144,21 +144,21 @@ export type FakeClientFromCapabilities<T extends FakeCapabilities> = Omit<
 > &
   EnabledCapabilityOverrideMap<T>;
 
-export function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(
+export function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(
   capability:
     | {
         factory?: TFactory;
-        provider?: (args: TProviderArgs) => TProvider;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
       }
     | undefined,
   defaults: {
     factory: TFactory;
-    provider: (args: TProviderArgs) => TProvider;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
   },
-  buildProviderArgs: (factory: TFactory) => TProviderArgs,
-): TProvider {
+  buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs,
+): TResolvedCapability {
   const factory = capability?.factory ?? defaults.factory;
-  const provider = capability?.provider ?? defaults.provider;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
 
-  return provider(buildProviderArgs(factory));
+  return capabilityFactory(buildCapabilityArgs(factory));
 }

package/{providers → packages}/fake/src/index.ts

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