@reactionary/source 0.6.2 → 0.6.3

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,
@@ -48,9 +48,9 @@ interface MeilisearchNativeOrderRecord {
   currency: string;
 }
 
-export class MeilisearchOrderSearchProvider<
+export class MeilisearchOrderSearchCapability<
   TFactory extends OrderSearchFactory = MeilisearchOrderSearchFactory,
-> extends OrderSearchProvider<OrderSearchFactoryOutput<TFactory>> {
+> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
   protected config: MeilisearchConfiguration;
   protected factory: OrderSearchFactoryWithOutput<TFactory>;
 

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,7 @@ import {
   type FacetValueIdentifier,
   FacetValueIdentifierSchema,
   ImageSchema,
-  ProductSearchProvider,
+  ProductSearchCapability,
   type ProductSearchFactory,
   type ProductSearchFactoryOutput,
   type ProductSearchFactoryWithOutput,
@@ -32,9 +32,9 @@ import type { MeilisearchNativeRecord, MeilisearchNativeVariant } from '../schem
 import type { MeilisearchProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
 
-export class MeilisearchSearchProvider<
+export class MeilisearchProductSearchCapability<
   TFactory extends ProductSearchFactory = MeilisearchProductSearchFactory,
-> extends ProductSearchProvider<ProductSearchFactoryOutput<TFactory>> {
+> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
   protected config: MeilisearchConfiguration;
   protected factory: ProductSearchFactoryWithOutput<TFactory>;
 

package/{providers → packages}/meilisearch/src/core/initialize.ts

@@ -1,8 +1,8 @@
 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 { 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,
@@ -12,8 +12,8 @@ import { MeilisearchOrderSearchFactory } from '../factories/order-search/order-s
 import { MeilisearchProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 import {
   type MeilisearchClientFromCapabilities,
-  resolveCapabilityProvider,
-  resolveProviderOnlyCapability,
+  resolveCapabilityWithFactory,
+  resolveDirectCapability,
 } from './initialize.types.js';
 
 export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(
@@ -29,12 +29,12 @@ export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(
     const caps = MeilisearchCapabilitiesSchema.parse(capabilities);
 
     if (caps.productSearch?.enabled) {
-      client.productSearch = resolveCapabilityProvider(
+      client.productSearch = resolveCapabilityWithFactory(
         capabilities.productSearch,
         {
           factory: new MeilisearchProductSearchFactory(ProductSearchResultSchema),
-          provider: (args) =>
-            new MeilisearchSearchProvider(
+          capability: (args) =>
+            new MeilisearchProductSearchCapability(
               args.config,
               args.cache,
               args.context,
@@ -51,12 +51,12 @@ export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(
     }
 
     if (caps.orderSearch?.enabled) {
-      client.orderSearch = resolveCapabilityProvider(
+      client.orderSearch = resolveCapabilityWithFactory(
         capabilities.orderSearch,
         {
           factory: new MeilisearchOrderSearchFactory(OrderSearchResultSchema),
-          provider: (args) =>
-            new MeilisearchOrderSearchProvider(
+          capability: (args) =>
+            new MeilisearchOrderSearchCapability(
               args.config,
               args.cache,
               args.context,
@@ -73,10 +73,10 @@ export function withMeilisearchCapabilities<T extends MeilisearchCapabilities>(
     }
 
     if (caps.productRecommendations?.enabled) {
-      client.productRecommendations = resolveProviderOnlyCapability(
+      client.productRecommendations = resolveDirectCapability(
         capabilities.productRecommendations,
         (args) =>
-          new MeilisearchProductRecommendationsProvider(
+          new MeilisearchProductRecommendationsCapability(
             args.config,
             args.cache,
             args.context,

package/{providers → packages}/meilisearch/src/core/initialize.types.ts

@@ -6,9 +6,9 @@ import type {
 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';
+import type { MeilisearchOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { MeilisearchProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import type { MeilisearchProductSearchCapability } from '../capabilities/product-search.capability.js';
 
 type EnabledCapability<TCapability> =
   TCapability extends { enabled: true } ? true : false;
@@ -27,19 +27,19 @@ type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
       : TDefaultFactory
     : TDefaultFactory;
 
-type ExtractCapabilityProvider<TCapability, TDefaultProvider> =
-  TCapability extends { enabled: true; provider?: infer TProviderFactory }
-    ? TProviderFactory extends (...args: unknown[]) => infer TProvider
-      ? TProvider
-      : TDefaultProvider
-    : TDefaultProvider;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> =
+  TCapability extends { enabled: true; capability?: infer TCapabilityFactory }
+    ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
 
 type CapabilityOverride<
   TCapability,
   TKey extends string,
-  TProvider,
+  TResolvedCapability,
 > = TCapability extends { enabled: true }
-  ? { [K in TKey]: TProvider }
+  ? { [K in TKey]: TResolvedCapability }
   : Record<never, never>;
 
 type ProductSearchFactoryFor<T extends MeilisearchCapabilities> =
@@ -56,64 +56,64 @@ type OrderSearchFactoryFor<T extends MeilisearchCapabilities> =
     MeilisearchOrderSearchFactory
   >;
 
-type ProductSearchProviderFor<T extends MeilisearchCapabilities> =
-  ExtractCapabilityProvider<
+type ProductSearchCapabilityFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityImplementation<
     T['productSearch'],
-    MeilisearchSearchProvider<ProductSearchFactoryFor<T>>
+    MeilisearchProductSearchCapability<ProductSearchFactoryFor<T>>
   >;
 
-type OrderSearchProviderFor<T extends MeilisearchCapabilities> =
-  ExtractCapabilityProvider<
+type OrderSearchCapabilityFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityImplementation<
     T['orderSearch'],
-    MeilisearchOrderSearchProvider<OrderSearchFactoryFor<T>>
+    MeilisearchOrderSearchCapability<OrderSearchFactoryFor<T>>
   >;
 
-type ProductRecommendationsProviderFor<T extends MeilisearchCapabilities> =
-  ExtractCapabilityProvider<
+type ProductRecommendationsCapabilityFor<T extends MeilisearchCapabilities> =
+  ExtractCapabilityImplementation<
     T['productRecommendations'],
-    MeilisearchProductRecommendationsProvider
+    MeilisearchProductRecommendationsCapability
   >;
 
 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['productSearch'], 'productSearch', ProductSearchCapabilityFor<T>> &
+  CapabilityOverride<T['orderSearch'], 'orderSearch', OrderSearchCapabilityFor<T>> &
   CapabilityOverride<
     T['productRecommendations'],
     'productRecommendations',
-    ProductRecommendationsProviderFor<T>
+    ProductRecommendationsCapabilityFor<T>
   >;
 
-export function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(
+export function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(
   capability:
     | {
         factory?: TFactory;
-        provider?: (args: TProviderArgs) => TProvider;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
       }
     | undefined,
   defaults: {
     factory: TFactory;
-    provider: (args: TProviderArgs) => TProvider;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
   },
-  buildProviderArgs: (factory: TFactory) => TProviderArgs,
-): TProvider {
+  buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs,
+): TResolvedCapability {
   const factory = capability?.factory ?? defaults.factory;
-  const provider = capability?.provider ?? defaults.provider;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
 
-  return provider(buildProviderArgs(factory));
+  return capabilityFactory(buildCapabilityArgs(factory));
 }
 
-export function resolveProviderOnlyCapability<TProvider, TProviderArgs>(
+export function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(
   capability:
     | {
-        provider?: (args: TProviderArgs) => TProvider;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
       }
     | undefined,
-  defaultProvider: (args: TProviderArgs) => TProvider,
-  args: TProviderArgs,
-): TProvider {
-  const provider = capability?.provider ?? defaultProvider;
-  return provider(args);
+  defaultCapability: (args: TCapabilityArgs) => TResolvedCapability,
+  args: TCapabilityArgs,
+): TResolvedCapability {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
 }

package/{providers → packages}/meilisearch/src/index.ts

@@ -1,9 +1,9 @@
 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';
+export * from './capabilities/product-search.capability.js';
+export * from './capabilities/product-recommendations.capability.js';
+export * from './capabilities/order-search.capability.js';
 
 export * from './schema/configuration.schema.js';
 export * from './schema/capabilities.schema.js';

package/{providers → packages}/meilisearch/src/schema/capabilities.schema.ts

@@ -2,11 +2,11 @@ import type {
   Cache,
   OrderSearchFactory,
   OrderSearchFactoryWithOutput,
-  OrderSearchProvider,
-  ProductRecommendationsProvider,
+  OrderSearchCapability,
+  ProductRecommendationsCapability,
   ProductSearchFactory,
   ProductSearchFactoryWithOutput,
-  ProductSearchProvider,
+  ProductSearchCapability,
   RequestContext,
 } from '@reactionary/core';
 import { CapabilitiesSchema } from '@reactionary/core';
@@ -16,12 +16,12 @@ import * as z from 'zod';
 const SearchCapabilitySchema = z.looseObject({
   enabled: z.boolean(),
   factory: z.unknown().optional(),
-  provider: z.unknown().optional(),
+  capability: z.unknown().optional(),
 });
 
-const ProviderCapabilitySchema = z.looseObject({
+const DirectCapabilitySchema = z.looseObject({
   enabled: z.boolean(),
-  provider: z.unknown().optional(),
+  capability: z.unknown().optional(),
 });
 
 export const MeilisearchCapabilitiesSchema = CapabilitiesSchema.pick({
@@ -32,67 +32,67 @@ export const MeilisearchCapabilitiesSchema = CapabilitiesSchema.pick({
   .extend({
     productSearch: SearchCapabilitySchema.optional(),
     orderSearch: SearchCapabilitySchema.optional(),
-    productRecommendations: ProviderCapabilitySchema.optional(),
+    productRecommendations: DirectCapabilitySchema.optional(),
   })
   .partial();
 
-export interface MeilisearchProviderFactoryArgs {
+export interface MeilisearchCapabilityFactoryArgs {
   cache: Cache;
   context: RequestContext;
   config: MeilisearchConfiguration;
 }
 
-export interface MeilisearchSearchProviderFactoryArgs<
+export interface MeilisearchProductSearchCapabilityFactoryArgs<
   TFactory extends ProductSearchFactory = ProductSearchFactory,
-> extends MeilisearchProviderFactoryArgs {
+> extends MeilisearchCapabilityFactoryArgs {
   factory: ProductSearchFactoryWithOutput<TFactory>;
 }
 
-export interface MeilisearchOrderSearchProviderFactoryArgs<
+export interface MeilisearchOrderSearchCapabilityFactoryArgs<
   TFactory extends OrderSearchFactory = OrderSearchFactory,
-> extends MeilisearchProviderFactoryArgs {
+> extends MeilisearchCapabilityFactoryArgs {
   factory: OrderSearchFactoryWithOutput<TFactory>;
 }
 
 export interface MeilisearchProductSearchCapabilityConfig<
   TFactory extends ProductSearchFactory = ProductSearchFactory,
-  TProvider extends ProductSearchProvider = ProductSearchProvider,
+  TCapability extends ProductSearchCapability = ProductSearchCapability,
 > {
   enabled: boolean;
   factory?: ProductSearchFactoryWithOutput<TFactory>;
-  provider?: (args: MeilisearchSearchProviderFactoryArgs<TFactory>) => TProvider;
+  capability?: (args: MeilisearchProductSearchCapabilityFactoryArgs<TFactory>) => TCapability;
 }
 
 export interface MeilisearchOrderSearchCapabilityConfig<
   TFactory extends OrderSearchFactory = OrderSearchFactory,
-  TProvider extends OrderSearchProvider = OrderSearchProvider,
+  TCapability extends OrderSearchCapability = OrderSearchCapability,
 > {
   enabled: boolean;
   factory?: OrderSearchFactoryWithOutput<TFactory>;
-  provider?: (args: MeilisearchOrderSearchProviderFactoryArgs<TFactory>) => TProvider;
+  capability?: (args: MeilisearchOrderSearchCapabilityFactoryArgs<TFactory>) => TCapability;
 }
 
 export interface MeilisearchProductRecommendationsCapabilityConfig<
-  TProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider,
+  TCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
 > {
   enabled: boolean;
-  provider?: (args: MeilisearchProviderFactoryArgs) => TProvider;
+  capability?: (args: MeilisearchCapabilityFactoryArgs) => TCapability;
 }
 
 export type MeilisearchCapabilities<
   TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
-  TProductSearchProvider extends ProductSearchProvider = ProductSearchProvider,
+  TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability,
   TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory,
-  TOrderSearchProvider extends OrderSearchProvider = OrderSearchProvider,
-  TProductRecommendationsProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider,
+  TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability,
+  TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
 > = {
   productSearch?: MeilisearchProductSearchCapabilityConfig<
     TProductSearchFactory,
-    TProductSearchProvider
+    TProductSearchCapability
   >;
   orderSearch?: MeilisearchOrderSearchCapabilityConfig<
     TOrderSearchFactory,
-    TOrderSearchProvider
+    TOrderSearchCapability
   >;
-  productRecommendations?: MeilisearchProductRecommendationsCapabilityConfig<TProductRecommendationsProvider>;
+  productRecommendations?: MeilisearchProductRecommendationsCapabilityConfig<TProductRecommendationsCapability>;
 };

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

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