@unchainedshop/core 4.3.6 → 4.4.0

package/src/services/removeFiles.ts

@@ -1,25 +0,0 @@
-import { getFileAdapter } from '@unchainedshop/core-files';
-import { Modules } from '../modules.js';
-
-export async function removeFilesService(this: Modules, { fileIds }: { fileIds: string[] }) {
-  if (fileIds && typeof fileIds !== 'string' && !Array.isArray(fileIds))
-    throw Error('Media id/s to be removed not provided as a string or array');
-
-  const fileUploadAdapter = getFileAdapter();
-
-  const fileObjects = await this.files.findFiles({
-    _id: { $in: fileIds },
-  });
-
-  try {
-    await fileUploadAdapter.removeFiles(fileObjects, { modules: this });
-  } catch {
-    /**/
-  }
-
-  const fileIdsToDelete = fileObjects.map((f) => f._id).filter(Boolean);
-
-  await this.files.deleteMany(fileIdsToDelete);
-
-  return fileIdsToDelete.length;
-}

package/src/services/removeProduct.ts

@@ -1,39 +0,0 @@
-import { ProductStatus } from '@unchainedshop/core-products';
-import { updateCalculationService } from './updateCalculation.js';
-import { Modules } from '../modules.js';
-
-export async function removeProductService(
-  this: Modules,
-  { productId }: { productId: string },
-): Promise<boolean> {
-  const product = await this.products.findProduct({ productId });
-
-  switch (product?.status) {
-    case ProductStatus.ACTIVE:
-      await this.products.unpublish(product);
-    // falls through
-    case null:
-    case ProductStatus.DRAFT:
-      {
-        await this.bookmarks.deleteByProductId(productId);
-        await this.assortments.products.deleteMany({ productId });
-        await this.products.removeAllAssignmentsAndBundleItems(productId);
-        const orderIdsToRecalculate =
-          await this.orders.positions.removeProductByIdFromAllOpenPositions(productId);
-        await Promise.all(
-          [...new Set(orderIdsToRecalculate)].map(async (orderIdToRecalculate) => {
-            await updateCalculationService.bind(this)(orderIdToRecalculate);
-          }),
-        );
-        await this.products.delete(productId);
-      }
-      break;
-    case ProductStatus.DELETED:
-      // Already deleted
-      return false;
-    default:
-      throw new Error(`Invalid status: ${product?.status}`);
-  }
-
-  return true;
-}

package/src/services/searchAssortments.ts

@@ -1,57 +0,0 @@
-import {
-  defaultAssortmentSelector,
-  defaultFilterSelector,
-  defaultSortStage,
-  SearchQuery,
-} from '@unchainedshop/core-filters';
-import { Modules } from '../modules.js';
-import { FilterDirector, SearchAssortmentsOptions } from '../directors/index.js';
-
-export async function searchAssortmentsService(
-  this: Modules,
-  searchQuery: SearchQuery,
-  options: { forceLiveCollection?: boolean; locale: Intl.Locale; userId?: string },
-) {
-  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
-
-  const filterSelector = await filterActions.transformFilterSelector(
-    defaultFilterSelector(searchQuery),
-    options,
-  );
-  const assortmentSelector = defaultAssortmentSelector(searchQuery);
-  const sortStage = await filterActions.transformSortStage(defaultSortStage(searchQuery), options);
-
-  const searchConfiguration: SearchAssortmentsOptions = {
-    searchQuery,
-    filterSelector,
-    assortmentSelector,
-    sortStage,
-    ...options,
-    forceLiveCollection: !!options.forceLiveCollection,
-  };
-
-  const assortmentIds = await searchQuery.assortmentIds;
-
-  const totalAssortmentIds =
-    (await filterActions.searchAssortments({ assortmentIds }, searchConfiguration)) ||
-    (await this.assortments.findAssortmentIds({ includeInactive: searchQuery.includeInactive }));
-
-  return {
-    searchConfiguration,
-    totalAssortmentIds,
-
-    assortmentsCount: async () =>
-      this.assortments.count({
-        assortmentSelector,
-        assortmentIds: totalAssortmentIds,
-      }),
-    assortments: async ({ offset, limit }) =>
-      this.assortments.search.findFilteredAssortments({
-        limit,
-        offset,
-        assortmentIds: totalAssortmentIds,
-        assortmentSelector,
-        sort: sortStage,
-      }),
-  };
-}

