@reactionary/source 0.6.2 → 0.6.3

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

@@ -1,39 +1,39 @@
 import type {
   CartFactory,
   CartFactoryWithOutput,
-  CartProvider,
+  CartCapability,
   CategoryFactory,
   CategoryFactoryWithOutput,
-  CategoryProvider,
+  CategoryCapability,
   CheckoutFactory,
   CheckoutFactoryWithOutput,
-  CheckoutProvider,
-  IdentityProvider,
+  CheckoutCapability,
+  IdentityCapability,
   InventoryFactory,
   InventoryFactoryWithOutput,
-  InventoryProvider,
+  InventoryCapability,
   OrderFactory,
   OrderFactoryWithOutput,
-  OrderProvider,
+  OrderCapability,
   OrderSearchFactory,
   OrderSearchFactoryWithOutput,
-  OrderSearchProvider,
+  OrderSearchCapability,
   PriceFactory,
   PriceFactoryWithOutput,
-  PriceProvider,
+  PriceCapability,
   ProductAssociationsFactory,
   ProductAssociationsFactoryWithOutput,
-  ProductAssociationsProvider,
+  ProductAssociationsCapability,
   ProductFactory,
   ProductFactoryWithOutput,
-  ProductProvider,
-  ProductRecommendationsProvider,
+  ProductCapability,
+  ProductRecommendationsCapability,
   ProductSearchFactory,
   ProductSearchFactoryWithOutput,
-  ProductSearchProvider,
+  ProductSearchCapability,
   ProfileFactory,
   ProfileFactoryWithOutput,
-  ProfileProvider,
+  ProfileCapability,
   RequestContext,
   Cache,
 } from '@reactionary/core';
@@ -45,12 +45,12 @@ import * as z from 'zod';
 const OverridableCapabilitySchema = 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 MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
@@ -78,154 +78,154 @@ export const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
     order: OverridableCapabilitySchema.optional(),
     orderSearch: OverridableCapabilitySchema.optional(),
     inventory: OverridableCapabilitySchema.optional(),
-    identity: ProviderCapabilitySchema.optional(),
+    identity: DirectCapabilitySchema.optional(),
     profile: OverridableCapabilitySchema.optional(),
     productAssociations: OverridableCapabilitySchema.optional(),
-    productRecommendations: ProviderCapabilitySchema.optional(),
+    productRecommendations: DirectCapabilitySchema.optional(),
   })
   .partial();
 
