@reactionary/source 0.6.1 → 0.6.3

package/{providers/medusa/src/test/price.provider.spec.ts → packages/medusa/src/test/price.capability.spec.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi, assert } from 'vitest';
-import { MedusaPriceProvider } from '../providers/price.provider.js';
+import { MedusaPriceCapability } from '../capabilities/price.capability.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 import {
   PriceSchema,
@@ -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',
@@ -17,7 +18,7 @@ const testData = {
 
 // FIXME: Currently broken in terms of actually looking up anything...
 describe('Medusa Price Provider', () => {
-  let provider: MedusaPriceProvider;
+  let provider: MedusaPriceCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -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 MedusaPriceCapability(
+      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 → packages/medusa/src/test/product.capability.spec.ts}

@@ -5,10 +5,11 @@ import {
   ProductSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { MedusaProductProvider } from '../providers/product.provider.js';
+import { MedusaProductCapability } from '../capabilities/product.capability.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: {
@@ -23,17 +24,18 @@ const testData = {
 };
 
 describe('Medusa Product Provider', () => {
-  let provider: MedusaProductProvider;
+  let provider: MedusaProductCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaProductProvider(
+    provider = new MedusaProductCapability(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
-      client
+      client,
+      new MedusaProductFactory(ProductSchema),
     );
   });
 

package/{providers/medusa/src/test/search.provider.spec.ts → packages/medusa/src/test/search.capability.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 { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../index.js';
-import { MedusaCategoryProvider } from '../providers/category.provider.js';
+import { MedusaCategoryCapability } from '../capabilities/category.capability.js';
+import { MedusaCategoryFactory } from '../factories/category/category.factory.js';
+import { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 const testData = {
   searchTerm: 'printer',
@@ -12,18 +23,20 @@ const testData = {
 describe('Medusa Search Provider', () => {
   const reqCtx = createInitialRequestContext();
   const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-  const provider = new MedusaSearchProvider(
+  const provider = new MedusaProductSearchCapability(
     getMedusaTestConfiguration(),
     new NoOpCache(),
     reqCtx,
-    client
+    client,
+    new MedusaProductSearchFactory(ProductSearchResultSchema),
   );
 
-  const categoryProvider = new MedusaCategoryProvider(
+  const categoryProvider = new MedusaCategoryCapability(
     getMedusaTestConfiguration(),
     new NoOpCache(),
     reqCtx,
-    client
+    client,
+    new MedusaCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
   );
 
   it('should be able to get a result by term', async () => {

package/{providers → packages}/medusa/src/utils/medusa-helpers.ts

@@ -75,7 +75,7 @@ export function parseMedusaItemPrice(
 }
 
 /**
- * Handles provider errors with consistent formatting
+ * Handles capability implementation errors with consistent formatting
  */
 export function handleProviderError(action: string, error: unknown): never {
   if (debug.enabled) {

package/packages/medusa/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/packages/medusa/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "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"
+  ]
+}

package/packages/medusa/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/medusa/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/medusa',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'medusa',
+    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/medusa',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/medusa/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/medusa',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'medusa',
+    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/medusa',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/meilisearch/README.md

@@ -0,0 +1,11 @@
+# meilisearch
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build meilisearch` to build the library.
+
+## Running unit tests
+
+Run `nx test meilisearch` to execute the unit tests via [Vitest](https://vitest.dev/).

package/packages/meilisearch/eslint.config.mjs

@@ -0,0 +1,23 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
+            '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/packages/meilisearch/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@reactionary/meilisearch",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5",
+    "@reactionary/core": "0.0.1",
+    "zod": "4.1.9",
+    "meilisearch": "^0.55.0"
+  },
+  "sideEffects": false
+}

package/{providers → packages}/meilisearch/project.json

@@ -1,14 +1,13 @@
 {
   "name": "meilisearch",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "providers/meilisearch/src",
+  "sourceRoot": "packages/meilisearch/src",
   "projectType": "library",
   "release": {
     "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
       "currentVersionResolver": "git-tag",
-      "fallbackCurrentVersionResolver": "disk",
-      "preserveLocalDependencyProtocols": false,
-      "manifestRootsToUpdate": ["dist/{projectRoot}"]
+      "fallbackCurrentVersionResolver": "disk"
     }
   },
   "tags": [],
@@ -17,10 +16,10 @@
       "executor": "@nx/esbuild:esbuild",
       "outputs": ["{options.outputPath}"],
       "options": {
-        "outputPath": "dist/providers/meilisearch",
-        "main": "providers/meilisearch/src/index.ts",
-        "tsConfig": "providers/meilisearch/tsconfig.lib.json",
-        "assets": ["providers/meilisearch/*.md"],
+        "outputPath": "dist/packages/meilisearch",
+        "main": "packages/meilisearch/src/index.ts",
+        "tsConfig": "packages/meilisearch/tsconfig.lib.json",
+        "assets": ["packages/meilisearch/*.md"],
         "format": ["esm"],
         "bundle": false
       }

package/packages/meilisearch/src/capabilities/index.ts

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

package/{providers/meilisearch/src/providers/order-search.provider.ts → packages/meilisearch/src/capabilities/order-search.capability.ts}

@@ -5,7 +5,7 @@ import {
   type OrderSearchResult,
   type OrderSearchResultItem,
   OrderSearchResultSchema,
-  OrderSearchProvider,
+  OrderSearchCapability,
   Reactionary,
   type RequestContext,
   type Result,
@@ -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 MeilisearchOrderSearchCapability<
+  TFactory extends OrderSearchFactory = MeilisearchOrderSearchFactory,
+> extends OrderSearchCapability<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-recommendations.provider.ts → packages/meilisearch/src/capabilities/product-recommendations.capability.ts}

@@ -1,6 +1,6 @@
 import {
   type Cache,
-  ProductRecommendationsProvider,
+  ProductRecommendationsCapability,
   type ProductRecommendation,
   type ProductRecommendationAlgorithmSimilarProductsQuery,
   type RequestContext,
@@ -15,7 +15,7 @@ import type { MeilisearchNativeRecord, MeilisearchNativeVariant } from '../schem
 
 
 /**
- * MeilisearchProductRecommendationsProvider
+ * MeilisearchProductRecommendationsCapability
  *
  * Provides product recommendations using Meilisearch's hybrid search and filtering capabilities.
  * Supports frequentlyBoughtTogether, similar, related, and trendingInCategory algorithms.
@@ -24,7 +24,7 @@ import type { MeilisearchNativeRecord, MeilisearchNativeVariant } from '../schem
  * For production use, consider implementing more sophisticated recommendation logic or integrating
  * with a dedicated recommendation engine.
  */
-export class MeilisearchProductRecommendationsProvider extends ProductRecommendationsProvider {
+export class MeilisearchProductRecommendationsCapability extends ProductRecommendationsCapability {
   protected config: MeilisearchConfiguration;
 
   constructor(config: MeilisearchConfiguration, cache: Cache, context: RequestContext) {

package/{providers/meilisearch/src/providers/product-search.provider.ts → packages/meilisearch/src/capabilities/product-search.capability.ts}

@@ -5,7 +5,10 @@ import {
   type FacetValueIdentifier,
   FacetValueIdentifierSchema,
   ImageSchema,
-  ProductSearchProvider,
+  ProductSearchCapability,
+  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 MeilisearchProductSearchCapability<
+  TFactory extends ProductSearchFactory = MeilisearchProductSearchFactory,
+> extends ProductSearchCapability<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

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

@@ -0,0 +1,94 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import { OrderSearchResultSchema, ProductSearchResultSchema } from '@reactionary/core';
+import { MeilisearchProductSearchCapability } from '../capabilities/product-search.capability.js';
+import { MeilisearchProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import { MeilisearchOrderSearchCapability } from '../capabilities/order-search.capability.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,
+  resolveCapabilityWithFactory,
+  resolveDirectCapability,
+} from './initialize.types.js';
+
+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 (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityWithFactory(
+        capabilities.productSearch,
+        {
+          factory: new MeilisearchProductSearchFactory(ProductSearchResultSchema),
+          capability: (args) =>
+            new MeilisearchProductSearchCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        (factory) => ({
+          cache,
+          context,
+          config: configuration,
+          factory,
+        }),
+      );
+    }
+
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityWithFactory(
+        capabilities.orderSearch,
+        {
+          factory: new MeilisearchOrderSearchFactory(OrderSearchResultSchema),
+          capability: (args) =>
+            new MeilisearchOrderSearchCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        (factory) => ({
+          cache,
+          context,
+          config: configuration,
+          factory,
+        }),
+      );
+    }
+
+    if (caps.productRecommendations?.enabled) {
+      client.productRecommendations = resolveDirectCapability(
+        capabilities.productRecommendations,
+        (args) =>
+          new MeilisearchProductRecommendationsCapability(
+            args.config,
+            args.cache,
+            args.context,
+          ),
+        {
+          cache,
+          context,
+          config: configuration,
+        },
+      );
+    }
+
+    return client;
+  };
+}