package/src/services/searchProducts.ts

@@ -1,71 +0,0 @@
-import {
-  defaultFilterSelector,
-  defaultProductSelector,
-  defaultSortStage,
-  SearchQuery,
-} from '@unchainedshop/core-filters';
-import { Modules } from '../modules.js';
-import { FilterDirector, SearchProductsOptions } from '../directors/index.js';
-
-export async function searchProductsService(
-  this: Modules,
-  searchQuery: SearchQuery,
-  options: { forceLiveCollection?: boolean; locale: Intl.Locale; userId?: string },
-) {
-  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
-
-  const filterSelector = await filterActions.transformFilterSelector(
-    defaultFilterSelector(searchQuery),
-    options,
-  );
-  const productSelector = await filterActions.transformProductSelector(
-    defaultProductSelector(searchQuery, { modules: this }),
-    options,
-  );
-  const sortStage = await filterActions.transformSortStage(defaultSortStage(searchQuery), options);
-
-  const searchConfiguration: SearchProductsOptions = {
-    searchQuery,
-    filterSelector,
-    productSelector,
-    sortStage,
-    ...options,
-    forceLiveCollection: !!options.forceLiveCollection,
-  };
-
-  if (searchQuery.productIds?.length === 0) {
-    // Restricted to an empty array of products
-    // will always lead to an empty result
-    return {
-      searchConfiguration,
-      aggregatedTotalProductIds: [],
-      aggregatedFilteredProductIds: [],
-      totalProductIds: [],
-    };
-  }
-
-  const totalProductIds =
-    (await filterActions.searchProducts(searchQuery, searchConfiguration)) ||
-    (await this.products.findProductIds({ includeDrafts: searchQuery.includeInactive }));
-
-  const filteredProductIds = await FilterDirector.productFacetedSearch(
-    totalProductIds,
-    searchConfiguration,
-    { modules: this },
-  );
-
-  const aggregatedTotalProductIds = filterActions.aggregateProductIds({
-    productIds: totalProductIds,
-  });
-
-  const aggregatedFilteredProductIds = filterActions.aggregateProductIds({
-    productIds: filteredProductIds,
-  });
-
-  return {
-    searchConfiguration,
-    totalProductIds,
-    aggregatedTotalProductIds,
-    aggregatedFilteredProductIds,
-  };
-}

package/src/services/simulateProductDispatching.ts

@@ -1,58 +0,0 @@
-import { Modules } from '../modules.js';
-import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
-import { Product } from '@unchainedshop/core-products';
-import { EstimatedDispatch, WarehousingDirector } from '../directors/WarehousingDirector.js';
-import { WarehousingContext } from '../directors/WarehousingAdapter.js';
-import { WarehousingProvider } from '@unchainedshop/core-warehousing';
-
-export async function simulateProductDispatchingService(
-  this: Modules,
-  {
-    product,
-    quantity,
-    referenceDate,
-  }: {
-    product: Product;
-    quantity: number;
-    referenceDate?: Date;
-  },
-) {
-  const deliveryProviders = await this.delivery.allProviders();
-
-  return deliveryProviders.reduce<
-    Promise<(WarehousingContext & EstimatedDispatch & { warehousingProvider: WarehousingProvider })[]>
-  >(async (oldResult, deliveryProvider) => {
-    const result = await oldResult;
-
-    const warehousingProviders: WarehousingProvider[] = await supportedWarehousingProvidersService.bind(
-      this,
-    )({
-      product,
-      deliveryProvider,
-    });
-
-    const mappedWarehousingProviders = await Promise.all(
-      warehousingProviders.map(async (warehousingProvider) => {
-        const warehousingContext: WarehousingContext = {
-          deliveryProvider,
-          product,
-          quantity,
-          referenceDate,
-        };
-
-        const director = await WarehousingDirector.actions(warehousingProvider, warehousingContext, {
-          modules: this,
-        });
-        const dispatch = await director.estimatedDispatch();
-
-        return {
-          warehousingProvider,
-          ...warehousingContext,
-          ...dispatch,
-        };
-      }),
-    );
-
-    return result.concat(result, mappedWarehousingProviders);
-  }, Promise.resolve([]));
-}