-export interface MedusaProviderFactoryArgs {
+export interface MedusaCapabilityFactoryArgs {
   cache: Cache;
   context: RequestContext;
   config: MedusaConfiguration;
   medusaApi: MedusaAPI;
 }
 
-export interface MedusaFactoryProviderArgs<TFactory>
-  extends MedusaProviderFactoryArgs {
+export interface MedusaFactoryCapabilityArgs<TFactory>
+  extends MedusaCapabilityFactoryArgs {
   factory: TFactory;
 }
 
-export interface MedusaCapabilityConfig<TFactory, TProvider> {
+export interface MedusaCapabilityConfig<TFactory, TCapability> {
   enabled: boolean;
   factory?: TFactory;
-  provider?: (args: MedusaFactoryProviderArgs<TFactory>) => TProvider;
+  capability?: (args: MedusaFactoryCapabilityArgs<TFactory>) => TCapability;
 }
 
-export interface MedusaProviderOnlyCapabilityConfig<TProvider> {
+export interface MedusaDirectCapabilityConfig<TCapability> {
   enabled: boolean;
-  provider?: (args: MedusaProviderFactoryArgs) => TProvider;
+  capability?: (args: MedusaCapabilityFactoryArgs) => TCapability;
 }
 
 export type MedusaProductCapabilityConfig = MedusaCapabilityConfig<
   ProductFactoryWithOutput<ProductFactory>,
-  ProductProvider
+  ProductCapability
 >;
 
 export type MedusaProductSearchCapabilityConfig = MedusaCapabilityConfig<
   ProductSearchFactoryWithOutput<ProductSearchFactory>,
-  ProductSearchProvider
+  ProductSearchCapability
 >;
 
 export type MedusaCartCapabilityConfig = MedusaCapabilityConfig<
   CartFactoryWithOutput<CartFactory>,
-  CartProvider
+  CartCapability
 >;
 
 export type MedusaCheckoutCapabilityConfig = MedusaCapabilityConfig<
   CheckoutFactoryWithOutput<CheckoutFactory>,
-  CheckoutProvider
+  CheckoutCapability
 >;
 
 export type MedusaCategoryCapabilityConfig = MedusaCapabilityConfig<
   CategoryFactoryWithOutput<CategoryFactory>,
-  CategoryProvider
+  CategoryCapability
 >;
 
 export type MedusaPriceCapabilityConfig = MedusaCapabilityConfig<
   PriceFactoryWithOutput<PriceFactory>,
-  PriceProvider
+  PriceCapability
 >;
 
 export type MedusaOrderCapabilityConfig = MedusaCapabilityConfig<
   OrderFactoryWithOutput<OrderFactory>,
-  OrderProvider
+  OrderCapability
 >;
 
 export type MedusaOrderSearchCapabilityConfig = MedusaCapabilityConfig<
   OrderSearchFactoryWithOutput<OrderSearchFactory>,
-  OrderSearchProvider
+  OrderSearchCapability
 >;
 
 export type MedusaInventoryCapabilityConfig = MedusaCapabilityConfig<
   InventoryFactoryWithOutput<InventoryFactory>,
-  InventoryProvider
+  InventoryCapability
 >;
 
 export type MedusaIdentityCapabilityConfig =
-  MedusaProviderOnlyCapabilityConfig<IdentityProvider>;
+  MedusaDirectCapabilityConfig<IdentityCapability>;
 
 export type MedusaProfileCapabilityConfig = MedusaCapabilityConfig<
   ProfileFactoryWithOutput<ProfileFactory>,
-  ProfileProvider
+  ProfileCapability
 >;
 
 export type MedusaProductAssociationsCapabilityConfig = MedusaCapabilityConfig<
   ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
-  ProductAssociationsProvider
+  ProductAssociationsCapability
 >;
 
 export type MedusaProductRecommendationsCapabilityConfig =
-  MedusaProviderOnlyCapabilityConfig<ProductRecommendationsProvider>;
+  MedusaDirectCapabilityConfig<ProductRecommendationsCapability>;
 
 export type MedusaCapabilities<
   TProductFactory extends ProductFactory = ProductFactory,
-  TProductProvider extends ProductProvider = ProductProvider,
+  TProductCapability extends ProductCapability = ProductCapability,
   TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory,
-  TProductSearchProvider extends ProductSearchProvider = ProductSearchProvider,
+  TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability,
   TCartFactory extends CartFactory = CartFactory,
-  TCartProvider extends CartProvider = CartProvider,
+  TCartCapability extends CartCapability = CartCapability,
   TCheckoutFactory extends CheckoutFactory = CheckoutFactory,
-  TCheckoutProvider extends CheckoutProvider = CheckoutProvider,
+  TCheckoutCapability extends CheckoutCapability = CheckoutCapability,
   TCategoryFactory extends CategoryFactory = CategoryFactory,
-  TCategoryProvider extends CategoryProvider = CategoryProvider,
+  TCategoryCapability extends CategoryCapability = CategoryCapability,
   TPriceFactory extends PriceFactory = PriceFactory,
-  TPriceProvider extends PriceProvider = PriceProvider,
+  TPriceCapability extends PriceCapability = PriceCapability,
   TOrderFactory extends OrderFactory = OrderFactory,
-  TOrderProvider extends OrderProvider = OrderProvider,
+  TOrderCapability extends OrderCapability = OrderCapability,
   TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory,
-  TOrderSearchProvider extends OrderSearchProvider = OrderSearchProvider,
+  TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability,
   TInventoryFactory extends InventoryFactory = InventoryFactory,
-  TInventoryProvider extends InventoryProvider = InventoryProvider,
-  TIdentityProvider extends IdentityProvider = IdentityProvider,
+  TInventoryCapability extends InventoryCapability = InventoryCapability,
+  TIdentityCapability extends IdentityCapability = IdentityCapability,
   TProfileFactory extends ProfileFactory = ProfileFactory,
-  TProfileProvider extends ProfileProvider = ProfileProvider,
+  TProfileCapability extends ProfileCapability = ProfileCapability,
   TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory,
-  TProductAssociationsProvider extends ProductAssociationsProvider = ProductAssociationsProvider,
-  TProductRecommendationsProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider,
+  TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability,
+  TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability,
 > = {
-  product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductProvider>;
+  product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
   productSearch?: MedusaCapabilityConfig<
     ProductSearchFactoryWithOutput<TProductSearchFactory>,
-    TProductSearchProvider
+    TProductSearchCapability
   >;
-  cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartProvider>;
+  cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartCapability>;
   checkout?: MedusaCapabilityConfig<
     CheckoutFactoryWithOutput<TCheckoutFactory>,
-    TCheckoutProvider
+    TCheckoutCapability
   >;
   category?: MedusaCapabilityConfig<
     CategoryFactoryWithOutput<TCategoryFactory>,
-    TCategoryProvider
+    TCategoryCapability
   >;
-  price?: MedusaCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceProvider>;
-  order?: MedusaCapabilityConfig<OrderFactoryWithOutput<TOrderFactory>, TOrderProvider>;
+  price?: MedusaCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceCapability>;
+  order?: MedusaCapabilityConfig<OrderFactoryWithOutput<TOrderFactory>, TOrderCapability>;
   orderSearch?: MedusaCapabilityConfig<
     OrderSearchFactoryWithOutput<TOrderSearchFactory>,
-    TOrderSearchProvider
+    TOrderSearchCapability
   >;
   inventory?: MedusaCapabilityConfig<
     InventoryFactoryWithOutput<TInventoryFactory>,
-    TInventoryProvider
+    TInventoryCapability
   >;
-  identity?: MedusaProviderOnlyCapabilityConfig<TIdentityProvider>;
-  profile?: MedusaCapabilityConfig<ProfileFactoryWithOutput<TProfileFactory>, TProfileProvider>;
+  identity?: MedusaDirectCapabilityConfig<TIdentityCapability>;
+  profile?: MedusaCapabilityConfig<ProfileFactoryWithOutput<TProfileFactory>, TProfileCapability>;
   productAssociations?: MedusaCapabilityConfig<
     ProductAssociationsFactoryWithOutput<TProductAssociationsFactory>,
-    TProductAssociationsProvider
+    TProductAssociationsCapability
   >;
-  productRecommendations?: MedusaProviderOnlyCapabilityConfig<TProductRecommendationsProvider>;
+  productRecommendations?: MedusaDirectCapabilityConfig<TProductRecommendationsCapability>;
 };
 
 export type ParsedMedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

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

@@ -11,7 +11,7 @@ import {
 } from '@reactionary/core';
 import { assert, beforeEach, describe, expect, it } from 'vitest';
 import { MedusaAPI } from '../core/client.js';
-import { MedusaCartProvider } from '../providers/cart.provider.js';
+import { MedusaCartCapability } from '../capabilities/cart.capability.js';
 import { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 
@@ -23,13 +23,13 @@ const testData = {
 
 
 describe('Medusa Cart Provider', () => {
-  let provider: MedusaCartProvider;
+  let provider: MedusaCartCapability;
   let reqCtx: RequestContext;
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaCartProvider(
+    provider = new MedusaCartCapability(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,

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

@@ -6,7 +6,7 @@ import {
   NoOpCache,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { MedusaCategoryProvider } from '../providers/category.provider.js';
+import { MedusaCategoryCapability } from '../capabilities/category.capability.js';
 import { MedusaCategoryFactory } from '../factories/category/category.factory.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
@@ -36,7 +36,7 @@ const testData = {
 };
 
 describe('Medusa Category Provider', () => {
-  let provider: MedusaCategoryProvider;
+  let provider: MedusaCategoryCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -44,7 +44,7 @@ describe('Medusa Category Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaCategoryProvider(
+    provider = new MedusaCategoryCapability(
       config,
       new NoOpCache(),
       reqCtx,

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, assert } from 'vitest';
-import { MedusaIdentityProvider } from '../providers/identity.provider.js';
+import { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
 import { IdentitySchema, NoOpCache, createInitialRequestContext, type RequestContext } from '@reactionary/core';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
@@ -12,7 +12,7 @@ const testData = {
 };
 
 describe('Medusa Identity Provider', () => {
-  let provider: MedusaIdentityProvider;
+  let provider: MedusaIdentityCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -20,7 +20,7 @@ describe('Medusa Identity Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaIdentityProvider(config, new NoOpCache(), reqCtx, client);
+    provider = new MedusaIdentityCapability(config, new NoOpCache(), reqCtx, client);
   });
 
   it('should return anonymous identity when not authenticated', async () => {

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, assert } from 'vitest';
-import { MedusaInventoryProvider } from '../providers/inventory.provider.js';
+import { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
 import {
   InventorySchema,
   NoOpCache,
@@ -18,7 +18,7 @@ const testData = {
 
 // FIXME: Currently broken in terms of actually looking up anything...
 describe('Medusa Inventory Provider', () => {
-  let provider: MedusaInventoryProvider;
+  let provider: MedusaInventoryCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
@@ -26,7 +26,7 @@ describe('Medusa Inventory Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaInventoryProvider(
+    provider = new MedusaInventoryCapability(
       config,
       new NoOpCache(),
       reqCtx,

package/{providers/medusa/src/test/large-cart.provider.spec.ts → packages/medusa/src/test/large-cart.capability.spec.ts}

@@ -10,8 +10,8 @@ import {
   type RequestContext,
 } from '@reactionary/core';
 import { assert, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { MedusaCartProvider } from '../providers/cart.provider.js';
-import { MedusaSearchProvider } from '../providers/product-search.provider.js';
+import { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
 import { getMedusaTestConfiguration } from './test-utils.js';
 import { MedusaAPI } from '../core/client.js';
 import { MedusaCartFactory } from '../factories/cart/cart.factory.js';
@@ -25,21 +25,21 @@ const testData = {
 */
 
 describe('Medusa Cart Provider - Large Scenarios', () => {
-  let provider: MedusaCartProvider;
-  let searchProvider: MedusaSearchProvider;
+  let provider: MedusaCartCapability;
+  let searchProvider: MedusaProductSearchCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaCartProvider(
+    provider = new MedusaCartCapability(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,
       client,
       new MedusaCartFactory(CartSchema, CartIdentifierSchema),
     );
-    searchProvider = new MedusaSearchProvider(
+    searchProvider = new MedusaProductSearchCapability(
       getMedusaTestConfiguration(),
       new NoOpCache(),
       reqCtx,

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,
@@ -18,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(() => {
@@ -26,7 +26,7 @@ describe('Medusa Price Provider', () => {
     const config = getMedusaTestConfiguration();
     const client = new MedusaAPI(config, reqCtx);
 
-    provider = new MedusaPriceProvider(
+    provider = new MedusaPriceCapability(
       config,
       new NoOpCache(),
       reqCtx,

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

@@ -5,7 +5,7 @@ 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';
@@ -24,13 +24,13 @@ 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,

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

@@ -10,10 +10,10 @@ import {
   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';
 
@@ -23,7 +23,7 @@ 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,
@@ -31,7 +31,7 @@ describe('Medusa Search Provider', () => {
     new MedusaProductSearchFactory(ProductSearchResultSchema),
   );
 
-  const categoryProvider = new MedusaCategoryProvider(
+  const categoryProvider = new MedusaCategoryCapability(
     getMedusaTestConfiguration(),
     new NoOpCache(),
     reqCtx,

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/).