@reactionary/source 0.3.18 → 0.6.2

package/providers/medusa/src/test/checkout.spec.ts

@@ -23,15 +23,15 @@ function createMedusaClient(config: MedusaConfiguration, reqCtx: RequestContext)
     .withCache(new NoOpCache())
     .withCapability(
       withMedusaCapabilities(config, {
-        cart: true,
-        product: true,
-        category: true,
-        checkout: true,
-        identity: true,
-        inventory: true,
-        order: true,
-        price: true,
-        productSearch: true,
+        cart: { enabled: true },
+        product: { enabled: true },
+        category: { enabled: true },
+        checkout: { enabled: true },
+        identity: { enabled: true },
+        inventory: { enabled: true },
+        order: { enabled: true },
+        price: { enabled: true },
+        productSearch: { enabled: true },
       })
     );
 

package/providers/medusa/src/test/inventory.provider.spec.ts

@@ -8,6 +8,7 @@ import {
 } from '@reactionary/core';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
+import { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
 
 const testData = {
   skuInStock: '	4007249524126',
@@ -29,7 +30,8 @@ describe('Medusa Inventory Provider', () => {
       config,
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaInventoryFactory(InventorySchema),
     );
   });
 

package/providers/medusa/src/test/large-cart.provider.spec.ts

@@ -1,6 +1,8 @@
 import {
+  CartIdentifierSchema,
   CartSchema,
   NoOpCache,
+  ProductSearchResultSchema,
   ProductSearchQueryByTermSchema,
   ProductSearchResultItemSchema,
   createInitialRequestContext,
@@ -12,6 +14,8 @@ import { MedusaCartProvider } from '../providers/cart.provider.js';
 import { MedusaSearchProvider } from '../providers/product-search.provider.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
+import { MedusaCartFactory } from '../factories/cart/cart.factory.js';
+import { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 /**
 const testData = {
@@ -32,13 +36,15 @@ describe('Medusa Cart Provider - Large Scenarios', () => {
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaCartFactory(CartSchema, CartIdentifierSchema),
     );
     searchProvider = new MedusaSearchProvider(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaProductSearchFactory(ProductSearchResultSchema),
     );
   });
 

package/providers/medusa/src/test/price.provider.spec.ts

@@ -9,6 +9,7 @@ import {
 } from '@reactionary/core';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
+import { MedusaPriceFactory } from '../factories/price/price.factory.js';
 
 const testData = {
   skuWithoutTiers: '8712581327934',
@@ -25,7 +26,13 @@ describe('Medusa Price Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaPriceProvider(config, new NoOpCache(), reqCtx, client);
+    provider = new MedusaPriceProvider(
+      config,
+      new NoOpCache(),
+      reqCtx,
+      client,
+      new MedusaPriceFactory(PriceSchema),
+    );
   });
 
   it('should be able to get prices for a product without tiers', async () => {

package/providers/medusa/src/test/product.provider.spec.ts

@@ -9,6 +9,7 @@ import { MedusaProductProvider } from '../providers/product.provider.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 import { MedusaAPI } from '../index.js';
+import { MedusaProductFactory } from '../factories/product/product.factory.js';
 
 const testData = {
   product: {
@@ -33,7 +34,8 @@ describe('Medusa Product Provider', () => {
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaProductFactory(ProductSchema),
     );
   });
 

package/providers/medusa/src/test/search.provider.spec.ts

@@ -1,10 +1,21 @@
 import 'dotenv/config';
-import { createInitialRequestContext, NoOpCache, ProductSearchQueryByTermSchema, ProductSearchResultItemSchema, type ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+import {
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  createInitialRequestContext,
+  NoOpCache,
+  ProductSearchQueryByTermSchema,
+  ProductSearchResultItemSchema,
+  ProductSearchResultSchema,
+  type ProductSearchQueryCreateNavigationFilter,
+} from '@reactionary/core';
 import { assert, describe, expect, it } from 'vitest';
 import { MedusaSearchProvider } from '../providers/product-search.provider.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../index.js';
 import { MedusaCategoryProvider } from '../providers/category.provider.js';
+import { MedusaCategoryFactory } from '../factories/category/category.factory.js';
+import { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 const testData = {
   searchTerm: 'printer',
@@ -16,14 +27,16 @@ describe('Medusa Search Provider', () => {
     getMedusaTestConfiguration(),
     new NoOpCache(),
     reqCtx,
-    client
+    client,
+    new MedusaProductSearchFactory(ProductSearchResultSchema),
   );
 
   const categoryProvider = new MedusaCategoryProvider(
     getMedusaTestConfiguration(),
     new NoOpCache(),
     reqCtx,
-    client
+    client,
+    new MedusaCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
   );
 
   it('should be able to get a result by term', async () => {

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

@@ -1,27 +1,94 @@
-import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
-import { MeilisearchSearchProvider } from "../providers/product-search.provider.js";
-import { MeilisearchProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
-import { MeilisearchOrderSearchProvider } from "../providers/order-search.provider.js";
-import type { MeilisearchCapabilities } from "../schema/capabilities.schema.js";
-import type { MeilisearchConfiguration } from "../schema/configuration.schema.js";
+import type { Cache, RequestContext } from '@reactionary/core';
+import { OrderSearchResultSchema, ProductSearchResultSchema } from '@reactionary/core';
+import { MeilisearchSearchProvider } from '../providers/product-search.provider.js';
+import { MeilisearchProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
+import { MeilisearchOrderSearchProvider } from '../providers/order-search.provider.js';
+import {
+  MeilisearchCapabilitiesSchema,
+  type MeilisearchCapabilities,
+} from '../schema/capabilities.schema.js';
+import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
+import { MeilisearchOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import { MeilisearchProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import {
+  type MeilisearchClientFromCapabilities,
+  resolveCapabilityProvider,
+  resolveProviderOnlyCapability,
+} from './initialize.types.js';
 
-export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(configuration: MeilisearchConfiguration, capabilities: T) {
-    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const client: any = {};
+export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(
+  configuration: MeilisearchConfiguration,
+  capabilities: T,
+) {
+  return (
+    cache: Cache,
+    context: RequestContext,
+  ): MeilisearchClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client: any = {};
+    const caps = MeilisearchCapabilitiesSchema.parse(capabilities);
 
-        if (capabilities.productSearch) {
-            client.productSearch = new MeilisearchSearchProvider(configuration, cache, context);
-        }
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityProvider(
+        capabilities.productSearch,
+        {
+          factory: new MeilisearchProductSearchFactory(ProductSearchResultSchema),
+          provider: (args) =>
+            new MeilisearchSearchProvider(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        (factory) => ({
+          cache,
+          context,
+          config: configuration,
+          factory,
+        }),
+      );
+    }
 
-        if (capabilities.productRecommendations) {
-            client.productRecommendations = new MeilisearchProductRecommendationsProvider(configuration, cache, context);
-        }
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityProvider(
+        capabilities.orderSearch,
+        {
+          factory: new MeilisearchOrderSearchFactory(OrderSearchResultSchema),
+          provider: (args) =>
+            new MeilisearchOrderSearchProvider(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        (factory) => ({
+          cache,
+          context,
+          config: configuration,
+          factory,
+        }),
+      );
+    }
 
-        if (capabilities.orderSearch) {
-            client.orderSearch = new MeilisearchOrderSearchProvider(configuration, cache, context);
-        }
+    if (caps.productRecommendations?.enabled) {
+      client.productRecommendations = resolveProviderOnlyCapability(
+        capabilities.productRecommendations,
+        (args) =>
+          new MeilisearchProductRecommendationsProvider(
+            args.config,
+            args.cache,
+            args.context,
+          ),
+        {
+          cache,
+          context,
+          config: configuration,
+        },
+      );
+    }
 
-        return client;
-    };
+    return client;
+  };
 }

package/providers/meilisearch/src/core/initialize.types.ts

@@ -0,0 +1,119 @@
+import type {
+  ClientFromCapabilities,
+  OrderSearchFactory,
+  ProductSearchFactory,
+} from '@reactionary/core';
+import type { MeilisearchCapabilities } from '../schema/capabilities.schema.js';
+import type { MeilisearchOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { MeilisearchProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { MeilisearchOrderSearchProvider } from '../providers/order-search.provider.js';
+import type { MeilisearchProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
+import type { MeilisearchSearchProvider } from '../providers/product-search.provider.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends MeilisearchCapabilities> =
+  Omit<T, 'productSearch' | 'orderSearch' | 'productRecommendations'> & {
+    productSearch?: EnabledCapability<T['productSearch']>;
+    orderSearch?: EnabledCapability<T['orderSearch']>;
+    productRecommendations?: EnabledCapability<T['productRecommendations']>;
+  };
+
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
+  TCapability extends { enabled: true; factory?: infer TFactory }
+    ? TFactory extends TContract
+      ? TFactory
+      : TDefaultFactory
+    : TDefaultFactory;
+
+type ExtractCapabilityProvider<TCapability, TDefaultProvider> =
+  TCapability extends { enabled: true; provider?: infer TProviderFactory }
+    ? TProviderFactory extends (...args: unknown[]) => infer TProvider
+      ? TProvider
+      : TDefaultProvider
+    : TDefaultProvider;
+
+type CapabilityOverride<
+  TCapability,
+  TKey extends string,
+  TProvider,
+> = TCapability extends { enabled: true }
+  ? { [K in TKey]: TProvider }
+  : Record<never, never>;
+
+type ProductSearchFactoryFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityFactory<
+    T['productSearch'],
+    ProductSearchFactory,
+    MeilisearchProductSearchFactory
+  >;
+
+type OrderSearchFactoryFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityFactory<
+    T['orderSearch'],
+    OrderSearchFactory,
+    MeilisearchOrderSearchFactory
+  >;
+
+type ProductSearchProviderFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityProvider<
+    T['productSearch'],
+    MeilisearchSearchProvider<ProductSearchFactoryFor<T>>
+  >;
+
+type OrderSearchProviderFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityProvider<
+    T['orderSearch'],
+    MeilisearchOrderSearchProvider<OrderSearchFactoryFor<T>>
+  >;
+
+type ProductRecommendationsProviderFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityProvider<
+    T['productRecommendations'],
+    MeilisearchProductRecommendationsProvider
+  >;
+
+export type MeilisearchClientFromCapabilities<T extends MeilisearchCapabilities> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  'productSearch' | 'orderSearch' | 'productRecommendations'
+> &
+  CapabilityOverride<T['productSearch'], 'productSearch', ProductSearchProviderFor<T>> &
+  CapabilityOverride<T['orderSearch'], 'orderSearch', OrderSearchProviderFor<T>> &
+  CapabilityOverride<
+    T['productRecommendations'],
+    'productRecommendations',
+    ProductRecommendationsProviderFor<T>
+  >;
+
+export function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(
+  capability:
+    | {
+        factory?: TFactory;
+        provider?: (args: TProviderArgs) => TProvider;
+      }
+    | undefined,
+  defaults: {
+    factory: TFactory;
+    provider: (args: TProviderArgs) => TProvider;
+  },
+  buildProviderArgs: (factory: TFactory) => TProviderArgs,
+): TProvider {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+
+  return provider(buildProviderArgs(factory));
+}
+
+export function resolveProviderOnlyCapability<TProvider, TProviderArgs>(
+  capability:
+    | {
+        provider?: (args: TProviderArgs) => TProvider;
+      }
+    | undefined,
+  defaultProvider: (args: TProviderArgs) => TProvider,
+  args: TProviderArgs,
+): TProvider {
+  const provider = capability?.provider ?? defaultProvider;
+  return provider(args);
+}

package/providers/meilisearch/src/factories/index.ts

@@ -0,0 +1,2 @@
+export * from './order-search/order-search.factory.js';
+export * from './product-search/product-search.factory.js';

package/providers/meilisearch/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyOrderSearchResultSchema,
+  OrderSearchFactory,
+  OrderSearchQueryByTerm,
+  OrderSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MeilisearchOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}

package/providers/meilisearch/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyProductSearchResultSchema,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MeilisearchProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    return this.productSearchResultSchema.parse(data);
+  }
+}

package/providers/meilisearch/src/index.ts

@@ -1,4 +1,6 @@
 export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './factories/index.js';
 export * from './providers/product-search.provider.js';
 export * from './providers/product-recommendations.provider.js';
 export * from './providers/order-search.provider.js';

package/providers/meilisearch/src/providers/index.ts

@@ -1,2 +1,3 @@
 export * from './product-search.provider.js';
 export * from './product-recommendations.provider.js';
+export * from './order-search.provider.js';

package/providers/meilisearch/src/providers/order-search.provider.ts

@@ -19,9 +19,13 @@ import {
   AddressIdentifierSchema,
   type AddressIdentifier,
   type OrderInventoryStatus,
+  type OrderSearchFactory,
+  type OrderSearchFactoryOutput,
+  type OrderSearchFactoryWithOutput,
 } from '@reactionary/core';
 import { MeiliSearch, type SearchParams, type SearchResponse } from 'meilisearch';
 import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
+import type { MeilisearchOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
 
 interface MeilisearchNativeOrderAddress {
   address1: string;
@@ -44,12 +48,21 @@ interface MeilisearchNativeOrderRecord {
   currency: string;
 }
 
-export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
+export class MeilisearchOrderSearchProvider<
+  TFactory extends OrderSearchFactory = MeilisearchOrderSearchFactory,
+> extends OrderSearchProvider<OrderSearchFactoryOutput<TFactory>> {
   protected config: MeilisearchConfiguration;
-
-  constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {
+  protected factory: OrderSearchFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: MeilisearchConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: OrderSearchFactoryWithOutput<TFactory>,
+  ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected queryByTermPayload(payload: OrderSearchQueryByTerm): SearchParams {
@@ -100,7 +113,9 @@ export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
     inputSchema: OrderSearchQueryByTermSchema,
     outputSchema: OrderSearchResultSchema,
   })
-  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+  public async queryByTerm(
+    payload: OrderSearchQueryByTerm,
+  ): Promise<Result<OrderSearchFactoryOutput<TFactory>>> {
     const client = new MeiliSearch({
       host: this.config.apiUrl,
       apiKey: this.config.apiKey,
@@ -114,9 +129,9 @@ export class MeilisearchOrderSearchProvider extends OrderSearchProvider {
       this.queryByTermPayload(payload)
     );
 
-    const result = this.parsePaginatedResult(remote, payload) as OrderSearchResult;
+    const result = this.parsePaginatedResult(remote, payload);
 
-    return success(result);
+    return success(this.factory.parseOrderSearchResult(this.context, result, payload));
   }
 
   protected mapOrderStatus(status: OrderStatus): string {

package/providers/meilisearch/src/providers/product-search.provider.ts

@@ -6,6 +6,9 @@ import {
   FacetValueIdentifierSchema,
   ImageSchema,
   ProductSearchProvider,
+  type ProductSearchFactory,
+  type ProductSearchFactoryOutput,
+  type ProductSearchFactoryWithOutput,
   type ProductSearchQueryByTerm,
   ProductSearchQueryByTermSchema,
   type ProductSearchQueryCreateNavigationFilter,
@@ -25,15 +28,25 @@ import {
 } from '@reactionary/core';
 import { MeiliSearch, type SearchParams, type SearchResponse } from 'meilisearch';
 import type { MeilisearchConfiguration } from '../schema/configuration.schema.js';
-import type { MeilisearchNativeRecord, MeilisearchNativeVariant, MeilisearchProductSearchResult } from '../schema/search.schema.js';
+import type { MeilisearchNativeRecord, MeilisearchNativeVariant } from '../schema/search.schema.js';
+import type { MeilisearchProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 
-export class MeilisearchSearchProvider extends ProductSearchProvider {
+export class MeilisearchSearchProvider<
+  TFactory extends ProductSearchFactory = MeilisearchProductSearchFactory,
+> extends ProductSearchProvider<ProductSearchFactoryOutput<TFactory>> {
   protected config: MeilisearchConfiguration;
-
-  constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {
+  protected factory: ProductSearchFactoryWithOutput<TFactory>;
+
+  constructor(
+    config: MeilisearchConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    factory: ProductSearchFactoryWithOutput<TFactory>,
+  ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected queryByTermPayload(payload: ProductSearchQueryByTerm) {
@@ -85,7 +98,7 @@ export class MeilisearchSearchProvider extends ProductSearchProvider {
   })
   public override async queryByTerm(
     payload: ProductSearchQueryByTerm
-  ): Promise<Result<ProductSearchResult>> {
+  ): Promise<Result<ProductSearchFactoryOutput<TFactory>>> {
     const client = new MeiliSearch({
       host: this.config.apiUrl,
       apiKey: this.config.apiKey,
@@ -96,7 +109,7 @@ export class MeilisearchSearchProvider extends ProductSearchProvider {
 
     const remote = await index.search<MeilisearchNativeRecord>(payload.search.term, this.queryByTermPayload(payload) as SearchParams);
 
-    const result = this.parsePaginatedResult(remote, payload) as MeilisearchProductSearchResult;
+    const result = this.parsePaginatedResult(remote, payload);
 
     // mark selected facets as active
     for (const selectedFacet of payload.search.facets) {
@@ -109,7 +122,7 @@ export class MeilisearchSearchProvider extends ProductSearchProvider {
       }
     }
 
-    return success(result);
+    return success(this.factory.parseSearchResult(this.context, result, payload));
   }
 
   public override async createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>> {
@@ -136,7 +149,10 @@ export class MeilisearchSearchProvider extends ProductSearchProvider {
     return product;
   }
 
-  protected override parseVariant(variant: MeilisearchNativeVariant, product: MeilisearchNativeRecord): ProductSearchResultItemVariant {
+  protected parseVariant(
+    variant: MeilisearchNativeVariant,
+    product: MeilisearchNativeRecord,
+  ): ProductSearchResultItemVariant {
     const result = ProductSearchResultItemVariantSchema.parse({
       variant: {
         sku: variant.sku