package/src/services/simulateProductInventory.ts

@@ -1,59 +0,0 @@
-import { Modules } from '../modules.js';
-import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
-import { Product } from '@unchainedshop/core-products';
-import { WarehousingDirector } from '../directors/WarehousingDirector.js';
-import { WarehousingContext } from '../directors/WarehousingAdapter.js';
-import { WarehousingProvider } from '@unchainedshop/core-warehousing';
-
-export async function simulateProductInventoryService(
-  this: Modules,
-  {
-    product,
-    referenceDate,
-  }: {
-    product: Product;
-    referenceDate?: Date;
-  },
-) {
-  const deliveryProviders = await this.delivery.allProviders();
-
-  return deliveryProviders.reduce<
-    Promise<
-      (WarehousingContext & { quantity?: number } & {
-        warehousingProvider: WarehousingProvider;
-      })[]
-    >
-  >(async (oldResult, deliveryProvider) => {
-    const result = await oldResult;
-
-    const warehousingProviders: WarehousingProvider[] = await supportedWarehousingProvidersService.bind(
-      this,
-    )({
-      product,
-      deliveryProvider,
-    });
-
-    const mappedWarehousingProviders = await Promise.all(
-      warehousingProviders.map(async (warehousingProvider) => {
-        const warehousingContext = {
-          deliveryProvider,
-          product,
-          referenceDate,
-        };
-
-        const director = await WarehousingDirector.actions(warehousingProvider, warehousingContext, {
-          modules: this,
-        });
-        const stock = await director.estimatedStock();
-
-        return {
-          warehousingProvider,
-          ...warehousingContext,
-          ...stock,
-        };
-      }),
-    );
-
-    return result.concat(result, mappedWarehousingProviders);
-  }, Promise.resolve([]));
-}

package/src/services/simulateProductPricing.ts

@@ -1,23 +0,0 @@
-import { Product, ProductConfiguration } from '@unchainedshop/core-products';
-import { ProductPricingDirector } from '../core-index.js';
-import { User } from '@unchainedshop/core-users';
-import { Modules } from '../modules.js';
-import { Order, OrderDiscount } from '@unchainedshop/core-orders';
-
-export async function simulateProductPricingService(
-  this: Modules,
-  pricingContext: {
-    currencyCode: string;
-    countryCode: string;
-    quantity: number;
-    discounts: OrderDiscount[];
-    order?: Order;
-    product: Product;
-    configuration?: ProductConfiguration[];
-    user?: User;
-  },
-) {
-  const calculated = await ProductPricingDirector.rebuildCalculation(pricingContext, { modules: this });
-  if (!calculated || !calculated.length) return null;
-  return ProductPricingDirector.calculationSheet(pricingContext, calculated);
-}

package/src/services/supportedDeliveryProviders.ts

