@unchainedshop/core-orders 4.3.4 → 4.4.0

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

package/src/module/configureOrdersModule.ts

@@ -1,257 +0,0 @@
-import { generateDbFilterById, ModuleInput, mongodb } from '@unchainedshop/mongodb';
-import { createRequire } from 'node:module';
-import { OrderDeliveriesCollection } from '../db/OrderDeliveriesCollection.js';
-import { OrderDiscountsCollection } from '../db/OrderDiscountsCollection.js';
-import { OrderPaymentsCollection } from '../db/OrderPaymentsCollection.js';
-import { OrderPositionsCollection } from '../db/OrderPositionsCollection.js';
-import { OrdersCollection, Order, OrderStatus } from '../db/OrdersCollection.js';
-import { ordersSettings, OrdersSettingsOptions } from '../orders-settings.js';
-import { configureOrderDeliveriesModule } from './configureOrderDeliveriesModule.js';
-import { configureOrderDiscountsModule } from './configureOrderDiscountsModule.js';
-import { configureOrderPaymentsModule } from './configureOrderPaymentsModule.js';
-import { configureOrderPositionsModule } from './configureOrderPositionsModule.js';
-import { configureOrderModuleMutations } from './configureOrdersModule-mutations.js';
-import { configureOrdersModuleQueries } from './configureOrdersModule-queries.js';
-import { emit, registerEvents } from '@unchainedshop/events';
-
-import renameCurrencyCode from '../migrations/20250502111800-currency-code.js';
-
-// @kontsedal/locco uses a deprecated way of importing files in ESM (node16 behavior)
-const require = createRequire(import.meta.url);
-const { Locker, MongoAdapter } = require('@kontsedal/locco');
-
-const ORDER_EVENTS: string[] = [
-  'ORDER_CHECKOUT',
-  'ORDER_CONFIRMED',
-  'ORDER_REJECTED',
-  'ORDER_FULLFILLED',
-];
-
-export const configureOrdersModule = async ({
-  db,
-  migrationRepository,
-  options: orderOptions = {},
-}: ModuleInput<OrdersSettingsOptions>) => {
-  // Migration v3 -> v4
-  renameCurrencyCode(migrationRepository);
-
-  registerEvents(ORDER_EVENTS);
-
-  ordersSettings.configureSettings(orderOptions);
-
-  const Orders = await OrdersCollection(db);
-  const OrderDeliveries = await OrderDeliveriesCollection(db);
-  const OrderDiscounts = await OrderDiscountsCollection(db);
-  const OrderPayments = await OrderPaymentsCollection(db);
-  const OrderPositions = await OrderPositionsCollection(db);
-
-  const mongoAdapter = new MongoAdapter({
-    client: {
-      db: () => db,
-    },
-  });
-  const locker = new Locker({
-    adapter: mongoAdapter,
-    retrySettings: { retryDelay: 200, retryTimes: 10 },
-  });
-
-  const orderQueries = configureOrdersModuleQueries({ Orders });
-
-  const orderMutations = configureOrderModuleMutations({
-    Orders,
-    OrderPositions,
-  });
-
-  const orderDiscountsModule = configureOrderDiscountsModule({
-    OrderDiscounts,
-  });
-
-  const orderPositionsModule = configureOrderPositionsModule({
-    OrderPositions,
-  });
-
-  const orderPaymentsModule = configureOrderPaymentsModule({
-    OrderPayments,
-  });
-
-  const orderDeliveriesModule = configureOrderDeliveriesModule({
-    OrderDeliveries,
-  });
-
-  const findNewOrderNumber = async (order: Order, index = 0) => {
-    const newHashID = ordersSettings.orderNumberHashFn(order, index);
-    if ((await Orders.countDocuments({ orderNumber: newHashID }, { limit: 1 })) === 0) {
-      return newHashID;
-    }
-    return findNewOrderNumber(order, index + 1);
-  };
-
-  return {
-    ...orderQueries,
-    ...orderMutations,
-
-    // Subentities
-    deliveries: orderDeliveriesModule,
-    discounts: orderDiscountsModule,
-    positions: orderPositionsModule,
-    payments: orderPaymentsModule,
-
-    updateStatus: async (
-      orderId: string,
-      { status, info }: { status: OrderStatus | null; info?: string },
-    ) => {
-      const selector = generateDbFilterById(orderId);
-      const order = await Orders.findOne(selector, {});
-
-      if (!order) return null;
-      if (order.status === status) return order;
-
-      const date = new Date();
-      const $set: Partial<Order> = {
-        status,
-        updated: new Date(),
-      };
-      switch (status) {
-        // explicitly use fallthrough here!
-        case OrderStatus.FULLFILLED:
-          $set.fullfilled = order.fullfilled || date;
-        case OrderStatus.REJECTED: // eslint-disable-line no-fallthrough
-        case OrderStatus.CONFIRMED:
-          if (status === OrderStatus.REJECTED) {
-            $set.rejected = order.rejected || date;
-          } else {
-            $set.confirmed = order.confirmed || date;
-          }
-        case OrderStatus.PENDING: // eslint-disable-line no-fallthrough
-          $set.ordered = order.ordered || date;
-          $set.orderNumber = order.orderNumber || (await findNewOrderNumber(order));
-          break;
-        default:
-          break;
-      }
-
-      const modifier: mongodb.UpdateFilter<Order> = {
-        $set,
-        $push: {
-          log: {
-            date,
-            status,
-            info,
-          },
-        },
-      };
-
-      const modificationResult = await Orders.findOneAndUpdate(
-        {
-          ...selector,
-          status: { $ne: status }, // Only update if status is different
-        },
-        modifier,
-        {
-          returnDocument: 'after',
-          includeResultMetadata: true,
-        },
-      );
-
-      if (modificationResult.ok) {
-        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 });
-        }
-        switch (status) {
-          case OrderStatus.FULLFILLED:
-            await emit('ORDER_FULLFILLED', { order: modificationResult.value, oldStatus: order.status });
-            break;
-          case OrderStatus.REJECTED:
-            await emit('ORDER_REJECTED', { order: modificationResult.value, oldStatus: order.status });
-            break;
-          case OrderStatus.CONFIRMED:
-            await emit('ORDER_CONFIRMED', { order: modificationResult.value, oldStatus: order.status });
-            break;
-          default:
-            break;
-        }
-      }
-
-      return modificationResult.value || Orders.findOne(selector, {});
-    },
-
-    acquireLock: async (orderId: string, identifier: string, timeout = 5000) => {
-      return await locker.lock(`order:${identifier}:${orderId}`, timeout).acquire();
-    },
-
-    setDeliveryProvider: async (orderId: string, deliveryProviderId: string) => {
-      const delivery = await OrderDeliveries.findOne({
-        orderId,
-        deliveryProviderId,
-      });
-      const deliveryId =
-        delivery?._id ||
-        (
-          await orderDeliveriesModule.create({
-            calculation: [],
-            deliveryProviderId,
-            log: [],
-            orderId,
-            status: null,
-          })
-        )._id;
-
-      const order = await Orders.findOneAndUpdate(
-        { _id: orderId, deliveryId: { $ne: deliveryId } },
-        {
-          $set: {
-            deliveryId,
-            updated: new Date(),
-          },
-        },
-        { returnDocument: 'after' },
-      );
-
-      if (!order) return null;
-      await emit('ORDER_SET_DELIVERY_PROVIDER', {
-        order,
-        deliveryProviderId,
-      });
-
-      return order;
-    },
-
-    setPaymentProvider: async (orderId: string, paymentProviderId: string) => {
-      const payment = await OrderPayments.findOne({
-        orderId,
-        paymentProviderId,
-      });
-
-      const paymentId =
-        payment?._id ||
-        (
-          await orderPaymentsModule.create({
-            calculation: [],
-            paymentProviderId,
-            log: [],
-            orderId,
-            status: null,
-          })
-        )._id;
-
-      const order = await Orders.findOneAndUpdate(
-        { _id: orderId, paymentId: { $ne: paymentId } },
-        {
-          $set: { paymentId, updated: new Date() },
-        },
-        { returnDocument: 'after' },
-      );
-
-      if (!order) return null;
-      await emit('ORDER_SET_PAYMENT_PROVIDER', {
-        order,
-        paymentProviderId,
-      });
-
-      return order;
-    },
-  };
-};
-
-export type OrdersModule = Awaited<ReturnType<typeof configureOrdersModule>>;

