@reactionary/source 0.6.2 → 0.6.3

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

@@ -19,19 +19,19 @@ import {
   ProfileSchema,
   ShippingMethodSchema,
 } from '@reactionary/core';
-import { MedusaCartProvider } from '../providers/cart.provider.js';
-import { MedusaCategoryProvider } from '../providers/category.provider.js';
-import { MedusaCheckoutProvider } from '../providers/checkout.provider.js';
-import { MedusaIdentityProvider } from '../providers/identity.provider.js';
-import { MedusaInventoryProvider } from '../providers/inventory.provider.js';
-import { MedusaOrderSearchProvider } from '../providers/order-search.provider.js';
-import { MedusaOrderProvider } from '../providers/order.provider.js';
-import { MedusaPriceProvider } from '../providers/price.provider.js';
-import { MedusaSearchProvider } from '../providers/product-search.provider.js';
-import { MedusaProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
-import { MedusaProductProvider } from '../providers/product.provider.js';
-import { MedusaProductAssociationsProvider } from '../providers/product-associations.provider.js';
-import { MedusaProfileProvider } from '../providers/profile.provider.js';
+import { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import { MedusaCategoryCapability } from '../capabilities/category.capability.js';
+import { MedusaCheckoutCapability } from '../capabilities/checkout.capability.js';
+import { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
+import { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
+import { MedusaOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import { MedusaOrderCapability } from '../capabilities/order.capability.js';
+import { MedusaPriceCapability } from '../capabilities/price.capability.js';
+import { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
+import { MedusaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import { MedusaProductCapability } from '../capabilities/product.capability.js';
+import { MedusaProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import { MedusaProfileCapability } from '../capabilities/profile.capability.js';
 import {
   MedusaCapabilitiesSchema,
   type MedusaCapabilities,
@@ -56,8 +56,8 @@ import {
 } from '../factories/index.js';
 import {
   type MedusaClientFromCapabilities,
-  resolveCapabilityProvider,
-  resolveProviderOnlyCapability,
+  resolveCapabilityWithFactory,
+  resolveDirectCapability,
 } from './initialize.types.js';
 
 export function withMedusaCapabilities<T extends MedusaCapabilities>(
@@ -74,7 +74,7 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
     const caps = MedusaCapabilitiesSchema.parse(capabilities);
     const medusaApi = new MedusaAPI(config, context);
 
-    const buildProviderArgs = <TFactory,>(factory: TFactory) => ({
+    const buildCapabilityArgs = <TFactory,>(factory: TFactory) => ({
       cache,
       context,
       config,
@@ -83,12 +83,12 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
     });
 
     if (caps.product?.enabled) {
-      client.product = resolveCapabilityProvider(
+      client.product = resolveCapabilityWithFactory(
         capabilities.product,
         {
           factory: new MedusaProductFactory(ProductSchema),
-          provider: (args) =>
-            new MedusaProductProvider(
+          capability: (args) =>
+            new MedusaProductCapability(
               args.config,
               args.cache,
               args.context,
@@ -96,17 +96,17 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.productSearch?.enabled) {
-      client.productSearch = resolveCapabilityProvider(
+      client.productSearch = resolveCapabilityWithFactory(
         capabilities.productSearch,
         {
           factory: new MedusaProductSearchFactory(ProductSearchResultSchema),
-          provider: (args) =>
-            new MedusaSearchProvider(
+          capability: (args) =>
+            new MedusaProductSearchCapability(
               args.config,
               args.cache,
               args.context,
@@ -114,20 +114,20 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.category?.enabled) {
-      client.category = resolveCapabilityProvider(
+      client.category = resolveCapabilityWithFactory(
         capabilities.category,
         {
           factory: new MedusaCategoryFactory(
             CategorySchema,
             CategoryPaginatedResultSchema,
           ),
-          provider: (args) =>
-            new MedusaCategoryProvider(
+          capability: (args) =>
+            new MedusaCategoryCapability(
               args.config,
               args.cache,
               args.context,
@@ -135,12 +135,12 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.checkout?.enabled) {
-      client.checkout = resolveCapabilityProvider(
+      client.checkout = resolveCapabilityWithFactory(
         capabilities.checkout,
         {
           factory: new MedusaCheckoutFactory(
@@ -148,8 +148,8 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
             ShippingMethodSchema,
             PaymentMethodSchema,
           ),
-          provider: (args) =>
-            new MedusaCheckoutProvider(
+          capability: (args) =>
+            new MedusaCheckoutCapability(
               args.config,
               args.cache,
               args.context,
@@ -157,15 +157,15 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.productRecommendations?.enabled) {
-      client.productRecommendations = resolveProviderOnlyCapability(
+      client.productRecommendations = resolveDirectCapability(
         capabilities.productRecommendations,
         (args) =>
-          new MedusaProductRecommendationsProvider(
+          new MedusaProductRecommendationsCapability(
             args.config,
             args.cache,
             args.context,
@@ -181,12 +181,12 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
     }
 
     if (caps.cart?.enabled) {
-      client.cart = resolveCapabilityProvider(
+      client.cart = resolveCapabilityWithFactory(
         capabilities.cart,
         {
           factory: new MedusaCartFactory(CartSchema, CartIdentifierSchema),
-          provider: (args) =>
-            new MedusaCartProvider(
+          capability: (args) =>
+            new MedusaCartCapability(
               args.config,
               args.cache,
               args.context,
@@ -194,17 +194,17 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.price?.enabled) {
-      client.price = resolveCapabilityProvider(
+      client.price = resolveCapabilityWithFactory(
         capabilities.price,
         {
           factory: new MedusaPriceFactory(PriceSchema),
-          provider: (args) =>
-            new MedusaPriceProvider(
+          capability: (args) =>
+            new MedusaPriceCapability(
               args.config,
               args.cache,
               args.context,
@@ -212,17 +212,17 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.inventory?.enabled) {
-      client.inventory = resolveCapabilityProvider(
+      client.inventory = resolveCapabilityWithFactory(
         capabilities.inventory,
         {
           factory: new MedusaInventoryFactory(InventorySchema),
-          provider: (args) =>
-            new MedusaInventoryProvider(
+          capability: (args) =>
+            new MedusaInventoryCapability(
               args.config,
               args.cache,
               args.context,
@@ -230,15 +230,15 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.identity?.enabled) {
-      client.identity = resolveProviderOnlyCapability(
+      client.identity = resolveDirectCapability(
         capabilities.identity,
         (args) =>
-          new MedusaIdentityProvider(
+          new MedusaIdentityCapability(
             args.config,
             args.cache,
             args.context,
@@ -254,12 +254,12 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
     }
 
     if (caps.profile?.enabled) {
-      client.profile = resolveCapabilityProvider(
+      client.profile = resolveCapabilityWithFactory(
         capabilities.profile,
         {
           factory: new MedusaProfileFactory(ProfileSchema),
-          provider: (args) =>
-            new MedusaProfileProvider(
+          capability: (args) =>
+            new MedusaProfileCapability(
               args.config,
               args.cache,
               args.context,
@@ -267,17 +267,17 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.order?.enabled) {
-      client.order = resolveCapabilityProvider(
+      client.order = resolveCapabilityWithFactory(
         capabilities.order,
         {
           factory: new MedusaOrderFactory(OrderSchema),
-          provider: (args) =>
-            new MedusaOrderProvider(
+          capability: (args) =>
+            new MedusaOrderCapability(
               args.config,
               args.cache,
               args.context,
@@ -285,17 +285,17 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.orderSearch?.enabled) {
-      client.orderSearch = resolveCapabilityProvider(
+      client.orderSearch = resolveCapabilityWithFactory(
         capabilities.orderSearch,
         {
           factory: new MedusaOrderSearchFactory(OrderSearchResultSchema),
-          provider: (args) =>
-            new MedusaOrderSearchProvider(
+          capability: (args) =>
+            new MedusaOrderSearchCapability(
               args.config,
               args.cache,
               args.context,
@@ -303,17 +303,17 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 
     if (caps.productAssociations?.enabled) {
-      client.productAssociations = resolveCapabilityProvider(
+      client.productAssociations = resolveCapabilityWithFactory(
         capabilities.productAssociations,
         {
           factory: new MedusaProductAssociationsFactory(ProductAssociationSchema),
-          provider: (args) =>
-            new MedusaProductAssociationsProvider(
+          capability: (args) =>
+            new MedusaProductAssociationsCapability(
               args.config,
               args.cache,
               args.context,
@@ -321,7 +321,7 @@ export function withMedusaCapabilities<T extends MedusaCapabilities>(
               args.factory,
             ),
         },
-        buildProviderArgs,
+        buildCapabilityArgs,
       );
     }
 

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

@@ -9,7 +9,7 @@ import type {
   PriceFactory,
   ProductAssociationsFactory,
   ProductFactory,
-  ProductRecommendationsProvider,
+  ProductRecommendationsCapability,
   ProductSearchFactory,
   ProfileFactory,
 } from '@reactionary/core';
@@ -25,19 +25,19 @@ import type { MedusaProductAssociationsFactory } from '../factories/product-asso
 import type { MedusaProductFactory } from '../factories/product/product.factory.js';
 import type { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 import type { MedusaProfileFactory } from '../factories/profile/profile.factory.js';
-import type { MedusaCartProvider } from '../providers/cart.provider.js';
-import type { MedusaCategoryProvider } from '../providers/category.provider.js';
-import type { MedusaCheckoutProvider } from '../providers/checkout.provider.js';
-import type { MedusaInventoryProvider } from '../providers/inventory.provider.js';
-import type { MedusaOrderProvider } from '../providers/order.provider.js';
-import type { MedusaOrderSearchProvider } from '../providers/order-search.provider.js';
-import type { MedusaPriceProvider } from '../providers/price.provider.js';
-import type { MedusaProductAssociationsProvider } from '../providers/product-associations.provider.js';
-import type { MedusaProductProvider } from '../providers/product.provider.js';
-import type { MedusaSearchProvider } from '../providers/product-search.provider.js';
-import type { MedusaProfileProvider } from '../providers/profile.provider.js';
-import type { MedusaProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
-import type { MedusaIdentityProvider } from '../providers/identity.provider.js';
+import type { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import type { MedusaCategoryCapability } from '../capabilities/category.capability.js';
+import type { MedusaCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { MedusaOrderCapability } from '../capabilities/order.capability.js';
+import type { MedusaOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { MedusaPriceCapability } from '../capabilities/price.capability.js';
+import type { MedusaProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import type { MedusaProductCapability } from '../capabilities/product.capability.js';
+import type { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { MedusaProfileCapability } from '../capabilities/profile.capability.js';
+import type { MedusaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import type { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
 
 type OverridableCapabilityKey =
   | 'product'
@@ -70,12 +70,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;
@@ -113,28 +113,28 @@ type ResolvedFactoryMap<T extends MedusaCapabilities> = {
   >;
 };
 
-type DefaultProviderMap<T extends MedusaCapabilities> = {
-  product: MedusaProductProvider<ResolvedFactoryMap<T>['product']>;
-  productSearch: MedusaSearchProvider<ResolvedFactoryMap<T>['productSearch']>;
-  cart: MedusaCartProvider<ResolvedFactoryMap<T>['cart']>;
-  checkout: MedusaCheckoutProvider<ResolvedFactoryMap<T>['checkout']>;
-  category: MedusaCategoryProvider<ResolvedFactoryMap<T>['category']>;
-  price: MedusaPriceProvider<ResolvedFactoryMap<T>['price']>;
-  order: MedusaOrderProvider<ResolvedFactoryMap<T>['order']>;
-  orderSearch: MedusaOrderSearchProvider<ResolvedFactoryMap<T>['orderSearch']>;
-  inventory: MedusaInventoryProvider<ResolvedFactoryMap<T>['inventory']>;
-  profile: MedusaProfileProvider<ResolvedFactoryMap<T>['profile']>;
-  productAssociations: MedusaProductAssociationsProvider<
+type DefaultCapabilityMap<T extends MedusaCapabilities> = {
+  product: MedusaProductCapability<ResolvedFactoryMap<T>['product']>;
+  productSearch: MedusaProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+  cart: MedusaCartCapability<ResolvedFactoryMap<T>['cart']>;
+  checkout: MedusaCheckoutCapability<ResolvedFactoryMap<T>['checkout']>;
+  category: MedusaCategoryCapability<ResolvedFactoryMap<T>['category']>;
+  price: MedusaPriceCapability<ResolvedFactoryMap<T>['price']>;
+  order: MedusaOrderCapability<ResolvedFactoryMap<T>['order']>;
+  orderSearch: MedusaOrderSearchCapability<ResolvedFactoryMap<T>['orderSearch']>;
+  inventory: MedusaInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+  profile: MedusaProfileCapability<ResolvedFactoryMap<T>['profile']>;
+  productAssociations: MedusaProductAssociationsCapability<
     ResolvedFactoryMap<T>['productAssociations']
   >;
-  identity: MedusaIdentityProvider;
-  productRecommendations: MedusaProductRecommendationsProvider;
+  identity: MedusaIdentityCapability;
+  productRecommendations: MedusaProductRecommendationsCapability;
 };
 
-type CapabilityProviderTypeMap<T extends MedusaCapabilities> = {
-  [K in OverridableCapabilityKey | 'productRecommendations' | 'identity']: ExtractCapabilityProvider<
+type CapabilityImplementationMap<T extends MedusaCapabilities> = {
+  [K in OverridableCapabilityKey | 'productRecommendations' | 'identity']: ExtractCapabilityImplementation<
     T[K],
-    DefaultProviderMap<T>[K]
+    DefaultCapabilityMap<T>[K]
   >;
 };
 
@@ -143,7 +143,7 @@ type EnabledCapabilityOverrideMap<T extends MedusaCapabilities> = {
     enabled: true;
   }
     ? K
-    : never]: CapabilityProviderTypeMap<T>[K];
+    : never]: CapabilityImplementationMap<T>[K];
 };
 
 export type MedusaClientFromCapabilities<T extends MedusaCapabilities> = Omit<
@@ -152,33 +152,33 @@ export type MedusaClientFromCapabilities<T extends MedusaCapabilities> = 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;
-  return provider(buildProviderArgs(factory));
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
 }
 
-export function resolveProviderOnlyCapability<TProvider, TProviderArgs>(
+export function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(
   capability:
     | {
-        provider?: (args: TProviderArgs) => TProvider;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
       }
     | undefined,
-  defaultProvider: (args: TProviderArgs) => TProvider,
-  args: TProviderArgs,
-): TProvider {
-  const provider = capability?.provider ?? defaultProvider;
-  return provider(args);
+  defaultCapability: (args: TCapabilityArgs) => TResolvedCapability,
+  args: TCapabilityArgs,
+): TResolvedCapability {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
 }

package/packages/medusa/src/index.ts

@@ -0,0 +1,17 @@
+export * from './schema/configuration.schema.js';
+export * from './schema/medusa.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './core/client.js';
+export * from './factories/index.js';
+export * from './capabilities/cart.capability.js';
+export * from './capabilities/identity.capability.js';
+export * from './capabilities/inventory.capability.js';
+export * from './capabilities/order.capability.js';
+export * from './capabilities/order-search.capability.js';
+export * from './capabilities/price.capability.js';
+export * from './capabilities/product-search.capability.js';
+export * from './capabilities/product-recommendations.capability.js';
+export * from './capabilities/product-associations.capability.js';
+export * from './capabilities/profile.capability.js';