@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc10

package/lib/services/verifyQuotation.d.ts

@@ -0,0 +1,6 @@
+import { Quotation } from '@unchainedshop/core-quotations';
+import { Modules } from '../modules.js';
+export declare function verifyQuotationService(this: Modules, quotation: Quotation, { quotationContext }: {
+    quotationContext?: any;
+}): Promise<any>;
+//# sourceMappingURL=verifyQuotation.d.ts.map

package/lib/services/verifyQuotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyQuotation.d.ts","sourceRoot":"","sources":["../../src/services/verifyQuotation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAmB,MAAM,gCAAgC,CAAC;AAE5E,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,SAAS,EACpB,EAAE,gBAAgB,EAAE,EAAE;IAAE,gBAAgB,CAAC,EAAE,GAAG,CAAA;CAAE,gBAUjD"}

package/lib/services/verifyQuotation.js

@@ -0,0 +1,12 @@
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { processQuotationService } from './processQuotation.js';
+export async function verifyQuotationService(quotation, { quotationContext }) {
+    if (quotation.status !== QuotationStatus.REQUESTED)
+        return quotation;
+    const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+        status: QuotationStatus.PROCESSING,
+        info: 'verified elligibility manually',
+    });
+    return await processQuotationService.bind(this)(updatedQuotation, { quotationContext });
+}
+//# sourceMappingURL=verifyQuotation.js.map

package/lib/services/verifyQuotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyQuotation.js","sourceRoot":"","sources":["../../src/services/verifyQuotation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAE1C,SAAoB,EACpB,EAAE,gBAAgB,EAA8B;IAEhD,IAAI,SAAS,CAAC,MAAM,KAAK,eAAe,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IAErE,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE;QACzE,MAAM,EAAE,eAAe,CAAC,UAAU;QAClC,IAAI,EAAE,gCAAgC;KACvC,CAAC,CAAC;IAEH,OAAO,MAAM,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,gBAAgB,EAAE,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1F,CAAC"}

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@unchainedshop/core",
-  "version": "3.0.0-alpha7",
+  "version": "3.0.0-rc10",
   "main": "lib/core-index.js",
-  "exports": {
-    ".": "./lib/core-index.js",
-    "./*": "./lib/*"
-  },
   "types": "lib/core-index.d.ts",
   "type": "module",
   "scripts": {
-    "clean": "rm -rf lib",
-    "prepublishOnly": "npm run clean && tsc",
+    "clean": "tsc -b --clean",
+    "build": "tsc -b",
+    "prepublishOnly": "npm run clean && npm run build",
     "watch": "tsc -w ",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
     "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
@@ -24,37 +21,41 @@
     "ecommerce",
     "core"
   ],
