@unchainedshop/core-orders 4.3.4 → 4.5.0

package/src/module/buildFindSelector.test.ts

@@ -1,121 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { OrderStatus } from '../db/OrdersCollection.js';
-import { buildFindByIdSelector as buildFindByIdSelectorForDelivery } from './configureOrderDeliveriesModule.js';
-import { buildFindOrderDiscountByIdSelector } from './configureOrderDiscountsModule.js';
-import {
-  buildFindOrderPaymentByIdSelector,
-  buildFindByContextDataSelector,
-} from './configureOrderPaymentsModule.js';
-import { buildFindOrderPositionByIdSelector } from './configureOrderPositionsModule.js';
-import buildFindSelectorForOrder from './buildFindSelector.js';
-
-describe('OrderPosition', () => {
-  describe('buildFindSelector', () => {
-    it('Return filter object when passed no argument', () => {
-      assert.deepStrictEqual(buildFindSelectorForOrder({}), { status: { $ne: null } });
-    });
-
-    it('Return filter object when passed includeCarts, queryString, status, userId and (status should take precedence over includeCarts)', () => {
-      assert.deepStrictEqual(
-        buildFindSelectorForOrder({
-          includeCarts: false,
-          queryString: 'hello world',
-          status: [OrderStatus.CONFIRMED],
-          userId: 'admin-id',
-        }),
-        {
-          userId: 'admin-id',
-          status: {
-            $in: ['CONFIRMED'],
-          },
-          $text: { $search: 'hello world' },
-        },
-      );
-    });
-
-    it('Return filter object when passed includeCarts, queryString, userId', () => {
-      assert.deepStrictEqual(
-        buildFindSelectorForOrder({
-          includeCarts: true,
-          queryString: 'hello world',
-          userId: 'admin-id',
-        }),
-        {
-          userId: 'admin-id',
-          $text: { $search: 'hello world' },
-        },
-      );
-    });
-
-    it('Return filter object when passed queryString, userId', () => {
-      assert.deepStrictEqual(
-        buildFindSelectorForOrder({ queryString: 'hello world', userId: 'admin-id' }),
-        {
-          userId: 'admin-id',
-          $text: { $search: 'hello world' },
-          status: { $ne: null },
-        },
-      );
-    });
-
-    it('Return filter object when passed queryString', () => {
-      assert.deepStrictEqual(buildFindSelectorForOrder({ queryString: 'hello world' }), {
-        $text: { $search: 'hello world' },
-        status: { $ne: null },
-      });
-    });
-  });
-});
-
-describe('OrderDelivery', () => {
-  describe('buildFindByIdSelector', () => {
-    it('Return correct db _id selector', () => {
-      assert.deepStrictEqual(buildFindByIdSelectorForDelivery('order-delivery-id'), {
-        _id: 'order-delivery-id',
-      });
-    });
-  });
-});
-
-describe('OrderDiscount', () => {
-  describe('buildFindByIdSelector', () => {
-    it('Return correct db _id selector', () => {
-      assert.deepStrictEqual(buildFindOrderDiscountByIdSelector('order-discount-id'), {
-        _id: 'order-discount-id',
-      });
-    });
-  });
-});
-
-describe('OrderPayment', () => {
-  describe('buildFindByIdSelector', () => {
-    it('Return correct db _id selector', () => {
-      assert.deepStrictEqual(buildFindOrderPaymentByIdSelector('order-payment-id'), {
-        _id: 'order-payment-id',
-      });
-    });
-  });
-
-  describe('buildFindByContextDataSelector', () => {
-    it('Return correct db context field selector object', () => {
-      assert.deepStrictEqual(
-        buildFindByContextDataSelector({ first: 'first value', second: 'second value' }),
-        {
-          'context.first': 'first value',
-          'context.second': 'second value',
-        },
-      );
-    });
-  });
-});
-
-describe('OrderPosition', () => {
-  describe('buildFindByIdSelector', () => {
-    it('Return correct db _id selector', () => {
-      assert.deepStrictEqual(buildFindOrderPositionByIdSelector('order-position-id'), {
-        _id: 'order-position-id',
-      });
-    });
-  });
-});

package/src/module/buildFindSelector.ts

@@ -1,49 +0,0 @@
-import { OrderQuery, Order } from '../db/OrdersCollection.js';
-import { assertDocumentDBCompatMode, mongodb } from '@unchainedshop/mongodb';
-
-export const buildFindSelector = ({
-  includeCarts,
-  status,
-  userId,
-  queryString,
-  paymentIds,
-  deliveryIds,
-  dateRange,
-  ...rest
-}: OrderQuery) => {
-  const selector: mongodb.Filter<Order> = { ...rest };
-
-  if (userId) {
-    selector.userId = userId;
-  }
-  if (dateRange) {
-    const dateFilter: mongodb.Filter<Order> = {};
-    if (dateRange.start) dateFilter.$gte = new Date(dateRange.start);
-    if (dateRange.end) dateFilter.$lte = new Date(dateRange.end);
-    if (Object.keys(dateFilter).length > 0) {
-      selector.ordered = dateFilter;
-    }
-  }
-
-  if (Array.isArray(deliveryIds) && deliveryIds?.length) {
-    selector.deliveryId = { $in: deliveryIds };
-  }
-
-  if (Array.isArray(paymentIds) && paymentIds?.length) {
-    selector.paymentId = { $in: paymentIds };
-  }
-
-  if (Array.isArray(status) && status?.length) {
-    selector.status = { $in: status };
-  } else if (!includeCarts) {
-    selector.status = { $ne: null };
-  }
-  if (queryString) {
-    assertDocumentDBCompatMode();
-    (selector as any).$text = { $search: queryString };
-  }
-
-  return selector;
-};
-
-export default buildFindSelector;

