@reactionary/source 0.0.48 → 0.0.52

package/providers/commercetools/src/test/checkout.provider.spec.ts

@@ -0,0 +1,312 @@
+import 'dotenv/config';
+import type { Cart, Checkout, RequestContext } from '@reactionary/core';
+import {
+  CartSchema,
+  CheckoutSchema,
+  IdentitySchema,
+  NoOpCache,
+  PaymentInstructionSchema,
+  ShippingInstructionSchema,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import { CommercetoolsCartProvider } from '../providers/cart.provider.js';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
+import { CommercetoolsCheckoutProvider } from '../providers/checkout.provider.js';
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01',
+};
+
+describe('Commercetools Checkout Provider', () => {
+  let provider: CommercetoolsCheckoutProvider;
+  let cartProvider: CommercetoolsCartProvider;
+  let identityProvider: CommercetoolsIdentityProvider;
+  let reqCtx: RequestContext;
+
+  beforeAll(() => {
+    provider = new CommercetoolsCheckoutProvider(
+      getCommercetoolsTestConfiguration(),
+      CheckoutSchema,
+      new NoOpCache()
+    );
+    cartProvider = new CommercetoolsCartProvider(
+      getCommercetoolsTestConfiguration(),
+      CartSchema,
+      new NoOpCache()
+    );
+    identityProvider = new CommercetoolsIdentityProvider(
+      getCommercetoolsTestConfiguration(),
+      IdentitySchema,
+      new NoOpCache()
+    );
+  });
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+  });
+
+  describe('anonymous sessions', () => {
+    let cart: Cart;
+
+    beforeEach(async () => {
+      cart = await cartProvider.add(
+        {
+          cart: { key: '', version: 0 },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1,
+        },
+        reqCtx
+      );
+    });
+
+    it('can create a checkout session from a cart', async () => {
+      //  we have either an anonymous user, or an authenticated user.
+      // if it is anonymous, we assume you will have collected some basic info by now ?
+
+      const checkout = await provider.initiateCheckoutForCart(
+        {
+          cart: cart.identifier,
+          billingAddress: {
+            countryCode: 'US',
+            firstName: 'John',
+            lastName: 'Doe',
+            streetAddress: '123 Main St',
+            streetNumber: '1A',
+            postalCode: '12345',
+            city: 'Anytown',
+            region: '',
+          },
+          notificationEmail: 'sample@example.com',
+          notificationPhone: '+4512345678',
+        },
+        reqCtx
+      );
+
+      expect(checkout.identifier.key).toBeDefined();
+      expect(checkout.originalCartReference.key).toBe(cart.identifier.key);
+      expect(checkout.billingAddress?.firstName).toBe('John');
+      expect(checkout.items.length).toBe(1);
+      expect(checkout.items[0].sku.key).toBe(testData.skuWithoutTiers);
+    });
+
+    describe('checkout actions', () => {
+      let checkout: Checkout;
+      beforeEach(async () => {
+        checkout = await provider.initiateCheckoutForCart(
+          {
+            cart: cart.identifier,
+            billingAddress: {
+              countryCode: 'US',
+              firstName: 'John',
+              lastName: 'Doe',
+              streetAddress: '123 Main St',
+              streetNumber: '1A',
+              postalCode: '12345',
+              city: 'Anytown',
+              region: '',
+            },
+            notificationEmail: 'sample@example.com',
+            notificationPhone: '+4512345678',
+          },
+          reqCtx
+        );
+      });
+
+      it('can list payment methods', async () => {
+        const paymentMethods = await provider.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        expect(paymentMethods.length).toBeGreaterThan(0);
+        expect(
+          paymentMethods.find((x) => x.identifier.method === 'stripe')
+        ).toBeDefined();
+      });
+
+      it('can list shipping methods', async () => {
+        const shippingMethods = await provider.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        expect(shippingMethods.length).toBeGreaterThan(0);
+        expect(
+          shippingMethods.find((x) => x.identifier.key === 'us-delivery')
+        ).toBeDefined();
+      });
+
+      it('can add a payment instruction', async () => {
+        const paymentMethods = await provider.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await provider.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: PaymentInstructionSchema.parse({
+              paymentMethod: pm?.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            }),
+          },
+          reqCtx
+        );
+
+        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+        expect(checkoutWithPi.paymentInstructions[0].paymentMethod.method).toBe(
+          'stripe'
+        );
+        expect(checkoutWithPi.paymentInstructions[0].protocolData.find(x => x.key === 'stripe_clientSecret')?.value).toBeDefined();
+
+      });
+
+      xit('can cancel an in-progress payment', async () => {
+        const paymentMethods = await provider.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await provider.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: PaymentInstructionSchema.parse({
+              paymentMethod: pm?.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            }),
+          },
+          reqCtx
+        );
+
+        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+
+        const checkoutAfterCancel = await provider.removePaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction:
+              checkoutWithPi.paymentInstructions[0].identifier,
+          },
+          reqCtx
+        );
+
+        expect(checkoutAfterCancel.paymentInstructions.length).toBe(0);
+      });
+
+      it('can set shipping address', async () => {
+        const checkoutWithShipping = await provider.setShippingAddress(
+          {
+            checkout: checkout.identifier,
+            shippingAddress: {
+              countryCode: 'US',
+              firstName: 'Jane',
+              lastName: 'Doe',
+              streetAddress: '456 Other St',
+              streetNumber: '2B',
+              postalCode: '54321',
+              city: 'Othertown',
+              region: '',
+            },
+          },
+          reqCtx
+        );
+
+        expect(checkoutWithShipping.shippingAddress).toBeDefined();
+        expect(checkoutWithShipping.shippingAddress?.firstName).toBe('Jane');
+      });
+
+      it('can set shipping instructions', async () => {
+        const shippingMethods = await provider.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        const sm = shippingMethods.find((x) => x.identifier.key === 'us-delivery');
+        expect(sm).toBeDefined();
+
+        const shippingInstruction = ShippingInstructionSchema.parse({
+          shippingMethod: sm?.identifier || { key: '' },
+          amount: checkout.price.totalShipping,
+          instructions: 'Leave at front door if not home',
+          consentForUnattendedDelivery: true,
+          pickupPoint: '4190asx141', // this would be a real pickup point ID in a real scenario
+        });
+
+        const checkoutWithShipping = await provider.setShippingInstruction(
+          {
+            checkout: checkout.identifier,
+            shippingInstruction,
+          },
+          reqCtx
+        );
+
+        expect(checkout.price.totalShipping.value).toBe(0);
+        expect(checkoutWithShipping.price.totalShipping.value).toBeGreaterThan(0);
+        expect(checkoutWithShipping.shippingInstruction).toBeDefined();
+        expect(
+          checkoutWithShipping.shippingInstruction?.shippingMethod.key
+        ).toBe('us-delivery');
+        expect(checkoutWithShipping.shippingInstruction?.instructions).toBe(
+          'Leave at front door if not home'
+        );
+        expect(checkoutWithShipping.shippingInstruction?.pickupPoint).toBe(
+          '4190asx141'
+        );
+        expect(
+          checkoutWithShipping.shippingInstruction?.consentForUnattendedDelivery
+        ).toBe(true);
+      });
+
+      xit('wont report it finalizable until everything is paid/authorized', async () => {
+        expect(checkout.readyForFinalization).toBe(false);
+        const pm = (
+          await provider.getAvailablePaymentMethods(
+            {
+              checkout: checkout.identifier,
+            },
+            reqCtx
+          )
+        ).find((x) => x.identifier.method === 'stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await provider.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: PaymentInstructionSchema.parse({
+              paymentMethod: pm?.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            }),
+          },
+          reqCtx
+        );
+
+        // do something to simulate payment authorization ?
+        const checkoutReady = await provider.getById(
+          { identifier: checkoutWithPi.identifier },
+          reqCtx
+        );
+        if (!checkoutReady) {
+          fail('checkout not found');
+        }
+        expect(checkoutReady.readyForFinalization).toBe(true);
+      });
+    });
+  });
+});

