@reactionary/source 0.3.18 → 0.6.2

package/providers/commercetools/src/core/capability-descriptors.ts

@@ -0,0 +1,324 @@
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  CheckoutSchema,
+  IdentitySchema,
+  InventorySchema,
+  OrderSearchResultSchema,
+  OrderSchema,
+  PaymentMethodSchema,
+  ProductAssociationSchema,
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListSchema,
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
+  ProductSchema,
+  ProductSearchResultSchema,
+  ProfileSchema,
+  PriceSchema,
+  ShippingMethodSchema,
+  StoreSchema,
+  type Cache,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import {
+  type CommercetoolsCapabilities,
+  type CommercetoolsCapabilitiesSchema,
+} from '../schema/capabilities.schema.js';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from './client.js';
+import { CommercetoolsCartFactory } from '../factories/cart/cart.factory.js';
+import { CommercetoolsCategoryFactory } from '../factories/category/category.factory.js';
+import { CommercetoolsCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
+import { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+import { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
+import { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+import { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+import { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
+import { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+import { CommercetoolsCartProvider } from '../providers/cart.provider.js';
+import { CommercetoolsCategoryProvider } from '../providers/category.provider.js';
+import { CommercetoolsCheckoutProvider } from '../providers/checkout.provider.js';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
+import { CommercetoolsInventoryProvider } from '../providers/inventory.provider.js';
+import { CommercetoolsOrderProvider } from '../providers/order.provider.js';
+import { CommercetoolsOrderSearchProvider } from '../providers/order-search.provider.js';
+import { CommercetoolsPriceProvider } from '../providers/price.provider.js';
+import { CommercetoolsProductAssociationsProvider } from '../providers/product-associations.provider.js';
+import { CommercetoolsProductListProvider } from '../providers/product-list.provider.js';
+import { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import { CommercetoolsProductReviewsProvider } from '../providers/product-reviews.provider.js';
+import { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
+import { CommercetoolsProfileProvider } from '../providers/profile.provider.js';
+import { CommercetoolsStoreProvider } from '../providers/store.provider.js';
+
+export const capabilityKeys = [
+  'product',
+  'profile',
+  'productSearch',
+  'productAssociations',
+  'productList',
+  'productReviews',
+  'identity',
+  'cart',
+  'inventory',
+  'price',
+  'category',
+  'checkout',
+  'store',
+  'order',
+  'orderSearch',
+] as const;
+
+export type OverridableCapabilityKey = (typeof capabilityKeys)[number];
+
+type ProviderArgs<TFactory> = {
+  cache: Cache;
+  context: RequestContext;
+  config: CommercetoolsConfiguration;
+  commercetoolsApi: CommercetoolsAPI;
+  factory: TFactory;
+};
+
+type ParsedCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+
+export type CapabilityDescriptor = {
+  isEnabled: (caps: ParsedCapabilities) => boolean | undefined;
+  getOverride: (caps: CommercetoolsCapabilities) => {
+    factory?: any;
+    provider?: (args: any) => any;
+  } | undefined;
+  createDefaultFactory: () => any;
+  createDefaultProvider: (args: any) => any;
+};
+
+export const capabilityDescriptors: Record<OverridableCapabilityKey, CapabilityDescriptor> = {
+  product: {
+    isEnabled: (caps) => caps.product?.enabled,
+    getOverride: (caps) => caps.product,
+    createDefaultFactory: () => new CommercetoolsProductFactory(ProductSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsProductProvider(
+        args.cache,
+        args.context,
+        args.config,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  profile: {
+    isEnabled: (caps) => caps.profile?.enabled,
+    getOverride: (caps) => caps.profile,
+    createDefaultFactory: () => new CommercetoolsProfileFactory(ProfileSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsProfileProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  productSearch: {
+    isEnabled: (caps) => caps.productSearch?.enabled,
+    getOverride: (caps) => caps.productSearch,
+    createDefaultFactory: () =>
+      new CommercetoolsProductSearchFactory(ProductSearchResultSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsSearchProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  productAssociations: {
+    isEnabled: (caps) => caps.productAssociations?.enabled,
+    getOverride: (caps) => caps.productAssociations,
+    createDefaultFactory: () =>
+      new CommercetoolsProductAssociationsFactory(ProductAssociationSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsProductAssociationsProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  productList: {
+    isEnabled: (caps) => caps.productList?.enabled,
+    getOverride: (caps) => caps.productList,
+    createDefaultFactory: () =>
+      new CommercetoolsProductListFactory(
+        ProductListSchema,
+        ProductListItemSchema,
+        ProductListPaginatedResultsSchema,
+        ProductListItemPaginatedResultsSchema,
+      ),
+    createDefaultProvider: (args) =>
+      new CommercetoolsProductListProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  productReviews: {
+    isEnabled: (caps) => caps.productReviews?.enabled,
+    getOverride: (caps) => caps.productReviews,
+    createDefaultFactory: () =>
+      new CommercetoolsProductReviewsFactory(
+        ProductRatingSummarySchema,
+        ProductReviewSchema,
+        ProductReviewPaginatedResultSchema,
+      ),
+    createDefaultProvider: (args) =>
+      new CommercetoolsProductReviewsProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  identity: {
+    isEnabled: (caps) => caps.identity?.enabled,
+    getOverride: (caps) => caps.identity,
+    createDefaultFactory: () => new CommercetoolsIdentityFactory(IdentitySchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsIdentityProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  cart: {
+    isEnabled: (caps) => caps.cart?.enabled,
+    getOverride: (caps) => caps.cart,
+    createDefaultFactory: () =>
+      new CommercetoolsCartFactory(CartSchema, CartIdentifierSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsCartProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  inventory: {
+    isEnabled: (caps) => caps.inventory?.enabled,
+    getOverride: (caps) => caps.inventory,
+    createDefaultFactory: () => new CommercetoolsInventoryFactory(InventorySchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsInventoryProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  price: {
+    isEnabled: (caps) => caps.price?.enabled,
+    getOverride: (caps) => caps.price,
+    createDefaultFactory: () => new CommercetoolsPriceFactory(PriceSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsPriceProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  category: {
+    isEnabled: (caps) => caps.category?.enabled,
+    getOverride: (caps) => caps.category,
+    createDefaultFactory: () =>
+      new CommercetoolsCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsCategoryProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  checkout: {
+    isEnabled: (caps) => caps.checkout?.enabled,
+    getOverride: (caps) => caps.checkout,
+    createDefaultFactory: () =>
+      new CommercetoolsCheckoutFactory(
+        CheckoutSchema,
+        ShippingMethodSchema,
+        PaymentMethodSchema,
+      ),
+    createDefaultProvider: (args) =>
+      new CommercetoolsCheckoutProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  store: {
+    isEnabled: (caps) => caps.store?.enabled,
+    getOverride: (caps) => caps.store,
+    createDefaultFactory: () => new CommercetoolsStoreFactory(StoreSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsStoreProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  order: {
+    isEnabled: (caps) => caps.order?.enabled,
+    getOverride: (caps) => caps.order,
+    createDefaultFactory: () => new CommercetoolsOrderFactory(OrderSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsOrderProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  orderSearch: {
+    isEnabled: (caps) => caps.orderSearch?.enabled,
+    getOverride: (caps) => caps.orderSearch,
+    createDefaultFactory: () =>
+      new CommercetoolsOrderSearchFactory(OrderSearchResultSchema),
+    createDefaultProvider: (args) =>
+      new CommercetoolsOrderSearchProvider(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+};

package/providers/commercetools/src/core/initialize.ts

@@ -1,171 +1,55 @@
-import type { Cache, RequestContext, Client, ClientFromCapabilities } from '@reactionary/core';
+import type { Cache, RequestContext } from '@reactionary/core';
 import {
   CommercetoolsCapabilitiesSchema,
   type CommercetoolsCapabilities,
 } from '../schema/capabilities.schema.js';
-import { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
-import { CommercetoolsProductProvider } from '../providers/product.provider.js';
 import {
   CommercetoolsConfigurationSchema,
   type CommercetoolsConfiguration,
 } from '../schema/configuration.schema.js';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
-import { CommercetoolsCartProvider } from '../providers/cart.provider.js';
-import { CommercetoolsInventoryProvider } from '../providers/inventory.provider.js';
-import { CommercetoolsPriceProvider } from '../providers/price.provider.js';
-import { CommercetoolsCategoryProvider } from '../providers/category.provider.js';
-import {
-  CommercetoolsCheckoutProvider,
-  CommercetoolsOrderProvider,
-  CommercetoolsOrderSearchProvider,
-  CommercetoolsProfileProvider,
-  CommercetoolsStoreProvider,
-  CommercetoolsProductReviewsProvider,
-  CommercetoolsProductAssociationsProvider,
-  CommercetoolsProductListProvider,
-} from '../providers/index.js';
 import { CommercetoolsAPI } from './client.js';
+import {
+  capabilityDescriptors,
+  capabilityKeys,
+} from './capability-descriptors.js';
+import {
+  type CommercetoolsClientFromCapabilities,
+  resolveCapabilityProvider,
+} from './initialize.types.js';
 
 export function withCommercetoolsCapabilities<
-  T extends CommercetoolsCapabilities
+  T extends CommercetoolsCapabilities,
 >(configuration: CommercetoolsConfiguration, capabilities: T) {
-  return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
+  return (
+    cache: Cache,
+    context: RequestContext,
+  ): CommercetoolsClientFromCapabilities<T> => {
     const client: any = {};
     const config = CommercetoolsConfigurationSchema.parse(configuration);
     const caps = CommercetoolsCapabilitiesSchema.parse(capabilities);
     const commercetoolsApi = new CommercetoolsAPI(config, context);
 
-    if (caps.product) {
-      client.product = new CommercetoolsProductProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.profile) {
-      client.profile = new CommercetoolsProfileProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.productSearch) {
-      client.productSearch = new CommercetoolsSearchProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.productAssociations) {
-      client.productAssociations = new CommercetoolsProductAssociationsProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.productList) {
-      client.productList = new CommercetoolsProductListProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.productReviews) {
-      client.productReviews = new CommercetoolsProductReviewsProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.identity) {
-      client.identity = new CommercetoolsIdentityProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.cart) {
-      client.cart = new CommercetoolsCartProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.inventory) {
-      client.inventory = new CommercetoolsInventoryProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.price) {
-      client.price = new CommercetoolsPriceProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.category) {
-      client.category = new CommercetoolsCategoryProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.checkout) {
-      client.checkout = new CommercetoolsCheckoutProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.store) {
-        client.store = new CommercetoolsStoreProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-
-    if (caps.order) {
-        client.store = new CommercetoolsOrderProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
-      );
-    }
-    if (caps.orderSearch) {
-        client.orderSearch = new CommercetoolsOrderSearchProvider(
-        config,
-        cache,
-        context,
-        commercetoolsApi
+    const buildProviderArgs = <TFactory,>(factory: TFactory) => ({
+      cache,
+      context,
+      config,
+      commercetoolsApi,
+      factory,
+    });
+
+    for (const key of capabilityKeys) {
+      const descriptor = capabilityDescriptors[key];
+      if (!descriptor.isEnabled(caps)) {
+        continue;
+      }
+
+      client[key] = resolveCapabilityProvider(
+        descriptor.getOverride(capabilities),
+        {
+          factory: descriptor.createDefaultFactory(),
+          provider: descriptor.createDefaultProvider,
+        },
+        buildProviderArgs,
       );
     }