@unchainedshop/core-orders 4.0.0-rc.16 → 4.0.0-rc.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/core-orders",
-  "version": "4.0.0-rc.16",
+  "version": "4.0.0-rc.18",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
@@ -32,9 +32,9 @@
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
     "@kontsedal/locco": "0.1.0",
-    "@unchainedshop/events": "^4.0.0-rc.15",
-    "@unchainedshop/logger": "^4.0.0-rc.15",
-    "@unchainedshop/utils": "^4.0.0-rc.15"
+    "@unchainedshop/events": "^4.0.0-rc.18",
+    "@unchainedshop/logger": "^4.0.0-rc.18",
+    "@unchainedshop/utils": "^4.0.0-rc.18"
   },
   "devDependencies": {
     "@types/node": "^24.0.13",

package/src/db/OrderDeliveriesCollection.ts

@@ -8,7 +8,7 @@ export enum OrderDeliveryStatus {
 }
 
 export type OrderDelivery = {
-  _id?: string;
+  _id: string;
   orderId: string;
   deliveryProviderId: string;
   delivered?: Date;
@@ -19,7 +19,7 @@ export type OrderDelivery = {
   TimestampFields;
 
 export type OrderDeliveryDiscount = Omit<Price, '_id'> & {
-  _id?: string;
+  _id: string;
   discountId: string;
   item: OrderDelivery;
 };

package/src/db/OrderDiscountsCollection.ts

@@ -2,12 +2,12 @@ import { mongodb, buildDbIndexes, TimestampFields } from '@unchainedshop/mongodb
 import { Price } from '@unchainedshop/utils';
 
 export type OrderDiscount = {
-  _id?: string;
+  _id: string;
   orderId: string;
   code?: string;
   total?: Price;
   trigger?: OrderDiscountTrigger;
-  discountKey?: string;
+  discountKey: string;
   reservation?: any;
   context?: any;
 } & TimestampFields;

package/src/db/OrderPaymentsCollection.ts

@@ -8,19 +8,19 @@ export enum OrderPaymentStatus {
 }
 
 export type OrderPayment = {
-  _id?: string;
+  _id: string;
   orderId: string;
   context?: any;
   paid?: Date;
   transactionId?: string;
-  paymentProviderId?: string;
+  paymentProviderId: string;
   status?: OrderPaymentStatus | null;
   calculation?: any[];
 } & LogFields &
   TimestampFields;
 
 export type OrderPaymentDiscount = Omit<Price, '_id'> & {
-  _id?: string;
+  _id: string;
   discountId: string;
   item: OrderPayment;
 };

package/src/db/OrderPositionsCollection.ts

@@ -2,7 +2,7 @@ import { mongodb, buildDbIndexes, TimestampFields } from '@unchainedshop/mongodb
 import { Price } from '@unchainedshop/utils';
 
 export type OrderPosition = {
-  _id?: string;
+  _id: string;
   calculation: any[];
   configuration: { key: string; value: string }[];
   context?: any;
@@ -15,7 +15,6 @@ export type OrderPosition = {
 } & TimestampFields;
 
 export type OrderPositionDiscount = Omit<Price, '_id'> & {
-  _id?: string;
   discountId: string;
   item: OrderPosition;
 };

package/src/db/OrdersCollection.ts

@@ -17,7 +17,7 @@ export enum OrderStatus {
 }
 
 export type Order = {
-  _id?: string;
+  _id: string;
   billingAddress?: Address;
   calculation: any[];
   confirmed?: Date;
@@ -50,32 +50,37 @@ export interface OrderQuery extends mongodb.Filter<Order> {
 export const OrdersCollection = async (db: mongodb.Db) => {
   const Orders = db.collection<Order>('orders');
 
+  if (!isDocumentDBCompatModeEnabled()) {
+    await buildDbIndexes<Order>(Orders, [
+      {
+        index: {
+          _id: 'text',
+          userId: 'text',
+          orderNumber: 'text',
+          status: 'text',
+          'contact.emailAddress': 'text',
+          'contact.telNumber': 'text',
+        } as any,
+        options: {
+          weights: {
+            _id: 8,
+            userId: 3,
+            orderNumber: 6,
+            'contact.telNumber': 5,
+            'contact.emailAddress': 4,
+            status: 1,
+          },
+          name: 'order_fulltext_search',
+        },
+      },
+    ]);
+  }
+
   // Order Indexes
   await buildDbIndexes<Order>(Orders, [
     { index: { userId: 1 } },
     { index: { status: 1 } },
     { index: { orderNumber: 1 } },
-    !isDocumentDBCompatModeEnabled() && {
-      index: {
-        _id: 'text',
-        userId: 'text',
-        orderNumber: 'text',
-        status: 'text',
-        'contact.emailAddress': 'text',
-        'contact.telNumber': 'text',
-      } as any,
-      options: {
-        weights: {
-          _id: 8,
-          userId: 3,
-          orderNumber: 6,
-          'contact.telNumber': 5,
-          'contact.emailAddress': 4,
-          status: 1,
-        },
-        name: 'order_fulltext_search',
-      },
-    },
   ]);
 
   return Orders;

package/src/module/configureOrderDeliveriesModule.ts

@@ -24,7 +24,7 @@ export const configureOrderDeliveriesModule = ({
   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() },
@@ -51,7 +51,7 @@ export const configureOrderDeliveriesModule = ({
     findDelivery: async (
       { orderDeliveryId }: { orderDeliveryId: string },
       options?: mongodb.FindOptions,
-    ): Promise<OrderDelivery> => {
+    ) => {
       return OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId), options);
     },
 
@@ -70,7 +70,9 @@ export const configureOrderDeliveriesModule = ({
 
     // Mutations
 
-    create: async (doc: OrderDelivery): Promise<OrderDelivery> => {
+    create: async (
+      doc: Omit<OrderDelivery, '_id' | 'created'> & Pick<Partial<OrderDelivery>, '_id' | 'created'>,
+    ) => {
       const { insertedId: orderDeliveryId } = await OrderDeliveries.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
@@ -79,7 +81,9 @@ export const configureOrderDeliveriesModule = ({
         status: null,
       });
 
-      const orderDelivery = await OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId));
+      const orderDelivery = (await OrderDeliveries.findOne(
+        buildFindByIdSelector(orderDeliveryId),
+      )) as OrderDelivery;
       return orderDelivery;
     },
 
@@ -98,7 +102,7 @@ export const configureOrderDeliveriesModule = ({
       return updatedOrderDelivery;
     },
 
-    updateContext: async (orderDeliveryId: string, context: any): Promise<OrderDelivery> => {
+    updateContext: async (orderDeliveryId: string, context: any) => {
       const selector = buildFindByIdSelector(orderDeliveryId);
       if (!context || Object.keys(context).length === 0) return OrderDeliveries.findOne(selector, {});
       const contextSetters = Object.fromEntries(
@@ -116,14 +120,11 @@ export const configureOrderDeliveriesModule = ({
         { returnDocument: 'after' },
       );
 
-      if (orderDelivery) {
-        await emit('ORDER_UPDATE_DELIVERY', {
-          orderDelivery,
-        });
-        return orderDelivery;
-      }
-
-      return null;
+      if (!orderDelivery) return null;
+      await emit('ORDER_UPDATE_DELIVERY', {
+        orderDelivery,
+      });
+      return orderDelivery;
     },
 
     updateStatus,
@@ -131,7 +132,7 @@ export const configureOrderDeliveriesModule = ({
     updateCalculation: async <T extends PricingCalculation>(
       orderDeliveryId: string,
       calculation: T[],
-    ): Promise<OrderDelivery> => {
+    ) => {
       return OrderDeliveries.findOneAndUpdate(
         { _id: orderDeliveryId },
         {

package/src/module/configureOrderDiscountsModule.ts

@@ -20,10 +20,7 @@ export const configureOrderDiscountsModule = ({
 
   return {
     // Queries
-    findOrderDiscount: async (
-      { discountId }: { discountId: string },
-      options?: mongodb.FindOptions,
-    ): Promise<OrderDiscount> => {
+    findOrderDiscount: async ({ discountId }: { discountId: string }, options?: mongodb.FindOptions) => {
       return OrderDiscounts.findOne(buildFindOrderDiscountByIdSelector(discountId), options);
     },
 
@@ -32,7 +29,10 @@ export const configureOrderDiscountsModule = ({
       return discounts.toArray();
     },
 
-    create: async (doc: OrderDiscount): Promise<OrderDiscount> => {
+    create: async (
+      doc: Omit<OrderDiscount, '_id' | 'created' | 'trigger'> &
+        Pick<Partial<OrderDiscount>, '_id' | 'created' | 'trigger'>,
+    ): Promise<OrderDiscount> => {
       const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;
       const { insertedId: discountId } = await OrderDiscounts.insertOne({
         _id: generateDbObjectId(),
@@ -40,14 +40,14 @@ export const configureOrderDiscountsModule = ({
         ...doc,
         trigger: normalizedTrigger,
       });
-      const discount = await OrderDiscounts.findOne({
+      const discount = (await OrderDiscounts.findOne({
         _id: discountId,
-      });
+      })) as OrderDiscount;
       await emit('ORDER_CREATE_DISCOUNT', { discount });
       return discount;
     },
 
-    delete: async (orderDiscountId: string): Promise<OrderDiscount> => {
+    delete: async (orderDiscountId: string) => {
       const selector = buildFindOrderDiscountByIdSelector(orderDiscountId);
       const orderDiscount = await OrderDiscounts.findOneAndDelete(selector);
       await emit('ORDER_REMOVE_DISCOUNT', { discount: orderDiscount });
@@ -63,14 +63,14 @@ export const configureOrderDiscountsModule = ({
       );
     },
 
-    findSpareDiscount: async ({ code }): Promise<OrderDiscount> => {
+    findSpareDiscount: async ({ code }) => {
       return OrderDiscounts.findOne({
         code,
-        orderId: { $in: [undefined, null] },
+        orderId: { $exists: false },
       });
     },
 
-    update: async (orderDiscountId: string, doc: OrderDiscount): Promise<OrderDiscount> => {
+    update: async (orderDiscountId: string, doc: Partial<OrderDiscount>) => {
       const discount = await OrderDiscounts.findOneAndUpdate(
         { _id: orderDiscountId },
         {

package/src/module/configureOrderPaymentsModule.ts

@@ -8,7 +8,7 @@ const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYM
 export const buildFindOrderPaymentByIdSelector = (orderPaymentId: string) =>
   generateDbFilterById(orderPaymentId) as mongodb.Filter<OrderPayment>;
 
-export const buildFindByContextDataSelector = (context: any): mongodb.Filter<OrderPayment> => {
+export const buildFindByContextDataSelector = (context: any) => {
   const contextKeys = Object.keys(context);
 
   if (contextKeys.length === 0) return null;
@@ -46,7 +46,7 @@ export const configureOrderPaymentsModule = ({
       status,
       info,
     }: { transactionId?: string; status: OrderPaymentStatus; info?: string },
-  ): Promise<OrderPayment> => {
+  ) => {
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderPayment> = {
       $set: { status, updated: new Date() },
@@ -82,7 +82,7 @@ export const configureOrderPaymentsModule = ({
         orderPaymentId: string;
       },
       options?: mongodb.FindOptions,
-    ): Promise<OrderPayment> => {
+    ) => {
       return OrderPayments.findOne(buildFindOrderPaymentByIdSelector(orderPaymentId), options);
     },
 
@@ -104,9 +104,9 @@ export const configureOrderPaymentsModule = ({
         context: any;
       },
       options?: mongodb.FindOptions,
-    ): Promise<OrderPayment> => {
+    ) => {
       const selector = buildFindByContextDataSelector(context);
-
+      if (!selector) return null;
       return OrderPayments.findOne(selector, options);
     },
     countOrderPaymentsByContextData: async (
@@ -118,7 +118,7 @@ export const configureOrderPaymentsModule = ({
       options?: mongodb.FindOptions,
     ) => {
       const selector = buildFindByContextDataSelector(context);
-
+      if (!selector) return 0;
       return OrderPayments.countDocuments(selector, options);
     },
 
@@ -126,7 +126,9 @@ export const configureOrderPaymentsModule = ({
 
     // Mutations
 
-    create: async (doc: OrderPayment): Promise<OrderPayment> => {
+    create: async (
+      doc: Omit<OrderPayment, '_id' | 'created'> & Pick<Partial<OrderPayment>, '_id' | 'created'>,
+    ): Promise<OrderPayment> => {
       const { insertedId: orderPaymentId } = await OrderPayments.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
@@ -135,9 +137,9 @@ export const configureOrderPaymentsModule = ({
         context: doc.context || {},
       });
 
-      const orderPayment = await OrderPayments.findOne(
+      const orderPayment = (await OrderPayments.findOne(
         buildFindOrderPaymentByIdSelector(orderPaymentId),
-      );
+      )) as OrderPayment;
 
       return orderPayment;
     },
@@ -168,7 +170,7 @@ export const configureOrderPaymentsModule = ({
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId: string, context: any): Promise<OrderPayment> => {
+    updateContext: async (orderPaymentId: string, context: any) => {
       const selector = buildFindOrderPaymentByIdSelector(orderPaymentId);
       if (!context || Object.keys(context).length === 0) return OrderPayments.findOne(selector, {});
 
@@ -186,14 +188,11 @@ export const configureOrderPaymentsModule = ({
         { returnDocument: 'after' },
       );
 
-      if (orderPayment) {
-        await emit('ORDER_UPDATE_PAYMENT', {
-          orderPayment,
-        });
-        return orderPayment;
-      }
-
-      return null;
+      if (!orderPayment) return null;
+      await emit('ORDER_UPDATE_PAYMENT', {
+        orderPayment,
+      });
+      return orderPayment;
     },
 
     updateStatus,

package/src/module/configureOrderPositionsModule.ts

@@ -2,7 +2,6 @@ import { emit, registerEvents } from '@unchainedshop/events';
 import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { PricingCalculation } from '@unchainedshop/utils';
 import { OrderPosition } from '../db/OrderPositionsCollection.js';
-import { Document } from 'mongodb';
 
 const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_UPDATE_CART_ITEM',
@@ -11,15 +10,15 @@ const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_ADD_PRODUCT',
 ];
 
-interface OrderPositionAggregateParams {
-  match?: Document;
-  matchAfterGroup?: Document;
-  project?: Document;
-  group?: Document;
-  addFields?: Document;
-  sort?: Document;
+export interface OrderPositionAggregateParams {
+  match?: mongodb.Document;
+  matchAfterGroup?: mongodb.Document;
+  project?: mongodb.Document;
+  group?: mongodb.Document;
+  addFields?: mongodb.Document;
+  sort?: mongodb.Document;
   limit?: number;
-  pipeline?: Document[];
+  pipeline?: mongodb.Document[];
 }
 
 export const buildFindOrderPositionByIdSelector = (orderPositionId: string, orderId?: string) =>
@@ -37,10 +36,7 @@ export const configureOrderPositionsModule = ({
 
   return {
     // Queries
-    findOrderPosition: async (
-      { itemId }: { itemId: string },
-      options?: mongodb.FindOptions,
-    ): Promise<OrderPosition> => {
+    findOrderPosition: async ({ itemId }: { itemId: string }, options?: mongodb.FindOptions) => {
       return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
     },
 
@@ -49,13 +45,13 @@ export const configureOrderPositionsModule = ({
       return positions.toArray();
     },
 
-    delete: async (orderPositionId: string): Promise<OrderPosition> => {
+    delete: async (orderPositionId: string) => {
       const selector = buildFindOrderPositionByIdSelector(orderPositionId);
       const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
       await emit('ORDER_REMOVE_CART_ITEM', {
         orderPosition,
       });
-      return { ...orderPosition, calculation: [] };
+      return orderPosition;
     },
 
     removePositions: async ({ orderId }: { orderId: string }): Promise<number> => {
@@ -72,7 +68,7 @@ export const configureOrderPositionsModule = ({
       orderPositionId: string;
       configuration?: { key: string; value: string }[];
       quantity?: number;
-    }): Promise<OrderPosition> => {
+    }) => {
       const modifier: any = {
         $set: {
           updated: new Date(),
@@ -97,6 +93,7 @@ export const configureOrderPositionsModule = ({
         },
       );
 
+      if (!updatedOrderPosition) return null;
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
       });
@@ -140,7 +137,7 @@ export const configureOrderPositionsModule = ({
       return orderIdsToRecalculate;
     },
 
-    updateScheduling: async (orderPositionId, scheduling): Promise<OrderPosition> => {
+    updateScheduling: async (orderPositionId, scheduling) => {
       return OrderPositions.findOneAndUpdate(
         generateDbFilterById(orderPositionId),
         {
@@ -155,7 +152,7 @@ export const configureOrderPositionsModule = ({
     updateCalculation: async <T extends PricingCalculation>(
       orderPositionId: string,
       calculation: T[],
-    ): Promise<OrderPosition> => {
+    ) => {
       return OrderPositions.findOneAndUpdate(
         { _id: orderPositionId },
         {
@@ -183,11 +180,11 @@ export const configureOrderPositionsModule = ({
         orderId,
         productId,
         originalProductId,
-        configuration: configuration || { $in: [null, undefined] },
+        configuration: configuration || { $exists: false },
         ...scope,
       };
 
-      await OrderPositions.updateOne(
+      const upsertedOrderPosition = (await OrderPositions.findOneAndUpdate(
         selector,
         {
           $set: {
@@ -206,13 +203,10 @@ export const configureOrderPositionsModule = ({
             ...scope,
           },
         },
-        { upsert: true },
-      );
-
-      const upsertedOrderPosition = await OrderPositions.findOne(selector);
+        { upsert: true, returnDocument: 'after' },
+      )) as OrderPosition;
 
       await emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });
-
       return upsertedOrderPosition;
     },
     deleteOrderPositions: async (orderId: string) => {
@@ -228,8 +222,8 @@ export const configureOrderPositionsModule = ({
       sort,
       limit,
       pipeline,
-    }: OrderPositionAggregateParams): Promise<Document[]> => {
-      const stages: Document[] = [];
+    }: OrderPositionAggregateParams): Promise<mongodb.Document[]> => {
+      const stages: mongodb.Document[] = [];
 
       if (pipeline?.length) {
         return await OrderPositions.aggregate(pipeline).toArray();