@unchainedshop/platform 4.3.3 → 4.4.0

package/src/context/setAccessToken.ts

@@ -1,22 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { sha256 } from '@unchainedshop/utils';
-
-export default async (
-  unchainedAPI: UnchainedCore,
-  username: string,
-  plainSecret: string,
-): Promise<void> => {
-  const secret = await sha256(`${username}:${plainSecret}`);
-
-  await unchainedAPI.modules.users.updateUser(
-    { username },
-    {
-      $set: {
-        'services.token': {
-          secret,
-        },
-      },
-    } as any,
-    {},
-  );
-};

package/src/migrations/createMigrationRunner.ts

@@ -1,65 +0,0 @@
-class MigrationError extends Error {
-  public migrationId;
-
-  public date: Date;
-
-  constructor(migrationId = null, ...params) {
-    // Pass remaining arguments (including vendor specific ones) to parent constructor
-    super(...params);
-
-    // Maintains proper stack trace for where our error was thrown (only available on V8)
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, MigrationError);
-    }
-
-    this.name = 'MigrationError';
-    this.migrationId = migrationId;
-    this.date = new Date();
-  }
-}
-
-export const createMigrationRunner = ({
-  currentId,
-  logger = console,
-  migrationRepository,
-  onMigrationComplete,
-  unchainedAPI,
-}) => ({
-  operationFactory(action) {
-    const migrationContext = { logger, unchainedAPI };
-
-    return (migration) => async () => {
-      try {
-        await migration[action](migrationContext);
-        await onMigrationComplete(migration.id, action);
-        return migration.id;
-      } catch (e) {
-        throw new MigrationError(migration.id, e.message);
-      }
-    };
-  },
-  isIdAfterCurrentId({ id }) {
-    return id > currentId;
-  },
-  migrateToLatest() {
-    return migrationRepository
-      .allMigrations()
-      .filter(this.isIdAfterCurrentId)
-      .map(this.operationFactory('up'));
-  },
-  async run() {
-    try {
-      const migrations = this.migrateToLatest();
-
-      const mostRecentId = await migrations.reduce(
-        (idPromise, migration) => Promise.resolve(idPromise).then(migration),
-        currentId,
-      );
-
-      return [mostRecentId, migrations.length];
-    } catch (e) {
-      logger.error(e.name, e);
-      return [e.migrationId, null];
-    }
-  },
-});

package/src/migrations/migrationRepository.ts

@@ -1,22 +0,0 @@
-import { mongodb, Migration, MigrationRepository } from '@unchainedshop/mongodb';
-
-export const createMigrationRepository = (db: mongodb.Db): MigrationRepository => {
-  const migrations = new Map();
-  return {
-    db,
-    migrations,
-    register: (migration: Migration) => {
-      if (migration.id < 19700000000000 || migration.id >= 100000000000000) {
-        throw new Error(
-          `Migration ID must be between 19700000000000 and 99999999999999, got ${migration.id}`,
-        );
-      }
-      migrations.set(migration.id, migration);
-    },
-    allMigrations: () => {
-      return [...migrations.values()].toSorted((left, right) => {
-        return left.id - right.id;
-      });
-    },
-  };
-};

package/src/migrations/runMigrations.ts

@@ -1,68 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-import { generateDbFilterById, MigrationRepository } from '@unchainedshop/mongodb';
-import { createMigrationRunner } from './createMigrationRunner.js';
-
-export const runMigrations = async ({
-  migrationRepository,
-  logger = createLogger('unchained:migrations'),
-  unchainedAPI,
-}: {
-  migrationRepository: MigrationRepository<UnchainedCore>;
-  logger?: any;
-  unchainedAPI: UnchainedCore;
-}) => {
-  const LastMigration = migrationRepository.db.collection<{
-    _id: string;
-    action: string;
-    category: string;
-    timestamp: Date;
-  }>('last-migration');
-
-  const findCurrentId = async () => {
-    const last = await LastMigration.findOne({ category: 'unchained' }, { sort: { _id: -1 } });
-    const id = last ? last._id : 0;
-    logger.debug(`Most recent migration id: ${id}`);
-    return id;
-  };
-
-  const onMigrationComplete = async (id: string, action: string) => {
-    await LastMigration.updateOne(
-      generateDbFilterById(id, { category: 'unchained' }),
-      {
-        $set: {
-          _id: id,
-          action,
-          category: 'unchained',
-          timestamp: new Date(),
-        },
-      },
-      {
-        upsert: true,
-      },
-    );
-    logger.info(`Migrated '${action}' to ${id}`);
-    return id;
-  };
-
-  const currentId = await findCurrentId();
-  const runner = createMigrationRunner({
-    currentId,
-    logger,
-    migrationRepository,
-    onMigrationComplete,
-    unchainedAPI,
-  });
-
-  const [lastMigrationId, operationCount] = await runner.run();
-
-  if (operationCount !== null) {
-    if (operationCount > 0) {
-      logger.info(`All ${operationCount} migrations completed with most recent id: ${lastMigrationId}`);
-    } else {
-      logger.debug(`No migrations run, already at latest id: ${currentId}`);
-    }
-  } else {
-    logger.warn(`Some migrations failed, last successful id: ${lastMigrationId}`);
-  }
-};