@@ -1,24 +0,0 @@
-import { DeliveryProvider, deliverySettings } from '@unchainedshop/core-delivery';
-import { Modules } from '../modules.js';
-import { DeliveryContext, DeliveryDirector } from '../directors/index.js';
-
-export async function supportedDeliveryProvidersService(this: Modules, params: DeliveryContext) {
-  const allProviders = await this.delivery.allProviders();
-
-  const providers = (
-    await Promise.all(
-      allProviders.map(async (provider: DeliveryProvider) => {
-        const adapter = await DeliveryDirector.actions(provider, params, { modules: this });
-        return adapter.isActive() ? [provider] : [];
-      }),
-    )
-  ).flat();
-
-  return deliverySettings.filterSupportedProviders(
-    {
-      providers,
-      order: params.order,
-    },
-    { modules: this },
-  );
-}

package/src/services/supportedPaymentProviders.ts

@@ -1,25 +0,0 @@
-import { PaymentProvider, paymentSettings } from '@unchainedshop/core-payment';
-import { PaymentDirector } from '../directors/PaymentDirector.js';
-import { PaymentContext } from '../directors/PaymentAdapter.js';
-import { Modules } from '../modules.js';
-
-export async function supportedPaymentProvidersService(this: Modules, params: PaymentContext) {
-  const allProviders = await this.payment.paymentProviders.allProviders();
-
-  const providers = (
-    await Promise.all(
-      allProviders.map(async (provider: PaymentProvider) => {
-        const adapter = await PaymentDirector.actions(provider, params, { modules: this });
-        return adapter.isActive() ? [provider] : [];
-      }),
-    )
-  ).flat();
-
-  return paymentSettings.filterSupportedProviders(
-    {
-      providers,
-      order: params.order,
-    },
-    { modules: this },
-  );
-}

package/src/services/supportedWarehousingProviders.ts

@@ -1,18 +0,0 @@
-import { WarehousingProvider } from '@unchainedshop/core-warehousing';
-import { WarehousingContext, WarehousingDirector } from '../directors/index.js';
-import { Modules } from '../modules.js';
-
-export async function supportedWarehousingProvidersService(this: Modules, params: WarehousingContext) {
-  const allProviders = await this.warehousing.allProviders();
-
-  const providers = (
-    await Promise.all(
-      allProviders.map(async (provider: WarehousingProvider) => {
-        const adapter = await WarehousingDirector.actions(provider, params, { modules: this });
-        return adapter.isActive() ? [provider] : [];
-      }),
-    )
-  ).flat();
-
-  return providers;
-}

package/src/services/terminateEnrollment.ts

@@ -1,25 +0,0 @@
-import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { processEnrollmentService } from './processEnrollment.js';
-import { addMessageService } from './addMessage.js';
-
-export async function terminateEnrollmentService(enrollment: Enrollment) {
-  if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
-
-  let updatedEnrollment = await this.enrollments.updateStatus(enrollment._id, {
-    status: EnrollmentStatus.TERMINATED,
-    info: 'terminated manually',
-  });
-
-  updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
-
-  const user = await this.users.findUserById(enrollment.userId);
-  const locale = this.users.userLocale(user);
-
-  await addMessageService.bind(this)('ENROLLMENT_STATUS', {
-    reason: 'status_change',
-    locale: locale.baseName,
-    enrollmentId: updatedEnrollment._id,
-  });
-
-  return updatedEnrollment;
-}

package/src/services/updateCalculation.ts

