@unchainedshop/core-orders 4.0.0-rc.9 → 4.0.1

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,9 +82,21 @@ export const configureOrderPaymentsModule = ({
         orderPaymentId: string;
       },
       options?: mongodb.FindOptions,
-    ): Promise<OrderPayment> => {
+    ) => {
       return OrderPayments.findOne(buildFindOrderPaymentByIdSelector(orderPaymentId), options);
     },
+
+    findOrderPaymentsByProviderIds: async (
+      {
+        paymentProviderIds,
+      }: {
+        paymentProviderIds: string[];
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderPayment[]> => {
+      if (!paymentProviderIds?.length) return [];
+      return OrderPayments.find({ paymentProviderId: { $in: paymentProviderIds } }, options).toArray();
+    },
     findOrderPaymentByContextData: async (
       {
         context,
@@ -92,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 (
@@ -106,7 +118,7 @@ export const configureOrderPaymentsModule = ({
       options?: mongodb.FindOptions,
     ) => {
       const selector = buildFindByContextDataSelector(context);
-
+      if (!selector) return 0;
       return OrderPayments.countDocuments(selector, options);
     },
 
@@ -114,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(),
@@ -123,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;
     },
@@ -156,14 +170,14 @@ 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, {});
 
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
-      const result = await OrderPayments.findOneAndUpdate(
+      const orderPayment = await OrderPayments.findOneAndUpdate(
         selector,
         {
           $set: {
@@ -171,17 +185,14 @@ export const configureOrderPaymentsModule = ({
             updated: new Date(),
           },
         },
-        { includeResultMetadata: true, returnDocument: 'after' },
+        { returnDocument: 'after' },
       );
 
-      if (result.ok) {
-        await emit('ORDER_UPDATE_PAYMENT', {
-          orderPayment: result.value,
-        });
-        return result.value;
-      }
-
-      return null;
+      if (!orderPayment) return null;
+      await emit('ORDER_UPDATE_PAYMENT', {
+        orderPayment,
+      });
+      return orderPayment;
     },
 
     updateStatus,

package/src/module/configureOrderPositionsModule.ts

@@ -10,6 +10,17 @@ const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_ADD_PRODUCT',
 ];
 
+export interface OrderPositionAggregateParams {
+  match?: mongodb.Document;
+  matchAfterGroup?: mongodb.Document;
+  project?: mongodb.Document;
+  group?: mongodb.Document;
+  addFields?: mongodb.Document;
+  sort?: mongodb.Document;
+  limit?: number;
+  pipeline?: mongodb.Document[];
+}
+
 export const buildFindOrderPositionByIdSelector = (orderPositionId: string, orderId?: string) =>
   generateDbFilterById(
     orderPositionId,
@@ -25,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);
     },
 
@@ -37,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> => {
@@ -60,7 +68,7 @@ export const configureOrderPositionsModule = ({
       orderPositionId: string;
       configuration?: { key: string; value: string }[];
       quantity?: number;
-    }): Promise<OrderPosition> => {
+    }) => {
       const modifier: any = {
         $set: {
           updated: new Date(),
@@ -85,6 +93,7 @@ export const configureOrderPositionsModule = ({
         },
       );
 
+      if (!updatedOrderPosition) return null;
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
       });
@@ -128,7 +137,7 @@ export const configureOrderPositionsModule = ({
       return orderIdsToRecalculate;
     },
 
-    updateScheduling: async (orderPositionId, scheduling): Promise<OrderPosition> => {
+    updateScheduling: async (orderPositionId, scheduling) => {
       return OrderPositions.findOneAndUpdate(
         generateDbFilterById(orderPositionId),
         {
@@ -143,7 +152,7 @@ export const configureOrderPositionsModule = ({
     updateCalculation: async <T extends PricingCalculation>(
       orderPositionId: string,
       calculation: T[],
-    ): Promise<OrderPosition> => {
+    ) => {
       return OrderPositions.findOneAndUpdate(
         { _id: orderPositionId },
         {
@@ -157,7 +166,7 @@ export const configureOrderPositionsModule = ({
 
     addProductItem: async (orderPosition: {
       context?: any;
-      configuration?: { key: string; value: string }[];
+      configuration?: { key: string; value: string }[] | null;
       orderId: string;
       originalProductId: string;
       productId: string;
@@ -171,11 +180,11 @@ export const configureOrderPositionsModule = ({
         orderId,
         productId,
         originalProductId,
-        configuration: configuration || { $in: [null, undefined] },
+        configuration: configuration ?? null,
         ...scope,
       };
 
-      await OrderPositions.updateOne(
+      const upsertedOrderPosition = (await OrderPositions.findOneAndUpdate(
         selector,
         {
           $set: {
@@ -194,19 +203,41 @@ 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) => {
       const { deletedCount } = await OrderPositions.deleteMany({ orderId });
       return deletedCount;
     },
+
+    aggregatePositions: async ({
+      match,
+      project,
+      group,
+      addFields,
+      sort,
+      limit,
+      pipeline,
+    }: OrderPositionAggregateParams): Promise<mongodb.Document[]> => {
+      const stages: mongodb.Document[] = [];
+
+      if (pipeline?.length) {
+        return await OrderPositions.aggregate(pipeline).toArray();
+      }
+
+      if (match) stages.push({ $match: match });
+      if (project) stages.push({ $project: project });
+      if (group) stages.push({ $group: group });
+      if (addFields) stages.push({ $addFields: addFields });
+      if (sort) stages.push({ $sort: sort });
+      if (typeof limit === 'number') stages.push({ $limit: limit });
+
+      return OrderPositions.aggregate(stages).toArray();
+    },
   };
 };
 

package/src/module/configureOrdersModule-mutations.ts

@@ -9,28 +9,6 @@ import {
 import { Order, OrderStatus } from '../db/OrdersCollection.js';
 import { OrderPosition } from '../db/OrderPositionsCollection.js';
 
-export interface OrderMutations {
-  create: (doc: {
-    userId: string;
-    billingAddress?: Address;
-    contact?: Contact;
-    countryCode: string;
-    currencyCode: 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>;
-
-  updateBillingAddress: (orderId: string, billingAddress: Address) => Promise<Order>;
-  updateContact: (orderId: string, contact: Contact) => Promise<Order>;
-  updateContext: (orderId: string, context: any) => Promise<Order>;
-  updateCalculationSheet: (orderId: string, calculation) => Promise<Order>;
-}
-
 const ORDER_EVENTS: string[] = [
   'ORDER_CREATE',
   'ORDER_REMOVE',
@@ -45,11 +23,28 @@ export const configureOrderModuleMutations = ({
 }: {
   Orders: mongodb.Collection<Order>;
   OrderPositions: mongodb.Collection<OrderPosition>;
-}): OrderMutations => {
+}) => {
   registerEvents(ORDER_EVENTS);
 
   return {
-    create: async ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact }) => {
+    create: async ({
+      userId,
+      orderNumber,
+      currencyCode,
+      countryCode,
+      billingAddress,
+      contact,
+      context,
+    }: {
+      userId: string;
+      billingAddress?: Address;
+      contact?: Contact;
+      countryCode: string;
+      currencyCode: string;
+      orderNumber?: string;
+      originEnrollmentId?: string;
+      context?: Record<string, any>;
+    }) => {
       const { insertedId: orderId } = await Orders.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
@@ -62,21 +57,23 @@ export const configureOrderModuleMutations = ({
         calculation: [],
         log: [],
         orderNumber,
+        context: context || {},
       });
 
-      const order = await Orders.findOne(generateDbFilterById(orderId), {});
+      const order = (await Orders.findOne(generateDbFilterById(orderId), {})) as Order;
 
       await emit('ORDER_CREATE', { order });
       return order;
     },
 
-    delete: async (orderId) => {
+    delete: async (orderId: string) => {
       const { deletedCount } = await Orders.deleteOne({ _id: orderId });
+      if (!deletedCount) return 0;
       await emit('ORDER_REMOVE', { orderId });
       return deletedCount;
     },
 
-    setCartOwner: async ({ orderId, userId }) => {
+    setCartOwner: async ({ orderId, userId }: { orderId: string; userId: string }) => {
       await Orders.updateOne(generateDbFilterById(orderId), {
         $set: {
           userId,
@@ -84,7 +81,13 @@ export const configureOrderModuleMutations = ({
       });
     },
 
-    moveCartPositions: async ({ fromOrderId, toOrderId }) => {
+    moveCartPositions: async ({
+      fromOrderId,
+      toOrderId,
+    }: {
+      fromOrderId: string;
+      toOrderId: string;
+    }) => {
       await OrderPositions.updateMany(
         { orderId: fromOrderId },
         {
@@ -95,7 +98,7 @@ export const configureOrderModuleMutations = ({
       );
     },
 
-    updateBillingAddress: async (orderId, billingAddress) => {
+    updateBillingAddress: async (orderId: string, billingAddress: Address) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
@@ -107,12 +110,12 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
-      await emit('ORDER_UPDATE', { order, field: 'billing' });
+      if (!order) return null;
+      await emit('ORDER_UPDATE', { order, field: 'billingAddress' });
       return order;
     },
 
-    updateContact: async (orderId, contact) => {
+    updateContact: async (orderId: string, contact: Contact) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
@@ -124,12 +127,12 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
+      if (!order) return null;
       await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateCalculationSheet: async (orderId, calculation) => {
+    updateCalculationSheet: async (orderId: string, calculation: any) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
@@ -141,12 +144,12 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
+      if (!order) return null;
       await emit('ORDER_UPDATE', { order, field: 'calculation' });
       return order;
     },
 
-    updateContext: async (orderId, context) => {
+    updateContext: async (orderId: string, context: any) => {
       const selector = generateDbFilterById<Order>(orderId);
       selector.status = { $in: [null, OrderStatus.PENDING] };
 
@@ -155,7 +158,7 @@ export const configureOrderModuleMutations = ({
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
-      const result = await Orders.findOneAndUpdate(
+      const order = await Orders.findOneAndUpdate(
         selector,
         {
           $set: {
@@ -163,14 +166,13 @@ export const configureOrderModuleMutations = ({
             updated: new Date(),
           },
         },
-        { includeResultMetadata: true, returnDocument: 'after' },
+        { returnDocument: 'after' },
       );
-
-      if (result.ok) {
-        await emit('ORDER_UPDATE', { order: result.value, field: 'context' });
-        return result.value;
-      }
-      return null;
+      if (!order) return null;
+      await emit('ORDER_UPDATE', { order, field: 'context' });
+      return order;
     },
   };
 };
+
+export type OrderMutations = ReturnType<typeof configureOrderModuleMutations>;

package/src/module/configureOrdersModule-queries.ts

@@ -1,4 +1,4 @@
-import { SortDirection, SortOption, DateFilterInput } from '@unchainedshop/utils';
+import { SortDirection, SortOption } from '@unchainedshop/utils';
 import { generateDbFilterById, buildSortOptions, mongodb } from '@unchainedshop/mongodb';
 import buildFindSelector from './buildFindSelector.js';
 import { Order, OrderQuery } from '../db/OrdersCollection.js';
@@ -10,21 +10,23 @@ export interface OrderReport {
   confirmCount: number;
   fulfillCount: number;
 }
-
-const normalizeOrderAggregateResult = (data = {}): OrderReport => {
-  const statusToFieldMap = {
-    newCount: 0,
-    checkoutCount: 0,
-    rejectCount: 0,
-    confirmCount: 0,
-    fulfillCount: 0,
+export interface OrderStatisticsRecord {
+  date: string;
+  total: {
+    amount: number;
+    currency: string;
   };
-
-  Object.entries(data).forEach(([key, value]) => {
-    statusToFieldMap[key] = value;
-  });
-  return statusToFieldMap;
-};
+}
+export interface OrderAggregateParams {
+  match?: Record<string, any>;
+  matchAfterGroup?: Record<string, any>;
+  project?: Record<string, any>;
+  group?: Record<string, any>;
+  sort?: Record<string, number>;
+  limit?: number;
+  addFields?: Record<string, any>;
+  pipeline?: any[];
+}
 
 export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Collection<Order> }) => {
   return {
@@ -40,7 +42,7 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
       countryCode?: string;
       orderNumber?: string;
       userId: string;
-    }): Promise<Order> => {
+    }) => {
       const selector: mongodb.Filter<Order> = {
         countryCode,
         status: { $eq: null },
@@ -72,7 +74,7 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
         orderNumber?: string;
       },
       options?: mongodb.FindOptions,
-    ): Promise<Order> => {
+    ) => {
       const selector = orderId ? generateDbFilterById(orderId) : { orderNumber };
       return Orders.findOne(selector, options);
     },
@@ -122,86 +124,35 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
 
       return Orders.find(selector, findOptions).toArray();
     },
-
-    getReport: async (params: { dateRange?: DateFilterInput }): Promise<OrderReport> => {
-      const { dateRange } = params || {};
-      const selector: any = { $exists: true };
-      if (dateRange?.end || dateRange?.start) {
-        if (dateRange?.start) {
-          const fromDate = new Date(dateRange?.start);
-          selector.$gte = fromDate;
-        }
-        if (dateRange?.end) {
-          const toDate = new Date(dateRange?.end);
-          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,
       });
       return !!orderCount;
     },
+    aggregateOrders: async ({
+      match,
+      project,
+      group,
+      sort,
+      limit,
+      addFields,
+      pipeline,
+    }: OrderAggregateParams): Promise<mongodb.Document[]> => {
+      const stages: mongodb.Document[] = [];
+      if (pipeline?.length) {
+        return await Orders.aggregate(pipeline).toArray();
+      }
+
+      if (match) stages.push({ $match: match });
+      if (project) stages.push({ $project: project });
+      if (group) stages.push({ $group: group });
+      if (addFields) stages.push({ $addFields: addFields });
+      if (sort) stages.push({ $sort: sort });
+      if (typeof limit === 'number') stages.push({ $limit: limit });
+
+      return Orders.aggregate(stages, { allowDiskUse: true }).toArray();
+    },
   };
 };