-  "author": "Joël Meiller",
+  "authors": [
+    "Joël Meiller",
+    "Pascal Kaufmann"
+  ],
   "license": "EUPL-1.2",
   "bugs": {
     "url": "https://github.com/unchainedshop/unchained/issues"
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/core-assortments": "^3.0.0-alpha4",
-    "@unchainedshop/core-bookmarks": "^3.0.0-alpha4",
-    "@unchainedshop/core-countries": "^3.0.0-alpha4",
-    "@unchainedshop/core-currencies": "^3.0.0-alpha4",
-    "@unchainedshop/core-delivery": "^3.0.0-alpha4",
-    "@unchainedshop/core-enrollments": "^3.0.0-alpha4",
-    "@unchainedshop/core-events": "^3.0.0-alpha4",
-    "@unchainedshop/core-files": "^3.0.0-alpha4",
-    "@unchainedshop/core-filters": "^3.0.0-alpha4",
-    "@unchainedshop/core-languages": "^3.0.0-alpha4",
-    "@unchainedshop/core-messaging": "^3.0.0-alpha4",
-    "@unchainedshop/core-orders": "^3.0.0-alpha4",
-    "@unchainedshop/core-payment": "^3.0.0-alpha4",
-    "@unchainedshop/core-products": "^3.0.0-alpha4",
-    "@unchainedshop/core-quotations": "^3.0.0-alpha4",
-    "@unchainedshop/core-users": "^3.0.0-alpha4",
-    "@unchainedshop/core-warehousing": "^3.0.0-alpha4",
-    "@unchainedshop/core-worker": "^3.0.0-alpha4",
-    "@unchainedshop/logger": "^3.0.0-alpha4"
+    "@breejs/later": "^4.2.0",
+    "@unchainedshop/core-assortments": "^3.0.0-rc10",
+    "@unchainedshop/core-bookmarks": "^3.0.0-rc10",
+    "@unchainedshop/core-countries": "^3.0.0-rc10",
+    "@unchainedshop/core-currencies": "^3.0.0-rc10",
+    "@unchainedshop/core-delivery": "^3.0.0-rc10",
+    "@unchainedshop/core-enrollments": "^3.0.0-rc10",
+    "@unchainedshop/core-events": "^3.0.0-rc10",
+    "@unchainedshop/core-files": "^3.0.0-rc10",
+    "@unchainedshop/core-filters": "^3.0.0-rc10",
+    "@unchainedshop/core-languages": "^3.0.0-rc10",
+    "@unchainedshop/core-orders": "^3.0.0-rc10",
+    "@unchainedshop/core-payment": "^3.0.0-rc10",
+    "@unchainedshop/core-products": "^3.0.0-rc10",
+    "@unchainedshop/core-quotations": "^3.0.0-rc10",
+    "@unchainedshop/core-users": "^3.0.0-rc10",
+    "@unchainedshop/core-warehousing": "^3.0.0-rc10",
+    "@unchainedshop/core-worker": "^3.0.0-rc10",
+    "@unchainedshop/logger": "^3.0.0-rc10",
+    "@unchainedshop/utils": "^3.0.0-rc10"
   },
   "devDependencies": {
-    "@types/node": "^22.8.1",
+    "@types/node": "^22.10.2",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   }
 }

package/src/core-index.ts

@@ -1,91 +1,12 @@
-import { BulkImporter } from './types.js';
-import {
-  AssortmentsModule,
-  AssortmentsSettingsOptions,
-  configureAssortmentsModule,
-} from '@unchainedshop/core-assortments';
-import {
-  BookmarkServices,
-  bookmarkServices,
-  BookmarksModule,
-  configureBookmarksModule,
-} from '@unchainedshop/core-bookmarks';
-import { configureCountriesModule, CountriesModule } from '@unchainedshop/core-countries';
-import { configureCurrenciesModule, CurrenciesModule } from '@unchainedshop/core-currencies';
-import {
-  configureDeliveryModule,
-  DeliveryModule,
-  DeliverySettingsOptions,
-} from '@unchainedshop/core-delivery';
-import {
-  configureEnrollmentsModule,
-  EnrollmentsModule,
-  EnrollmentsSettingsOptions,
-} from '@unchainedshop/core-enrollments';
-import { configureEventsModule, EventsModule } from '@unchainedshop/core-events';
-import {
-  configureFilesModule,
-  FileServices,
-  fileServices,
-  FilesModule,
-  FilesSettingsOptions,
-} from '@unchainedshop/core-files';
-import {
-  configureFiltersModule,
-  FiltersModule,
-  FiltersSettingsOptions,
-} from '@unchainedshop/core-filters';
-import { configureLanguagesModule, LanguagesModule } from '@unchainedshop/core-languages';
-import { configureMessagingModule, MessagingModule } from '@unchainedshop/core-messaging';
-import {
-  configureOrdersModule,
-  OrderServices,
-  orderServices,
-  OrdersModule,
-  OrdersSettingsOptions,
-} from '@unchainedshop/core-orders';
-import {
-  configurePaymentModule,
-  PaymentModule,
-  PaymentSettingsOptions,
-} from '@unchainedshop/core-payment';
-import {
-  configureProductsModule,
-  ProductServices,
-  productServices,
-  ProductsModule,
-  ProductsSettingsOptions,
-} from '@unchainedshop/core-products';
-import {
-  configureQuotationsModule,
-  QuotationsModule,
-  QuotationsSettingsOptions,
-} from '@unchainedshop/core-quotations';
-import {
-  configureUsersModule,
-  UserServices,
-  userServices,
-  UserSettingsOptions,
-  UsersModule,
-} from '@unchainedshop/core-users';
-import { configureWarehousingModule, WarehousingModule } from '@unchainedshop/core-warehousing';
-import { configureWorkerModule, WorkerModule, WorkerSettingsOptions } from '@unchainedshop/core-worker';
 import { mongodb, MigrationRepository, ModuleInput } from '@unchainedshop/mongodb';
