@unchainedshop/core-orders 4.8.9 → 4.8.11

package/lib/db/OrderDeliveriesCollection.js

@@ -6,6 +6,9 @@ export const OrderDeliveryStatus = {
 };
 export const OrderDeliveriesCollection = async (db) => {
     const OrderDeliveries = db.collection('order_deliveries');
-    await buildDbIndexes(OrderDeliveries, [{ index: { orderId: 1 } }]);
+    await buildDbIndexes(OrderDeliveries, [
+        { index: { orderId: 1 } },
+        { index: { deliveryProviderId: 1 } },
+    ]);
     return OrderDeliveries;
 };

package/lib/db/OrderDiscountsCollection.js

@@ -3,7 +3,7 @@ export const OrderDiscountsCollection = async (db) => {
     const OrderDiscounts = db.collection('order_discounts');
     await buildDbIndexes(OrderDiscounts, [
         { index: { orderId: 1 } },
-        { index: { trigger: 1 } },
+        { index: { code: 1 }, options: { sparse: true } },
     ]);
     return OrderDiscounts;
 };

package/lib/db/OrderPaymentsCollection.js

@@ -6,6 +6,10 @@ export const OrderPaymentStatus = {
 };
 export const OrderPaymentsCollection = async (db) => {
     const OrderPayments = db.collection('order_payments');
-    await buildDbIndexes(OrderPayments, [{ index: { orderId: 1 } }]);
+    await buildDbIndexes(OrderPayments, [
+        { index: { orderId: 1 } },
+        { index: { paymentProviderId: 1 } },
+        { index: { transactionId: 1 }, options: { sparse: true } },
+    ]);
     return OrderPayments;
 };

package/lib/db/OrderPositionsCollection.js

@@ -2,8 +2,8 @@ import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
 export const OrderPositionsCollection = async (db) => {
     const OrderPositions = db.collection('order_positions');
     await buildDbIndexes(OrderPositions, [
+        { index: { orderId: 1, quantity: 1 } },
         { index: { productId: 1 } },
-        { index: { orderId: 1 } },
     ]);
     return OrderPositions;
 };

package/lib/db/OrdersCollection.js