package/src/platform-index.ts

@@ -1,19 +0,0 @@
-export * from './startPlatform.js';
-export * from './context/index.js';
-export * from './templates/index.js';
-export * from './migrations/runMigrations.js';
-
-import { MessagingDirector, getAllAdapters } from '@unchainedshop/core';
-import { getRegisteredEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-
-export const printRuntimeConfiguration = () => {
-  const messaging = MessagingDirector.getRegisteredTemplates();
-  log(`Messaging Templates: ${messaging.length}`, { messaging });
-
-  const events = getRegisteredEvents();
-  log(`Events: ${events.length}`, { events });
-
-  const adapters = getAllAdapters().map((adapter) => adapter.asString());
-  log(`Adapters: ${adapters.length}`, { adapters });
-};

package/src/setup/setupAccounts.ts

@@ -1,11 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { subscribe } from '@unchainedshop/events';
-
-export const setupAccounts = (unchainedAPI: UnchainedCore) => {
-  subscribe('USER_ACCOUNT_ACTION', async ({ payload }: { payload: any }) => {
-    await unchainedAPI.services.worker.addMessage('ACCOUNT_ACTION', {
-      recipientEmail: payload.address,
-      ...payload,
-    });
-  });
-};

package/src/setup/setupTemplates.ts

@@ -1,67 +0,0 @@
-import { MessagingDirector, UnchainedCore } from '@unchainedshop/core';
-import { subscribe } from '@unchainedshop/events';
-import { Order, OrderStatus } from '@unchainedshop/core-orders';
-import { RawPayloadType } from '@unchainedshop/events';
-import { resolveOrderRejectionTemplate } from '../templates/resolveOrderRejectionTemplate.js';
-import { resolveAccountActionTemplate } from '../templates/resolveAccountActionTemplate.js';
-import { resolveForwardDeliveryTemplate } from '../templates/resolveForwardDeliveryTemplate.js';
-import { resolveOrderConfirmationTemplate } from '../templates/resolveOrderConfirmationTemplate.js';
-import { resolveQuotationStatusTemplate } from '../templates/resolveQuotationStatusTemplate.js';
-import { resolveEnrollmentStatusTemplate } from '../templates/resolveEnrollmentStatusTemplate.js';
-import { resolveErrorReportTemplate } from '../templates/resolveErrorReportTemplate.js';
-
-export enum MessageTypes {
-  ACCOUNT_ACTION = 'ACCOUNT_ACTION',
-  DELIVERY = 'DELIVERY',
-  ORDER_CONFIRMATION = 'ORDER_CONFIRMATION',
-  ORDER_REJECTION = 'ORDER_REJECTION',
-  QUOTATION_STATUS = 'QUOTATION_STATUS',
-  ENROLLMENT_STATUS = 'ENROLLMENT_STATUS',
-  ERROR_REPORT = 'ERROR_REPORT',
-}
-
-export const setupTemplates = (unchainedAPI: UnchainedCore) => {
-  MessagingDirector.registerTemplate(MessageTypes.ACCOUNT_ACTION, resolveAccountActionTemplate);
-  MessagingDirector.registerTemplate(MessageTypes.DELIVERY, resolveForwardDeliveryTemplate);
-  MessagingDirector.registerTemplate(MessageTypes.ORDER_CONFIRMATION, resolveOrderConfirmationTemplate);
-  MessagingDirector.registerTemplate(MessageTypes.ORDER_REJECTION, resolveOrderRejectionTemplate);
-  MessagingDirector.registerTemplate(MessageTypes.QUOTATION_STATUS, resolveQuotationStatusTemplate);
-  MessagingDirector.registerTemplate(MessageTypes.ENROLLMENT_STATUS, resolveEnrollmentStatusTemplate);
-  MessagingDirector.registerTemplate(MessageTypes.ERROR_REPORT, resolveErrorReportTemplate);
-
-  subscribe('ORDER_CHECKOUT', async ({ payload }: RawPayloadType<{ order: Order }>) => {
-    const { order } = payload;
-    const user = await unchainedAPI.modules.users.findUserById(order.userId);
-    const locale = unchainedAPI.modules.users.userLocale(user);
-
-    if (order.status === OrderStatus.PENDING) {
-      // We only send the "confirmation" when pending, else we let the other events handle it
-      await unchainedAPI.services.worker.addMessage(MessageTypes.ORDER_CONFIRMATION, {
-        locale: locale.baseName,
-        orderId: order._id,
-      });
-    }
-  });
-
-  subscribe('ORDER_CONFIRMED', async ({ payload }: RawPayloadType<{ order: Order }>) => {
-    const { order } = payload;
-    const user = await unchainedAPI.modules.users.findUserById(order.userId);
-    const locale = unchainedAPI.modules.users.userLocale(user);
-
-    await unchainedAPI.services.worker.addMessage(MessageTypes.ORDER_CONFIRMATION, {
-      locale: locale.baseName,
-      orderId: order._id,
-    });
-  });
-
-  subscribe('ORDER_REJECTED', async ({ payload }: RawPayloadType<{ order: Order }>) => {
-    const { order } = payload;
-    const user = await unchainedAPI.modules.users.findUserById(order.userId);
-    const locale = unchainedAPI.modules.users.userLocale(user);
-
-    await unchainedAPI.services.worker.addMessage(MessageTypes.ORDER_REJECTION, {
-      locale: locale.baseName,
-      orderId: order._id,
-    });
-  });
-};

package/src/setup/setupUploadHandlers.ts

@@ -1,22 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { FileDirector } from '@unchainedshop/file-upload';
-
-export const setupUploadHandlers = ({ services, modules }: UnchainedCore) => {
-  FileDirector.registerFileUploadCallback('user-avatars', async (file) => {
-    return services.users.updateUserAvatarAfterUpload({ file });
-  });
-
-  FileDirector.registerFileUploadCallback('product-media', async (file) => {
-    await modules.products.media.create({
-      productId: file.meta?.productId as string,
-      mediaId: file._id,
-    });
-  });
-
-  FileDirector.registerFileUploadCallback('assortment-media', async (file) => {
-    await modules.assortments.media.create({
-      assortmentId: file.meta?.assortmentId as string,
-      mediaId: file._id,
-    });
-  });
-};

package/src/setup/setupWorkqueue.ts

@@ -1,104 +0,0 @@
-import {
-  EventListenerWorker,
-  FailedRescheduler,
-  FailedReschedulerParams,
-  IntervalWorker,
-  IntervalWorkerParams,
-  IScheduler,
-  IWorker,
-  UnchainedCore,
-} from '@unchainedshop/core';
-import { runMigrations } from '../migrations/runMigrations.js';
-import { MigrationRepository } from '@unchainedshop/mongodb';
-import { createLogger } from '@unchainedshop/logger';
-const logger = createLogger('unchained:worker');
-
-export type WorkQueueQueueManager = IWorker<any> | IScheduler<any>;
-export interface SetupWorkqueueOptions extends IntervalWorkerParams, FailedReschedulerParams {
-  enabledQueueManagers?: WorkQueueQueueManager[];
-  invalidateProviders?: boolean;
-  providerInvalidationMaxAgeDays?: number;
-  assignCartForUsers?: boolean;
-  disableWorker?: boolean;
-  skipInvalidationOnStartup?: boolean;
-}
-
-const {
-  UNCHAINED_DISABLE_PROVIDER_INVALIDATION,
-  UNCHAINED_DISABLE_WORKER,
-  UNCHAINED_ASSIGN_CART_FOR_USERS,
-} = process.env;
-
-export const defaultQueueManagers: WorkQueueQueueManager[] = [
-  FailedRescheduler,
-  EventListenerWorker,
-  IntervalWorker,
-];
-
-export const queueWorkers: any[] = [];
-
-export async function setupWorkqueue({
-  unchainedAPI,
-  migrationRepository,
-  ...workQueueOptions
-}: {
-  unchainedAPI: UnchainedCore;
-  migrationRepository: MigrationRepository<UnchainedCore>;
-} & SetupWorkqueueOptions) {
-  if (workQueueOptions.disableWorker || UNCHAINED_DISABLE_WORKER) return;
-
-  // Run migrations
-  await runMigrations({ migrationRepository, unchainedAPI });
-
-  // Start queue managers
-  (workQueueOptions?.enabledQueueManagers || defaultQueueManagers).forEach((f) => {
-    const handler = f.actions(workQueueOptions, unchainedAPI);
-    queueWorkers.push(handler);
-    handler.start();
-  });
-
-  // Invalidate providers on carts
-  if (workQueueOptions.invalidateProviders ?? !UNCHAINED_DISABLE_PROVIDER_INVALIDATION) {
-    const orders = await unchainedAPI.modules.orders.findCartsToInvalidate(
-      workQueueOptions.providerInvalidationMaxAgeDays,
-    );
-    await Promise.allSettled(
-      orders.map(async (order) => {
-        await unchainedAPI.services.orders.updateCalculation(order._id);
-      }),
-    );
-  }
-
-  // Ensure users have carts
-  if (workQueueOptions.assignCartForUsers ?? Boolean(UNCHAINED_ASSIGN_CART_FOR_USERS)) {
-    const users = await unchainedAPI.modules.users.findUsers({});
-
-    await Promise.all(
-      users.map((user) => {
-        const locale = unchainedAPI.modules.users.userLocale(user);
-        if (!locale.region) return null;
-        return unchainedAPI.services.orders.nextUserCart({
-          user,
-          countryCode: locale.region,
-        });
-      }),
-    );
-  }
-
-  // Setup filter cache
-  if (!workQueueOptions?.skipInvalidationOnStartup) {
-    unchainedAPI.services.filters
-      .invalidateFilterCache()
-      .then(() => {
-        logger.info('Filter cache rebuilt');
-      })
-      .catch(logger.warn);
-  }
-}
-
-export function stopWorkqueue() {
-  queueWorkers.forEach((worker) => {
-    worker?.stop();
-  });
-  queueWorkers.length = 0;
-}

package/src/startPlatform.ts

@@ -1,128 +0,0 @@
-import { startAPIServer, roles, UnchainedServerOptions } from '@unchainedshop/api';
-import { initCore, UnchainedCoreOptions } from '@unchainedshop/core';
-import { initDb, mongodb, stopDb } from '@unchainedshop/mongodb';
-import { defaultLogger } from '@unchainedshop/logger';
-import { UnchainedCore } from '@unchainedshop/core';
-import { setupAccounts } from './setup/setupAccounts.js';
-import { setupUploadHandlers } from './setup/setupUploadHandlers.js';
-import { setupTemplates, MessageTypes } from './setup/setupTemplates.js';
-import { SetupWorkqueueOptions, stopWorkqueue, setupWorkqueue } from './setup/setupWorkqueue.js';
-import { createMigrationRepository } from './migrations/migrationRepository.js';
-import { IRoleOptionConfig } from '@unchainedshop/roles';
-
-export { MessageTypes };
-
-export type PlatformOptions = {
-  rolesOptions?: IRoleOptionConfig;
-  workQueueOptions?: SetupWorkqueueOptions;
-} & Omit<UnchainedCoreOptions, 'migrationRepository' | 'db'> &
-  Omit<UnchainedServerOptions, 'roles' | 'unchainedAPI'>;
-
-const REQUIRED_ENV_VARIABLES = [
-  'EMAIL_WEBSITE_NAME',
-  'EMAIL_WEBSITE_URL',
-  'EMAIL_FROM',
-  'ROOT_URL',
-  'UNCHAINED_TOKEN_SECRET',
-];
-
-const exitOnMissingEnvironmentVariables = () => {
-  const failedEnv = REQUIRED_ENV_VARIABLES.filter((key) => !process.env[key]);
-  if (failedEnv.length > 0) {
-    defaultLogger.error(`Missing required environment variables at boot time: ${failedEnv.join(', ')}`);
-    process.exit(1);
-  }
-};
-
-const existOnInvalidEnvironmentVariables = () => {
-  if ((process.env?.UNCHAINED_TOKEN_SECRET || '').length < 32) {
-    defaultLogger.error(
-      'UNCHAINED_TOKEN_SECRET must be assigned a string that has a length of 32 or greater',
-    );
-    process.exit(1);
-  }
-};
-
-export const startPlatform = async ({
-  modules,
-  services,
-  options,
-  rolesOptions,
-  bulkImporter,
-  workQueueOptions,
-  ...arbitraryAPIServerConfiguration
-}: PlatformOptions): Promise<{
-  unchainedAPI: UnchainedCore;
-  graphqlHandler: any;
-  db: mongodb.Db;
-}> => {
-  const start = performance.now();
-
-  exitOnMissingEnvironmentVariables();
-  existOnInvalidEnvironmentVariables();
-
-  const configuredRoles = roles.configureRoles(rolesOptions || {});
-
-  // Configure database
-  const db = await initDb();
-
-  // Prepare Migrations
-  const migrationRepository = createMigrationRepository(db);
-
-  // Initialise core api using the database
-  const unchainedAPI = await initCore({
-    db,
-    migrationRepository,
-    bulkImporter,
-    modules,
-    services,
-    options,
-  });
-
-  // Setup Accounts specific extensions and event handlers
-  setupAccounts(unchainedAPI);
-
-  // Setup Messaging Templates
-  setupTemplates(unchainedAPI);
-
-  // Setup File Upload Handlers
-  setupUploadHandlers(unchainedAPI);
-
-  // Start GraphQL Server
-  const graphqlHandler = await startAPIServer({
-    unchainedAPI,
-    roles: configuredRoles,
-    ...arbitraryAPIServerConfiguration,
-  });
-
-  // Setup Work Queue
-  await setupWorkqueue({
-    unchainedAPI,
-    migrationRepository,
-    ...workQueueOptions,
-  });
-
-  const { default: packageJson } = await import(`${import.meta.dirname}/../package.json`, {
-    with: { type: 'json' },
-  });
-  defaultLogger.info(`Unchained Engine running`, { version: packageJson.version });
-
-  const cleanup = (signal) => async () => {
-    defaultLogger.debug('Stopping Workqueue', { signal });
-    stopWorkqueue();
-    defaultLogger.debug('Stopping GraphQL server', { signal });
-    await graphqlHandler.dispose();
-    defaultLogger.debug('Stopping DB Connection', { signal });
-    await stopDb();
-    defaultLogger.debug(`Unchained Engine exiting`, { signal, version: packageJson.version });
-    process.exit(0);
-  };
-
-  process.on('SIGTERM', cleanup('SIGTERM'));
-  process.on('SIGINT', cleanup('SIGINT'));
-
-  const end = performance.now();
-  defaultLogger.debug(`Unchained Engine started in ${(end - start).toFixed(0)} ms`);
-
-  return { unchainedAPI, graphqlHandler, db };
-};

package/src/templates/index.ts

@@ -1,9 +0,0 @@
-export { resolveOrderRejectionTemplate } from './resolveOrderRejectionTemplate.js';
-export { resolveAccountActionTemplate } from './resolveAccountActionTemplate.js';
-export { resolveForwardDeliveryTemplate } from './resolveForwardDeliveryTemplate.js';
-export { resolveOrderConfirmationTemplate } from './resolveOrderConfirmationTemplate.js';
-export { resolveQuotationStatusTemplate } from './resolveQuotationStatusTemplate.js';
-export { resolveEnrollmentStatusTemplate } from './resolveEnrollmentStatusTemplate.js';
-export { resolveErrorReportTemplate } from './resolveErrorReportTemplate.js';
-
-export * as parser from './order-parser/index.js';

package/src/templates/order-parser/getOrderPositionsData.ts

@@ -1,50 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { Order } from '@unchainedshop/core-orders';
-import { ProductPricingSheet } from '@unchainedshop/core';
-import { ch } from '@unchainedshop/utils';
-
-type PriceFormatter = ({ amount, currencyCode }: { amount: number; currencyCode: string }) => string;
-
-export const getOrderPositionsData = async (
-  order: Order,
-  params: { locale: Intl.Locale; useNetPrice?: boolean; format?: PriceFormatter },
-  context: UnchainedCore,
-) => {
-  const { modules } = context;
-  const { useNetPrice, format = ch.priceToString } = params || {};
-  const orderPositions = await modules.orders.positions.findOrderPositions({
-    orderId: order._id,
-  });
-
-  return Promise.all(
-    orderPositions.map(async (orderPosition) => {
-      const productTexts = await modules.products.texts.findLocalizedText({
-        productId: orderPosition.productId,
-        locale: params.locale,
-      });
-
-      const positionPricing = ProductPricingSheet({
-        calculation: orderPosition.calculation,
-        currencyCode: order.currencyCode,
-        quantity: orderPosition.quantity,
-      });
-
-      const total = positionPricing.total({ useNetPrice });
-      const unitPrice = positionPricing.unitPrice({ useNetPrice });
-
-      const { quantity } = positionPricing;
-      return {
-        productId: orderPosition.productId,
-        configuration: orderPosition.configuration,
-        productTexts,
-        quantity,
-        rawPrices: {
-          unitPrice,
-          total,
-        },
-        unitPrice: format(unitPrice),
-        total: format(total),
-      };
-    }),
-  );
-};

package/src/templates/order-parser/getOrderSummaryData.ts

@@ -1,91 +0,0 @@
-import { Order } from '@unchainedshop/core-orders';
-import { UnchainedCore, OrderPricingSheet, OrderPricingRowCategory } from '@unchainedshop/core';
-import { ch } from '@unchainedshop/utils';
-
-type PriceFormatter = ({ amount, currencyCode }: { amount: number; currencyCode: string }) => string;
-
-export const getOrderSummaryData = async (
-  order: Order,
-  params: { locale: Intl.Locale; useNetPrice?: boolean; format?: PriceFormatter },
-  context: UnchainedCore,
-) => {
-  const { modules } = context;
-  const { useNetPrice, format = ch.priceToString } = params || {};
-  const orderDelivery =
-    order.deliveryId &&
-    (await modules.orders.deliveries.findDelivery({
-      orderDeliveryId: order.deliveryId,
-    }));
-
-  if (!orderDelivery) throw new Error('Order delivery not found');
-
-  const orderPayment =
-    order.paymentId &&
-    (await modules.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    }));
-
-  if (!orderPayment) throw new Error('Order payment not found');
-
-  const paymentProvider = await modules.payment.paymentProviders.findProvider({
-    paymentProviderId: orderPayment.paymentProviderId,
-  });
-  const deliveryProvider = await modules.delivery.findProvider({
-    deliveryProviderId: orderDelivery.deliveryProviderId,
-  });
-
-  const deliveryAddress = ch.addressToString(
-    orderDelivery?.context?.deliveryAddress || order.billingAddress,
-  );
-  const billingAddress = ch.addressToString(order.billingAddress);
-  const orderPricing = OrderPricingSheet({
-    calculation: order.calculation,
-    currencyCode: order.currencyCode,
-  });
-
-  const paymentTotal = orderPricing.total({
-    category: OrderPricingRowCategory.Payment,
-    useNetPrice,
-  });
-
-  const deliveryTotal = orderPricing.total({
-    category: OrderPricingRowCategory.Delivery,
-    useNetPrice,
-  });
-
-  const taxesTotal = orderPricing.total({
-    category: OrderPricingRowCategory.Taxes,
-    useNetPrice,
-  });
-
-  const itemsTotal = orderPricing.total({
-    category: OrderPricingRowCategory.Items,
-    useNetPrice,
-  });
-
-  const total = orderPricing.total({ useNetPrice });
-
-  const payment = paymentProvider?.adapterKey;
-  const delivery = deliveryProvider?.adapterKey;
-
-  return {
-    rawPrices: {
-      items: itemsTotal,
-      taxes: taxesTotal,
-      delivery: deliveryTotal,
-      payment: paymentTotal,
-      gross: total,
-    },
-    prices: {
-      items: format(itemsTotal),
-      taxes: format(taxesTotal),
-      delivery: format(deliveryTotal),
-      payment: format(paymentTotal),
-      gross: format(total),
-    },
-    payment,
-    delivery,
-    deliveryAddress,
-    billingAddress,
-  };
-};