+import initServices, { Services } from './services/index.js';
+import initModules, { Modules, ModuleOptions } from './modules.js';
 
-export * from './types.js';
+export * from './services/index.js';
+export * from './directors/index.js';
 
-export interface ModuleOptions {
-  assortments?: AssortmentsSettingsOptions;
-  products?: ProductsSettingsOptions;
-  delivery?: DeliverySettingsOptions;
-  filters?: FiltersSettingsOptions;
-  enrollments?: EnrollmentsSettingsOptions;
-  orders?: OrdersSettingsOptions;
-  quotations?: QuotationsSettingsOptions;
-  files?: FilesSettingsOptions;
-  payment?: PaymentSettingsOptions;
-  worker?: WorkerSettingsOptions;
-  users?: UserSettingsOptions;
+export interface BulkImporter {
+  createBulkImporter: (options: any) => any;
 }
 
 export interface UnchainedCoreOptions {
@@ -98,39 +19,10 @@ export interface UnchainedCoreOptions {
       configure: (params: ModuleInput<any>) => any;
     }
   >;
-  services?: Record<string, any>;
+  services?: Record<string, (this: Modules, ...args) => any>;
   options?: ModuleOptions;
 }
 
-export interface Modules {
-  assortments: AssortmentsModule;
-  bookmarks: BookmarksModule;
-  countries: CountriesModule;
-  currencies: CurrenciesModule;
-  delivery: DeliveryModule;
-  enrollments: EnrollmentsModule;
-  events: EventsModule;
-  files: FilesModule;
-  filters: FiltersModule;
-  languages: LanguagesModule;
-  messaging: MessagingModule;
-  orders: OrdersModule;
-  payment: PaymentModule;
-  products: ProductsModule;
-  quotations: QuotationsModule;
-  users: UsersModule;
-  warehousing: WarehousingModule;
-  worker: WorkerModule;
-}
-
-export interface Services {
-  bookmarks: BookmarkServices;
-  files: FileServices;
-  orders: OrderServices;
-  products: ProductServices;
-  users: UserServices;
-}
-
 export interface UnchainedCore {
   modules: Modules;
   services: Services;
@@ -142,137 +34,18 @@ export const initCore = async ({
   db,
   migrationRepository,
   bulkImporter,
-  modules = {},
-  services = {},
+  modules: customModules = {},
+  services: customServices = {},
   options = {},
 }: UnchainedCoreOptions): Promise<UnchainedCore> => {
-  const assortments = await configureAssortmentsModule({
-    db,
-    options: options.assortments,
-    migrationRepository,
-  });
-  const bookmarks = await configureBookmarksModule({
-    db,
-    migrationRepository,
-  });
-  const countries = await configureCountriesModule({
-    db,
-    migrationRepository,
-  });
-  const currencies = await configureCurrenciesModule({
-    db,
-    migrationRepository,
-  });
-  const delivery = await configureDeliveryModule({
-    db,
-    options: options.delivery,
-    migrationRepository,
-  });
-  const enrollments = await configureEnrollmentsModule({
-    db,
-    options: options.enrollments,
-    migrationRepository,
-  });
-  const events = await configureEventsModule({
-    db,
-    migrationRepository,
-  });
-  const files = await configureFilesModule({
-    db,
-    options: options.files,
-    migrationRepository,
-  });
-  const filters = await configureFiltersModule({
-    db,
-    options: options.filters,
-    migrationRepository,
-  });
-  const languages = await configureLanguagesModule({
-    db,
-    migrationRepository,
-  });
-  const messaging = await configureMessagingModule({
-    db,
-    migrationRepository,
-  });
-  const orders = await configureOrdersModule({
-    db,
-    options: options.orders,
-    migrationRepository,
-  });
-  const payment = await configurePaymentModule({
-    db,
-    options: options.payment,
-    migrationRepository,
-  });
-  const products = await configureProductsModule({
-    db,
-    migrationRepository,
-  });
-  const quotations = await configureQuotationsModule({
-    db,
-    options: options.quotations,
-    migrationRepository,
-  });
-  const users = await configureUsersModule({
-    db,
-    migrationRepository,
-  });
-  const warehousing = await configureWarehousingModule({
-    db,
-    migrationRepository,
-  });
-  const worker = await configureWorkerModule({
-    db,
-    options: options.worker,
-    migrationRepository,
-  });
-
   // Configure custom modules
-  const customModules = await Object.entries(modules).reduce(
-    async (modulesPromise, [key, customModule]: any) => {
-      return {
-        ...(await modulesPromise),
-        [key]: await customModule.configure({
-          db,
-          options: options?.[key],
-          migrationRepository,
-        }),
-      };
-    },
-    Promise.resolve({}),
-  );
+
+  const modules = await initModules({ db, migrationRepository, options }, customModules);
+  const services = initServices(modules, customServices);
 
   return {
-    modules: {
-      assortments,
-      bookmarks,
-      countries,
-      currencies,
-      delivery,
-      enrollments,
-      events,
-      files,
-      filters,
-      languages,
-      messaging,
-      orders,
-      payment,
-      products,
-      quotations,
-      users,
-      warehousing,
-      worker,
-      ...customModules,
-    },
-    services: {
-      bookmarks: bookmarkServices,
-      files: fileServices,
-      orders: orderServices,
-      products: productServices,
-      users: userServices,
-      ...services,
-    },
+    modules,
+    services,
     bulkImporter,
     options,
   };

package/src/directors/BaseDiscountAdapter.test.ts

@@ -0,0 +1,49 @@
+import { BaseDiscountAdapter } from './BaseDiscountAdapter.js';
+
+describe('BaseDiscountAdapter instantiation', () => {
+  const adapter = BaseDiscountAdapter;
+  const context = null as any;
+  it('should initialize with default values', async () => {
+    expect(adapter.orderIndex).toEqual(0);
+    expect(adapter.log).toEqual(expect.any(Function));
+    expect(await adapter.isManualAdditionAllowed('')).toEqual(false);
+    expect(await adapter.isManualRemovalAllowed()).toEqual(false);
+    expect(await adapter.actions(context)).toEqual({
+      isValidForSystemTriggering: expect.any(Function),
+      reserve: expect.any(Function),
+      release: expect.any(Function),
+      isValidForCodeTriggering: expect.any(Function),
+      discountForPricingAdapterKey: expect.any(Function),
+    });
+  });
+
+  describe('actions', () => {
+    it('isValidForSystemTriggering', async () => {
+      const result = await adapter.actions(context);
+      expect(await result.isValidForSystemTriggering()).toEqual(false);
+    });
+
+    it('reserve', async () => {
+      const result = await adapter.actions(context);
+      expect(await result.reserve({ code: '' })).toEqual({});
+    });
+
+    it('release', async () => {
+      const result = await adapter.actions(context);
+      expect(await result.release()).toEqual(null);
+    });
+
+    it('isValidForCodeTriggering', async () => {
+      const result = await adapter.actions(context);
+      expect(await result.isValidForCodeTriggering({ code: '' })).toEqual(false);
+    });
+
+    it('discountForPricingAdapterKey', async () => {
+      const result = await adapter.actions(context);
+      const calculationSheet = {};
+      expect(
+        await result.discountForPricingAdapterKey({ calculationSheet, pricingAdapterKey: 'key' } as any),
+      ).toEqual(null);
+    });
+  });
+});

package/src/directors/BaseDiscountAdapter.ts

@@ -0,0 +1,90 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { IPricingSheet } from './BasePricingSheet.js';
+import { PricingCalculation } from '@unchainedshop/utils';
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+export interface DiscountContext {
+  code?: string;
+  orderDiscount?: OrderDiscount;
+  order?: Order;
+}
+
+export type IDiscountAdapter<DiscountConfiguration> = IBaseAdapter & {
+  orderIndex: number;
+
+  isManualAdditionAllowed: (code: string) => Promise<boolean>;
+  isManualRemovalAllowed: () => Promise<boolean>;
+
+  actions: (params: {
+    context: DiscountContext & { modules: Modules };
+  }) => Promise<DiscountAdapterActions<DiscountConfiguration>>;
+};
+
+export interface DiscountAdapterActions<DiscountConfiguration> {
+  isValidForSystemTriggering: () => Promise<boolean>;
+  isValidForCodeTriggering: (params: { code: string }) => Promise<boolean>;
+
+  discountForPricingAdapterKey: (params: {
+    pricingAdapterKey: string;
+    calculationSheet: IPricingSheet<PricingCalculation>;
+  }) => DiscountConfiguration;
+
+  reserve: (params: { code: string }) => Promise<any>;
+  release: () => Promise<void>;
+}
+
+export const BaseDiscountAdapter: Omit<IDiscountAdapter<unknown>, 'key' | 'label' | 'version'> = {
+  orderIndex: 0,
+
+  isManualAdditionAllowed: async () => {
+    return false;
+  },
+
+  // return true if a discount is allowed to get removed manually by a user
+  isManualRemovalAllowed: async () => {
+    return false;
+  },
+
+  actions: async () => ({
+    // return true if a discount is valid to be part of the order
+    // without input of a user. that could be a time based global discount
+    // like a 10% discount day
+    // if you return false, this discount will
+    // get removed from the order before any price calculation
+    // takes place.
+    // eslint-disable-next-line
+    isValidForSystemTriggering: async () => {
+      return false;
+    },
+
+    // return an arbitrary JSON serializable object with reservation data
+    // this method is called when a discount is added through a manual code and let's
+    // you manually deduct expendable discounts (coupon balances for ex.) before checkout
+    reserve: async () => {
+      return {};
+    },
+
+    // return void, allows you to free up any reservations in backend systems
+    release: async () => {
+      return null;
+    },
+
+    // return true if a discount is valid to be part of the order.
+    // if you return false, this discount will
+    // get removed from the order before any price calculation
+    // takes place.
+    isValidForCodeTriggering: async () => {
+      return false;
+    },
+
+    // returns the appropriate discount context for a calculation adapter
+    discountForPricingAdapterKey() {
+      return null;
+    },
+  }),
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/BaseDiscountDirector.ts

@@ -0,0 +1,73 @@
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import { DiscountContext, IDiscountAdapter } from './BaseDiscountAdapter.js';
+import { Modules } from '../modules.js';
+
+export type IDiscountDirector<DiscountConfiguration> = IBaseDirector<
+  IDiscountAdapter<DiscountConfiguration>
+> & {
+  actions: (
+    discountContext: DiscountContext,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<{
+    resolveDiscountAdapterFromStaticCode: (params: {
+      code: string;
+    }) => Promise<IDiscountAdapter<DiscountConfiguration>>;
+    findSystemDiscounts: () => Promise<Array<string>>;
+  }>;
+};
+
+export const BaseDiscountDirector = <DiscountConfigurationType>(
+  directorName: string,
+): IDiscountDirector<DiscountConfigurationType> => {
+  const baseDirector = BaseDirector<IDiscountAdapter<DiscountConfigurationType>>(directorName, {
+    adapterSortKey: 'orderIndex',
+  });
+
+  return {
+    ...baseDirector,
+
+    actions: async (discountContext, unchainedAPI) => {
+      const context = { ...discountContext, ...unchainedAPI };
+
+      return {
+        resolveDiscountAdapterFromStaticCode: async (options) => {
+          if (!context.order) return null;
+
+          const discounts = await Promise.all(
+            baseDirector
+              .getAdapters()
+              .filter((Adapter) => Adapter.isManualAdditionAllowed(options?.code))
+              .map(async (Adapter) => {
+                const adapter = await Adapter.actions({ context });
+                return {
+                  Adapter,
+                  isValid: await adapter.isValidForCodeTriggering(options),
+                };
+              }),
+          );
+
+          return discounts.find(({ isValid }) => isValid === true)?.Adapter;
+        },
+
+        async findSystemDiscounts() {
+          if (!context.order) return [];
+          const discounts = await Promise.all(
+            baseDirector.getAdapters().map(async (Adapter) => {
+              const adapter = await Adapter.actions({ context });
+              return {
+                key: Adapter.key,
+                isValid: await adapter.isValidForSystemTriggering(),
+              };
+            }),
+          );
+
+          const validDiscounts = discounts
+            .filter(({ isValid }) => isValid === true)
+            .map(({ key }) => key);
+
+          return validDiscounts;
+        },
+      };
+    },
+  };
+};

package/src/directors/BasePricingAdapter.ts

@@ -0,0 +1,80 @@
+import { createLogger } from '@unchainedshop/logger';
+import { IPricingSheet } from './BasePricingSheet.js';
+import { IBaseAdapter, PricingCalculation } from '@unchainedshop/utils';
+import { Discount } from './BasePricingDirector.js';
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+
+const logger = createLogger('unchained:core');
+
+interface IDiscountableItem {
+  _id?: string;
+  orderId?: string;
+}
+
+export interface BasePricingAdapterContext {
+  order?: Order;
+  discounts: Array<OrderDiscount>;
+}
+
+export type BasePricingContext =
+  | {
+      order?: Order;
+      discounts?: Array<OrderDiscount>;
+    }
+  | {
+      item: IDiscountableItem;
+    };
+
+export interface IPricingAdapterActions<
+  Calculation extends PricingCalculation,
+  Sheet extends IPricingSheet<Calculation>,
+> {
+  calculate: () => Promise<Array<Calculation>>;
+  resultSheet: () => Sheet;
+}
+
+export type IPricingAdapter<
+  PricingAdapterContext extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+  Sheet extends IPricingSheet<Calculation>,
+  DiscountConfiguration = unknown,
+> = IBaseAdapter & {
+  orderIndex: number;
+
+  isActivatedFor: (context: PricingAdapterContext) => boolean;
+
+  actions: (params: {
+    context: PricingAdapterContext;
+    calculationSheet: Sheet;
+    discounts: Array<Discount<DiscountConfiguration>>;
+  }) => IPricingAdapterActions<Calculation, Sheet>;
+};
+
+export const BasePricingAdapter = <
+  PricingAdapterContext extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+>(): IPricingAdapter<PricingAdapterContext, Calculation, IPricingSheet<Calculation>> => ({
+  key: '',
+  label: '',
+  version: '',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: () => {
+    return {
+      calculate: async () => {
+        throw new Error('Method not implemented.');
+      },
+      resultSheet: () => {
+        throw new Error('Method not implemented.');
+      }, // abstract
+    };
+  },
+
+  log(message: string, options) {
+    return logger.debug(message, options);
+  },
+});