@@ -1,4 +1,4 @@
-import { mongodb, buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchainedshop/mongodb';
+import { mongodb, buildDbIndexes, } from '@unchainedshop/mongodb';
 export const OrderStatus = {
     PENDING: 'PENDING',
     CONFIRMED: 'CONFIRMED',
@@ -7,36 +7,33 @@ export const OrderStatus = {
 };
 export const OrdersCollection = async (db) => {
     const Orders = db.collection('orders');
-    if (!isDocumentDBCompatModeEnabled()) {
-        await buildDbIndexes(Orders, [
-            {
-                index: {
-                    _id: 'text',
-                    userId: 'text',
-                    orderNumber: 'text',
-                    status: 'text',
-                    'contact.emailAddress': 'text',
-                    'contact.telNumber': 'text',
-                },
-                options: {
-                    weights: {
-                        _id: 8,
-                        userId: 3,
-                        orderNumber: 6,
-                        'contact.telNumber': 5,
-                        'contact.emailAddress': 4,
-                        status: 1,
-                    },
-                    name: 'order_fulltext_search',
+    await buildDbIndexes(Orders, [
+        {
+            index: {
+                _id: 'text',
+                userId: 'text',
+                orderNumber: 'text',
+                status: 'text',
+                'contact.emailAddress': 'text',
+                'contact.telNumber': 'text',
+            },
+            options: {
+                weights: {
+                    _id: 8,
+                    userId: 3,
+                    orderNumber: 6,
+                    'contact.telNumber': 5,
+                    'contact.emailAddress': 4,
+                    status: 1,
                 },
+                name: 'order_fulltext_search',
             },
-        ]);
-    }
+        },
+    ]);
     await buildDbIndexes(Orders, [
-        { index: { deleted: 1 } },
-        { index: { userId: 1 } },
-        { index: { status: 1 } },
-        { index: { orderNumber: 1 } },
+        { index: { userId: 1, status: 1 } },
+        { index: { status: 1, updated: 1 } },
+        { index: { orderNumber: 1 }, options: { sparse: true } },
     ]);
     return Orders;
 };

package/lib/module/buildFindSelector.js

@@ -1,4 +1,4 @@
-import { assertDocumentDBCompatMode, mongodb } from '@unchainedshop/mongodb';
+import { mongodb } from '@unchainedshop/mongodb';
 export const buildFindSelector = ({ includeCarts, status, userId, queryString, paymentIds, deliveryIds, dateRange, orderIds, }) => {
     const selector = {};
     if (userId) {
@@ -30,7 +30,6 @@ export const buildFindSelector = ({ includeCarts, status, userId, queryString, p
         selector.status = { $ne: null };
     }
     if (queryString) {
-        assertDocumentDBCompatMode();
         selector.$text = { $search: queryString };
     }
     return selector;

package/lib/module/configureOrderDeliveriesModule.d.ts

@@ -8,6 +8,9 @@ export declare const configureOrderDeliveriesModule: ({ OrderDeliveries, }: {
     findDelivery: ({ orderDeliveryId }: {
         orderDeliveryId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderDelivery | null>;
+    findDeliveries: ({ orderDeliveryIds }: {
+        orderDeliveryIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<OrderDelivery[]>;
     findDeliveryByProvidersId: ({ deliveryProviderIds }: {
         deliveryProviderIds: string[];
     }, options?: mongodb.FindOptions) => Promise<OrderDelivery[]>;

package/lib/module/configureOrderDeliveriesModule.js

@@ -32,6 +32,11 @@ export const configureOrderDeliveriesModule = ({ OrderDeliveries, }) => {
         findDelivery: async ({ orderDeliveryId }, options) => {
             return OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId), options);
         },
+        findDeliveries: async ({ orderDeliveryIds }, options) => {
+            if (!orderDeliveryIds?.length)
+                return [];
+            return OrderDeliveries.find({ _id: { $in: orderDeliveryIds } }, options).toArray();
+        },
         findDeliveryByProvidersId: async ({ deliveryProviderIds }, options) => {
             if (!deliveryProviderIds?.length)
                 return [];

package/lib/module/configureOrderDiscountsModule.d.ts

@@ -7,8 +7,10 @@ export declare const configureOrderDiscountsModule: ({ OrderDiscounts, }: {
     findOrderDiscount: ({ discountId }: {
         discountId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderDiscount | null>;
-    findOrderDiscounts: ({ orderId }: {
+    findOrderDiscounts: (query: {
         orderId: string;
+    } | {
+        orderIds: string[];
     }) => Promise<OrderDiscount[]>;
     create: (doc: Omit<OrderDiscount, "_id" | "created" | "trigger"> & Pick<Partial<OrderDiscount>, "_id" | "created" | "trigger">) => Promise<OrderDiscount>;
     delete: (orderDiscountId: string) => Promise<mongodb.WithId<OrderDiscount> | null>;

package/lib/module/configureOrderDiscountsModule.js

@@ -13,9 +13,13 @@ export const configureOrderDiscountsModule = ({ OrderDiscounts, }) => {
         findOrderDiscount: async ({ discountId }, options) => {
             return OrderDiscounts.findOne(buildFindOrderDiscountByIdSelector(discountId), options);
         },
-        findOrderDiscounts: async ({ orderId }) => {
-            const discounts = OrderDiscounts.find({ orderId });
-            return discounts.toArray();
+        findOrderDiscounts: async (query) => {
+            if ('orderIds' in query) {
+                if (!query.orderIds?.length)
+                    return [];
+                return OrderDiscounts.find({ orderId: { $in: query.orderIds } }).toArray();
+            }
+            return OrderDiscounts.find({ orderId: query.orderId }).toArray();
         },
         create: async (doc) => {
             const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;

package/lib/module/configureOrderPaymentsModule.d.ts

@@ -8,6 +8,9 @@ export declare const configureOrderPaymentsModule: ({ OrderPayments, }: {
     findOrderPayment: ({ orderPaymentId, }: {
         orderPaymentId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderPayment | null>;
+    findOrderPayments: ({ orderPaymentIds }: {
+        orderPaymentIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<OrderPayment[]>;
     findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
         paymentProviderIds: string[];
     }, options?: mongodb.FindOptions) => Promise<OrderPayment[]>;

package/lib/module/configureOrderPaymentsModule.js

@@ -35,6 +35,11 @@ export const configureOrderPaymentsModule = ({ OrderPayments, }) => {
         findOrderPayment: async ({ orderPaymentId, }, options) => {
             return OrderPayments.findOne(buildFindOrderPaymentByIdSelector(orderPaymentId), options);
         },
+        findOrderPayments: async ({ orderPaymentIds }, options) => {
+            if (!orderPaymentIds?.length)
+                return [];
+            return OrderPayments.find({ _id: { $in: orderPaymentIds } }, options).toArray();
+        },
         findOrderPaymentsByProviderIds: async ({ paymentProviderIds, }, options) => {
             if (!paymentProviderIds?.length)
                 return [];

package/lib/module/configureOrderPositionsModule.d.ts

@@ -23,8 +23,10 @@ export declare const configureOrderPositionsModule: ({ OrderPositions, }: {
     findOrderPosition: ({ itemId }: {
         itemId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderPosition | null>;
-    findOrderPositions: ({ orderId }: {
+    findOrderPositions: (query: {
         orderId: string;
+    } | {
+        orderIds: string[];
     }) => Promise<OrderPosition[]>;
     delete: (orderPositionId: string) => Promise<mongodb.WithId<OrderPosition> | null>;
     removePositions: ({ orderId }: {

package/lib/module/configureOrderPositionsModule.js

@@ -13,9 +13,16 @@ export const configureOrderPositionsModule = ({ OrderPositions, }) => {
         findOrderPosition: async ({ itemId }, options) => {
             return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
         },
-        findOrderPositions: async ({ orderId }) => {
-            const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } });
-            return positions.toArray();
+        findOrderPositions: async (query) => {
+            if ('orderIds' in query) {
+                if (!query.orderIds?.length)
+                    return [];
+                return OrderPositions.find({
+                    orderId: { $in: query.orderIds },
+                    quantity: { $gt: 0 },
+                }).toArray();
+            }
+            return OrderPositions.find({ orderId: query.orderId, quantity: { $gt: 0 } }).toArray();
         },
         delete: async (orderPositionId) => {
             const selector = buildFindOrderPositionByIdSelector(orderPositionId);

package/lib/module/configureOrdersModule.d.ts

@@ -6,6 +6,9 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findDelivery: ({ orderDeliveryId }: {
             orderDeliveryId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery | null>;
+        findDeliveries: ({ orderDeliveryIds }: {
+            orderDeliveryIds: string[];
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery[]>;
         findDeliveryByProvidersId: ({ deliveryProviderIds }: {
             deliveryProviderIds: string[];
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery[]>;
@@ -25,8 +28,10 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderDiscount: ({ discountId }: {
             discountId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount | null>;
-        findOrderDiscounts: ({ orderId }: {
+        findOrderDiscounts: (query: {
             orderId: string;
+        } | {
+            orderIds: string[];
         }) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount[]>;
         create: (doc: Omit<import("../db/OrderDiscountsCollection.ts").OrderDiscount, "_id" | "created" | "trigger"> & Pick<Partial<import("../db/OrderDiscountsCollection.ts").OrderDiscount>, "_id" | "created" | "trigger">) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount>;
         delete: (orderDiscountId: string) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.ts").OrderDiscount> | null>;
@@ -44,8 +49,10 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderPosition: ({ itemId }: {
             itemId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition | null>;
-        findOrderPositions: ({ orderId }: {
+        findOrderPositions: (query: {
             orderId: string;
+        } | {
+            orderIds: string[];
         }) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition[]>;
         delete: (orderPositionId: string) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.ts").OrderPosition> | null>;
         removePositions: ({ orderId }: {
@@ -84,6 +91,9 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderPayment: ({ orderPaymentId, }: {
             orderPaymentId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment | null>;
+        findOrderPayments: ({ orderPaymentIds }: {
+            orderPaymentIds: string[];
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment[]>;
         findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
             paymentProviderIds: string[];
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core-orders",
   "description": "Order management module for the Unchained Engine",
-  "version": "4.8.9",
+  "version": "4.8.11",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",