@reactionary/source 0.6.1 → 0.6.3

package/packages/fake/src/schema/capabilities.schema.ts

@@ -0,0 +1,178 @@
+import type {
+  Cache,
+  CartFactory,
+  CartFactoryWithOutput,
+  CartCapability,
+  CategoryFactory,
+  CategoryFactoryWithOutput,
+  CategoryCapability,
+  CheckoutFactory,
+  CheckoutFactoryWithOutput,
+  CheckoutCapability,
+  IdentityFactory,
+  IdentityFactoryWithOutput,
+  IdentityCapability,
+  InventoryFactory,
+  InventoryFactoryWithOutput,
+  InventoryCapability,
+  OrderFactory,
+  OrderFactoryWithOutput,
+  OrderCapability,
+  OrderSearchFactory,
+  OrderSearchFactoryWithOutput,
+  OrderSearchCapability,
+  PriceFactory,
+  PriceFactoryWithOutput,
+  PriceCapability,
+  ProductAssociationsFactory,
+  ProductAssociationsFactoryWithOutput,
+  ProductAssociationsCapability,
+  ProductFactory,
+  ProductFactoryWithOutput,
+  ProductCapability,
+  ProductReviewsFactory,
+  ProductReviewsFactoryWithOutput,
+  ProductReviewsCapability,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchCapability,
+  ProfileFactory,
+  ProfileFactoryWithOutput,
+  ProfileCapability,
+  RequestContext,
+  StoreFactory,
+  StoreFactoryWithOutput,
+  StoreCapability,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { FakeConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional(),
+});
+
+export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  productSearch: true,
+  identity: true,
+  category: true,
+  cart: true,
+  inventory: true,
+  store: true,
+  price: true,
+  checkout: true,
+  order: true,
+  orderSearch: true,
+  profile: true,
+  productReviews: true,
+  productAssociations: true,
+})
+  .extend({
+    product: OverridableCapabilitySchema.optional(),
+    productSearch: OverridableCapabilitySchema.optional(),
+    identity: OverridableCapabilitySchema.optional(),
+    category: OverridableCapabilitySchema.optional(),
+    cart: OverridableCapabilitySchema.optional(),
+    inventory: OverridableCapabilitySchema.optional(),
+    store: OverridableCapabilitySchema.optional(),
+    price: OverridableCapabilitySchema.optional(),
+    checkout: OverridableCapabilitySchema.optional(),
+    order: OverridableCapabilitySchema.optional(),
+    orderSearch: OverridableCapabilitySchema.optional(),
+    profile: OverridableCapabilitySchema.optional(),
+    productReviews: OverridableCapabilitySchema.optional(),
+    productAssociations: OverridableCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface FakeCapabilityFactoryArgs<TFactory> {
+  cache: Cache;
+  context: RequestContext;
+  config: FakeConfiguration;
+  factory: TFactory;
+}
+
+export interface FakeCapabilityConfig<TFactory, TCapability> {
+  enabled: boolean;
+  factory?: TFactory;
+  capability?: (args: FakeCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+
+export type FakeProductCapabilityConfig = FakeCapabilityConfig<
+  ProductFactoryWithOutput<ProductFactory>,
+  ProductCapability
+>;
+export type FakeProductSearchCapabilityConfig = FakeCapabilityConfig<
+  ProductSearchFactoryWithOutput<ProductSearchFactory>,
+  ProductSearchCapability
+>;
+export type FakeIdentityCapabilityConfig = FakeCapabilityConfig<
+  IdentityFactoryWithOutput<IdentityFactory>,
+  IdentityCapability
+>;
+export type FakeCategoryCapabilityConfig = FakeCapabilityConfig<
+  CategoryFactoryWithOutput<CategoryFactory>,
+  CategoryCapability
+>;
+export type FakeCartCapabilityConfig = FakeCapabilityConfig<
+  CartFactoryWithOutput<CartFactory>,
+  CartCapability
+>;
+export type FakeInventoryCapabilityConfig = FakeCapabilityConfig<
+  InventoryFactoryWithOutput<InventoryFactory>,
+  InventoryCapability
+>;
+export type FakeStoreCapabilityConfig = FakeCapabilityConfig<
+  StoreFactoryWithOutput<StoreFactory>,
+  StoreCapability
+>;
+export type FakePriceCapabilityConfig = FakeCapabilityConfig<
+  PriceFactoryWithOutput<PriceFactory>,
+  PriceCapability
+>;
+export type FakeCheckoutCapabilityConfig = FakeCapabilityConfig<
+  CheckoutFactoryWithOutput<CheckoutFactory>,
+  CheckoutCapability
+>;
+export type FakeOrderCapabilityConfig = FakeCapabilityConfig<
+  OrderFactoryWithOutput<OrderFactory>,
+  OrderCapability
+>;
+export type FakeOrderSearchCapabilityConfig = FakeCapabilityConfig<
+  OrderSearchFactoryWithOutput<OrderSearchFactory>,
+  OrderSearchCapability
+>;
+export type FakeProfileCapabilityConfig = FakeCapabilityConfig<
+  ProfileFactoryWithOutput<ProfileFactory>,
+  ProfileCapability
+>;
+export type FakeProductReviewsCapabilityConfig = FakeCapabilityConfig<
+  ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
+  ProductReviewsCapability
+>;
+export type FakeProductAssociationsCapabilityConfig = FakeCapabilityConfig<
+  ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
+  ProductAssociationsCapability
+>;
+
+export type FakeCapabilities = {
+  product?: FakeProductCapabilityConfig;
+  productSearch?: FakeProductSearchCapabilityConfig;
+  identity?: FakeIdentityCapabilityConfig;
+  category?: FakeCategoryCapabilityConfig;
+  cart?: FakeCartCapabilityConfig;
+  inventory?: FakeInventoryCapabilityConfig;
+  store?: FakeStoreCapabilityConfig;
+  price?: FakePriceCapabilityConfig;
+  checkout?: FakeCheckoutCapabilityConfig;
+  order?: FakeOrderCapabilityConfig;
+  orderSearch?: FakeOrderSearchCapabilityConfig;
+  profile?: FakeProfileCapabilityConfig;
+  productReviews?: FakeProductReviewsCapabilityConfig;
+  productAssociations?: FakeProductAssociationsCapabilityConfig;
+};
+
+export type ParsedFakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

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

@@ -1,9 +1,16 @@
 import 'dotenv/config';
 import type { RequestContext} from '@reactionary/core';
-import { CartSchema, IdentitySchema, NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeCartProvider } from '../providers/cart.provider.js';
-import { FakeIdentityProvider } from '../providers/index.js';
+import { FakeCartCapability } from '../capabilities/cart.capability.js';
+import { FakeIdentityCapability } from '../capabilities/index.js';
+import { FakeCartFactory, FakeIdentityFactory } from '../factories/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
 const testData = {
@@ -12,14 +19,24 @@ const testData = {
 }
 
 describe('Fake Cart Provider', () => {
-  let provider: FakeCartProvider;
-  let identityProvider: FakeIdentityProvider;
+  let provider: FakeCartCapability;
+  let identityProvider: FakeIdentityCapability;
   let reqCtx: RequestContext;
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeCartProvider(getFakerTestConfiguration(), new NoOpCache(), reqCtx);
-    identityProvider = new FakeIdentityProvider(getFakerTestConfiguration(), new NoOpCache(), reqCtx);
+    provider = new FakeCartCapability(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      new FakeCartFactory(CartSchema, CartIdentifierSchema),
+    );
+    identityProvider = new FakeIdentityCapability(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      new FakeIdentityFactory(IdentitySchema),
+    );
   });
 
   describe('anonymous sessions', () => {

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

@@ -1,16 +1,18 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
+  CategoryPaginatedResultSchema,
   CategorySchema,
   MemoryCache,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { FakeCategoryProvider } from '../providers/index.js';
+import { FakeCategoryCapability } from '../capabilities/index.js';
+import { FakeCategoryFactory } from '../factories/index.js';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
 describe('Faker Category Provider', () => {
-  let provider: FakeCategoryProvider;
+  let provider: FakeCategoryCapability;
   let reqCtx: RequestContext;
   const cache = new MemoryCache();
 
@@ -18,10 +20,11 @@ describe('Faker Category Provider', () => {
     reqCtx = createInitialRequestContext();
     cache.clear();
 
-    provider = new FakeCategoryProvider(
+    provider = new FakeCategoryCapability(
       getFakerTestConfiguration(),
       cache,
-      reqCtx
+      reqCtx,
+      new FakeCategoryFactory(CategorySchema, CategoryPaginatedResultSchema),
     );
   });
 

package/{providers/fake/src/test/checkout.provider.spec.ts → packages/fake/src/test/checkout.capability.spec.ts}

@@ -2,22 +2,31 @@ import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
   NoOpCache,
+  CheckoutSchema,
+  ShippingMethodSchema,
+  PaymentMethodSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
+import { FakeCheckoutFactory } from '../factories/index.js';
 
 describe('Fake Checkout Provider', () => {
-  let provider: FakeCheckoutProvider;
+  let provider: FakeCheckoutCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeCheckoutProvider(
+    provider = new FakeCheckoutCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeCheckoutFactory(
+        CheckoutSchema,
+        ShippingMethodSchema,
+        PaymentMethodSchema,
+      ),
     );
   });
 
@@ -177,7 +186,8 @@ describe('Fake Checkout Provider', () => {
         },
         userId: {
             userId: 'Fake'
-        }
+        },
+        appliedPromotions: [],
       },
     });
 

package/packages/fake/src/test/client-builder-product-extension.example.ts

@@ -0,0 +1,75 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  ProductSchema,
+  createInitialRequestContext,
+  type RequestContext,
+} from '@reactionary/core';
+import * as z from 'zod';
+import { withFakeCapabilities } from '../core/initialize.js';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { FakeProductFactory } from '../factories/product/product.factory.js';
+
+const assertType = <T>(_value: T) => {
+  void _value;
+};
+
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+const assertNotAny = <T>(_value: IsAny<T> extends true ? never : T) => {
+  void _value;
+};
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedValue: z.string(),
+});
+
+class ExtendedFakeProductFactory extends FakeProductFactory<typeof ExtendedProductSchema> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+
+  public override parseProduct(context: RequestContext, data: unknown) {
+    const base = super.parseProduct(context, data);
+    return this.productSchema.parse({
+      ...base,
+      extendedValue: 'from-fake-factory',
+    });
+  }
+}
+
+const config = {
+  jitter: {
+    mean: 0,
+    deviation: 0,
+  },
+  seeds: {
+    product: 1,
+    search: 1,
+    category: 1,
+  },
+} satisfies FakeConfiguration;
+
+const client = new ClientBuilder(createInitialRequestContext())
+  .withCache(new NoOpCache())
+  .withCapability(
+    withFakeCapabilities(config, {
+      product: {
+        enabled: true,
+        factory: new ExtendedFakeProductFactory(),
+      },
+    }),
+  )
+  .build();
+
+client.product
+  .getById({
+    identifier: { key: 'example-product-id' },
+  })
+  .then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      assertNotAny(result.value);
+      assertNotAny(result.value.extendedValue);
+      assertType<string>(result.value.extendedValue);
+    }
+  });

