@unchainedshop/core-orders 3.0.0-alpha7 → 3.0.0-rc10

package/src/db/OrderDeliveriesCollection.ts

@@ -1,5 +1,28 @@
-import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { OrderDelivery } from '@unchainedshop/core-orders';
+import { mongodb, buildDbIndexes, LogFields, TimestampFields } from '@unchainedshop/mongodb';
+import { Price } from '@unchainedshop/utils';
+
+export enum OrderDeliveryStatus {
+  OPEN = 'OPEN', // Null value is mapped to OPEN status
+  DELIVERED = 'DELIVERED',
+  RETURNED = 'RETURNED',
+}
+
+export type OrderDelivery = {
+  _id?: string;
+  orderId: string;
+  deliveryProviderId: string;
+  delivered?: Date;
+  status: OrderDeliveryStatus | null;
+  context?: any;
+  calculation: Array<any>;
+} & LogFields &
+  TimestampFields;
+
+export type OrderDeliveryDiscount = Omit<Price, '_id'> & {
+  _id?: string;
+  discountId: string;
+  item: OrderDelivery;
+};
 
 export const OrderDeliveriesCollection = async (db: mongodb.Db) => {
   const OrderDeliveries = db.collection<OrderDelivery>('order_deliveries');

package/src/db/OrderDiscountsCollection.ts

@@ -1,5 +1,16 @@
-import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { OrderDiscount } from '@unchainedshop/core-orders';
+import { mongodb, buildDbIndexes, TimestampFields } from '@unchainedshop/mongodb';
+import { Price } from '@unchainedshop/utils';
+
+export type OrderDiscount = {
+  _id?: string;
+  orderId: string;
+  code?: string;
+  total?: Price;
+  trigger?: OrderDiscountTrigger;
+  discountKey?: string;
+  reservation?: any;
+  context?: any;
+} & TimestampFields;
 
 export const OrderDiscountsCollection = async (db: mongodb.Db) => {
   const OrderDiscounts = db.collection<OrderDiscount>('order_discounts');
@@ -12,3 +23,8 @@ export const OrderDiscountsCollection = async (db: mongodb.Db) => {
 
   return OrderDiscounts;
 };
+
+export enum OrderDiscountTrigger {
+  USER = 'USER',
+  SYSTEM = 'SYSTEM',
+}

package/src/db/OrderPaymentsCollection.ts

@@ -1,5 +1,29 @@
-import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { OrderPayment } from '@unchainedshop/core-orders';
+import { mongodb, buildDbIndexes, LogFields, TimestampFields } from '@unchainedshop/mongodb';
+import { Price } from '@unchainedshop/utils';
+
+export enum OrderPaymentStatus {
+  OPEN = 'OPEN', // Null value is mapped to OPEN status
+  PAID = 'PAID',
+  REFUNDED = 'REFUNDED',
+}
+
+export type OrderPayment = {
+  _id?: string;
+  orderId: string;
+  context?: any;
+  paid?: Date;
+  transactionId?: string;
+  paymentProviderId?: string;
+  status?: OrderPaymentStatus | null;
+  calculation?: Array<any>;
+} & LogFields &
+  TimestampFields;
+
+export type OrderPaymentDiscount = Omit<Price, '_id'> & {
+  _id?: string;
+  discountId: string;
+  item: OrderPayment;
+};
 
 export const OrderPaymentsCollection = async (db: mongodb.Db) => {
   const OrderPayments = db.collection<OrderPayment>('order_payments');

package/src/db/OrderPositionsCollection.ts

@@ -1,5 +1,24 @@
-import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { OrderPosition } from '@unchainedshop/core-orders';
+import { mongodb, buildDbIndexes, TimestampFields } from '@unchainedshop/mongodb';
+import { Price } from '@unchainedshop/utils';
+
+export type OrderPosition = {
+  _id?: string;
+  calculation: Array<any>;
+  configuration: Array<{ key: string; value: string }>;
+  context?: any;
+  orderId: string;
+  originalProductId: string;
+  productId: string;
+  quantity: number;
+  quotationId?: string;
+  scheduling: Array<any>;
+} & TimestampFields;
+
+export type OrderPositionDiscount = Omit<Price, '_id'> & {
+  _id?: string;
+  discountId: string;
+  item: OrderPosition;
+};
 
 export const OrderPositionsCollection = async (db: mongodb.Db) => {
   const OrderPositions = db.collection<OrderPosition>('order_positions');

package/src/db/OrdersCollection.ts

@@ -1,5 +1,47 @@
-import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { Order } from '../types.js';
+import {
+  mongodb,
+  buildDbIndexes,
+  Address,
+  Contact,
+  LogFields,
+  TimestampFields,
+} from '@unchainedshop/mongodb';
+
+export enum OrderStatus {
+  PENDING = 'PENDING',
+  CONFIRMED = 'CONFIRMED',
+  FULLFILLED = 'FULLFILLED',
+  REJECTED = 'REJECTED',
+}
+
+export type Order = {
+  _id?: string;
+  billingAddress?: Address;
+  calculation: Array<any>;
+  confirmed?: Date;
+  rejected?: Date;
+  contact?: Contact;
+  context?: any;
+  countryCode: string;
+  currency: string;
+  deliveryId?: string;
+  fullfilled?: Date;
+  ordered?: Date;
+  orderNumber?: string;
+  originEnrollmentId?: string;
+  paymentId?: string;
+  status: OrderStatus | null;
+  userId: string;
+} & LogFields &
+  TimestampFields;
+
+export type OrderQuery = {
+  includeCarts?: boolean;
+  orderStatus?: OrderStatus[];
+  queryString?: string;
+  status?: OrderStatus[];
+  userId?: string;
+};
 
 export const OrdersCollection = async (db: mongodb.Db) => {
   const Orders = db.collection<Order>('orders');

package/src/module/buildFindSelector.test.ts

@@ -1,12 +1,12 @@
-import { OrderStatus } from '../types.js';
+import { OrderStatus } from '../db/OrdersCollection.js';
 import { buildFindByIdSelector as buildFindByIdSelectorForDelivery } from './configureOrderDeliveriesModule.js';
-import { buildFindByIdSelector as buildFindByIdSelectorForDiscount } from './configureOrderDiscountsModule.js';
+import { buildFindOrderDiscountByIdSelector } from './configureOrderDiscountsModule.js';
 import {
-  buildFindByIdSelector as buildFindByIdSelectorForPayment,
+  buildFindOrderPaymentByIdSelector,
   buildFindByContextDataSelector,
 } from './configureOrderPaymentsModule.js';
-import { buildFindByIdSelector as buildFindByIdSelectorForPosition } from './configureOrderPositionsModule.js';
-import { buildFindSelector as buildFindSelectorForOrder } from './configureOrdersModule-queries.js';
+import { buildFindOrderPositionByIdSelector } from './configureOrderPositionsModule.js';
+import buildFindSelectorForOrder from './buildFindSelector.js';
 
 describe('OrderPosition', () => {
   describe('buildFindSelector', () => {
@@ -75,7 +75,7 @@ describe('OrderDelivery', () => {
 describe('OrderDiscount', () => {
   describe('buildFindByIdSelector', () => {
     it('Return correct db _id selector', () => {
-      expect(buildFindByIdSelectorForDiscount('order-discount-id')).toEqual({
+      expect(buildFindOrderDiscountByIdSelector('order-discount-id')).toEqual({
         _id: 'order-discount-id',
       });
     });
@@ -85,7 +85,7 @@ describe('OrderDiscount', () => {
 describe('OrderPayment', () => {
   describe('buildFindByIdSelector', () => {
     it('Return correct db _id selector', () => {
-      expect(buildFindByIdSelectorForPayment('order-payment-id')).toEqual({ _id: 'order-payment-id' });
+      expect(buildFindOrderPaymentByIdSelector('order-payment-id')).toEqual({ _id: 'order-payment-id' });
     });
   });
 
@@ -102,7 +102,7 @@ describe('OrderPayment', () => {
 describe('OrderPosition', () => {
   describe('buildFindByIdSelector', () => {
     it('Return correct db _id selector', () => {
-      expect(buildFindByIdSelectorForPosition('order-position-id')).toEqual({
+      expect(buildFindOrderPositionByIdSelector('order-position-id')).toEqual({
         _id: 'order-position-id',
       });
     });

package/src/module/buildFindSelector.ts

@@ -0,0 +1,24 @@
+import { OrderQuery, Order } from '../db/OrdersCollection.js';
+import { mongodb } from '@unchainedshop/mongodb';
+
+export const buildFindSelector = ({ includeCarts, status, userId, queryString }: OrderQuery) => {
+  const selector: mongodb.Filter<Order> = {};
+
+  if (userId) {
+    selector.userId = userId;
+  }
+
+  if (Array.isArray(status) && status?.length) {
+    selector.status = { $in: status };
+  } else if (!includeCarts) {
+    selector.status = { $ne: null }; // TODO: Slow performance! IDXSCAN in common query!
+  }
+
+  if (queryString) {
+    (selector as any).$text = { $search: queryString };
+  }
+
+  return selector;
+};
+
+export default buildFindSelector;

package/src/module/configureOrderDeliveriesModule.ts

@@ -1,65 +1,7 @@
-import { UnchainedCore } from '@unchainedshop/core';
 import { mongodb, generateDbFilterById, generateDbObjectId } from '@unchainedshop/mongodb';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { Order, OrderDelivery, OrderDeliveryStatus, OrderDiscount } from '../types.js';
-import { DeliveryLocation, IDeliveryPricingSheet } from '@unchainedshop/core-delivery';
-import { DeliveryDirector } from '@unchainedshop/core-delivery';
-import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
-
-export type OrderDeliveriesModule = {
-  // Queries
-  findDelivery: (
-    params: { orderDeliveryId: string },
-    options?: mongodb.FindOptions,
-  ) => Promise<OrderDelivery>;
-
-  // Transformations
-  discounts: (
-    orderDelivery: OrderDelivery,
-    params: { order: Order; orderDiscount: OrderDiscount },
-    unchainedAPI: UnchainedCore,
-  ) => Array<OrderPricingDiscount>;
-  isBlockingOrderConfirmation: (
-    orderDelivery: OrderDelivery,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-  isBlockingOrderFullfillment: (orderDelivery: OrderDelivery) => boolean;
-  normalizedStatus: (orderDelivery: OrderDelivery) => string;
-  pricingSheet: (
-    orderDelivery: OrderDelivery,
-    currency: string,
-    unchainedAPI: UnchainedCore,
-  ) => IDeliveryPricingSheet;
-
-  // Mutations
-  create: (doc: OrderDelivery) => Promise<OrderDelivery>;
-  delete: (orderDeliveryId: string) => Promise<number>;
-
-  markAsDelivered: (orderDelivery: OrderDelivery) => Promise<void>;
-
-  activePickUpLocation: (
-    orderDelivery: OrderDelivery,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<DeliveryLocation | null>;
-
-  send: (
-    orderDelivery: OrderDelivery,
-    params: { order: Order; deliveryContext?: any },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderDelivery>;
-
-  updateContext: (orderDeliveryId: string, context: any) => Promise<OrderDelivery | null>;
-
-  updateStatus: (
-    orderDeliveryId: string,
-    params: { status: OrderDeliveryStatus; info?: string },
-  ) => Promise<OrderDelivery>;
-
-  updateCalculation: (
-    orderDelivery: OrderDelivery,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderDelivery>;
-};
+import { PricingCalculation } from '@unchainedshop/utils';
+import { OrderDelivery, OrderDeliveryStatus } from '../db/OrderDeliveriesCollection.js';
 
 const ORDER_DELIVERY_EVENTS: string[] = ['ORDER_DELIVER', 'ORDER_UPDATE_DELIVERY'];
 
@@ -70,19 +12,19 @@ export const configureOrderDeliveriesModule = ({
   OrderDeliveries,
 }: {
   OrderDeliveries: mongodb.Collection<OrderDelivery>;
-}): OrderDeliveriesModule => {
+}) => {
   registerEvents(ORDER_DELIVERY_EVENTS);
 
-  const normalizedStatus: OrderDeliveriesModule['normalizedStatus'] = (orderDelivery) => {
+  const normalizedStatus = (orderDelivery: OrderDelivery) => {
     return orderDelivery.status === null
       ? OrderDeliveryStatus.OPEN
       : (orderDelivery.status as OrderDeliveryStatus);
   };
 
-  const updateStatus: OrderDeliveriesModule['updateStatus'] = async (
-    orderDeliveryId,
-    { status, info },
-  ) => {
+  const updateStatus = async (
+    orderDeliveryId: string,
+    { status, info }: { status: OrderDeliveryStatus; info?: string },
+  ): Promise<OrderDelivery> => {
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderDelivery> = {
       $set: { status, updated: new Date() },
@@ -106,72 +48,18 @@ export const configureOrderDeliveriesModule = ({
 
   return {
     // Queries
-    findDelivery: async ({ orderDeliveryId }, options) => {
+    findDelivery: async (
+      { orderDeliveryId }: { orderDeliveryId: string },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderDelivery> => {
       return OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId), options);
     },
 
-    // Transformations
-    discounts: (orderDelivery, { order, orderDiscount }, context) => {
-      const { modules } = context;
-      if (!orderDelivery) return [];
-
-      const pricingSheet = modules.orders.deliveries.pricingSheet(
-        orderDelivery,
-        order.currency,
-        context,
-      );
-
-      return pricingSheet.discountPrices(orderDiscount._id).map((discount) => ({
-        delivery: orderDelivery,
-        ...discount,
-      }));
-    },
-
-    isBlockingOrderConfirmation: async (orderDelivery, unchainedAPI) => {
-      const provider = await unchainedAPI.modules.delivery.findProvider({
-        deliveryProviderId: orderDelivery.deliveryProviderId,
-      });
-
-      const isAutoReleaseAllowed = await unchainedAPI.modules.delivery.isAutoReleaseAllowed(
-        provider,
-        unchainedAPI,
-      );
-
-      return !isAutoReleaseAllowed;
-    },
-
-    activePickUpLocation: async (orderDelivery, unchainedAPI) => {
-      const { orderPickUpLocationId } = orderDelivery.context || {};
-
-      const provider = await unchainedAPI.modules.delivery.findProvider({
-        deliveryProviderId: orderDelivery.deliveryProviderId,
-      });
-      const director = await DeliveryDirector.actions(
-        provider,
-        { orderDelivery: orderDelivery },
-        unchainedAPI,
-      );
-
-      return director.pickUpLocationById(orderPickUpLocationId);
-    },
-
-    isBlockingOrderFullfillment: (orderDelivery) => {
-      if (orderDelivery.status === OrderDeliveryStatus.DELIVERED) return false;
-      return true;
-    },
-
     normalizedStatus,
 
-    pricingSheet: (orderDelivery, currency, { modules }) => {
-      return modules.delivery.pricingSheet({
-        calculation: orderDelivery.calculation,
-        currency,
-      });
-    },
-
     // Mutations
 
-    create: async (doc) => {
+    create: async (doc: OrderDelivery): Promise<OrderDelivery> => {
       const { insertedId: orderDeliveryId } = await OrderDeliveries.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
@@ -184,56 +72,22 @@ export const configureOrderDeliveriesModule = ({
       return orderDelivery;
     },
 
-    delete: async (orderDeliveryId) => {
+    delete: async (orderDeliveryId: string) => {
       const { deletedCount } = await OrderDeliveries.deleteOne({ _id: orderDeliveryId });
       return deletedCount;
     },
 
-    markAsDelivered: async (orderDelivery) => {
+    markAsDelivered: async (orderDelivery: OrderDelivery) => {
       if (normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN) return;
       const updatedOrderDelivery = await updateStatus(orderDelivery._id, {
         status: OrderDeliveryStatus.DELIVERED,
         info: 'mark delivered manually',
       });
       await emit('ORDER_DELIVER', { orderDelivery: updatedOrderDelivery });
+      return updatedOrderDelivery;
     },
 
-    send: async (orderDelivery, { order, deliveryContext }, unchainedAPI) => {
-      if (normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN) return orderDelivery;
-
-      const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
-        deliveryProviderId: orderDelivery.deliveryProviderId,
-      });
-
-      const deliveryProviderId = deliveryProvider._id;
-
-      const address = orderDelivery.context?.address || order || order.billingAddress;
-
-      const arbitraryResponseData = await unchainedAPI.modules.delivery.send(
-        deliveryProviderId,
-        {
-          order,
-          orderDelivery,
-          transactionContext: {
-            ...(deliveryContext || {}),
-            ...(orderDelivery.context || {}),
-            ...(address || {}),
-          },
-        },
-        unchainedAPI,
-      );
-
-      if (arbitraryResponseData) {
-        return updateStatus(orderDelivery._id, {
-          status: OrderDeliveryStatus.DELIVERED,
-          info: JSON.stringify(arbitraryResponseData),
-        });
-      }
-
-      return orderDelivery;
-    },
-
-    updateContext: async (orderDeliveryId, context) => {
+    updateContext: async (orderDeliveryId: string, context: any): Promise<OrderDelivery> => {
       const selector = buildFindByIdSelector(orderDeliveryId);
       if (!context || Object.keys(context).length === 0) return OrderDeliveries.findOne(selector, {});
       const contextSetters = Object.fromEntries(
@@ -263,16 +117,12 @@ export const configureOrderDeliveriesModule = ({
 
     updateStatus,
 
-    updateCalculation: async (orderDelivery, unchainedAPI) => {
-      const calculation = await unchainedAPI.modules.delivery.calculate(
-        {
-          item: orderDelivery,
-        },
-        unchainedAPI,
-      );
-
+    updateCalculation: async <T extends PricingCalculation>(
+      orderDeliveryId: string,
+      calculation: Array<T>,
+    ): Promise<OrderDelivery> => {
       return OrderDeliveries.findOneAndUpdate(
-        buildFindByIdSelector(orderDelivery._id),
+        { _id: orderDeliveryId },
         {
           $set: {
             calculation,
@@ -284,5 +134,12 @@ export const configureOrderDeliveriesModule = ({
         },
       );
     },
+
+    deleteOrderDeliveries: async (orderId: string) => {
+      const { deletedCount } = await OrderDeliveries.deleteMany({ orderId });
+      return deletedCount;
+    },
   };
 };
+
+export type OrderDeliveriesModule = ReturnType<typeof configureOrderDeliveriesModule>;