@unchainedshop/core-orders 4.3.4 → 4.4.0

package/src/module/configureOrderDiscountsModule.ts

@@ -1,95 +0,0 @@
-import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
-import { OrderDiscount, OrderDiscountTrigger } from '../db/OrderDiscountsCollection.js';
-
-const ORDER_DISCOUNT_EVENTS: string[] = [
-  'ORDER_CREATE_DISCOUNT',
-  'ORDER_UPDATE_DISCOUNT',
-  'ORDER_REMOVE_DISCOUNT',
-];
-
-export const buildFindOrderDiscountByIdSelector = (orderDiscountId: string) =>
-  generateDbFilterById(orderDiscountId) as mongodb.Filter<OrderDiscount>;
-
-export const configureOrderDiscountsModule = ({
-  OrderDiscounts,
-}: {
-  OrderDiscounts: mongodb.Collection<OrderDiscount>;
-}) => {
-  registerEvents(ORDER_DISCOUNT_EVENTS);
-
-  return {
-    // Queries
-    findOrderDiscount: async ({ discountId }: { discountId: string }, options?: mongodb.FindOptions) => {
-      return OrderDiscounts.findOne(buildFindOrderDiscountByIdSelector(discountId), options);
-    },
-
-    findOrderDiscounts: async ({ orderId }: { orderId: string }): Promise<OrderDiscount[]> => {
-      const discounts = OrderDiscounts.find({ orderId });
-      return discounts.toArray();
-    },
-
-    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(),
-        created: new Date(),
-        ...doc,
-        trigger: normalizedTrigger,
-      });
-      const discount = (await OrderDiscounts.findOne({
-        _id: discountId,
-      })) as OrderDiscount;
-      await emit('ORDER_CREATE_DISCOUNT', { discount });
-      return discount;
-    },
-
-    delete: async (orderDiscountId: string) => {
-      const selector = buildFindOrderDiscountByIdSelector(orderDiscountId);
-      const orderDiscount = await OrderDiscounts.findOneAndDelete(selector);
-      await emit('ORDER_REMOVE_DISCOUNT', { discount: orderDiscount });
-      return orderDiscount;
-    },
-
-    isDiscountCodeUsed: async ({ code, orderId }): Promise<boolean> => {
-      return (
-        (await OrderDiscounts.countDocuments({
-          code,
-          orderId,
-        })) > 0
-      );
-    },
-
-    findSpareDiscount: async ({ code }) => {
-      return OrderDiscounts.findOne({
-        code,
-        orderId: { $exists: false },
-      });
-    },
-
-    update: async (orderDiscountId: string, doc: Partial<OrderDiscount>) => {
-      const discount = await OrderDiscounts.findOneAndUpdate(
-        { _id: orderDiscountId },
-        {
-          $set: {
-            updated: new Date(),
-            ...doc,
-          },
-        },
-        { returnDocument: 'after' },
-      );
-
-      await emit('ORDER_UPDATE_DISCOUNT', { discount });
-      return discount;
-    },
-    deleteOrderDiscounts: async (orderId: string) => {
-      const { deletedCount } = await OrderDiscounts.deleteMany({ orderId });
-      return deletedCount;
-    },
-  };
-};
-
-export type OrderDiscountsModule = ReturnType<typeof configureOrderDiscountsModule>;

package/src/module/configureOrderPaymentsModule.ts

