@unchainedshop/core-orders 3.0.0-alpha2 → 3.0.0-alpha4

package/src/module/configureOrderPaymentsModule.ts

@@ -1,12 +1,94 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import {
-  OrderPayment,
-  OrderPaymentsModule,
-  OrderPaymentStatus,
-} from '@unchainedshop/types/orders.payments.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
-import { OrderPaymentsSchema } from '../db/OrderPaymentsSchema.js';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
+import { Order, OrderDiscount, OrderPayment, OrderPaymentStatus } from '../types.js';
+import { IPaymentPricingSheet } from '@unchainedshop/core-payment';
+import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
+
+export type OrderPaymentsModule = {
+  // Queries
+  findOrderPayment: (
+    params: {
+      orderPaymentId: string;
+    },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderPayment>;
+
+  findOrderPaymentByContextData: (
+    params: {
+      context: any;
+    },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderPayment>;
+
+  countOrderPaymentsByContextData: (
+    params: {
+      context: any;
+    },
+    options?: mongodb.FindOptions,
+  ) => Promise<number>;
+
+  // Transformations
+  discounts: (
+    orderPayment: OrderPayment,
+    params: { order: Order; orderDiscount: OrderDiscount },
+    unchainedAPI: UnchainedCore,
+  ) => Array<OrderPricingDiscount>;
+  isBlockingOrderConfirmation: (
+    orderPayment: OrderPayment,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<boolean>;
+  isBlockingOrderFullfillment: (orderPayment: OrderPayment) => boolean;
+  normalizedStatus: (orderPayment: OrderPayment) => string;
+  pricingSheet: (
+    orderPayment: OrderPayment,
+    currency: string,
+    unchainedAPI: UnchainedCore,
+  ) => IPaymentPricingSheet;
+
+  // Mutations
+  create: (doc: OrderPayment) => Promise<OrderPayment>;
+
+  cancel: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPayment>;
+
+  confirm: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPayment>;
+
+  charge: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPayment>;
+
+  logEvent: (orderPaymentId: string, event: any) => Promise<boolean>;
+
+  markAsPaid: (payment: OrderPayment, meta: any) => Promise<void>;
+
+  updateContext: (orderPaymentId: string, context: any) => Promise<OrderPayment | null>;
+
+  updateStatus: (
+    orderPaymentId: string,
+    params: { transactionId?: string; status: OrderPaymentStatus; info?: string },
+  ) => Promise<OrderPayment>;
+
+  updateCalculation: (orderPayment: OrderPayment, unchainedAPI: UnchainedCore) => Promise<OrderPayment>;
+};
 
 const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
 
@@ -38,11 +120,6 @@ export const configureOrderPaymentsModule = ({
 }): OrderPaymentsModule => {
   registerEvents(ORDER_PAYMENT_EVENTS);
 
-  const mutations = generateDbMutations<OrderPayment>(OrderPayments, OrderPaymentsSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderPayment>;
-
   const normalizedStatus: OrderPaymentsModule['normalizedStatus'] = (orderPayment) => {
     return orderPayment.status === null
       ? OrderPaymentStatus.OPEN
@@ -149,7 +226,9 @@ export const configureOrderPaymentsModule = ({
     // Mutations
 
     create: async (doc) => {
-      const orderPaymentId = await mutations.create({
+      const { insertedId: orderPaymentId } = await OrderPayments.insertOne({
+        _id: generateDbObjectId(),
+        created: new Date(),
         ...doc,
         status: null,
         context: doc.context || {},

package/src/module/configureOrderPositionsModule.ts

@@ -1,7 +1,78 @@
-import { OrderPosition, OrderPositionsModule } from '@unchainedshop/types/orders.positions.js';
+import type { OrderDiscount } from '@unchainedshop/core-orders';
+import type { UnchainedCore } from '@unchainedshop/core';
+import { IProductPricingSheet, Product } from '@unchainedshop/core-products';
+
+import { Order, OrderPosition } from '../types.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { ordersSettings } from '../orders-settings.js';
+import { OrderDelivery } from '@unchainedshop/core-orders';
+import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
+
+export type OrderPositionsModule = {
+  // Queries
+  findOrderPosition: (
+    params: { itemId: string },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderPosition>;
+  findOrderPositions: (params: { orderId: string }) => Promise<Array<OrderPosition>>;
+
+  // Transformations
+  discounts: (
+    orderPosition: OrderPosition,
+    params: { order: Order; orderDiscount: OrderDiscount },
+    unchainedAPI: UnchainedCore,
+  ) => Array<OrderPricingDiscount>;
+
+  pricingSheet: (
+    orderPosition: OrderPosition,
+    currency: string,
+    unchainedAPI: UnchainedCore,
+  ) => IProductPricingSheet;
+
+  delete: (orderPositionId: string) => Promise<OrderPosition>;
+
+  removePositions: ({ orderId }: { orderId: string }) => Promise<number>;
+  removeProductByIdFromAllOpenPositions: (productId: string) => Promise<Array<string>>;
+
+  updateProductItem: (
+    doc: {
+      context?: any;
+      configuration?: Array<{ key: string; value: string }>;
+      quantity?: number;
+    },
+    params: { order: Order; product: Product; orderPosition: OrderPosition },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+
+  updateScheduling: (
+    params: {
+      order: Order;
+      orderDelivery: OrderDelivery;
+      orderPosition: OrderPosition;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+
+  updateCalculation: (
+    orderPosition: OrderPosition,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+
+  addProductItem: (
+    doc: {
+      context?: any;
+      configuration?: Array<{ key: string; value: string }>;
+      orderId?: string;
+      originalProductId?: string;
+      productId?: string;
+      quantity: number;
+      quotationId?: string;
+    },
+    params: { order: Order; product: Product },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+};
 
 const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_UPDATE_CART_ITEM',

package/src/module/configureOrdersModule-mutations.ts

@@ -1,11 +1,48 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { Order, OrderStatus, OrderMutations } from '@unchainedshop/types/orders.js';
-import { OrderDelivery } from '@unchainedshop/types/orders.deliveries.js';
-import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { Order, OrderStatus } from '../types.js';
+import { OrderDelivery } from '@unchainedshop/core-orders';
+import { OrderPayment } from '@unchainedshop/core-orders';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
-import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
-import { OrdersSchema } from '../db/OrdersSchema.js';
+import {
+  Address,
+  Contact,
+  generateDbFilterById,
+  generateDbObjectId,
+  mongodb,
+} from '@unchainedshop/mongodb';
+import { OrderPosition } from '@unchainedshop/core-orders';
+
+export interface OrderMutations {
+  create: (doc: {
+    userId: string;
+    billingAddress?: Address;
+    contact?: Contact;
+    countryCode: string;
+    currency: string;
+    orderNumber?: string;
+    originEnrollmentId?: string;
+  }) => Promise<Order>;
+
+  delete: (orderId: string) => Promise<number>;
+
+  setCartOwner: (params: { orderId: string; userId: string }) => Promise<void>;
+  moveCartPositions: (params: { fromOrderId: string; toOrderId: string }) => Promise<void>;
+
+  setDeliveryProvider: (
+    orderId: string,
+    deliveryProviderId: string,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<Order>;
+  setPaymentProvider: (
+    orderId: string,
+    paymentProviderId: string,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<Order>;
+
+  updateBillingAddress: (orderId: string, billingAddress: Address) => Promise<Order>;
+  updateContact: (orderId: string, contact: Contact) => Promise<Order>;
+  updateContext: (orderId: string, context: any) => Promise<Order | null>;
+}
 
 const ORDER_EVENTS: string[] = [
   'ORDER_CREATE',
@@ -28,14 +65,10 @@ export const configureOrderModuleMutations = ({
 }): OrderMutations => {
   registerEvents(ORDER_EVENTS);
 
-  const mutations = generateDbMutations<Order>(Orders, OrdersSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<Order>;
-
   return {
     create: async ({ userId, orderNumber, currency, countryCode, billingAddress, contact }) => {
-      const orderId = await mutations.create({
+      const { insertedId: orderId } = await Orders.insertOne({
+        _id: generateDbObjectId(),
         created: new Date(),
         status: null,
         billingAddress,
@@ -55,7 +88,7 @@ export const configureOrderModuleMutations = ({
     },
 
     delete: async (orderId) => {
-      const deletedCount = await mutations.delete(orderId);
+      const { deletedCount } = await Orders.deleteOne({ _id: orderId });
       await emit('ORDER_REMOVE', { orderId });
       return deletedCount;
     },

package/src/module/configureOrdersModule-processing.ts

@@ -1,14 +1,41 @@
 import { mongodb, generateDbFilterById } from '@unchainedshop/mongodb';
-import { Order, OrderStatus, OrderProcessing, OrdersModule } from '@unchainedshop/types/orders.js';
-import type { Locker } from '@kontsedal/locco';
-import { OrderDelivery } from '@unchainedshop/types/orders.deliveries.js';
-import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
-import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
+import { ProductTypes } from '@unchainedshop/core-products';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { ProductType } from '@unchainedshop/types/products.js';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+
+import type { Locker } from '@kontsedal/locco';
+import { Order, OrderStatus } from '../types.js';
+import { OrderDelivery } from '@unchainedshop/core-orders';
+import { OrderPayment } from '@unchainedshop/core-orders';
+import { OrderPosition } from '@unchainedshop/core-orders';
+import { UnchainedCore } from '@unchainedshop/core';
+
 import { ordersSettings } from '../orders-settings.js';
 
+export type OrderContextParams<P> = (
+  order: Order,
+  params: P,
+  unchainedAPI: UnchainedCore,
+) => Promise<Order>;
+
+export type OrderTransactionContext = {
+  paymentContext?: any;
+  deliveryContext?: any;
+  comment?: string;
+  nextStatus?: OrderStatus;
+};
+
+export interface OrderProcessing {
+  checkout: (
+    orderId: string,
+    params: OrderTransactionContext,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<Order>;
+  confirm: OrderContextParams<OrderTransactionContext>;
+  reject: OrderContextParams<OrderTransactionContext>;
+  processOrder: OrderContextParams<OrderTransactionContext>;
+  updateStatus: (orderId: string, params: { status: OrderStatus; info?: string }) => Promise<Order>;
+}
+
 const ORDER_PROCESSING_EVENTS: string[] = [
   'ORDER_CHECKOUT',
   'ORDER_CONFIRMED',
@@ -39,7 +66,7 @@ export const configureOrderModuleProcessing = ({
     return findNewOrderNumber(order, index + 1);
   };
 
-  const updateStatus: OrdersModule['updateStatus'] = async (orderId, { status, info }) => {
+  const updateStatus: OrderProcessing['updateStatus'] = async (orderId, { status, info }) => {
     const selector = generateDbFilterById(orderId);
     const order = await Orders.findOne(selector, {});
 
@@ -249,7 +276,7 @@ export const configureOrderModuleProcessing = ({
   };
 
   return {
-    checkout: async (orderId, { paymentContext, deliveryContext }, unchainedAPI) => {
+    checkout: async (orderId, transactionContext, unchainedAPI) => {
       const { modules, services } = unchainedAPI;
 
       const order = await Orders.findOne(generateDbFilterById(orderId), {});
@@ -268,10 +295,7 @@ export const configureOrderModuleProcessing = ({
       try {
         const processedOrder = await modules.orders.processOrder(
           order,
-          {
-            paymentContext,
-            deliveryContext,
-          },
+          transactionContext,
           unchainedAPI,
         );
 
@@ -288,7 +312,7 @@ export const configureOrderModuleProcessing = ({
         await services.orders.nextUserCart(
           {
             user,
-            countryCode: locale.country,
+            countryCode: locale.region,
           },
           unchainedAPI,
         );
@@ -299,7 +323,7 @@ export const configureOrderModuleProcessing = ({
       }
     },
 
-    confirm: async (order, { paymentContext, deliveryContext }, unchainedAPI) => {
+    confirm: async (order, transactionContext, unchainedAPI) => {
       const { modules } = unchainedAPI;
 
       if (order.status !== OrderStatus.PENDING) return order;
@@ -309,8 +333,7 @@ export const configureOrderModuleProcessing = ({
         return await modules.orders.processOrder(
           order,
           {
-            paymentContext,
-            deliveryContext,
+            ...transactionContext,
             nextStatus: OrderStatus.CONFIRMED,
           },
           unchainedAPI,
@@ -320,7 +343,7 @@ export const configureOrderModuleProcessing = ({
       }
     },
 
-    reject: async (order, { paymentContext, deliveryContext }, unchainedAPI) => {
+    reject: async (order, transactionContext, unchainedAPI) => {
       const { modules } = unchainedAPI;
 
       if (order.status !== OrderStatus.PENDING) return order;
@@ -330,8 +353,7 @@ export const configureOrderModuleProcessing = ({
         return await modules.orders.processOrder(
           order,
           {
-            paymentContext,
-            deliveryContext,
+            ...transactionContext,
             nextStatus: OrderStatus.REJECTED,
           },
           unchainedAPI,
@@ -341,9 +363,14 @@ export const configureOrderModuleProcessing = ({
       }
     },
 
-    processOrder: async (initialOrder, params, unchainedAPI) => {
+    processOrder: async (initialOrder, orderTransactionContext, unchainedAPI) => {
       const { modules } = unchainedAPI;
-      const { paymentContext, deliveryContext, nextStatus: forceNextStatus } = params;
+      const {
+        paymentContext,
+        deliveryContext,
+        nextStatus: forceNextStatus,
+        comment,
+      } = orderTransactionContext;
 
       const orderId = initialOrder._id;
       let order = initialOrder;
@@ -393,7 +420,7 @@ export const configureOrderModuleProcessing = ({
           // numbers that are needed for delivery
           order = await updateStatus(orderId, {
             status: OrderStatus.CONFIRMED,
-            info: 'before delivery',
+            info: comment,
           });
 
           const orderDelivery = await modules.orders.deliveries.findDelivery({
@@ -421,7 +448,7 @@ export const configureOrderModuleProcessing = ({
             }),
           );
           const tokenizedItems = mappedProductOrderPositions.filter(
-            (item) => item.product?.type === ProductType.TokenizedProduct,
+            (item) => item.product?.type === ProductTypes.TokenizedProduct,
           );
           if (tokenizedItems.length > 0) {
             // Give virtual warehouse a chance to instantiate new virtual objects
@@ -436,7 +463,7 @@ export const configureOrderModuleProcessing = ({
 
           // Enrollments: Generate enrollments for plan products
           const planItems = mappedProductOrderPositions.filter(
-            (item) => item.product?.type === ProductType.PlanProduct && !order.originEnrollmentId,
+            (item) => item.product?.type === ProductTypes.PlanProduct && !order.originEnrollmentId,
           );
           if (planItems.length > 0) {
             await modules.enrollments.createFromCheckout(
@@ -473,7 +500,7 @@ export const configureOrderModuleProcessing = ({
         nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
       }
 
-      return updateStatus(order._id, { status: nextStatus, info: 'order processed' });
+      return updateStatus(order._id, { status: nextStatus, info: comment });
     },
 
     updateStatus,

package/src/module/configureOrdersModule-queries.ts

@@ -1,5 +1,5 @@
-import { SortDirection, SortOption } from '@unchainedshop/types/api.js';
-import { Order, OrderQueries, OrderQuery, OrderStatus } from '@unchainedshop/types/orders.js';
+import { SortDirection, SortOption } from '@unchainedshop/utils';
+import { Order, OrderQuery, OrderReport } from '../types.js';
 import { generateDbFilterById, buildSortOptions, mongodb } from '@unchainedshop/mongodb';
 
 export const buildFindSelector = ({ includeCarts, status, userId, queryString }: OrderQuery) => {
@@ -9,8 +9,8 @@ export const buildFindSelector = ({ includeCarts, status, userId, queryString }:
     selector.userId = userId;
   }
 
-  if (status) {
-    selector.status = status as OrderStatus;
+  if (Array.isArray(status) && status?.length) {
+    selector.status = { $in: status };
   } else if (!includeCarts) {
     selector.status = { $ne: null }; // TODO: Slow performance! IDXSCAN in common query!
   }
@@ -22,23 +22,56 @@ export const buildFindSelector = ({ includeCarts, status, userId, queryString }:
   return selector;
 };
 
-export const configureOrdersModuleQueries = ({
-  Orders,
-}: {
-  Orders: mongodb.Collection<Order>;
-}): OrderQueries => {
+const normalizeOrderAggregateResult = (data = {}): OrderReport => {
+  const statusToFieldMap = {
+    newCount: 0,
+    checkoutCount: 0,
+    rejectCount: 0,
+    confirmCount: 0,
+    fulfillCount: 0,
+  };
+
+  Object.entries(data).forEach(([key, value]) => {
+    statusToFieldMap[key] = value;
+  });
+  return statusToFieldMap;
+};
+
+export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Collection<Order> }) => {
   return {
-    count: async (query) => {
+    count: async (query: OrderQuery): Promise<number> => {
       const orderCount = await Orders.countDocuments(buildFindSelector(query));
       return orderCount;
     },
 
-    findOrder: async ({ orderId, orderNumber }, options) => {
+    findOrder: async (
+      {
+        orderId,
+        orderNumber,
+      }: {
+        orderId?: string;
+        orderNumber?: string;
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<Order> => {
       const selector = orderId ? generateDbFilterById(orderId) : { orderNumber };
       return Orders.findOne(selector, options);
     },
 
-    findOrders: async ({ limit, offset, queryString, sort, ...query }, options) => {
+    findOrders: async (
+      {
+        limit,
+        offset,
+        queryString,
+        sort,
+        ...query
+      }: OrderQuery & {
+        limit?: number;
+        offset?: number;
+        sort?: Array<SortOption>;
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<Array<Order>> => {
       const defaultSortOption: Array<SortOption> = [{ key: 'created', value: SortDirection.DESC }];
       const findOptions: mongodb.FindOptions = {
         skip: offset,
@@ -58,7 +91,80 @@ export const configureOrdersModuleQueries = ({
       return Orders.find(selector, findOptions).toArray();
     },
 
-    orderExists: async ({ orderId }) => {
+    getReport: async (params?: { from?: Date; to?: Date }): Promise<OrderReport> => {
+      const { from, to } = params || {};
+      const selector: any = { $exists: true };
+      if (from || to) {
+        if (from) {
+          const fromDate = new Date(from);
+          selector.$gte = fromDate;
+        }
+        if (to) {
+          const toDate = new Date(to);
+          selector.$lte = toDate;
+        }
+      }
+
+      const pipeline = [
+        {
+          $facet: {
+            checkoutCount: [
+              {
+                $match: {
+                  ordered: selector,
+                },
+              },
+              { $count: 'count' },
+            ],
+            fulfillCount: [
+              {
+                $match: {
+                  fullfilled: selector,
+                },
+              },
+              { $count: 'count' },
+            ],
+            rejectCount: [
+              {
+                $match: {
+                  rejected: selector,
+                },
+              },
+              { $count: 'count' },
+            ],
+            newCount: [
+              {
+                $match: {
+                  created: selector,
+                },
+              },
+              { $count: 'count' },
+            ],
+            confirmCount: [
+              {
+                $match: {
+                  confirmed: selector,
+                },
+              },
+              { $count: 'count' },
+            ],
+          },
+        },
+        {
+          $project: {
+            checkoutCount: { $arrayElemAt: ['$checkoutCount.count', 0] },
+            fulfillCount: { $arrayElemAt: ['$fulfillCount.count', 0] },
+            rejectCount: { $arrayElemAt: ['$rejectCount.count', 0] },
+            newCount: { $arrayElemAt: ['$newCount.count', 0] },
+            confirmCount: { $arrayElemAt: ['$confirmCount.count', 0] },
+          },
+        },
+      ];
+      const [facetedResult] = await Orders.aggregate(pipeline).toArray();
+      return normalizeOrderAggregateResult(facetedResult);
+    },
+
+    orderExists: async ({ orderId }: { orderId: string }): Promise<boolean> => {
       const orderCount = await Orders.countDocuments(generateDbFilterById(orderId), {
         limit: 1,
       });
@@ -66,3 +172,5 @@ export const configureOrdersModuleQueries = ({
     },
   };
 };
+
+export type OrderQueries = ReturnType<typeof configureOrdersModuleQueries>;

package/src/module/configureOrdersModule-transformations.ts

@@ -1,10 +1,32 @@
-import { Order, OrderTransformations } from '@unchainedshop/types/orders.js';
+import { Order, OrderDiscount } from '../types.js';
 import { mongodb } from '@unchainedshop/mongodb';
-import { DeliveryPricingRowCategory } from '@unchainedshop/types/delivery.pricing.js';
-import { PaymentPricingRowCategory } from '@unchainedshop/types/payments.pricing.js';
-import { ProductPricingRowCategory } from '@unchainedshop/types/products.pricing.js';
-import { OrderPricingRowCategory } from '@unchainedshop/types/orders.pricing.js';
-import { OrderPricingSheet } from '../director/OrderPricingSheet.js';
+import { PaymentPricingRowCategory } from '@unchainedshop/core-payment';
+import {
+  IOrderPricingSheet,
+  OrderPricingRowCategory,
+  OrderPricingSheet,
+} from '../director/OrderPricingSheet.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { ProductPricingRowCategory } from '@unchainedshop/core-products';
+import { DeliveryPricingRowCategory } from '@unchainedshop/core-delivery';
+import { OrderPrice, OrderPricingDiscount } from '../director/OrderPricingDirector.js';
+
+export interface OrderTransformations {
+  discounted: (
+    order: Order,
+    orderDiscount: OrderDiscount,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<Array<OrderPricingDiscount>>;
+  discountTotal: (
+    order: Order,
+    orderDiscount: OrderDiscount,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPrice>;
+
+  isCart: (order: Order) => boolean;
+  cart: (order: { countryContext?: string; orderNumber?: string; userId: string }) => Promise<Order>;
+  pricingSheet: (order: Order) => IOrderPricingSheet;
+}
 
 export const configureOrderModuleTransformations = ({
   Orders,