@unchainedshop/core-orders 4.3.4 → 4.5.0

package/src/module/configureOrderPositionsModule.ts

@@ -1,244 +0,0 @@
-import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
-import { PricingCalculation } from '@unchainedshop/utils';
-import { OrderPosition } from '../db/OrderPositionsCollection.js';
-
-const ORDER_POSITION_EVENTS: string[] = [
-  'ORDER_UPDATE_CART_ITEM',
-  'ORDER_REMOVE_CART_ITEM',
-  'ORDER_EMPTY_CART',
-  '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,
-    orderId ? { orderId } : undefined,
-  ) as mongodb.Filter<OrderPosition>;
-
-export const configureOrderPositionsModule = ({
-  OrderPositions,
-}: {
-  OrderPositions: mongodb.Collection<OrderPosition>;
-}) => {
-  registerEvents(ORDER_POSITION_EVENTS);
-
-  return {
-    // Queries
-    findOrderPosition: async ({ itemId }: { itemId: string }, options?: mongodb.FindOptions) => {
-      return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
-    },
-
-    findOrderPositions: async ({ orderId }: { orderId: string }): Promise<OrderPosition[]> => {
-      const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } });
-      return positions.toArray();
-    },
-
-    delete: async (orderPositionId: string) => {
-      const selector = buildFindOrderPositionByIdSelector(orderPositionId);
-      const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
-      await emit('ORDER_REMOVE_CART_ITEM', {
-        orderPosition,
-      });
-      return orderPosition;
-    },
-
-    removePositions: async ({ orderId }: { orderId: string }): Promise<number> => {
-      const result = await OrderPositions.deleteMany({ orderId });
-      await emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
-      return result.deletedCount;
-    },
-
-    updateProductItem: async ({
-      orderPositionId,
-      quantity,
-      configuration,
-    }: {
-      orderPositionId: string;
-      configuration: { key: string; value: string }[] | null;
-      quantity: number | null;
-    }) => {
-      const modifier: any = {
-        $set: {
-          updated: new Date(),
-        },
-      };
-
-      if (quantity !== null) {
-        modifier.$set.quantity = quantity;
-      }
-
-      if (configuration !== null) {
-        modifier.$set.configuration = configuration;
-      }
-
-      const updatedOrderPosition = await OrderPositions.findOneAndUpdate(
-        {
-          _id: orderPositionId,
-        },
-        modifier,
-        {
-          returnDocument: 'after',
-        },
-      );
-
-      if (!updatedOrderPosition) return null;
-      await emit('ORDER_UPDATE_CART_ITEM', {
-        orderPosition: updatedOrderPosition,
-      });
-
-      return updatedOrderPosition;
-    },
-
-    removeProductByIdFromAllOpenPositions: async (productId: string): Promise<string[]> => {
-      const positions = await OrderPositions.aggregate([
-        {
-          $match: {
-            productId,
-          },
-        },
-        {
-          $lookup: {
-            from: 'orders',
-            localField: 'orderId',
-            foreignField: '_id',
-            as: 'order',
-          },
-        },
-        {
-          $match: {
-            'order.status': null,
-          },
-        },
-      ]).toArray();
-
-      const positionIds = positions.map((o) => o._id);
-      await OrderPositions.deleteMany({ _id: { $in: positionIds } });
-      await Promise.all(
-        positions.map(async (orderPosition) => {
-          await emit('ORDER_REMOVE_CART_ITEM', {
-            orderPosition,
-          });
-        }),
-      );
-
-      const orderIdsToRecalculate = positions.map((o) => o.orderId);
-      return orderIdsToRecalculate;
-    },
-
-    updateScheduling: async (orderPositionId, scheduling) => {
-      return OrderPositions.findOneAndUpdate(
-        generateDbFilterById(orderPositionId),
-        {
-          $set: { scheduling },
-        },
-        {
-          returnDocument: 'after',
-        },
-      );
-    },
-
-    updateCalculation: async <T extends PricingCalculation>(
-      orderPositionId: string,
-      calculation: T[],
-    ) => {
-      return OrderPositions.findOneAndUpdate(
-        { _id: orderPositionId },
-        {
-          $set: { calculation },
-        },
-        {
-          returnDocument: 'after',
-        },
-      );
-    },
-
-    addProductItem: async (orderPosition: {
-      context?: any;
-      configuration?: { key: string; value: string }[] | null;
-      orderId: string;
-      originalProductId: string;
-      productId: string;
-      quantity: number;
-      quotationId?: string;
-    }): Promise<OrderPosition> => {
-      const { configuration, orderId, originalProductId, productId, quantity, ...scope } = orderPosition;
-
-      // Search for existing position
-      const selector: mongodb.Filter<OrderPosition> = {
-        orderId,
-        productId,
-        originalProductId,
-        configuration: configuration ?? null,
-        ...scope,
-      };
-
-      const upsertedOrderPosition = (await OrderPositions.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            updated: new Date(),
-          },
-          $inc: { quantity },
-          $setOnInsert: {
-            _id: generateDbObjectId(),
-            created: new Date(),
-            calculation: [],
-            scheduling: [],
-            orderId,
-            productId,
-            originalProductId,
-            configuration,
-            ...scope,
-          },
-        },
-        { 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();
-    },
-  };
-};
-
-export type OrderPositionsModule = ReturnType<typeof configureOrderPositionsModule>;

package/src/module/configureOrdersModule-mutations.ts