package/providers/commercetools/src/test/identity.provider.spec.ts

@@ -6,9 +6,9 @@ import {
   NoOpCache,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
-import { CommercetoolsCartProvider } from '../providers/cart.provider';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
+import { CommercetoolsCartProvider } from '../providers/cart.provider.js';
 
 describe('Commercetools Identity Provider', () => {
   let provider: CommercetoolsIdentityProvider;

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

@@ -5,8 +5,8 @@ import {
   NoOpCache,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsInventoryProvider } from '../providers/inventory.provider';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import { CommercetoolsInventoryProvider } from '../providers/inventory.provider.js';
 
 describe('Commercetools Inventory Provider', () => {
   let provider: CommercetoolsInventoryProvider;

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

@@ -2,10 +2,10 @@ import 'dotenv/config';
 
 
 import type { RequestContext} from '@reactionary/core';
-import { NoOpCache, PriceSchema, Session, createInitialRequestContext,} from '@reactionary/core';
-import {   getCommercetoolsTestConfiguration } from './test-utils';
+import { NoOpCache, PriceSchema, createInitialRequestContext,} from '@reactionary/core';
+import {   getCommercetoolsTestConfiguration } from './test-utils.js';
 
-import { CommercetoolsPriceProvider } from '../providers/price.provider';
+import { CommercetoolsPriceProvider } from '../providers/price.provider.js';
 
 const testData = {
   skuWithoutTiers: 'SGB-01',
@@ -39,7 +39,7 @@ describe('Commercetools Price Provider', () => {
     }
   });
 
-  it('should be able to get prices for a product with tiers', async () => {
+  xit('should be able to get prices for a product with tiers', async () => {
     const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, reqCtx);
 
     expect(result).toBeTruthy();

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

@@ -1,15 +1,18 @@
 import 'dotenv/config';
 import type { RequestContext} from '@reactionary/core';
-import { NoOpCache, ProductSchema, Session, createInitialRequestContext } from '@reactionary/core';
-import { CommercetoolsProductProvider } from '../providers/product.provider';
-import {  getCommercetoolsTestConfiguration } from './test-utils';
+import { NoOpCache, ProductSchema, createInitialRequestContext } from '@reactionary/core';
+import { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import {  getCommercetoolsTestConfiguration } from './test-utils.js';
 
 const testData = {
   product : {
     id: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
     name: 'Sunnai Glass Bowl',
-    image: 'https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg'
-  }
+    image: 'https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg',
+    sku: 'SGB-01',
+
+  },
+
 }
 
 describe('Commercetools Product Provider', () => {
@@ -48,12 +51,26 @@ describe('Commercetools Product Provider', () => {
     }
   });
 
+  it('should be able to get a product by sku', async () => {
+    const result = await provider.getBySKU( { sku: { key: testData.product.sku } }, reqCtx);
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.meta.placeholder).toBe(false);
+      expect(result.identifier.key).toBe(testData.product.id);
+      expect(result.name).toBe(testData.product.name);
+      expect(result.image).toBe(testData.product.image);
+    }
+  });
+
   it('should return null for unknown slug', async () => {
     const result = await provider.getBySlug( { slug: 'unknown-slug' }, reqCtx);
 
     expect(result).toBeNull();
   });
 
+
+
   it('should return a placeholder product for unknown id', async () => {
     const result = await provider.getById( { id: 'unknown-id' }, reqCtx);
 

package/providers/commercetools/src/test/profile.provider.spec.ts

@@ -6,9 +6,9 @@ import {
   ProfileSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsProfileProvider } from '../providers/profile.provider';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import { CommercetoolsProfileProvider } from '../providers/profile.provider.js';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
 
 describe('Commercetools Profile Provider', () => {
   let provider: CommercetoolsProfileProvider;

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

@@ -1,8 +1,8 @@
 import 'dotenv/config';
 import type { RequestContext} from '@reactionary/core';
 import { NoOpCache, SearchResultSchema, createInitialRequestContext } from '@reactionary/core';
-import { CommercetoolsSearchProvider } from '../providers/search.provider';
-import { getCommercetoolsTestConfiguration } from './test-utils';
+import { CommercetoolsSearchProvider } from '../providers/search.provider.js';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
 
 const testData = {
   searchTerm: 'bowl'

package/providers/commercetools/src/test/store.provider.spec.ts

@@ -5,8 +5,8 @@ import {
   StoreSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsStoreProvider } from '../providers/store.provider';
+import { getCommercetoolsTestConfiguration } from './test-utils.js';
+import { CommercetoolsStoreProvider } from '../providers/store.provider.js';
 
 describe('Commercetools Store Provider', () => {
   let provider: CommercetoolsStoreProvider;

package/providers/commercetools/src/test/test-utils.ts

@@ -1,3 +1,6 @@
+import { PaymentMethodSchema } from '@reactionary/core';
+import { PaymentMethodIdentifierSchema } from '@reactionary/core';
+
 export function getCommercetoolsTestConfiguration() {
   return {
         apiUrl: process.env['CTP_API_URL'] || '',
@@ -6,6 +9,17 @@ export function getCommercetoolsTestConfiguration() {
         clientSecret: process.env['CTP_CLIENT_SECRET'] || '',
         projectKey: process.env['CTP_PROJECT_KEY'] || '',
         scopes: (process.env['CTP_SCOPES'] || '').split(',').map(x => x.trim()).filter(x => x && x.length > 0),
+
+        paymentMethods: [
+          PaymentMethodSchema.parse({
+            identifier: PaymentMethodIdentifierSchema.parse({
+              paymentProvider: 'stripe',
+              method: 'stripe',
+              name: 'Stripe',
+            }),
+            description: 'Stripe payment gateway'
+          })
+        ]
     }
 }
 

package/providers/commercetools/tsconfig.json

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

package/providers/commercetools/tsconfig.spec.json

@@ -1,13 +1,14 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
     "module": "commonjs",
-    "moduleResolution": "node10",
+    "moduleResolution": "node",
+    "verbatimModuleSyntax": false,
+    "outDir": "../../dist/out-tsc",
     "types": ["jest", "node"]
   },
   "include": [
-    "jest.config.ts",
+    "jest.config.cjs",
     "src/**/*.test.ts",
     "src/**/*.spec.ts",
     "src/**/*.d.ts"

package/providers/fake/{jest.config.ts → jest.config.cjs}

@@ -1,4 +1,4 @@
-export default {
+module.exports = {
   displayName: 'provider-faker',
   preset: '../../jest.preset.js',
   testEnvironment: 'node',

package/providers/fake/package.json

@@ -5,8 +5,8 @@
   "types": "src/index.d.ts",
   "dependencies": {
     "@reactionary/core": "0.0.1",
-    "@reactionary/otel": "0.0.1",
     "zod": "4.1.9",
     "@faker-js/faker": "^9.8.0"
-  }
+  },
+  "type": "module"
 }

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

@@ -18,17 +18,17 @@ import {
   StoreSchema,
   PriceSchema,
 } from '@reactionary/core';
-import { FakeProductProvider } from '../providers/product.provider';
-import { FakeSearchProvider } from '../providers/search.provider';
-import type { FakeConfiguration } from '../schema/configuration.schema';
-import type { FakeCapabilities } from '../schema/capabilities.schema';
-import { FakeCategoryProvider } from '../providers/category.provider';
+import { FakeProductProvider } from '../providers/product.provider.js';
+import { FakeSearchProvider } from '../providers/search.provider.js';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import { FakeCategoryProvider } from '../providers/category.provider.js';
 import {
   FakeCartProvider,
   FakeInventoryProvider,
   FakePriceProvider,
   FakeStoreProvider,
-} from '../providers';
+} from '../providers/index.js';
 
 type FakeClient<T extends FakeCapabilities> = (T['cart'] extends true
   ? { cart: CartProvider }

package/providers/fake/src/index.ts

@@ -1,5 +1,5 @@
-export * from './core/initialize';
+export * from './core/initialize.js';
 
-export * from './providers/'
-export * from './schema/capabilities.schema';
-export * from './schema/configuration.schema';
+export * from './providers/index.js'
+export * from './schema/capabilities.schema.js';
+export * from './schema/configuration.schema.js';

package/providers/fake/src/providers/analytics.provider.ts

@@ -5,7 +5,7 @@ import {
   AnalyticsProvider
 } from '@reactionary/core';
 import type z from 'zod';
-import type { FakeConfiguration } from '../schema/configuration.schema';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
 
 export class FakeAnalyticsProvider<
   T extends BaseModel = BaseModel

package/providers/fake/src/providers/cart.provider.ts

@@ -4,7 +4,7 @@ import type {
   CartMutationItemAdd,
   CartMutationItemRemove,
   CartMutationItemQuantityChange,
-  Session, RequestContext,
+  RequestContext,
   Cache,
   CartIdentifier,
   CartMutationApplyCoupon,
@@ -19,7 +19,7 @@ import {
   CartProvider
 } from '@reactionary/core';
 import type z from 'zod';
-import type { FakeConfiguration } from '../schema/configuration.schema';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { Faker, en, base } from '@faker-js/faker';
 
 export class FakeCartProvider<

package/providers/fake/src/providers/category.provider.ts

@@ -1,6 +1,6 @@
 import type { Category, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext} from "@reactionary/core";
-import { CategoryProvider, Session } from "@reactionary/core";
-import type { FakeConfiguration } from "../schema/configuration.schema";
+import { CategoryProvider, Reactionary } from "@reactionary/core";
+import type { FakeConfiguration } from "../schema/configuration.schema.js";
 import type { Cache as ReactionaryCache } from "@reactionary/core";
 import type z from "zod";
 import { Faker, en, base } from '@faker-js/faker';
@@ -71,9 +71,10 @@ export class FakeCategoryProvider<
     });
   }
 
+  @Reactionary({})
   public override async getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T> {
     const category = this.allCategories.get(payload.id.key);
-    
+
     if(!category) {
       const dummyCategory = this.newModel();
       dummyCategory.meta.placeholder = true;
@@ -82,6 +83,8 @@ export class FakeCategoryProvider<
     }
     return category;
   }
+
+  @Reactionary({})
   public override getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null> {
     for(const p of this.allCategories.values()) {
       if(p.slug === payload.slug) {
@@ -91,6 +94,7 @@ export class FakeCategoryProvider<
     return Promise.resolve(null);
   }
 
+  @Reactionary({})
   public override getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]> {
     const path = new Array<T>();
     let category = this.allCategories.get(payload.id.key);

package/providers/fake/src/providers/identity.provider.ts

@@ -9,7 +9,7 @@ import {
   type IdentityMutationRegister,
 } from '@reactionary/core';
 import type z from 'zod';
-import type { FakeConfiguration } from '../schema/configuration.schema';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 
 export class FakeIdentityProvider<

package/providers/fake/src/providers/index.ts

@@ -1,9 +1,9 @@
-export * from './analytics.provider';
-export * from './cart.provider';
-export * from './category.provider';
-export * from './identity.provider';
-export * from './inventory.provider';
-export * from './price.provider';
-export * from './product.provider';
-export * from './search.provider';
-export * from './store.provider';
+export * from './analytics.provider.js';
+export * from './cart.provider.js';
+export * from './category.provider.js';
+export * from './identity.provider.js';
+export * from './inventory.provider.js';
+export * from './price.provider.js';
+export * from './product.provider.js';
+export * from './search.provider.js';
+export * from './store.provider.js';

package/providers/fake/src/providers/inventory.provider.ts

@@ -8,7 +8,7 @@ import {
   InventoryProvider
 } from '@reactionary/core';
 import type z from 'zod';
-import type { FakeConfiguration } from '../schema/configuration.schema';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import { base, en, Faker } from '@faker-js/faker';
 
 export class FakeInventoryProvider<