@reactionary/source 0.6.1 → 0.6.2

package/providers/algolia/src/schema/capabilities.schema.ts

@@ -1,10 +1,84 @@
-import { CapabilitiesSchema } from "@reactionary/core";
-import type * as z from 'zod';
+import type {
+  AnalyticsProvider,
+  Cache,
+  ProductRecommendationsProvider,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchProvider,
+  RequestContext,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { AlgoliaConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const ProductSearchCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  provider: z.unknown().optional(),
+});
+
+const ProviderCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  provider: z.unknown().optional(),
+});
 
 export const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
-    productSearch: true,
-    analytics: true,
-    productRecommendations: true
-}).partial();
+  productSearch: true,
+  analytics: true,
+  productRecommendations: true,
+})
+  .extend({
+    productSearch: ProductSearchCapabilitySchema.optional(),
+    analytics: ProviderCapabilitySchema.optional(),
+    productRecommendations: ProviderCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface AlgoliaProviderFactoryArgs {
+  cache: Cache;
+  context: RequestContext;
+  config: AlgoliaConfiguration;
+}
+
+export interface AlgoliaProductSearchProviderFactoryArgs<
+  TFactory extends ProductSearchFactory = ProductSearchFactory,
+> extends AlgoliaProviderFactoryArgs {
+  factory: ProductSearchFactoryWithOutput<TFactory>;
+}
+
+export interface AlgoliaProductSearchCapabilityConfig<
+  TFactory extends ProductSearchFactory = ProductSearchFactory,
+  TProvider extends ProductSearchProvider = ProductSearchProvider,
+> {
+  enabled: boolean;
+  factory?: ProductSearchFactoryWithOutput<TFactory>;
+  provider?: (args: AlgoliaProductSearchProviderFactoryArgs<TFactory>) => TProvider;
+}
+
+export interface AlgoliaAnalyticsCapabilityConfig<
+  TProvider extends AnalyticsProvider = AnalyticsProvider,
+> {
+  enabled: boolean;
+  provider?: (args: AlgoliaProviderFactoryArgs) => TProvider;
+}
+
+export interface AlgoliaProductRecommendationsCapabilityConfig<
+  TProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider,
+> {
+  enabled: boolean;
+  provider?: (args: AlgoliaProviderFactoryArgs) => TProvider;
+}
 
-export type AlgoliaCapabilities = z.infer<typeof AlgoliaCapabilitiesSchema>;
+export type AlgoliaCapabilities<
+  TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
+  TProductSearchProvider extends ProductSearchProvider = ProductSearchProvider,
+  TAnalyticsProvider extends AnalyticsProvider = AnalyticsProvider,
+  TProductRecommendationsProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider,
+> = {
+  productSearch?: AlgoliaProductSearchCapabilityConfig<
+    TProductSearchFactory,
+    TProductSearchProvider
+  >;
+  analytics?: AlgoliaAnalyticsCapabilityConfig<TAnalyticsProvider>;
+  productRecommendations?: AlgoliaProductRecommendationsCapabilityConfig<TProductRecommendationsProvider>;
+};

package/providers/algolia/src/test/analytics.spec.ts

@@ -3,6 +3,8 @@ import { AlgoliaAnalyticsProvider } from '../providers/analytics.provider.js';
 import { createInitialRequestContext, NoOpCache } from '@reactionary/core';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
 import { AlgoliaProductSearchProvider } from '../providers/product-search.provider.js';
+import { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { AlgoliaProductSearchResultSchema } from '../schema/search.schema.js';
 
 describe('Analytics event tracking', async () => {
   const config = {
@@ -13,7 +15,13 @@ describe('Analytics event tracking', async () => {
   const cache = new NoOpCache();
   const context = createInitialRequestContext();
 
-  const search = new AlgoliaProductSearchProvider(cache, context, config);
+  const searchFactory = new AlgoliaProductSearchFactory(AlgoliaProductSearchResultSchema);
+  const search = new AlgoliaProductSearchProvider<typeof searchFactory>(
+    cache,
+    context,
+    config,
+    searchFactory,
+  );
   const analytics = new AlgoliaAnalyticsProvider(cache, context, config);
   const searchResult = await search.queryByTerm({
     search: {

package/providers/algolia/src/test/client-builder-product-search-extension.example.ts

@@ -0,0 +1,85 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  createInitialRequestContext,
+  type ProductSearchQueryByTerm,
+  type RequestContext,
+} from '@reactionary/core';
+import * as z from 'zod';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
+import { withAlgoliaCapabilities } from '../core/initialize.js';
+import { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { AlgoliaProductSearchResultSchema } from '../schema/search.schema.js';
+
+const assertType = <T>(_value: T) => {
+  void _value;
+};
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+const assertNotAny = <T>(_value: IsAny<T> extends true ? never : T) => {
+  void _value;
+};
+
+const ExtendedProductSearchResultSchema = AlgoliaProductSearchResultSchema.safeExtend(
+  {
+    extendedMeta: z.string(),
+  },
+);
+
+class ExtendedAlgoliaProductSearchFactory extends AlgoliaProductSearchFactory<
+  typeof ExtendedProductSearchResultSchema
+> {
+  constructor() {
+    super(ExtendedProductSearchResultSchema);
+  }
+
+  public override parseSearchResult(
+    context: RequestContext,
+    data: unknown,
+    query: ProductSearchQueryByTerm,
+  ) {
+    const base = super.parseSearchResult(context, data, query);
+    return this.productSearchResultSchema.parse({
+      ...base,
+      extendedMeta: 'from-factory',
+    });
+  }
+}
+
+const config = {
+  appId: 'ALGOLIA_APP_ID',
+  apiKey: 'ALGOLIA_API_KEY',
+  indexName: 'ALGOLIA_INDEX',
+} satisfies AlgoliaConfiguration;
+
+const client = new ClientBuilder(createInitialRequestContext())
+  .withCache(new NoOpCache())
+  .withCapability(
+    withAlgoliaCapabilities(config, {
+      productSearch: {
+        enabled: true,
+        factory: new ExtendedAlgoliaProductSearchFactory(),
+      },
+    }),
+  )
+  .build();
+
+client.productSearch
+  .queryByTerm({
+    search: {
+      term: 'test',
+      facets: [],
+      filters: [],
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 10,
+      },
+    },
+  })
+  .then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      assertNotAny(result.value);
+      assertNotAny(result.value.extendedMeta);
+      assertType<string>(result.value.extendedMeta);
+    }
+  });

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,
+      ),
+  },
+};