package/{providers/fake/src/test/order-search.provider.spec.ts → packages/fake/src/test/order-search.capability.spec.ts}

@@ -1,29 +1,26 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
-  CartSchema,
-  IdentitySchema,
   NoOpCache,
+  OrderSearchResultSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeCartProvider } from '../providers/cart.provider.js';
-import { FakeIdentityProvider } from '../providers/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
-import { FakeOrderProvider } from '../providers/order.provider.js';
-import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+import { FakeOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import { FakeOrderSearchFactory } from '../factories/index.js';
 
 describe('Fake Order Search Provider', () => {
-  let provider: FakeOrderSearchProvider;
+  let provider: FakeOrderSearchCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeOrderSearchProvider(
+    provider = new FakeOrderSearchCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeOrderSearchFactory(OrderSearchResultSchema),
     );
   });
 

package/{providers/fake/src/test/order.provider.spec.ts → packages/fake/src/test/order.capability.spec.ts}

@@ -1,28 +1,26 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
-  CartSchema,
-  IdentitySchema,
   NoOpCache,
+  OrderSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeCartProvider } from '../providers/cart.provider.js';
-import { FakeIdentityProvider } from '../providers/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
-import { FakeOrderProvider } from '../providers/order.provider.js';
+import { FakeOrderCapability } from '../capabilities/order.capability.js';
+import { FakeOrderFactory } from '../factories/index.js';
 
 describe('Fake Order Provider', () => {
-  let provider: FakeOrderProvider;
+  let provider: FakeOrderCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeOrderProvider(
+    provider = new FakeOrderCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeOrderFactory(OrderSchema),
     );
   });
 

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