package/src/module/configureOrderDeliveriesModule.ts

@@ -1,157 +0,0 @@
-import { mongodb, generateDbFilterById, generateDbObjectId } from '@unchainedshop/mongodb';
-import { emit, registerEvents } from '@unchainedshop/events';
-import { PricingCalculation } from '@unchainedshop/utils';
-import { OrderDelivery, OrderDeliveryStatus } from '../db/OrderDeliveriesCollection.js';
-
-const ORDER_DELIVERY_EVENTS: string[] = ['ORDER_DELIVER', 'ORDER_UPDATE_DELIVERY'];
-
-export const buildFindByIdSelector = (orderDeliveryId: string) =>
-  generateDbFilterById(orderDeliveryId) as mongodb.Filter<OrderDelivery>;
-
-export const configureOrderDeliveriesModule = ({
-  OrderDeliveries,
-}: {
-  OrderDeliveries: mongodb.Collection<OrderDelivery>;
-}) => {
-  registerEvents(ORDER_DELIVERY_EVENTS);
-
-  const normalizedStatus = (orderDelivery: OrderDelivery) => {
-    return orderDelivery.status === null
-      ? OrderDeliveryStatus.OPEN
-      : (orderDelivery.status as OrderDeliveryStatus);
-  };
-
-  const updateStatus = async (
-    orderDeliveryId: string,
-    { status, info }: { status: OrderDeliveryStatus; info?: string },
-  ) => {
-    const date = new Date();
-    const modifier: mongodb.UpdateFilter<OrderDelivery> = {
-      $set: { status, updated: new Date() },
-      $push: {
-        log: {
-          date,
-          status,
-          info,
-        },
-      },
-    };
-    if (status === OrderDeliveryStatus.DELIVERED) {
-      // eslint-disable-next-line
-      // @ts-ignore
-      modifier.$set.delivered = date;
-    }
-
-    const selector = buildFindByIdSelector(orderDeliveryId);
-    return OrderDeliveries.findOneAndUpdate(selector, modifier, { returnDocument: 'after' });
-  };
-
-  return {
-    // Queries
-    findDelivery: async (
-      { orderDeliveryId }: { orderDeliveryId: string },
-      options?: mongodb.FindOptions,
-    ) => {
-      return OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId), options);
-    },
-
-    findDeliveryByProvidersId: async (
-      { deliveryProviderIds }: { deliveryProviderIds: string[] },
-      options?: mongodb.FindOptions,
-    ): Promise<OrderDelivery[]> => {
-      if (!deliveryProviderIds?.length) return [];
-      return OrderDeliveries.find(
-        { deliveryProviderId: { $in: deliveryProviderIds } },
-        options,
-      ).toArray();
-    },
-
-    normalizedStatus,
-
-    // Mutations
-
-    create: async (
-      doc: Omit<OrderDelivery, '_id' | 'created'> & Pick<Partial<OrderDelivery>, '_id' | 'created'>,
-    ) => {
-      const { insertedId: orderDeliveryId } = await OrderDeliveries.insertOne({
-        _id: generateDbObjectId(),
-        created: new Date(),
-        ...doc,
-        context: doc.context || {},
-        status: null,
-      });
-
-      const orderDelivery = (await OrderDeliveries.findOne(
-        buildFindByIdSelector(orderDeliveryId),
-      )) as OrderDelivery;
-      return orderDelivery;
-    },
-
-    delete: async (orderDeliveryId: string) => {
-      const { deletedCount } = await OrderDeliveries.deleteOne({ _id: orderDeliveryId });
-      return deletedCount;
-    },
-
-    markAsDelivered: async (orderDelivery: OrderDelivery) => {
-      if (normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN) return;
-      const updatedOrderDelivery = await updateStatus(orderDelivery._id, {
-        status: OrderDeliveryStatus.DELIVERED,
-        info: 'mark delivered manually',
-      });
-      await emit('ORDER_DELIVER', { orderDelivery: updatedOrderDelivery });
-      return updatedOrderDelivery;
-    },
-
-    updateContext: async (orderDeliveryId: string, context: any) => {
-      const selector = buildFindByIdSelector(orderDeliveryId);
-      if (!context || Object.keys(context).length === 0) return OrderDeliveries.findOne(selector, {});
-      const contextSetters = Object.fromEntries(
-        Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
-      );
-
-      const orderDelivery = await OrderDeliveries.findOneAndUpdate(
-        selector,
-        {
-          $set: {
-            ...contextSetters,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-
-      if (!orderDelivery) return null;
-      await emit('ORDER_UPDATE_DELIVERY', {
-        orderDelivery,
-      });
-      return orderDelivery;
-    },
-
-    updateStatus,
-
-    updateCalculation: async <T extends PricingCalculation>(
-      orderDeliveryId: string,
-      calculation: T[],
-    ) => {
-      return OrderDeliveries.findOneAndUpdate(
-        { _id: orderDeliveryId },
-        {
-          $set: {
-            calculation,
-            updated: new Date(),
-          },
-        },
-        {
-          returnDocument: 'after',
-        },
-      );
-    },
-
-    deleteOrderDeliveries: async (orderId: string) => {
-      const { deletedCount } = await OrderDeliveries.deleteMany({ orderId });
-      return deletedCount;
-    },
-  };
-};
-
-export type OrderDeliveriesModule = ReturnType<typeof configureOrderDeliveriesModule>;

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