@@ -1,159 +0,0 @@
-import {
-  OrderDelivery,
-  OrderDiscountTrigger,
-  OrderPayment,
-  Order,
-  OrderPosition,
-} from '@unchainedshop/core-orders';
-import { initCartProvidersService } from './initCartProviders.js';
-import { Modules } from '../modules.js';
-import { updateSchedulingService } from './updateScheduling.js';
-import {
-  OrderDiscountDirector,
-  OrderPricingDirector,
-  DeliveryPricingDirector,
-  ProductPricingDirector,
-  PaymentPricingDirector,
-} from '../directors/index.js';
-
-export async function updateCalculationService(this: Modules, orderId: string) {
-  let order = await this.orders.findOrder({ orderId });
-  if (!order) throw new Error('Order not found');
-
-  // Don't recalculate orders, only carts
-  if (order.status !== null) return order;
-
-  // 1. go through existing order-discounts and check if discount still valid,
-  // those who are not valid anymore should get removed
-  const discounts = await this.orders.discounts.findOrderDiscounts({
-    orderId: order._id,
-  });
-
-  await Promise.all(
-    discounts.map(async (orderDiscount) => {
-      const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
-      if (!Adapter) return null;
-      const adapter = await Adapter.actions({
-        context: { order: order!, orderDiscount, code: orderDiscount.code, modules: this },
-      });
-
-      let isValid = false;
-      if (orderDiscount.trigger === OrderDiscountTrigger.SYSTEM) {
-        isValid = await adapter.isValidForSystemTriggering();
-      } else if (orderDiscount.trigger === OrderDiscountTrigger.USER && orderDiscount.code) {
-        isValid = await adapter.isValidForCodeTriggering({
-          code: orderDiscount.code,
-        });
-      }
-
-      if (!isValid) {
-        if (orderDiscount.trigger === OrderDiscountTrigger.USER) {
-          await adapter.release();
-        }
-        await this.orders.discounts.delete(orderDiscount._id);
-      }
-    }),
-  );
-
-  // 2. run auto-system discount
-  const cleanedDiscounts = await this.orders.discounts.findOrderDiscounts({
-    orderId: order._id,
-  });
-
-  const currentDiscountKeys = cleanedDiscounts.map(({ discountKey }) => discountKey);
-  const director = await OrderDiscountDirector.actions({ order }, { modules: this });
-  const systemDiscounts = await director.findSystemDiscounts();
-  await Promise.all(
-    systemDiscounts
-      .filter((key) => currentDiscountKeys.indexOf(key) === -1)
-      .map(async (discountKey) =>
-        this.orders.discounts.create({
-          orderId: order!._id,
-          discountKey,
-          trigger: OrderDiscountTrigger.SYSTEM,
-        }),
-      ),
-  );
-
-  let orderPositions = await this.orders.positions.findOrderPositions({
-    orderId,
-  });
-  orderPositions = await Promise.all(
-    orderPositions.map(async (orderPosition) => {
-      const positionCalculation = await ProductPricingDirector.rebuildCalculation(
-        {
-          currencyCode: order!.currencyCode,
-          quantity: orderPosition.quantity,
-          item: orderPosition,
-        },
-        { modules: this },
-      );
-      return (await this.orders.positions.updateCalculation(
-        orderPosition._id,
-        positionCalculation,
-      )) as OrderPosition;
-    }),
-  );
-
-  let orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId!,
-  });
-  if (orderDelivery) {
-    const deliveryCalculation = await DeliveryPricingDirector.rebuildCalculation(
-      {
-        currencyCode: order.currencyCode,
-        item: orderDelivery,
-      },
-      { modules: this },
-    );
-    orderDelivery = (await this.orders.deliveries.updateCalculation(
-      orderDelivery._id,
-      deliveryCalculation,
-    )) as OrderDelivery;
-  }
-  let orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId!,
-  });
-  if (orderPayment) {
-    const paymentCalculation = await PaymentPricingDirector.rebuildCalculation(
-      {
-        currencyCode: order.currencyCode,
-        item: orderPayment,
-      },
-      { modules: this },
-    );
-    orderPayment = (await this.orders.payments.updateCalculation(
-      orderPayment._id,
-      paymentCalculation,
-    )) as OrderPayment;
-  }
-
-  orderPositions = await updateSchedulingService.bind(this)({
-    order,
-    orderPositions,
-    orderDelivery,
-  });
-
-  const calculation = await OrderPricingDirector.rebuildCalculation(
-    { currencyCode: order.currencyCode, order, orderPositions, orderDelivery, orderPayment },
-    { modules: this },
-  );
-
-  if (JSON.stringify(order.calculation) !== JSON.stringify(calculation)) {
-    order = (await this.orders.updateCalculationSheet(orderId, calculation)) as Order;
-  }
-
-  /*
-       // We have to do initCartProviders after calculation, only then filterSupportedProviders will work correctly and has access to recent pricing
-       // initCartProviders calls updateCalculation anyways recursively when a new payment or delivery provider gets set
-       // Thus, if for example a discount change leads to a free delivery and free payment due to free items amount, the following happens in the stack:
-        // 1. create discount
-        // 2. update calculation -> order pricing updated to items 0
-        // 3. initCartProviders with updated order -> filterSupportedProviders -> delivery provider is invalid -> set new delivery provider
-        // 4. update calculation -> order pricing updated to items 0 and delivery 0
-        // 5. initCartProviders with updated order -> filterSupportedProviders -> payment provider is invalid -> set new payment provider
-        // 6. update calculation -> order pricing updated to items 0, delivery 0, payment 0
-        // 7. initCartProviders with updated order -> all providers are valid -> return order
-    */
-  return initCartProvidersService.bind(this)(order);
-}