@@ -1,224 +0,0 @@
-import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
-import { PricingCalculation } from '@unchainedshop/utils';
-import { OrderPayment, OrderPaymentStatus } from '../db/OrderPaymentsCollection.js';
-
-const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
-
-export const buildFindOrderPaymentByIdSelector = (orderPaymentId: string) =>
-  generateDbFilterById(orderPaymentId) as mongodb.Filter<OrderPayment>;
-
-export const buildFindByContextDataSelector = (context: any) => {
-  const contextKeys = Object.keys(context);
-
-  if (contextKeys.length === 0) return null;
-
-  const selector: mongodb.Filter<OrderPayment> = contextKeys.reduce(
-    (currentSelector, key) =>
-      context[key] !== undefined
-        ? {
-            ...currentSelector,
-            [`context.${key}`]: context[key],
-          }
-        : currentSelector,
-    {},
-  );
-  return selector;
-};
-
-export const configureOrderPaymentsModule = ({
-  OrderPayments,
-}: {
-  OrderPayments: mongodb.Collection<OrderPayment>;
-}) => {
-  registerEvents(ORDER_PAYMENT_EVENTS);
-
-  const normalizedStatus = (orderPayment: OrderPayment) => {
-    return orderPayment.status === null
-      ? OrderPaymentStatus.OPEN
-      : (orderPayment.status as OrderPaymentStatus);
-  };
-
-  const updateStatus = async (
-    orderPaymentId: string,
-    {
-      transactionId,
-      status,
-      info,
-    }: { transactionId?: string; status: OrderPaymentStatus; info?: string },
-  ) => {
-    const date = new Date();
-    const modifier: mongodb.UpdateFilter<OrderPayment> = {
-      $set: { status, updated: new Date() },
-      $push: {
-        log: {
-          date,
-          status,
-          info,
-        },
-      },
-    };
-    if (transactionId) {
-      // eslint-disable-next-line
-      // @ts-ignore
-      modifier.$set.transactionId = transactionId;
-    }
-    if (status === OrderPaymentStatus.PAID) {
-      // eslint-disable-next-line
-      // @ts-ignore
-      modifier.$set.paid = date;
-    }
-
-    const selector = buildFindOrderPaymentByIdSelector(orderPaymentId);
-    return OrderPayments.findOneAndUpdate(selector, modifier, { returnDocument: 'after' });
-  };
-
-  return {
-    // Queries
-    findOrderPayment: async (
-      {
-        orderPaymentId,
-      }: {
-        orderPaymentId: string;
-      },
-      options?: mongodb.FindOptions,
-    ) => {
-      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,
-      }: {
-        context: any;
-      },
-      options?: mongodb.FindOptions,
-    ) => {
-      const selector = buildFindByContextDataSelector(context);
-      if (!selector) return null;
-      return OrderPayments.findOne(selector, options);
-    },
-    countOrderPaymentsByContextData: async (
-      {
-        context,
-      }: {
-        context: any;
-      },
-      options?: mongodb.FindOptions,
-    ) => {
-      const selector = buildFindByContextDataSelector(context);
-      if (!selector) return 0;
-      return OrderPayments.countDocuments(selector, options);
-    },
-
-    normalizedStatus,
-
-    // Mutations
-
-    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(),
-        ...doc,
-        status: null,
-        context: doc.context || {},
-      });
-
-      const orderPayment = (await OrderPayments.findOne(
-        buildFindOrderPaymentByIdSelector(orderPaymentId),
-      )) as OrderPayment;
-
-      return orderPayment;
-    },
-
-    logEvent: async (orderPaymentId: string, event: any): Promise<boolean> => {
-      const date = new Date();
-      const modifier = {
-        $push: {
-          log: {
-            date,
-            status: undefined,
-            info: JSON.stringify(event),
-          },
-        },
-      };
-      await OrderPayments.updateOne(generateDbFilterById(orderPaymentId), modifier);
-
-      return true;
-    },
-
-    markAsPaid: async (orderPayment: OrderPayment, meta: any) => {
-      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) return;
-
-      await updateStatus(orderPayment._id, {
-        status: OrderPaymentStatus.PAID,
-        info: meta ? JSON.stringify(meta) : 'mark paid manually',
-      });
-      await emit('ORDER_PAY', { 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 orderPayment = await OrderPayments.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            ...contextSetters,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-
-      if (!orderPayment) return null;
-      await emit('ORDER_UPDATE_PAYMENT', {
-        orderPayment,
-      });
-      return orderPayment;
-    },
-
-    updateStatus,
-
-    updateCalculation: async <T extends PricingCalculation>(
-      orderPaymentId: string,
-      calculation: T[],
-    ) => {
-      return OrderPayments.findOneAndUpdate(
-        buildFindOrderPaymentByIdSelector(orderPaymentId),
-        {
-          $set: {
-            calculation,
-            updated: new Date(),
-          },
-        },
-        {
-          returnDocument: 'after',
-        },
-      );
-    },
-    deleteOrderPayments: async (orderId: string) => {
-      const { deletedCount } = await OrderPayments.deleteMany({ orderId });
-      return deletedCount;
-    },
-  };
-};
-
-export type OrderPaymentsModule = ReturnType<typeof configureOrderPaymentsModule>;

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>;