@unchainedshop/core-orders 2.12.2 → 3.0.0-alpha2

package/src/module/configureOrderPaymentsModule.ts

@@ -1,12 +1,10 @@
 import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
 import {
   OrderPayment,
   OrderPaymentsModule,
   OrderPaymentStatus,
 } from '@unchainedshop/types/orders.payments.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
 import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
 import { OrderPaymentsSchema } from '../db/OrderPaymentsSchema.js';
 
@@ -35,10 +33,8 @@ export const buildFindByContextDataSelector = (context: any): mongodb.Filter<Ord
 
 export const configureOrderPaymentsModule = ({
   OrderPayments,
-  updateCalculation,
 }: {
   OrderPayments: mongodb.Collection<OrderPayment>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderPaymentsModule => {
   registerEvents(ORDER_PAYMENT_EVENTS);
 
@@ -70,8 +66,6 @@ export const configureOrderPaymentsModule = ({
     orderPaymentId,
     { status, transactionId, info },
   ) => {
-    log(`OrderPayment ${orderPaymentId} -> New Status: ${status}`);
-
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderPayment> = {
       $set: { status, updated: new Date() },
@@ -293,13 +287,10 @@ export const configureOrderPaymentsModule = ({
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId, context, unchainedAPI) => {
+    updateContext: async (orderPaymentId, context) => {
       const selector = buildFindByIdSelector(orderPaymentId);
       if (!context || Object.keys(context).length === 0) return OrderPayments.findOne(selector, {});
 
-      log(`OrderPayment ${orderPaymentId} -> Update Context`, {
-        context,
-      });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -315,7 +306,6 @@ export const configureOrderPaymentsModule = ({
       );
 
       if (result.ok) {
-        await updateCalculation(result.value.orderId, unchainedAPI);
         await emit('ORDER_UPDATE_PAYMENT', {
           orderPayment: result.value,
         });
@@ -328,10 +318,6 @@ export const configureOrderPaymentsModule = ({
     updateStatus,
 
     updateCalculation: async (orderPayment, unchainedAPI) => {
-      log(`OrderPayment ${orderPayment._id} -> Update Calculation`, {
-        orderId: orderPayment.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.payment.paymentProviders.calculate(
         {
           item: orderPayment,

package/src/module/configureOrderPositionsModule.ts

@@ -1,15 +1,6 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
 import { OrderPosition, OrderPositionsModule } from '@unchainedshop/types/orders.positions.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import {
-  generateDbFilterById,
-  generateDbMutations,
-  generateDbObjectId,
-  mongodb,
-} from '@unchainedshop/mongodb';
-import { OrderPositionsSchema } from '../db/OrderPositionsSchema.js';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { ordersSettings } from '../orders-settings.js';
 
 const ORDER_POSITION_EVENTS: string[] = [
@@ -27,18 +18,11 @@ export const buildFindByIdSelector = (orderPositionId: string, orderId?: string)
 
 export const configureOrderPositionsModule = ({
   OrderPositions,
-  updateCalculation,
 }: {
   OrderPositions: mongodb.Collection<OrderPosition>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderPositionsModule => {
   registerEvents(ORDER_POSITION_EVENTS);
 
-  const mutations = generateDbMutations<OrderPosition>(OrderPositions, OrderPositionsSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderPosition>;
-
   return {
     // Queries
     findOrderPosition: async ({ itemId }, options) => {
@@ -72,68 +56,18 @@ export const configureOrderPositionsModule = ({
       });
     },
 
-    // Mutations
-
-    create: async (
-      { configuration, context, quantity, quotationId },
-      { order, product, originalProduct },
-      unchainedAPI,
-    ) => {
-      const orderId = order._id;
-      const productId = product._id;
-      const originalProductId = originalProduct ? originalProduct._id : undefined;
-
-      log(
-        `Create ${quantity}x Position with Product ${productId} ${
-          quotationId ? ` (${quotationId})` : ''
-        }`,
-        { orderId, productId, originalProductId },
-      );
-
-      const positionId = await mutations.create({
-        orderId,
-        productId,
-        originalProductId,
-        quotationId,
-        quantity,
-        configuration,
-        context,
-        calculation: [],
-        scheduling: [],
-      });
-
-      await updateCalculation(orderId, unchainedAPI);
-
-      return OrderPositions.findOne(buildFindByIdSelector(positionId));
-    },
-
-    delete: async (orderPositionId, unchainedAPI) => {
+    delete: async (orderPositionId) => {
       const selector = buildFindByIdSelector(orderPositionId);
-
-      log(`Remove Position ${orderPositionId}`, {
-        orderPositionId,
-      });
-
       const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
-
-      await updateCalculation(orderPosition.orderId, unchainedAPI);
-
       await emit('ORDER_REMOVE_CART_ITEM', {
         orderPosition,
       });
-
       return { ...orderPosition, calculation: [] };
     },
 
-    removePositions: async ({ orderId }, unchainedAPI) => {
-      log('Remove Positions', { orderId });
-
+    removePositions: async ({ orderId }) => {
       const result = await OrderPositions.deleteMany({ orderId });
-
-      await updateCalculation(orderId, unchainedAPI);
-
       await emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
-
       return result.deletedCount;
     },
 
@@ -173,11 +107,9 @@ export const configureOrderPositionsModule = ({
         unchainedAPI,
       );
 
-      await OrderPositions.updateOne(selector, modifier);
-
-      await updateCalculation(order._id, unchainedAPI);
-
-      const updatedOrderPosition = await OrderPositions.findOne(selector, {});
+      const updatedOrderPosition = await OrderPositions.findOneAndUpdate(selector, modifier, {
+        returnDocument: 'after',
+      });
 
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
@@ -186,9 +118,7 @@ export const configureOrderPositionsModule = ({
       return updatedOrderPosition;
     },
 
-    removeProductByIdFromAllOpenPositions: async (productId, unchainedAPI) => {
-      log('Remove Position Product', { productId });
-
+    removeProductByIdFromAllOpenPositions: async (productId) => {
       const positions = await OrderPositions.aggregate([
         {
           $match: {
@@ -211,15 +141,7 @@ export const configureOrderPositionsModule = ({
       ]).toArray();
 
       const positionIds = positions.map((o) => o._id);
-      const result = await OrderPositions.deleteMany({ _id: { $in: positionIds } });
-
-      const orderIdsToRecalculate = positions.map((o) => o.orderId);
-      await Promise.all(
-        [...new Set(orderIdsToRecalculate)].map(async (orderIdToRecalculate) => {
-          await updateCalculation(orderIdToRecalculate, unchainedAPI);
-        }),
-      );
-
+      await OrderPositions.deleteMany({ _id: { $in: positionIds } });
       await Promise.all(
         positions.map(async (orderPosition) => {
           await emit('ORDER_REMOVE_CART_ITEM', {
@@ -228,7 +150,8 @@ export const configureOrderPositionsModule = ({
         }),
       );
 
-      return result.deletedCount;
+      const orderIdsToRecalculate = positions.map((o) => o.orderId);
+      return orderIdsToRecalculate;
     },
 
     updateScheduling: async ({ order, orderDelivery, orderPosition }, unchainedAPI) => {
@@ -291,10 +214,6 @@ export const configureOrderPositionsModule = ({
     },
 
     updateCalculation: async (orderPosition, unchainedAPI) => {
-      log(`OrderPosition ${orderPosition._id} -> Update Calculation`, {
-        orderId: orderPosition.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.products.calculate(
         { item: orderPosition, configuration: orderPosition.configuration },
         unchainedAPI,
@@ -364,8 +283,6 @@ export const configureOrderPositionsModule = ({
         { upsert: true },
       );
 
-      await updateCalculation(orderId, unchainedAPI);
-
       const upsertedOrderPosition = await OrderPositions.findOne(selector);
 
       await emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });

package/src/module/configureOrdersModule-mutations.ts

@@ -1,9 +1,8 @@
 import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { Order, OrderStatus, OrderMutations, OrdersModule } from '@unchainedshop/types/orders.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 { emit, registerEvents } from '@unchainedshop/events';
-import { log, LogLevel } from '@unchainedshop/logger';
 import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
 import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
 import { OrdersSchema } from '../db/OrdersSchema.js';
@@ -21,15 +20,11 @@ export const configureOrderModuleMutations = ({
   OrderDeliveries,
   OrderPayments,
   OrderPositions,
-  initProviders,
-  updateCalculation,
 }: {
   Orders: mongodb.Collection<Order>;
   OrderDeliveries: mongodb.Collection<OrderDelivery>;
   OrderPayments: mongodb.Collection<OrderPayment>;
   OrderPositions: mongodb.Collection<OrderPosition>;
-  initProviders: OrdersModule['initProviders'];
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderMutations => {
   registerEvents(ORDER_EVENTS);
 
@@ -65,25 +60,6 @@ export const configureOrderModuleMutations = ({
       return deletedCount;
     },
 
-    initProviders,
-
-    invalidateProviders: async (unchainedAPI, maxAgeDays = 30) => {
-      log('Orders: Start invalidating cart providers', {
-        level: LogLevel.Verbose,
-      });
-
-      const ONE_DAY_IN_MILLISECONDS = 86400000;
-
-      const minValidDate = new Date(new Date().getTime() - maxAgeDays * ONE_DAY_IN_MILLISECONDS);
-
-      const orders = await Orders.find({
-        status: { $eq: null },
-        updated: { $gte: minValidDate },
-      }).toArray();
-
-      await Promise.all(orders.map((order) => initProviders(order, unchainedAPI)));
-    },
-
     setCartOwner: async ({ orderId, userId }) => {
       await Orders.updateOne(generateDbFilterById(orderId), {
         $set: {
@@ -103,8 +79,7 @@ export const configureOrderModuleMutations = ({
       );
     },
 
-    setDeliveryProvider: async (orderId, deliveryProviderId, unchainedAPI) => {
-      const { modules } = unchainedAPI;
+    setDeliveryProvider: async (orderId, deliveryProviderId, { modules }) => {
       const delivery = await OrderDeliveries.findOne({
         orderId,
         deliveryProviderId,
@@ -121,17 +96,17 @@ export const configureOrderModuleMutations = ({
           })
         )._id;
 
-      log(`Set Delivery Provider ${deliveryProviderId}`, { orderId });
-
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          deliveryId,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            deliveryId,
+            updated: new Date(),
+          },
         },
-      });
-
-      const order = await updateCalculation(orderId, unchainedAPI);
+        { returnDocument: 'after' },
+      );
 
       await emit('ORDER_SET_DELIVERY_PROVIDER', {
         order,
@@ -159,14 +134,14 @@ export const configureOrderModuleMutations = ({
             status: null,
           })
         )._id;
-      log(`Set Payment Provider ${paymentProviderId}`, { orderId });
-
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: { paymentId, updated: new Date() },
-      });
-
-      const order = await updateCalculation(orderId, unchainedAPI);
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: { paymentId, updated: new Date() },
+        },
+        { returnDocument: 'after' },
+      );
 
       await emit('ORDER_SET_PAYMENT_PROVIDER', {
         order,
@@ -176,45 +151,46 @@ export const configureOrderModuleMutations = ({
       return order;
     },
 
-    updateBillingAddress: async (orderId, billingAddress, unchainedAPI) => {
-      log('Update Invoicing Address', { orderId });
-
+    updateBillingAddress: async (orderId, billingAddress) => {
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          billingAddress,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            billingAddress,
+            updated: new Date(),
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const order = await updateCalculation(orderId, unchainedAPI);
       await emit('ORDER_UPDATE', { order, field: 'billing' });
       return order;
     },
 
-    updateContact: async (orderId, contact, unchainedAPI) => {
-      log('Update Contact', { orderId });
-
+    updateContact: async (orderId, contact) => {
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          contact,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            contact,
+            updated: new Date(),
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const order = await updateCalculation(orderId, unchainedAPI);
       await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateContext: async (orderId, context, unchainedAPI) => {
+    updateContext: async (orderId, context) => {
       const selector = generateDbFilterById<Order>(orderId);
       selector.status = { $in: [null, OrderStatus.PENDING] };
 
       if (!context || Object.keys(context).length === 0) return Orders.findOne(selector, {});
 
-      log('Update Arbitrary Context', { orderId, context });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -226,17 +202,14 @@ export const configureOrderModuleMutations = ({
             updated: new Date(),
           },
         },
-        { includeResultMetadata: true },
+        { includeResultMetadata: true, returnDocument: 'after' },
       );
 
       if (result.ok) {
-        const calculatedOrder = await updateCalculation(orderId, unchainedAPI);
-        await emit('ORDER_UPDATE', { order: calculatedOrder, field: 'context' });
-        return calculatedOrder;
+        await emit('ORDER_UPDATE', { order: result.value, field: 'context' });
+        return result.value;
       }
       return null;
     },
-
-    updateCalculation,
   };
 };

package/src/module/configureOrdersModule-processing.ts

@@ -5,7 +5,6 @@ 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 { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
 import { ProductType } from '@unchainedshop/types/products.js';
 import { UnchainedCore } from '@unchainedshop/types/core.js';
 import { ordersSettings } from '../orders-settings.js';
@@ -94,7 +93,6 @@ export const configureOrderModuleProcessing = ({
     );
 
     if (modificationResult.ok) {
-      log(`New Status: ${status}`, { orderId });
       if (order.status === null) {
         // The first time that an order transitions away from cart is a checkout event
         await emit('ORDER_CHECKOUT', { order: modificationResult.value, oldStatus: order.status });
@@ -149,11 +147,6 @@ export const configureOrderModuleProcessing = ({
     const validationErrors = await Promise.all(
       orderPositions.map(async (orderPosition) => {
         const errors = [];
-
-        log(`OrderPosition ${orderPosition._id} -> Validate ${orderPosition.quantity}`, {
-          orderId: orderPosition.orderId,
-        });
-
         const product = await unchainedAPI.modules.products.findProduct({
           productId: orderPosition.productId,
         });
@@ -475,11 +468,6 @@ export const configureOrderModuleProcessing = ({
               );
             }),
           );
-
-          // TODO: we will use this function to keep a "Ordered in Flight" amount, allowing us to
-          // do live stock stuff
-          // 2. Reserve quantity at Warehousing Provider until order is CANCELLED/FULLFILLED
-          // ???
         }
 
         nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);

package/src/module/configureOrdersModule.ts

@@ -95,7 +95,7 @@ export const configureOrdersModule = async ({
     await Promise.all(
       systemDiscounts
         .filter((key) => currentDiscountKeys.indexOf(key) === -1)
-        .map((discountKey) =>
+        .map(async (discountKey) =>
           modules.orders.discounts.create({
             orderId: order._id,
             discountKey,
@@ -256,6 +256,23 @@ export const configureOrdersModule = async ({
     );
   };
 
+  const invalidateProviders = async (unchainedAPI, maxAgeDays = 30) => {
+    const ONE_DAY_IN_MILLISECONDS = 86400000;
+
+    const minValidDate = new Date(new Date().getTime() - maxAgeDays * ONE_DAY_IN_MILLISECONDS);
+
+    const orders = await Orders.find({
+      status: { $eq: null },
+      updated: { $gte: minValidDate },
+    }).toArray();
+
+    await Promise.allSettled(
+      orders.map(async (order) => {
+        await updateCalculation(order._id, unchainedAPI);
+      }),
+    );
+  };
+
   const orderQueries = configureOrdersModuleQueries({ Orders });
   const orderTransformations = configureOrderModuleTransformations({
     Orders,
@@ -272,28 +289,22 @@ export const configureOrdersModule = async ({
     OrderDeliveries,
     OrderPayments,
     OrderPositions,
-    initProviders,
-    updateCalculation,
   });
 
   const orderDiscountsModule = configureOrderDiscountsModule({
     OrderDiscounts,
-    updateCalculation,
   });
 
   const orderPositionsModule = configureOrderPositionsModule({
     OrderPositions,
-    updateCalculation,
   });
 
   const orderPaymentsModule = configureOrderPaymentsModule({
     OrderPayments,
-    updateCalculation,
   });
 
   const orderDeliveriesModule = configureOrderDeliveriesModule({
     OrderDeliveries,
-    updateCalculation,
   });
 
   return {
@@ -302,6 +313,10 @@ export const configureOrdersModule = async ({
     ...orderProcessing,
     ...orderMutations,
 
+    initProviders,
+    updateCalculation,
+    invalidateProviders,
+
     // Subentities
     deliveries: orderDeliveriesModule,
     discounts: orderDiscountsModule,

package/src/service/migrateOrderCartService.ts

@@ -29,16 +29,12 @@ export const migrateOrderCartsService: MigrateOrderCartsService = async (
 
   // Move billing address if target order has none
   if (fromCart.billingAddress && !toCart.billingAddress) {
-    await unchainedAPI.modules.orders.updateBillingAddress(
-      toCart._id,
-      fromCart.billingAddress,
-      unchainedAPI,
-    );
+    await unchainedAPI.modules.orders.updateBillingAddress(toCart._id, fromCart.billingAddress);
   }
 
   // Move contact data if target order has none
   if (fromCart.contact && !toCart.contact) {
-    await unchainedAPI.modules.orders.updateContact(toCart._id, fromCart.contact, unchainedAPI);
+    await unchainedAPI.modules.orders.updateContact(toCart._id, fromCart.contact);
   }
 
   await unchainedAPI.modules.orders.updateCalculation(fromCart._id, unchainedAPI);

package/src/service/nextUserCartService.ts

@@ -1,11 +1,12 @@
 import { NextUserCartService } from '@unchainedshop/types/orders.js';
 import { ordersSettings } from '../orders-settings.js';
+import { resolveBestCurrency } from '@unchainedshop/utils';
 
 export const nextUserCartService: NextUserCartService = async (
   { user, orderNumber, countryCode, forceCartCreation },
   unchainedAPI,
 ) => {
-  const { modules, services } = unchainedAPI;
+  const { modules } = unchainedAPI;
 
   const cart = await modules.orders.cart({
     countryContext: countryCode || user.lastLogin?.countryCode,
@@ -17,12 +18,9 @@ export const nextUserCartService: NextUserCartService = async (
   const shouldCreateNewCart = forceCartCreation || ordersSettings.ensureUserHasCart;
   if (!shouldCreateNewCart) return null;
 
-  const currency = await services.countries.resolveDefaultCurrencyCode(
-    {
-      isoCode: countryCode,
-    },
-    unchainedAPI,
-  );
+  const countryObject = await modules.countries.findCountry({ isoCode: countryCode });
+  const currencies = await modules.currencies.findCurrencies({ includeInactive: false });
+  const currency = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
 
   const order = await modules.orders.create({
     userId: user._id,