@@ -6,7 +6,8 @@ import {
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakePriceProvider } from '../providers/price.provider.js';
+import { FakePriceCapability } from '../capabilities/price.capability.js';
+import { FakePriceFactory } from '../factories/index.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 const testData = {
@@ -15,15 +16,16 @@ const testData = {
 };
 
 describe('Fake Price Provider', () => {
-  let provider: FakePriceProvider;
+  let provider: FakePriceCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakePriceProvider(
+    provider = new FakePriceCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakePriceFactory(PriceSchema),
     );
   });
 

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

@@ -1,18 +1,24 @@
 import 'dotenv/config';
 
 import type { RequestContext } from '@reactionary/core';
-import { createInitialRequestContext, MemoryCache } from '@reactionary/core';
+import { createInitialRequestContext, MemoryCache, ProductSchema } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeProductProvider } from '../providers/index.js';
+import { FakeProductCapability } from '../capabilities/index.js';
+import { FakeProductFactory } from '../factories/index.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 describe('Fake Product Provider', () => {
-  let provider: FakeProductProvider;
+  let provider: FakeProductCapability;
   let reqCtx: RequestContext;
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeProductProvider(getFakerTestConfiguration(),  new MemoryCache(), reqCtx);
+    provider = new FakeProductCapability(
+      getFakerTestConfiguration(),
+      new MemoryCache(),
+      reqCtx,
+      new FakeProductFactory(ProductSchema),
+    );
   })
 
   it('should cache repeat product lookups by id', async () => {

package/{providers/fake/src/test/profile.provider.spec.ts → packages/fake/src/test/profile.capability.spec.ts}

@@ -1,20 +1,22 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
-import { NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import { NoOpCache, ProfileSchema, createInitialRequestContext } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
-import { FakeProfileProvider } from '../providers/profile.provider.js';
+import { FakeProfileCapability } from '../capabilities/profile.capability.js';
+import { FakeProfileFactory } from '../factories/index.js';
 
 describe('Fake Profile Provider', () => {
-  let provider: FakeProfileProvider;
+  let provider: FakeProfileCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeProfileProvider(
+    provider = new FakeProfileCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeProfileFactory(ProfileSchema),
     );
   });
 

package/{providers/commercetools → packages/fake}/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "NodeNext",
+    "module": "nodenext",
     "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,

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

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