@reactionary/source 0.6.2 → 0.6.3

package/{providers → packages}/commercetools/src/schema/capabilities.schema.ts

@@ -2,50 +2,50 @@ import type {
   Cache,
   CartFactory,
   CartFactoryWithOutput,
-  CartProvider,
+  CartCapability,
   CategoryFactory,
   CategoryFactoryWithOutput,
-  CategoryProvider,
+  CategoryCapability,
   CheckoutFactory,
   CheckoutFactoryWithOutput,
-  CheckoutProvider,
+  CheckoutCapability,
   IdentityFactory,
   IdentityFactoryWithOutput,
-  IdentityProvider,
+  IdentityCapability,
   InventoryFactory,
   InventoryFactoryWithOutput,
-  InventoryProvider,
+  InventoryCapability,
   OrderFactory,
   OrderFactoryWithOutput,
-  OrderProvider,
+  OrderCapability,
   OrderSearchFactory,
   OrderSearchFactoryWithOutput,
-  OrderSearchProvider,
+  OrderSearchCapability,
   PriceFactory,
   PriceFactoryWithOutput,
-  PriceProvider,
+  PriceCapability,
   ProductAssociationsFactory,
   ProductAssociationsFactoryWithOutput,
-  ProductAssociationsProvider,
+  ProductAssociationsCapability,
   ProductFactory,
   ProductFactoryWithOutput,
   ProductListFactory,
   ProductListFactoryWithOutput,
-  ProductListProvider,
-  ProductProvider,
+  ProductListCapability,
+  ProductCapability,
   ProductReviewsFactory,
   ProductReviewsFactoryWithOutput,
-  ProductReviewsProvider,
+  ProductReviewsCapability,
   ProductSearchFactory,
   ProductSearchFactoryWithOutput,
-  ProductSearchProvider,
+  ProductSearchCapability,
   ProfileFactory,
   ProfileFactoryWithOutput,
-  ProfileProvider,
+  ProfileCapability,
   RequestContext,
   StoreFactory,
   StoreFactoryWithOutput,
-  StoreProvider,
+  StoreCapability,
 } from '@reactionary/core';
 import { CapabilitiesSchema } from '@reactionary/core';
 import type { CommercetoolsAPI } from '../core/client.js';
@@ -59,7 +59,7 @@ const EnabledCapabilitySchema = z.looseObject({
 const OverridableCapabilitySchema = z.looseObject({
   enabled: z.boolean(),
   factory: z.unknown().optional(),
-  provider: z.unknown().optional(),
+  capability: z.unknown().optional(),
 });
 
 export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
@@ -98,7 +98,7 @@ export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   })
   .partial();
 
