@reactionary/source 0.6.2 → 0.6.3

package/packages/core/src/capabilities/index.ts

@@ -0,0 +1,18 @@
+export * from './analytics.capability.js';
+export * from './base.capability.js';
+export * from './cart.capability.js';
+export * from './category.capability.js';
+export * from './checkout.capability.js';
+export * from './identity.capability.js';
+export * from './inventory.capability.js';
+export * from './price.capability.js';
+export * from './product.capability.js';
+export * from './profile.capability.js';
+export * from './product-search.capability.js';
+export * from './product-recommendations.capability.js';
+export * from './product-associations.capability.js';
+export * from './product-reviews.capability.js';
+export * from './product-list.capability.js'
+export * from './store.capability.js';
+export * from './order.capability.js'
+export * from './order-search.capability.js'

package/{core/src/providers/inventory.provider.ts → packages/core/src/capabilities/inventory.capability.ts}

@@ -3,9 +3,9 @@ import type { InventoryIdentifier } from '../schemas/models/identifiers.model.js
 import type { Inventory } from '../schemas/models/inventory.model.js';
 import type { InventoryQueryBySKU } from '../schemas/queries/inventory.query.js';
 import type { Result } from '../schemas/result.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 
-export abstract class InventoryProvider<TInventory extends Inventory = Inventory> extends BaseProvider {
+export abstract class InventoryCapability<TInventory extends Inventory = Inventory> extends BaseCapability {
   public abstract getBySKU(payload: InventoryQueryBySKU): Promise<Result<TInventory, NotFoundError>>;
 
   protected override getResourceName(): string {

package/{core/src/providers/order-search.provider.ts → packages/core/src/capabilities/order-search.capability.ts}

@@ -1,7 +1,7 @@
 import type { OrderSearchResult } from "../schemas/models/order-search.model.js";
 import type { OrderSearchQueryByTerm } from "../schemas/queries/order-search.query.js";
 import type { Result } from "../schemas/result.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 
 /**
  * This provider handles order search operations. In some situations you may have different providers for order history listing and detail retrieval.
@@ -9,9 +9,9 @@ import { BaseProvider } from "./base.provider.js";
  *
  * Usecase: An e-commerce platform wants to provide customers with a way to search through their past orders using filters like date range, order status, or total amount spent.
  */
-export abstract class OrderSearchProvider<
+export abstract class OrderSearchCapability<
   TOrderSearchResult extends OrderSearchResult = OrderSearchResult,
-> extends BaseProvider {
+> extends BaseCapability {
   protected override getResourceName(): string {
     return 'order-search';
   }

package/{core/src/providers/order.provider.ts → packages/core/src/capabilities/order.capability.ts}

@@ -1,10 +1,10 @@
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 import type { Order } from '../schemas/models/index.js';
 import type { OrderQueryById } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
 import type { NotFoundError } from '../schemas/index.js';
 
-export abstract class OrderProvider<TOrder extends Order = Order> extends BaseProvider {
+export abstract class OrderCapability<TOrder extends Order = Order> extends BaseCapability {
   /**
    * Get order by ID.
    *

package/{core/src/providers/price.provider.ts → packages/core/src/capabilities/price.capability.ts}

@@ -3,9 +3,9 @@ import type {
   CustomerPriceQuery,
   ListPriceQuery,
 } from '../schemas/queries/price.query.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 
-export abstract class PriceProvider<TPrice extends Price = Price> extends BaseProvider {
+export abstract class PriceCapability<TPrice extends Price = Price> extends BaseCapability {
   /**
    * Get a list price price by SKU. This is the most general, undiscounted price and is typically
    * used as the "before" price in most ecommerce setups.

package/{core/src/providers/product-associations.provider.ts → packages/core/src/capabilities/product-associations.capability.ts}

@@ -1,6 +1,6 @@
 import type { ProductIdentifier, ProductVariantIdentifier } from "../schemas/index.js";
 import type { ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery } from "../schemas/queries/product-associations.query.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 import type { Result } from '../schemas/result.js';
 import type { ProductAssociation } from '../schemas/models/product-associations.model.js';
 
@@ -9,9 +9,9 @@ import type { ProductAssociation } from '../schemas/models/product-associations.
  * accessories, spareparts, and replacements. These associations are typically used to provide recommendations to customers on the product detail page, but can also be used in other contexts such as the cart or post-purchase, but
  * do not carry any personalization concept to them.
  */
-export abstract class ProductAssociationsProvider<
+export abstract class ProductAssociationsCapability<
   TProductAssociation extends ProductAssociation = ProductAssociation,
-> extends BaseProvider {
+> extends BaseCapability {
 
   /**
    * Returns a list of product identifiers which are accessories to the given product.

package/{core/src/providers/product-list.provider.ts → packages/core/src/capabilities/product-list.capability.ts}

@@ -3,7 +3,7 @@ import type { ProductListItemMutationCreate, ProductListItemMutationDelete, Prod
 import type { ProductListQuery, ProductListQueryById } from "../schemas/queries/product-list.query.js";
 import { type ProductListItemsQuery } from "../schemas/queries/product-list.query.js";
 import type { Result } from "../schemas/result.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 
 /**
  * The product list provider is a general purpose provider for creating various types of product lists, such as favorite lists, projects, wishlists, requisitionlists, etc
@@ -13,12 +13,12 @@ import { BaseProvider } from "./base.provider.js";
  *
  * Some systems might only support single entries of each type, but the general case is to support multiples.
  */
-export abstract class ProductListProvider<
+export abstract class ProductListCapability<
   TProductList extends ProductList = ProductList,
   TProductListItem extends ProductListItem = ProductListItem,
   TProductListPaginatedResult extends ProductListPaginatedResult = ProductListPaginatedResult,
   TProductListItemPaginatedResult extends ProductListItemPaginatedResult = ProductListItemPaginatedResult,
-> extends BaseProvider {
+> extends BaseCapability {
 
   protected getResourceName(): string {
     return 'product-lists';

package/{core/src/providers/product-recommendations.provider.ts → packages/core/src/capabilities/product-recommendations.capability.ts}

@@ -2,12 +2,12 @@ import type { Cache } from '../cache/cache.interface.js';
 import { Reactionary } from "../decorators/reactionary.decorator.js";
 import { success, type ProductRecommendation, type ProductRecommendationsByCollectionQuery, type RequestContext, type Result } from "../schemas/index.js";
 import { ProductRecommendationsQuerySchema, type ProductRecommendationAlgorithmAlsoViewedProductsQuery, type ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery, type ProductRecommendationAlgorithmPopuplarProductsQuery, type ProductRecommendationAlgorithmRelatedProductsQuery, type ProductRecommendationAlgorithmSimilarProductsQuery, type ProductRecommendationAlgorithmTopPicksProductsQuery, type ProductRecommendationAlgorithmTrendingInCategoryQuery, type ProductRecommendationsQuery } from "../schemas/queries/product-recommendations.query.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 
-export abstract class ProductRecommendationsProvider extends BaseProvider {
+export abstract class ProductRecommendationsCapability extends BaseCapability {
 
   /**
-   * returns a list of recommended products, based on the selected algorithm and the provided query parameters. The recommendations should be relevant to the product specified in the query, and can be personalized based on the customer segments or contexts provided. The provider should return a list of product variant identifiers that are recommended for the given product, which can then be used to fetch the full product details from the product provider if needed.
+   * returns a list of recommended products, based on the selected algorithm and the provided query parameters. The recommendations should be relevant to the product specified in the query, and can be personalized based on the customer segments or contexts provided. The capability should return a list of product variant identifiers that are recommended for the given product, which can then be used to fetch the full product details from the product capability if needed.
    *   *
    * Usecase:
    *   - PDP - "Customers who viewed this product also viewed"
@@ -89,17 +89,17 @@ export abstract class ProductRecommendationsProvider extends BaseProvider {
 
 
 
-export class MulticastProductRecommendationsProvider extends ProductRecommendationsProvider {
-  protected providers: Array<ProductRecommendationsProvider>;
+export class MulticastProductRecommendationsCapability extends ProductRecommendationsCapability {
+  protected capabilities: Array<ProductRecommendationsCapability>;
 
   constructor(
     cache: Cache,
     requestContext: RequestContext,
-    providers: Array<ProductRecommendationsProvider>
+    capabilities: Array<ProductRecommendationsCapability>
   ) {
     super(cache, requestContext);
 
-    this.providers = providers;
+    this.capabilities = capabilities;
   }
 
   @Reactionary({
@@ -107,15 +107,15 @@ export class MulticastProductRecommendationsProvider extends ProductRecommendati
   })
   public override  async getRecommendations(query: ProductRecommendationsQuery): Promise<Result<ProductRecommendation[]>> {
     const output = [];
-    for (const provider of this.providers) {
-      const providerOutput = await provider.getRecommendations(query);
-      if (providerOutput.success) {
+    for (const capability of this.capabilities) {
+      const capabilityOutput = await capability.getRecommendations(query);
+      if (capabilityOutput.success) {
 
-        output.push(...providerOutput.value);
+        output.push(...capabilityOutput.value);
       } else {
         // For other types of errors, we might want to log them or handle them differently
-        console.error(`Error from provider ${provider.constructor.name}:`, providerOutput.error);
-        return providerOutput
+        console.error(`Error from capability ${capability.constructor.name}:`, capabilityOutput.error);
+        return capabilityOutput
       }
       if (output.length >= query.numberOfRecommendations) {
         break;
@@ -126,18 +126,18 @@ export class MulticastProductRecommendationsProvider extends ProductRecommendati
 
   public override async getCollection(query: ProductRecommendationsByCollectionQuery): Promise<Result<ProductRecommendation[]>> {
     const output = [];
-    for (const provider of this.providers) {
-      const providerOutput = await provider.getCollection(query);
-      if (providerOutput.success) {
-        output.push(...providerOutput.value);
+    for (const capability of this.capabilities) {
+      const capabilityOutput = await capability.getCollection(query);
+      if (capabilityOutput.success) {
+        output.push(...capabilityOutput.value);
       } else {
-        if (providerOutput.error.type === 'NotFound') {
-          // If the error is a NotFound error, we can ignore it and continue to the next provider
+        if (capabilityOutput.error.type === 'NotFound') {
+          // If the error is a NotFound error, we can ignore it and continue to the next capability
           continue;
         } else {
           // For other types of errors, we might want to log them or handle them differently
-          console.error(`Error from provider ${provider.constructor.name}:`, providerOutput.error);
-          return providerOutput;
+          console.error(`Error from capability ${capability.constructor.name}:`, capabilityOutput.error);
+          return capabilityOutput;
         }
       }
       if (output.length >= query.numberOfRecommendations) {

package/{core/src/providers/product-reviews.provider.ts → packages/core/src/capabilities/product-reviews.capability.ts}

@@ -1,18 +1,18 @@
 import type { Result, ProductReview, ProductRatingSummary, ProductReviewPaginatedResult } from '../schemas/index.js';
 import type { ProductReviewsListQuery, ProductReviewsGetRatingSummaryQuery } from '../schemas/queries/product-reviews.query.js';
 import type { ProductReviewMutationSubmit } from '../schemas/mutations/product-reviews.mutation.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 import { type ProductRatingIdentifier } from '../schemas/models/identifiers.model.js';
 /**
  * The product reviews provider is responsible for providing detailed product reviews from customers.
  * Reviews contain ratings along with textual feedback, author information, and verification status.
  * This provider also handles aggregated rating summaries for products.
  */
-export abstract class ProductReviewsProvider<
+export abstract class ProductReviewsCapability<
   TProductRatingSummary extends ProductRatingSummary = ProductRatingSummary,
   TProductReviewPaginatedResult extends ProductReviewPaginatedResult = ProductReviewPaginatedResult,
   TProductReview extends ProductReview = ProductReview,
-> extends BaseProvider {
+> extends BaseCapability {
   /**
    * Get the rating summary for a product, including average rating and distribution.
    *

package/{core/src/providers/product-search.provider.ts → packages/core/src/capabilities/product-search.capability.ts}

@@ -4,11 +4,11 @@ import type {
   ProductSearchQueryByTerm,
   ProductSearchQueryCreateNavigationFilter,
 } from '../schemas/queries/product-search.query.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 
-export abstract class ProductSearchProvider<
+export abstract class ProductSearchCapability<
   TProductSearchResult extends ProductSearchResult = ProductSearchResult,
-> extends BaseProvider {
+> extends BaseCapability {
   protected override getResourceName(): string {
     return 'product-search';
   }

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

@@ -1,10 +1,10 @@
 import type { Product } from '../schemas/models/product.model.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug } from '../schemas/queries/product.query.js';
 import type { Result } from '../schemas/result.js';
 import type { NotFoundError } from '../schemas/index.js';
 
-export abstract class ProductProvider<TProduct extends Product = Product> extends BaseProvider {
+export abstract class ProductCapability<TProduct extends Product = Product> extends BaseCapability {
 
 
   /**

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

@@ -3,9 +3,9 @@ import type { Profile } from '../schemas/models/index.js';
 import type { ProfileMutationAddShippingAddress, ProfileMutationMakeShippingAddressDefault, ProfileMutationRemoveShippingAddress, ProfileMutationSetBillingAddress, ProfileMutationUpdate, ProfileMutationUpdateShippingAddress } from '../schemas/mutations/index.js';
 import type { ProfileQuerySelf as ProfileQueryById } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 
-export abstract class ProfileProvider<TProfile extends Profile = Profile> extends BaseProvider {
+export abstract class ProfileCapability<TProfile extends Profile = Profile> extends BaseCapability {
 
   /**
    * Returns the profile of the currently authenticated (registered) user.

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

@@ -1,9 +1,9 @@
 import type { Store } from '../schemas/models/store.model.js';
 import type { StoreQueryByProximity } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 
-export abstract class StoreProvider<TStore extends Store = Store> extends BaseProvider {
+export abstract class StoreCapability<TStore extends Store = Store> extends BaseCapability {
   public abstract queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<TStore>>>;
 
   protected override getResourceName(): string {

package/{core → packages/core}/src/client/client-builder.ts

@@ -1,12 +1,12 @@
 import type { Cache } from '../cache/cache.interface.js';
 import { NoOpCache } from '../cache/noop-cache.js';
 import type { Client } from './client.js';
-import { MulticastAnalyticsProvider, type AnalyticsProvider } from '../providers/analytics.provider.js';
+import { MulticastAnalyticsCapability, type AnalyticsCapability } from '../capabilities/analytics.capability.js';
 import {
   RequestContextSchema,
   type RequestContext,
 } from '../schemas/session.schema.js';
-import { MulticastProductRecommendationsProvider, type ProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
+import { MulticastProductRecommendationsCapability, type ProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
 
 export interface ClientBuilderFactoryArgs {
   cache: Cache;
@@ -71,28 +71,27 @@ export class ClientBuilder<TClient = Client> {
       throw new Error('Invalid context: ' + validatedContext.error);
     }
 
-    const mergedAnalytics: AnalyticsProvider[] = [];
-
-    const mergedProductRecommendationsProviders: ProductRecommendationsProvider[] = [];
+    const mergedAnalytics: AnalyticsCapability[] = [];
+    const mergedProductRecommendations: ProductRecommendationsCapability[] = [];
 
     for (const factory of this.factories) {
-      const provider = this.resolveFactory(factory, sharedCache, this.context);
-      client = this.mergeProviders(client, provider as Partial<TClient>);
+      const capability = this.resolveFactory(factory, sharedCache, this.context);
+      client = this.mergeCapabilities(client, capability as Partial<TClient>);
 
-      if (provider.analytics) {
-        mergedAnalytics.push(provider.analytics);
+      if (capability.analytics) {
+        mergedAnalytics.push(capability.analytics);
       }
 
-      if (provider.productRecommendations) {
-        mergedProductRecommendationsProviders.push(provider.productRecommendations);
+      if (capability.productRecommendations) {
+        mergedProductRecommendations.push(capability.productRecommendations);
       }
     }
 
     // Add cache to complete the client
     const completeClient = {
       ...client,
-      analytics: new MulticastAnalyticsProvider(sharedCache, this.context, mergedAnalytics),
-      productRecommendations: new MulticastProductRecommendationsProvider(sharedCache, this.context, mergedProductRecommendationsProviders),
+      analytics: new MulticastAnalyticsCapability(sharedCache, this.context, mergedAnalytics),
+      productRecommendations: new MulticastProductRecommendationsCapability(sharedCache, this.context, mergedProductRecommendations),
       cache: sharedCache,
     } as TClient & { cache: Cache };
 
@@ -110,7 +109,7 @@ export class ClientBuilder<TClient = Client> {
     return (factory as (cache: Cache, context: RequestContext) => TNew)(cache, context);
   }
 
-  private mergeProviders(
+  private mergeCapabilities(
     target: TClient,
     source: Partial<TClient>,
   ): TClient {

package/packages/core/src/client/client.ts

@@ -0,0 +1,35 @@
+import type { ProductCapability } from "../capabilities/product.capability.js";
+import type { ProductSearchCapability } from "../capabilities/product-search.capability.js";
+import type { IdentityCapability } from '../capabilities/identity.capability.js';
+import type { CartCapability } from "../capabilities/cart.capability.js";
+import type { PriceCapability } from "../capabilities/price.capability.js";
+import type { InventoryCapability } from "../capabilities/inventory.capability.js";
+import type { Cache } from "../cache/cache.interface.js";
+import type { CategoryCapability } from "../capabilities/category.capability.js";
+import type { AnalyticsCapability, CheckoutCapability, OrderCapability, ProductListCapability, ProfileCapability, StoreCapability } from "../capabilities/index.js";
+import type { OrderSearchCapability } from "../capabilities/order-search.capability.js";
+import type { ProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
+import type { ProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import type { ProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+
+export interface Client {
+    product: ProductCapability,
+    productSearch: ProductSearchCapability,
+    productRecommendations: ProductRecommendationsCapability,
+    productAssociations: ProductAssociationsCapability,
+    productReviews: ProductReviewsCapability,
+    productList: ProductListCapability,
+    identity: IdentityCapability,
+    cache: Cache,
+    cart: CartCapability,
+    checkout: CheckoutCapability,
+    analytics: AnalyticsCapability,
+    price: PriceCapability,
+    inventory: InventoryCapability,
+    category: CategoryCapability,
+    profile: ProfileCapability,
+    store: StoreCapability,
+    order: OrderCapability,
+    orderSearch: OrderSearchCapability,
+}
+

package/{core → packages/core}/src/decorators/reactionary.decorator.ts

@@ -1,7 +1,7 @@
 import type { Tracer } from '@opentelemetry/api';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
 import * as z from 'zod';
-import type { BaseProvider } from '../providers/index.js';
+import type { BaseCapability } from '../capabilities/index.js';
 import { getReactionaryMeter } from '../metrics/metrics.js';
 import { error, success, type Result } from '../schemas/result.js';
 import type {
@@ -18,7 +18,7 @@ export function getTracer(): Tracer {
 }
 
 /**
- * The options associated with annotating a provider function and marking
+ * The options associated with annotating a capability function and marking
  * it as a reactionary entrypoint to be called
  */
 export class ReactionaryDecoratorOptions {
@@ -59,13 +59,13 @@ export class ReactionaryDecoratorOptions {
 }
 
 /**
- * Decorator for provider functions to provide functionality such as caching, tracing and type-checked
+ * Decorator for capability functions to provide functionality such as caching, tracing and type-checked
  * assertion through Zod. It should only be used with publically accessible queries or mutations on
- * providers.
+ * capabilities.
  */
 export function Reactionary(options: Partial<ReactionaryDecoratorOptions>) {
   return function (
-    target: BaseProvider,
+    target: BaseCapability,
     propertyKey: string | symbol,
     descriptor: PropertyDescriptor
   ): PropertyDescriptor {
@@ -82,11 +82,11 @@ export function Reactionary(options: Partial<ReactionaryDecoratorOptions>) {
 
     if (!original) {
       throw new Error(
-        '@Reactionary decorator may only be applied to methods on classes extending BaseProvider.'
+        '@Reactionary decorator may only be applied to methods on classes extending BaseCapability.'
       );
     }
 
-    descriptor.value = async function (this: BaseProvider, ...args: any[]) {
+    descriptor.value = async function (this: BaseCapability, ...args: any[]) {
       return traceSpan(scope, async () => {
         meter.requestInProgress.add(1, attributes);
         try {

package/{core → packages/core}/src/index.ts

@@ -2,7 +2,7 @@ export * from './cache/index.js';
 export * from './client/index.js';
 export * from './decorators/index.js';
 export * from './factories/index.js';
-export * from './providers/index.js';
+export * from './capabilities/index.js';
 export * from './schemas/index.js';
 export * from './initialization.js';
 export type { InferType } from './zod-utils.js';

package/{core → packages/core}/src/test/client-builder.spec.ts

@@ -2,15 +2,15 @@ import { describe, expect, it } from "vitest";
 import type { Capabilities, ClientFromCapabilities } from "../schemas/capabilities.schema.js";
 import type { Cache } from '../cache/cache.interface.js';
 import type { RequestContext } from "../schemas/session.schema.js";
-import { AnalyticsProvider } from "../providers/analytics.provider.js";
+import { AnalyticsCapability } from "../capabilities/analytics.capability.js";
 import type { AnalyticsMutation } from "../schemas/index.js";
 import { NoOpCache } from "../cache/noop-cache.js";
 import { createInitialRequestContext } from "../initialization.js";
 import { ClientBuilder } from "../client/client-builder.js";
 import type { Client } from "../client/client.js";
-import { ProductProvider } from "../providers/product.provider.js";
+import { ProductCapability } from "../capabilities/product.capability.js";
 
-export class MockAnalyticsProvider extends AnalyticsProvider {
+export class MockAnalyticsCapability extends AnalyticsCapability {
     public events: Array<AnalyticsMutation> = [];
 
     public override async track(event: AnalyticsMutation): Promise<void> {
@@ -38,12 +38,12 @@ describe('Client Builder', () => {
     const cache = new NoOpCache();
     const context = createInitialRequestContext();
     const builder = new ClientBuilder(context);
-    const analyticsProvider = new MockAnalyticsProvider(cache, context);
-    const secondaryAnalyticsProvider = new MockAnalyticsProvider(cache, context);
+    const analyticsCapability = new MockAnalyticsCapability(cache, context);
+    const secondaryAnalyticsCapability = new MockAnalyticsCapability(cache, context);
     const client = builder
         .withCache(cache)
-        .withCapability(withMockCapabilities({ analytics: analyticsProvider }))
-        .withCapability(withMockCapabilities({ analytics: secondaryAnalyticsProvider }))
+        .withCapability(withMockCapabilities({ analytics: analyticsCapability }))
+        .withCapability(withMockCapabilities({ analytics: secondaryAnalyticsCapability }))
         .build();
 
     const track = await client.analytics.track({
@@ -53,24 +53,24 @@ describe('Client Builder', () => {
         }
     });
 
-    expect(analyticsProvider.events.length).toBe(1);
-    expect(analyticsProvider.events[0].event).toBe('product-details-view');
-    expect(secondaryAnalyticsProvider.events.length).toBe(1);
-    expect(secondaryAnalyticsProvider.events[0].event).toBe('product-details-view');
+    expect(analyticsCapability.events.length).toBe(1);
+    expect(analyticsCapability.events[0].event).toBe('product-details-view');
+    expect(secondaryAnalyticsCapability.events.length).toBe(1);
+    expect(secondaryAnalyticsCapability.events[0].event).toBe('product-details-view');
   });
 
   it('supports capability factories with args object signature', () => {
     const cache = new NoOpCache();
     const context = createInitialRequestContext();
     const builder = new ClientBuilder(context);
-    const analyticsProvider = new MockAnalyticsProvider(cache, context);
+    const analyticsCapability = new MockAnalyticsCapability(cache, context);
 
     const client = builder
       .withCache(cache)
       .withCapability(({ cache: sharedCache, context: sharedContext }) => {
         expect(sharedCache).toBe(cache);
         expect(sharedContext).toBe(context);
-        return { analytics: analyticsProvider };
+        return { analytics: analyticsCapability };
       })
       .build();
 
@@ -82,7 +82,7 @@ describe('Client Builder', () => {
     const context = createInitialRequestContext();
     const builder = new ClientBuilder(context);
 
-    class TestProductProvider extends ProductProvider {
+    class TestProductCapability extends ProductCapability {
       public override async getById(): Promise<any> {
         throw new Error('not implemented');
       }
@@ -98,8 +98,8 @@ describe('Client Builder', () => {
       builder
         .withCache(cache)
         .withCollisionStrategy('throw')
-        .withCapability(() => ({ product: new TestProductProvider(cache, context) }))
-        .withCapability(() => ({ product: new TestProductProvider(cache, context) }))
+        .withCapability(() => ({ product: new TestProductCapability(cache, context) }))
+        .withCapability(() => ({ product: new TestProductCapability(cache, context) }))
         .build(),
     ).toThrow(/Capability collision detected for "product"/);
   });
@@ -109,7 +109,7 @@ describe('Client Builder', () => {
     const context = createInitialRequestContext();
     const builder = new ClientBuilder(context);
 
-    class TestProductProvider extends ProductProvider {
+    class TestProductCapability extends ProductCapability {
       public name: string;
       constructor(cache: Cache, context: RequestContext, name: string) {
         super(cache, context);
@@ -126,8 +126,8 @@ describe('Client Builder', () => {
       }
     }
 
-    const first = new TestProductProvider(cache, context, 'first');
-    const second = new TestProductProvider(cache, context, 'second');
+    const first = new TestProductCapability(cache, context, 'first');
+    const second = new TestProductCapability(cache, context, 'second');
 
     const client = builder
       .withCache(cache)
@@ -136,6 +136,6 @@ describe('Client Builder', () => {
       .withCapability(() => ({ product: second }))
       .build();
 
-    expect((client.product as TestProductProvider).name).toBe('first');
+    expect((client.product as TestProductCapability).name).toBe('first');
   });
 });