package/src/orders-index.ts

@@ -1,13 +0,0 @@
-export * from './module/configureOrdersModule.js';
-export * from './module/configureOrderDeliveriesModule.js';
-export * from './module/configureOrderDiscountsModule.js';
-export * from './module/configureOrderPaymentsModule.js';
-export * from './module/configureOrderPositionsModule.js';
-export * from './module/configureOrdersModule-mutations.js';
-export * from './module/configureOrdersModule-queries.js';
-export * from './db/OrderDeliveriesCollection.js';
-export * from './db/OrderDiscountsCollection.js';
-export * from './db/OrderPaymentsCollection.js';
-export * from './db/OrderPositionsCollection.js';
-export * from './db/OrdersCollection.js';
-export * from './orders-settings.js';

package/src/orders-settings.ts

@@ -1,45 +0,0 @@
-import { generateRandomHash } from '@unchainedshop/utils';
-import { Order } from './db/OrdersCollection.js';
-
-export interface OrderSettingsOrderPositionValidation<Product = unknown> {
-  order: Order;
-  product: Product;
-  quantityDiff?: number;
-  configuration?: { key: string; value: string }[] | null;
-}
-
-export interface OrdersSettings {
-  ensureUserHasCart: boolean;
-  orderNumberHashFn: (order: Order, index: number) => string;
-  validateOrderPosition: <UnchainedAPI = unknown>(
-    validationParams: OrderSettingsOrderPositionValidation,
-    unchainedAPI: UnchainedAPI,
-  ) => Promise<void>;
-  lockOrderDuringCheckout: boolean;
-  configureSettings: (options?: OrdersSettingsOptions) => void;
-}
-export type OrdersSettingsOptions = Omit<Partial<OrdersSettings>, 'configureSettings'>;
-
-export const defaultValidateOrderPosition = async ({ product }, { modules }: any) => {
-  if (!modules.products.isActive(product)) {
-    throw new Error('This product is inactive');
-  }
-};
-
-export const ordersSettings: OrdersSettings = {
-  ensureUserHasCart: false,
-  orderNumberHashFn: generateRandomHash,
-  validateOrderPosition: defaultValidateOrderPosition,
-  lockOrderDuringCheckout: false,
-  configureSettings({
-    ensureUserHasCart,
-    orderNumberHashFn,
-    validateOrderPosition,
-    lockOrderDuringCheckout,
-  } = {}) {
-    this.ensureUserHasCart = ensureUserHasCart || false;
-    this.orderNumberHashFn = orderNumberHashFn || generateRandomHash;
-    this.validateOrderPosition = validateOrderPosition || defaultValidateOrderPosition;
-    this.lockOrderDuringCheckout = lockOrderDuringCheckout || false;
-  },
-};

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../shared/base.tsconfig.json",
-  "compilerOptions": {
-    "declarationDir": "./lib",
-    "rootDir": "./src",
-    "outDir": "./lib"
-  },
-  "exclude": ["**/*.test.ts", "**/*.test.js", "tests", "lib"]
-}