-export interface CommercetoolsCapabilityProviderFactoryArgs<TFactory> {
+export interface CommercetoolsCapabilityFactoryArgs<TFactory> {
   cache: Cache;
   context: RequestContext;
   config: CommercetoolsConfiguration;
@@ -106,131 +106,131 @@ export interface CommercetoolsCapabilityProviderFactoryArgs<TFactory> {
   factory: TFactory;
 }
 
-export interface CommercetoolsCapabilityConfig<TFactory, TProvider> {
+export interface CommercetoolsCapabilityConfig<TFactory, TCapability> {
   factory?: TFactory;
-  provider?: (args: CommercetoolsCapabilityProviderFactoryArgs<TFactory>) => TProvider;
+  capability?: (args: CommercetoolsCapabilityFactoryArgs<TFactory>) => TCapability;
 }
 
-type EnabledCapabilityConfig<TFactory, TProvider> = {
+type EnabledCapabilityConfig<TFactory, TCapability> = {
   enabled: boolean;
-} & CommercetoolsCapabilityConfig<TFactory, TProvider>;
+} & CommercetoolsCapabilityConfig<TFactory, TCapability>;
 
 export type CommercetoolsProductCapabilityConfig<
   TFactory extends ProductFactory = ProductFactory,
-  TProvider extends ProductProvider = ProductProvider,
-> = CommercetoolsCapabilityConfig<ProductFactoryWithOutput<TFactory>, TProvider>;
+  TCapability extends ProductCapability = ProductCapability,
+> = CommercetoolsCapabilityConfig<ProductFactoryWithOutput<TFactory>, TCapability>;
 
 export type CommercetoolsCheckoutCapabilityConfig<
   TFactory extends CheckoutFactory = CheckoutFactory,
-  TProvider extends CheckoutProvider = CheckoutProvider,
-> = CommercetoolsCapabilityConfig<CheckoutFactoryWithOutput<TFactory>, TProvider>;
+  TCapability extends CheckoutCapability = CheckoutCapability,
+> = CommercetoolsCapabilityConfig<CheckoutFactoryWithOutput<TFactory>, TCapability>;
 
 export type CommercetoolsProductSearchCapabilityConfig = CommercetoolsCapabilityConfig<
   ProductSearchFactoryWithOutput<ProductSearchFactory>,
-  ProductSearchProvider
+  ProductSearchCapability
 >;
 export type CommercetoolsProductAssociationsCapabilityConfig = CommercetoolsCapabilityConfig<
   ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
-  ProductAssociationsProvider
+  ProductAssociationsCapability
 >;
 export type CommercetoolsProductReviewsCapabilityConfig = CommercetoolsCapabilityConfig<
   ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
-  ProductReviewsProvider
+  ProductReviewsCapability
 >;
 export type CommercetoolsProductListCapabilityConfig = CommercetoolsCapabilityConfig<
   ProductListFactoryWithOutput<ProductListFactory>,
-  ProductListProvider
+  ProductListCapability
 >;
 export type CommercetoolsIdentityCapabilityConfig = CommercetoolsCapabilityConfig<
   IdentityFactoryWithOutput<IdentityFactory>,
-  IdentityProvider
+  IdentityCapability
 >;
 export type CommercetoolsCartCapabilityConfig = CommercetoolsCapabilityConfig<
   CartFactoryWithOutput<CartFactory>,
-  CartProvider
+  CartCapability
 >;
 export type CommercetoolsInventoryCapabilityConfig = CommercetoolsCapabilityConfig<
   InventoryFactoryWithOutput<InventoryFactory>,
-  InventoryProvider
+  InventoryCapability
 >;
 export type CommercetoolsPriceCapabilityConfig = CommercetoolsCapabilityConfig<
   PriceFactoryWithOutput<PriceFactory>,
-  PriceProvider
+  PriceCapability
 >;
 export type CommercetoolsCategoryCapabilityConfig = CommercetoolsCapabilityConfig<
   CategoryFactoryWithOutput<CategoryFactory>,
-  CategoryProvider
+  CategoryCapability
 >;
 export type CommercetoolsStoreCapabilityConfig = CommercetoolsCapabilityConfig<
   StoreFactoryWithOutput<StoreFactory>,
-  StoreProvider
+  StoreCapability
 >;
 export type CommercetoolsProfileCapabilityConfig = CommercetoolsCapabilityConfig<
   ProfileFactoryWithOutput<ProfileFactory>,
-  ProfileProvider
+  ProfileCapability
 >;
 export type CommercetoolsOrderCapabilityConfig = CommercetoolsCapabilityConfig<
   OrderFactoryWithOutput<OrderFactory>,
-  OrderProvider
+  OrderCapability
 >;
 export type CommercetoolsOrderSearchCapabilityConfig = CommercetoolsCapabilityConfig<
   OrderSearchFactoryWithOutput<OrderSearchFactory>,
-  OrderSearchProvider
+  OrderSearchCapability
 >;
 
 export type CommercetoolsCapabilityConfigMap<
   TProductFactory extends ProductFactory = ProductFactory,
-  TProductProvider extends ProductProvider = ProductProvider,
+  TProductCapability extends ProductCapability = ProductCapability,
   TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
-  TCheckoutProvider extends CheckoutProvider = CheckoutProvider,
+  TCheckoutCapability extends CheckoutCapability = CheckoutCapability,
 > = {
   product: EnabledCapabilityConfig<
     ProductFactoryWithOutput<TProductFactory>,
-    TProductProvider
+    TProductCapability
   >;
   checkout: EnabledCapabilityConfig<
     CheckoutFactoryWithOutput<TCheckoutFactory>,
-    TCheckoutProvider
+    TCheckoutCapability
   >;
   productSearch: EnabledCapabilityConfig<
     ProductSearchFactoryWithOutput<ProductSearchFactory>,
-    ProductSearchProvider
+    ProductSearchCapability
   >;
   productAssociations: EnabledCapabilityConfig<
     ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
-    ProductAssociationsProvider
+    ProductAssociationsCapability
   >;
   productReviews: EnabledCapabilityConfig<
     ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
-    ProductReviewsProvider
+    ProductReviewsCapability
   >;
   productList: EnabledCapabilityConfig<
     ProductListFactoryWithOutput<ProductListFactory>,
-    ProductListProvider
+    ProductListCapability
   >;
   identity: EnabledCapabilityConfig<
     IdentityFactoryWithOutput<IdentityFactory>,
-    IdentityProvider
+    IdentityCapability
   >;
-  cart: EnabledCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartProvider>;
+  cart: EnabledCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
   inventory: EnabledCapabilityConfig<
     InventoryFactoryWithOutput<InventoryFactory>,
-    InventoryProvider
+    InventoryCapability
   >;
-  price: EnabledCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceProvider>;
+  price: EnabledCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
   category: EnabledCapabilityConfig<
     CategoryFactoryWithOutput<CategoryFactory>,
-    CategoryProvider
+    CategoryCapability
   >;
-  store: EnabledCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreProvider>;
+  store: EnabledCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
   profile: EnabledCapabilityConfig<
     ProfileFactoryWithOutput<ProfileFactory>,
-    ProfileProvider
+    ProfileCapability
   >;
-  order: EnabledCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderProvider>;
+  order: EnabledCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
   orderSearch: EnabledCapabilityConfig<
     OrderSearchFactoryWithOutput<OrderSearchFactory>,
-    OrderSearchProvider
+    OrderSearchCapability
   >;
 };
 
@@ -238,23 +238,23 @@ type CommercetoolsCapabilitiesBase = z.infer<typeof CommercetoolsCapabilitiesSch
 
 export type CommercetoolsCapabilities<
   TProductFactory extends ProductFactory = ProductFactory,
-  TProductProvider extends ProductProvider = ProductProvider,
+  TProductCapability extends ProductCapability = ProductCapability,
   TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
-  TCheckoutProvider extends CheckoutProvider = CheckoutProvider,
+  TCheckoutCapability extends CheckoutCapability = CheckoutCapability,
 > = Omit<
   CommercetoolsCapabilitiesBase,
   keyof CommercetoolsCapabilityConfigMap<
     TProductFactory,
-    TProductProvider,
+    TProductCapability,
     TCheckoutFactory,
-    TCheckoutProvider
+    TCheckoutCapability
   >
 > &
   Partial<
     CommercetoolsCapabilityConfigMap<
       TProductFactory,
-      TProductProvider,
+      TProductCapability,
       TCheckoutFactory,
-      TCheckoutProvider
+      TCheckoutCapability
     >
   >;

package/{providers → packages}/commercetools/src/test/caching.spec.ts

@@ -9,9 +9,9 @@ import {
   type ProductIdentifier,
   type ProductSearchQueryByTerm,
 } from '@reactionary/core';
-import { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import { CommercetoolsProductCapability } from '../capabilities/product.capability.js';
 import { CommercetoolsAPI } from '../core/client.js';
-import { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
+import { CommercetoolsProductSearchCapability } from '../capabilities/product-search.capability.js';
 import { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
 import { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
@@ -21,7 +21,7 @@ describe('Caching', () => {
     const context = createInitialRequestContext();
     const cache = new MemoryCache();
     const client = new CommercetoolsAPI(config, context);
-    const provider = new CommercetoolsProductProvider(
+    const capability = new CommercetoolsProductCapability(
       cache,
       context,
       config,
@@ -33,7 +33,7 @@ describe('Caching', () => {
         key: 'product_10959528'
     } satisfies ProductIdentifier;
 
-    const uncached = await provider.getById({
+    const uncached = await capability.getById({
         identifier
     });
 
@@ -43,7 +43,7 @@ describe('Caching', () => {
 
     expect(uncached.meta.cache.hit).toBe(false);
 
-    const cached = await provider.getById({
+    const cached = await capability.getById({
         identifier
     });
 
@@ -59,7 +59,7 @@ describe('Caching', () => {
     const context = createInitialRequestContext();
     const cache = new MemoryCache();
     const client = new CommercetoolsAPI(config, context);
-    const provider = new CommercetoolsSearchProvider(
+    const capability = new CommercetoolsProductSearchCapability(
       config,
       cache,
       context,
@@ -79,7 +79,7 @@ describe('Caching', () => {
       }
     } satisfies ProductSearchQueryByTerm;
 
-    const uncached = await provider.queryByTerm(query);
+    const uncached = await capability.queryByTerm(query);
 
     if (!uncached.success) {
       assert.fail();
@@ -87,7 +87,7 @@ describe('Caching', () => {
 
     expect(uncached.meta.cache.hit).toBe(false);
 
-    const cached = await provider.queryByTerm(query);
+    const cached = await capability.queryByTerm(query);
 
     if (!cached.success) {
       assert.fail();

package/{providers/algolia → packages/commercetools}/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "NodeNext",
+    "module": "nodenext",
     "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,

package/{core → packages/commercetools}/tsconfig.lib.json

@@ -1,7 +1,7 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "outDir": "../dist/out-tsc",
+    "outDir": "../../dist/out-tsc",
     "declaration": true,
     "types": ["node"]
   },

package/packages/commercetools/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/packages/commercetools/vite.config.ts

@@ -0,0 +1,26 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+  cacheDir: '../../node_modules/.vite/packages/commercetools',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'commercetools',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/commercetools',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/commercetools/vitest.config.mts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/commercetools',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'commercetools',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/commercetools',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/{providers/fake → packages/core}/eslint.config.mjs

@@ -9,8 +9,9 @@ export default [
         'error',
         {
           ignoredFiles: [
-            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
           ],
         },
       ],

package/{core → packages/core}/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@reactionary/core",
   "version": "0.0.1",
-  "main": "index.js",
-  "types": "src/index.d.ts",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
     "@upstash/redis": "^1.34.9",
-    "node-object-hash": "^3.1.1"
-  },
-  "peerDependencies": {
-    "@opentelemetry/api": "^1.0.0"
+    "@opentelemetry/api": "^1.9.0",
+    "node-object-hash": "^3.1.1",
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5"
   },
-  "type": "module",
   "sideEffects": false
 }

package/packages/core/project.json

@@ -0,0 +1,33 @@
+{
+  "name": "core",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/core/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk"
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/core",
+        "main": "packages/core/src/index.ts",
+        "tsConfig": "packages/core/tsconfig.lib.json",
+        "assets": ["packages/core/*.md"],
+        "format": ["esm"],
+        "bundle": false
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

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

@@ -1,5 +1,5 @@
 import type { RequestContext } from '../schemas/session.schema.js';
-import { BaseProvider } from './base.provider.js';
+import { BaseCapability } from './base.capability.js';
 import type { Cache } from '../cache/cache.interface.js';
 import {
   AnalyticsMutationSchema,
@@ -12,7 +12,7 @@ import {
 } from '../schemas/index.js';
 import { Reactionary } from '../decorators/reactionary.decorator.js';
 
-export abstract class AnalyticsProvider extends BaseProvider {
+export abstract class AnalyticsCapability extends BaseCapability {
   protected override getResourceName(): string {
     return 'analytics';
   }
@@ -58,25 +58,25 @@ export abstract class AnalyticsProvider extends BaseProvider {
   }
 }
 
-export class MulticastAnalyticsProvider extends AnalyticsProvider {
-  protected providers: Array<AnalyticsProvider>;
+export class MulticastAnalyticsCapability extends AnalyticsCapability {
+  protected capabilities: Array<AnalyticsCapability>;
 
   constructor(
     cache: Cache,
     requestContext: RequestContext,
-    providers: Array<AnalyticsProvider>
+    capabilities: Array<AnalyticsCapability>
   ) {
     super(cache, requestContext);
 
-    this.providers = providers;
+    this.capabilities = capabilities;
   }
 
   @Reactionary({
     inputSchema: AnalyticsMutationSchema,
   })
   public override async track(event: AnalyticsMutation) {
-    for (const provider of this.providers) {
-      provider.track(event);
+    for (const capability of this.capabilities) {
+      capability.track(event);
     }
   }
 }

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

@@ -3,10 +3,10 @@ import { type RequestContext } from '../schemas/session.schema.js';
 import { hasher } from "node-object-hash";
 
 /**
- * Base capability provider, responsible for mutations (changes) and queries (fetches)
+ * Base capability abstraction, responsible for mutations (changes) and queries (fetches)
  * for a given business object domain.
  */
-export abstract class BaseProvider {
+export abstract class BaseCapability {
   protected cache: Cache;
   protected context: RequestContext;
 

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

@@ -4,15 +4,15 @@ import type { CartIdentifier } from "../schemas/models/identifiers.model.js";
 import type { CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon } from "../schemas/mutations/cart.mutation.js";
 import type { CartQueryById } from "../schemas/queries/cart.query.js";
 import type { Result } from "../schemas/result.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 
 /**
  * @group Providers
  */
-export abstract class CartProvider<
+export abstract class CartCapability<
   TCart extends Cart = Cart,
   TCartIdentifier extends CartIdentifier = CartIdentifier,
-> extends BaseProvider {
+> extends BaseCapability {
 
   /**
    * Get cart by ID.

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

@@ -1,22 +1,22 @@
 import type { Category, CategoryPaginatedResult, NotFoundError, Result } from "../schemas/index.js";
 import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 
 
 
 /**
- * CategoryProvider
+ * CategoryCapability
  *
- * This provider allows fetching of single or sets of categories.
+ * This capability allows fetching of single or sets of categories.
  *
  * We only allow fetching one hierachy level at a time, for now. This is to avoid development patterns of "fetch 5000 categories in one go.."
  *
  * @group Foo
  */
-export abstract class CategoryProvider<
+export abstract class CategoryCapability<
   TCategory extends Category = Category,
   TCategoryPaginatedResult extends CategoryPaginatedResult = CategoryPaginatedResult,
-> extends BaseProvider {
+> extends BaseCapability {
   /**
    * Get a single category by its ID. Cannot return null, because HOW did you come across a categories ID that does not exist?
    *

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

@@ -1,15 +1,15 @@
 import type { Checkout, PaymentMethod, ShippingMethod } from "../schemas/models/index.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 import type { CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationSetShippingAddress,  CheckoutMutationAddPaymentInstruction, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingInstruction } from "../schemas/mutations/checkout.mutation.js";
 import type { CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods } from "../schemas/queries/index.js";
 import type { Result } from "../schemas/result.js";
 import type { NotFoundError } from "../schemas/index.js";
 
-export abstract class CheckoutProvider<
+export abstract class CheckoutCapability<
   TCheckout extends Checkout = Checkout,
   TShippingMethod extends ShippingMethod = ShippingMethod,
   TPaymentMethod extends PaymentMethod = PaymentMethod,
-> extends BaseProvider {
+> extends BaseCapability {
 
   /**
    * This starts a new checkout session for the given cart. The checkout might duplicate the cart, or just reference it, depending on implementation, but changes to the cart,

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

@@ -2,9 +2,9 @@ import type { Identity } from "../schemas/models/identity.model.js";
 import type { IdentityMutationLogin, IdentityMutationLogout, IdentityMutationRegister } from "../schemas/mutations/identity.mutation.js";
 import type { IdentityQuerySelf } from "../schemas/queries/identity.query.js";
 import type { Result } from "../schemas/result.js";
-import { BaseProvider } from "./base.provider.js";
+import { BaseCapability } from "./base.capability.js";
 
-export abstract class IdentityProvider<TIdentity extends Identity = Identity> extends BaseProvider {
+export abstract class IdentityCapability<TIdentity extends Identity = Identity> extends BaseCapability {
   public abstract getSelf(payload: IdentityQuerySelf): Promise<Result<TIdentity>>;
   public abstract login(payload: IdentityMutationLogin): Promise<Result<TIdentity>>;
   public abstract logout(payload: IdentityMutationLogout): Promise<Result<TIdentity>>;