@@ -1,178 +0,0 @@
-import { emit, registerEvents } from '@unchainedshop/events';
-import {
-  Address,
-  Contact,
-  generateDbFilterById,
-  generateDbObjectId,
-  mongodb,
-} from '@unchainedshop/mongodb';
-import { Order, OrderStatus } from '../db/OrdersCollection.js';
-import { OrderPosition } from '../db/OrderPositionsCollection.js';
-
-const ORDER_EVENTS: string[] = [
-  'ORDER_CREATE',
-  'ORDER_REMOVE',
-  'ORDER_SET_DELIVERY_PROVIDER',
-  'ORDER_SET_PAYMENT_PROVIDER',
-  'ORDER_UPDATE',
-];
-
-export const configureOrderModuleMutations = ({
-  Orders,
-  OrderPositions,
-}: {
-  Orders: mongodb.Collection<Order>;
-  OrderPositions: mongodb.Collection<OrderPosition>;
-}) => {
-  registerEvents(ORDER_EVENTS);
-
-  return {
-    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(),
-        status: null,
-        billingAddress,
-        contact,
-        userId,
-        currencyCode,
-        countryCode,
-        calculation: [],
-        log: [],
-        orderNumber,
-        context: context || {},
-      });
-
-      const order = (await Orders.findOne(generateDbFilterById(orderId), {})) as Order;
-
-      await emit('ORDER_CREATE', { order });
-      return order;
-    },
-
-    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 }: { orderId: string; userId: string }) => {
-      await Orders.updateOne(generateDbFilterById(orderId), {
-        $set: {
-          userId,
-        },
-      });
-    },
-
-    moveCartPositions: async ({
-      fromOrderId,
-      toOrderId,
-    }: {
-      fromOrderId: string;
-      toOrderId: string;
-    }) => {
-      await OrderPositions.updateMany(
-        { orderId: fromOrderId },
-        {
-          $set: {
-            orderId: toOrderId,
-          },
-        },
-      );
-    },
-
-    updateBillingAddress: async (orderId: string, billingAddress: Address) => {
-      const selector = generateDbFilterById(orderId);
-      const order = await Orders.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            billingAddress,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-      if (!order) return null;
-      await emit('ORDER_UPDATE', { order, field: 'billingAddress' });
-      return order;
-    },
-
-    updateContact: async (orderId: string, contact: Contact) => {
-      const selector = generateDbFilterById(orderId);
-      const order = await Orders.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            contact,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-      if (!order) return null;
-      await emit('ORDER_UPDATE', { order, field: 'contact' });
-      return order;
-    },
-
-    updateCalculationSheet: async (orderId: string, calculation: any) => {
-      const selector = generateDbFilterById(orderId);
-      const order = await Orders.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            calculation,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-      if (!order) return null;
-      await emit('ORDER_UPDATE', { order, field: 'calculation' });
-      return order;
-    },
-
-    updateContext: async (orderId: string, context: any) => {
-      const selector = generateDbFilterById<Order>(orderId);
-      selector.status = { $in: [null, OrderStatus.PENDING] };
-
-      if (!context || Object.keys(context).length === 0) return Orders.findOne(selector, {});
-
-      const contextSetters = Object.fromEntries(
-        Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
-      );
-      const order = await Orders.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            ...contextSetters,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-      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,159 +0,0 @@
-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';
-
-export interface OrderReport {
-  newCount: number;
-  checkoutCount: number;
-  rejectCount: number;
-  confirmCount: number;
-  fulfillCount: number;
-}
-export interface OrderStatisticsRecord {
-  date: string;
-  total: {
-    amount: number;
-    currency: string;
-  };
-}
-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 {
-    isCart: (order: Order) => {
-      return order.status === null;
-    },
-
-    cart: async ({
-      orderNumber,
-      countryCode,
-      userId,
-    }: {
-      countryCode?: string;
-      orderNumber?: string;
-      userId: string;
-    }) => {
-      const selector: mongodb.Filter<Order> = {
-        countryCode,
-        status: { $eq: null },
-        userId,
-      };
-
-      if (orderNumber) {
-        selector.orderNumber = orderNumber;
-      }
-
-      const options: mongodb.FindOptions = {
-        sort: {
-          updated: -1,
-        },
-      };
-      return Orders.findOne(selector, options);
-    },
-
-    count: async (query: OrderQuery): Promise<number> => {
-      const orderCount = await Orders.countDocuments(buildFindSelector(query));
-      return orderCount;
-    },
-    findOrder: async (
-      {
-        orderId,
-        orderNumber,
-      }: {
-        orderId?: string;
-        orderNumber?: string;
-      },
-      options?: mongodb.FindOptions,
-    ) => {
-      const selector = orderId ? generateDbFilterById(orderId) : { orderNumber };
-      return Orders.findOne(selector, options);
-    },
-
-    findCartsToInvalidate: async (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();
-
-      return orders;
-    },
-
-    findOrders: async (
-      {
-        limit,
-        offset,
-        queryString,
-        sort,
-        ...query
-      }: OrderQuery & {
-        limit?: number;
-        offset?: number;
-        sort?: SortOption[];
-      },
-      options?: mongodb.FindOptions,
-    ): Promise<Order[]> => {
-      const defaultSortOption: SortOption[] = [{ key: 'created', value: SortDirection.DESC }];
-      const findOptions: mongodb.FindOptions = {
-        skip: offset,
-        limit,
-        sort: buildSortOptions(sort || defaultSortOption),
-      };
-      const selector = buildFindSelector({ queryString, ...query });
-
-      if (queryString) {
-        return Orders.find(selector, {
-          ...options,
-          projection: { score: { $meta: 'textScore' } },
-          sort: { score: { $meta: 'textScore' } },
-        }).toArray();
-      }
-
-      return Orders.find(selector, findOptions).toArray();
-    },
-    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();
-    },
-  };
-};
-
-export type OrderQueries = ReturnType<typeof configureOrdersModuleQueries>;