@reactionary/source 0.6.1 → 0.6.3

package/packages/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 { CommercetoolsCartCapability } from '../capabilities/cart.capability.js';
+import { CommercetoolsCategoryCapability } from '../capabilities/category.capability.js';
+import { CommercetoolsCheckoutCapability } from '../capabilities/checkout.capability.js';
+import { CommercetoolsIdentityCapability } from '../capabilities/identity.capability.js';
+import { CommercetoolsInventoryCapability } from '../capabilities/inventory.capability.js';
+import { CommercetoolsOrderCapability } from '../capabilities/order.capability.js';
+import { CommercetoolsOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import { CommercetoolsPriceCapability } from '../capabilities/price.capability.js';
+import { CommercetoolsProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import { CommercetoolsProductListCapability } from '../capabilities/product-list.capability.js';
+import { CommercetoolsProductCapability } from '../capabilities/product.capability.js';
+import { CommercetoolsProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import { CommercetoolsProductSearchCapability } from '../capabilities/product-search.capability.js';
+import { CommercetoolsProfileCapability } from '../capabilities/profile.capability.js';
+import { CommercetoolsStoreCapability } from '../capabilities/store.capability.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 CapabilityArgs<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;
+    capability?: (args: any) => any;
+  } | undefined;
+  createDefaultFactory: () => any;
+  createDefaultCapability: (args: any) => any;
+};
+
+export const capabilityDescriptors: Record<OverridableCapabilityKey, CapabilityDescriptor> = {
+  product: {
+    isEnabled: (caps) => caps.product?.enabled,
+    getOverride: (caps) => caps.product,
+    createDefaultFactory: () => new CommercetoolsProductFactory(ProductSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsProductCapability(
+        args.cache,
+        args.context,
+        args.config,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  profile: {
+    isEnabled: (caps) => caps.profile?.enabled,
+    getOverride: (caps) => caps.profile,
+    createDefaultFactory: () => new CommercetoolsProfileFactory(ProfileSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsProfileCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  productSearch: {
+    isEnabled: (caps) => caps.productSearch?.enabled,
+    getOverride: (caps) => caps.productSearch,
+    createDefaultFactory: () =>
+      new CommercetoolsProductSearchFactory(ProductSearchResultSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsProductSearchCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  productAssociations: {
+    isEnabled: (caps) => caps.productAssociations?.enabled,
+    getOverride: (caps) => caps.productAssociations,
+    createDefaultFactory: () =>
+      new CommercetoolsProductAssociationsFactory(ProductAssociationSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsProductAssociationsCapability(
+        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,
+      ),
+    createDefaultCapability: (args) =>
+      new CommercetoolsProductListCapability(
+        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,
+      ),
+    createDefaultCapability: (args) =>
+      new CommercetoolsProductReviewsCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  identity: {
+    isEnabled: (caps) => caps.identity?.enabled,
+    getOverride: (caps) => caps.identity,
+    createDefaultFactory: () => new CommercetoolsIdentityFactory(IdentitySchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsIdentityCapability(
+        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),
+    createDefaultCapability: (args) =>
+      new CommercetoolsCartCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  inventory: {
+    isEnabled: (caps) => caps.inventory?.enabled,
+    getOverride: (caps) => caps.inventory,
+    createDefaultFactory: () => new CommercetoolsInventoryFactory(InventorySchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsInventoryCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  price: {
+    isEnabled: (caps) => caps.price?.enabled,
+    getOverride: (caps) => caps.price,
+    createDefaultFactory: () => new CommercetoolsPriceFactory(PriceSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsPriceCapability(
+        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),
+    createDefaultCapability: (args) =>
+      new CommercetoolsCategoryCapability(
+        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,
+      ),
+    createDefaultCapability: (args) =>
+      new CommercetoolsCheckoutCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  store: {
+    isEnabled: (caps) => caps.store?.enabled,
+    getOverride: (caps) => caps.store,
+    createDefaultFactory: () => new CommercetoolsStoreFactory(StoreSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsStoreCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  order: {
+    isEnabled: (caps) => caps.order?.enabled,
+    getOverride: (caps) => caps.order,
+    createDefaultFactory: () => new CommercetoolsOrderFactory(OrderSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsOrderCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+  orderSearch: {
+    isEnabled: (caps) => caps.orderSearch?.enabled,
+    getOverride: (caps) => caps.orderSearch,
+    createDefaultFactory: () =>
+      new CommercetoolsOrderSearchFactory(OrderSearchResultSchema),
+    createDefaultCapability: (args) =>
+      new CommercetoolsOrderSearchCapability(
+        args.config,
+        args.cache,
+        args.context,
+        args.commercetoolsApi,
+        args.factory,
+      ),
+  },
+};

package/{providers → packages}/commercetools/src/core/client.ts

@@ -306,7 +306,7 @@ export class CommercetoolsAPI {
     });
 
 
-    const body = await response.json();
+    const body: any = await response.json();
     if (!body) {
       return AnonymousIdentitySchema.parse({});
     }
@@ -368,7 +368,7 @@ export class CommercetoolsAPI {
       }
     );
 
-    const result = await response.json();
+    const result: any = await response.json();
 
     this.tokenCache.set({
       expirationTime:

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

@@ -0,0 +1,58 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import {
+  CommercetoolsCapabilitiesSchema,
+  type CommercetoolsCapabilities,
+} from '../schema/capabilities.schema.js';
+import {
+  CommercetoolsConfigurationSchema,
+  type CommercetoolsConfiguration,
+} from '../schema/configuration.schema.js';
+import { CommercetoolsAPI } from './client.js';
+import {
+  capabilityDescriptors,
+  capabilityKeys,
+} from './capability-descriptors.js';
+import {
+  type CommercetoolsClientFromCapabilities,
+  resolveCapabilityWithFactory,
+} from './initialize.types.js';
+
+export function withCommercetoolsCapabilities<
+  T extends CommercetoolsCapabilities,
+>(configuration: CommercetoolsConfiguration, capabilities: 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);
+
+    const buildCapabilityArgs = <TFactory,>(factory: TFactory) => ({
+      cache,
+      context,
+      config,
+      commercetoolsApi,
+      factory,
+    });
+
+    for (const key of capabilityKeys) {
+      const descriptor = capabilityDescriptors[key];
+      if (!descriptor.isEnabled(caps)) {
+        continue;
+      }
+
+      client[key] = resolveCapabilityWithFactory(
+        descriptor.getOverride(capabilities),
+        {
+          factory: descriptor.createDefaultFactory(),
+          capability: descriptor.createDefaultCapability,
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    return client;
+  };
+}

package/packages/commercetools/src/core/initialize.types.ts

@@ -0,0 +1,174 @@
+import type {
+  CartFactory,
+  CategoryFactory,
+  CheckoutFactory,
+  ClientFromCapabilities,
+  IdentityFactory,
+  InventoryFactory,
+  OrderFactory,
+  OrderSearchFactory,
+  PriceFactory,
+  ProductAssociationsFactory,
+  ProductFactory,
+  ProductListFactory,
+  ProductReviewsFactory,
+  ProductSearchFactory,
+  ProfileFactory,
+  StoreFactory,
+} from '@reactionary/core';
+import type { CommercetoolsCapabilities } from '../schema/capabilities.schema.js';
+import type { OverridableCapabilityKey } from './capability-descriptors.js';
+import type { CommercetoolsCartFactory } from '../factories/cart/cart.factory.js';
+import type { CommercetoolsCategoryFactory } from '../factories/category/category.factory.js';
+import type { CommercetoolsCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
+import type { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+import type { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+import type { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+import type { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
+import type { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+import type { CommercetoolsCartCapability } from '../capabilities/cart.capability.js';
+import type { CommercetoolsCategoryCapability } from '../capabilities/category.capability.js';
+import type { CommercetoolsCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { CommercetoolsIdentityCapability } from '../capabilities/identity.capability.js';
+import type { CommercetoolsInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { CommercetoolsOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { CommercetoolsOrderCapability } from '../capabilities/order.capability.js';
+import type { CommercetoolsPriceCapability } from '../capabilities/price.capability.js';
+import type { CommercetoolsProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import type { CommercetoolsProductListCapability } from '../capabilities/product-list.capability.js';
+import type { CommercetoolsProductCapability } from '../capabilities/product.capability.js';
+import type { CommercetoolsProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import type { CommercetoolsProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { CommercetoolsProfileCapability } from '../capabilities/profile.capability.js';
+import type { CommercetoolsStoreCapability } from '../capabilities/store.capability.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends CommercetoolsCapabilities> =
+  Omit<T, OverridableCapabilityKey> & {
+    [K in OverridableCapabilityKey]?: EnabledCapability<T[K]>;
+  };
+
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
+  TCapability extends { enabled: true; factory?: infer TFactory }
+    ? TFactory extends TContract
+      ? TFactory
+      : TDefaultFactory
+    : TDefaultFactory;
+
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> =
+  TCapability extends { enabled: true; capability?: infer TCapabilityFactory }
+    ? TCapabilityFactory extends (...args: any[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
+
+type FactoryContractMap = {
+  product: ProductFactory;
+  productSearch: ProductSearchFactory;
+  productAssociations: ProductAssociationsFactory;
+  productReviews: ProductReviewsFactory;
+  productList: ProductListFactory;
+  identity: IdentityFactory;
+  cart: CartFactory;
+  checkout: CheckoutFactory;
+  order: OrderFactory;
+  orderSearch: OrderSearchFactory;
+  inventory: InventoryFactory;
+  price: PriceFactory;
+  category: CategoryFactory;
+  store: StoreFactory;
+  profile: ProfileFactory;
+};
+
+type DefaultFactoryMap = {
+  product: CommercetoolsProductFactory;
+  productSearch: CommercetoolsProductSearchFactory;
+  productAssociations: CommercetoolsProductAssociationsFactory;
+  productReviews: CommercetoolsProductReviewsFactory;
+  productList: CommercetoolsProductListFactory;
+  identity: CommercetoolsIdentityFactory;
+  cart: CommercetoolsCartFactory;
+  checkout: CommercetoolsCheckoutFactory;
+  order: CommercetoolsOrderFactory;
+  orderSearch: CommercetoolsOrderSearchFactory;
+  inventory: CommercetoolsInventoryFactory;
+  price: CommercetoolsPriceFactory;
+  category: CommercetoolsCategoryFactory;
+  store: CommercetoolsStoreFactory;
+  profile: CommercetoolsProfileFactory;
+};
+
+type ResolvedFactoryMap<T extends CommercetoolsCapabilities> = {
+  [K in OverridableCapabilityKey]: ExtractCapabilityFactory<
+    T[K],
+    FactoryContractMap[K],
+    DefaultFactoryMap[K]
+  >;
+};
+
+type DefaultCapabilityMap<T extends CommercetoolsCapabilities> = {
+  product: CommercetoolsProductCapability<ResolvedFactoryMap<T>['product']>;
+  productSearch: CommercetoolsProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+  productAssociations: CommercetoolsProductAssociationsCapability<
+    ResolvedFactoryMap<T>['productAssociations']
+  >;
+  productReviews: CommercetoolsProductReviewsCapability<
+    ResolvedFactoryMap<T>['productReviews']
+  >;
+  productList: CommercetoolsProductListCapability<ResolvedFactoryMap<T>['productList']>;
+  identity: CommercetoolsIdentityCapability<ResolvedFactoryMap<T>['identity']>;
+  cart: CommercetoolsCartCapability<ResolvedFactoryMap<T>['cart']>;
+  checkout: CommercetoolsCheckoutCapability<ResolvedFactoryMap<T>['checkout']>;
+  order: CommercetoolsOrderCapability<ResolvedFactoryMap<T>['order']>;
+  orderSearch: CommercetoolsOrderSearchCapability<ResolvedFactoryMap<T>['orderSearch']>;
+  inventory: CommercetoolsInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+  price: CommercetoolsPriceCapability<ResolvedFactoryMap<T>['price']>;
+  category: CommercetoolsCategoryCapability<ResolvedFactoryMap<T>['category']>;
+  store: CommercetoolsStoreCapability<ResolvedFactoryMap<T>['store']>;
+  profile: CommercetoolsProfileCapability<ResolvedFactoryMap<T>['profile']>;
+};
+
+type CapabilityImplementationMap<T extends CommercetoolsCapabilities> = {
+  [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap<T>[K]>;
+};
+
+type EnabledCapabilityOverrideMap<T extends CommercetoolsCapabilities> = {
+  [K in OverridableCapabilityKey as T[K] extends { enabled: true } ? K : never]:
+    CapabilityImplementationMap<T>[K];
+};
+
+export type CommercetoolsClientFromCapabilities<
+  T extends CommercetoolsCapabilities,
+> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  OverridableCapabilityKey
+> &
+  EnabledCapabilityOverrideMap<T>;
+
+export function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(
+  capability:
+    | {
+        factory?: TFactory;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
+      }
+    | undefined,
+  defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+  },
+  buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs,
+): TResolvedCapability {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+
+  return capabilityFactory(buildCapabilityArgs(factory));
+}