package/src/services/updateScheduling.ts

@@ -1,63 +0,0 @@
-import { Order, OrderDelivery, OrderPosition } from '@unchainedshop/core-orders';
-import { WarehousingDirector } from '../directors/index.js';
-import { Modules } from '../modules.js';
-import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
-import { Product } from '@unchainedshop/core-products';
-
-export async function updateSchedulingService(
-  this: Modules,
-  {
-    orderPositions,
-    order,
-    orderDelivery,
-  }: { orderPositions: OrderPosition[]; order: Order; orderDelivery: OrderDelivery | null },
-) {
-  const deliveryProvider =
-    orderDelivery &&
-    (await this.delivery.findProvider({
-      deliveryProviderId: orderDelivery.deliveryProviderId,
-    }));
-
-  if (!deliveryProvider) return [];
-
-  return (await Promise.all(
-    orderPositions.map(async (orderPosition) => {
-      // scheduling (store in db for auditing)
-      const product = (await this.products.findProduct({
-        productId: orderPosition.productId,
-      })) as Product;
-
-      const scheduling = await Promise.all(
-        (
-          await supportedWarehousingProvidersService.bind(this)({
-            product,
-            deliveryProvider,
-          })
-        ).map(async (warehousingProvider) => {
-          const director = await WarehousingDirector.actions(
-            warehousingProvider,
-            {
-              deliveryProvider,
-              product,
-              orderPosition,
-              order,
-              referenceDate: order.ordered,
-              quantity: orderPosition.quantity,
-            },
-            {
-              modules: this,
-            },
-          );
-          const dispatch = await director.estimatedDispatch();
-
-          return {
-            warehousingProviderId: warehousingProvider._id,
-            ...dispatch,
-          };
-        }),
-      );
-
-      return this.orders.positions.updateScheduling(orderPosition._id, scheduling);
-    }),
-  )) as OrderPosition[];
-}

package/src/services/updateUserAvatarAfterUpload.ts

@@ -1,33 +0,0 @@
-import { File } from '@unchainedshop/core-files';
-import { removeFilesService } from './removeFiles.js';
-import { Modules } from '../modules.js';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:core');
-
-export async function updateUserAvatarAfterUploadService(
-  this: Modules,
-  { file }: { file: Pick<File, '_id' | 'path' | 'meta'> },
-) {
-  const { userId } = file.meta as { userId: string };
-
-  const files = await this.files.findFiles({
-    _id: { $ne: file._id },
-    path: file.path,
-    'meta.userId': userId,
-  });
-  const fileIds = files.map((f) => f._id);
-
-  try {
-    if (fileIds?.length) {
-      await removeFilesService.bind(this)({
-        fileIds,
-      });
-    }
-  } catch (e: unknown) {
-    // cleanup error, not critical
-    logger.warn(`could not clean up all old avatars: ${(e as Error).message}`);
-  }
-
-  await this.users.updateAvatar(userId, file._id);
-}