@unchainedshop/core 4.3.5 → 4.4.0

package/src/services/createSignedURL.ts

@@ -1,21 +0,0 @@
-import { getFileFromFileData, getFileAdapter, SignedFileUpload } from '@unchainedshop/core-files';
-import { Modules } from '../modules.js';
-
-export async function createSignedURLService(
-  this: Modules,
-  { directoryName, fileName, meta }: { directoryName: string; fileName: string; meta?: any },
-) {
-  const fileUploadAdapter = getFileAdapter();
-  const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {
-    modules: this,
-  });
-  if (!preparedFileData) throw new Error('Could not prepare signed URL');
-  const fileData = getFileFromFileData(preparedFileData, meta);
-  const fileId = await this.files.create(fileData);
-  const file = await this.files.findFile({ fileId });
-
-  return {
-    ...file,
-    putURL: preparedFileData.putURL as string,
-  } as SignedFileUpload;
-}

package/src/services/deleteUser.ts

@@ -1,48 +0,0 @@
-import { Modules } from '../modules.js';
-
-export async function deleteUserService(this: Modules, { userId }: { userId: string }) {
-  const user = await this.users.markDeleted(userId);
-
-  if (!user) return null;
-
-  await this.bookmarks.deleteByUserId(userId);
-  await this.quotations.deleteRequestedUserQuotations(userId);
-  await this.enrollments.deleteInactiveUserEnrollments(userId);
-  await this.payment.paymentCredentials.deleteUserPaymentCredentials(userId);
-
-  if (user.username) {
-    await this.users.webAuthn.deleteUserWebAuthnCredentials(user.username);
-  }
-
-  const carts = (await this.orders.findOrders({ userId, includeCarts: true })).filter(
-    (c) => c.status === null,
-  );
-
-  await Array.fromAsync(carts, async (userCart) => {
-    await this.orders.positions.deleteOrderPositions(userCart?._id);
-    await this.orders.payments.deleteOrderPayments(userCart?._id);
-    await this.orders.deliveries.deleteOrderDeliveries(userCart?._id);
-    await this.orders.discounts.deleteOrderDiscounts(userCart?._id);
-    await this.orders.delete(userCart?._id);
-  });
-
-  const ordersCount = await this.orders.count({ userId, includeCarts: true });
-  const quotationsCount = await this.quotations.count({ userId });
-  const reviewsCount = await this.products.reviews.count({ authorId: userId });
-  const enrollmentsCount = await this.enrollments.count({ userId });
-  const tokens = await this.warehousing.findTokensForUser({ userId });
-  const paymentCredentials = await this.payment.paymentCredentials.count({ userId });
-
-  if (
-    !ordersCount &&
-    !reviewsCount &&
-    !enrollmentsCount &&
-    !quotationsCount &&
-    !tokens?.length &&
-    !paymentCredentials
-  ) {
-    await this.users.deletePermanently({ userId });
-  }
-
-  return user;
-}

package/src/services/discountedEntities.ts

@@ -1,81 +0,0 @@
-import { Order, OrderDiscount } from '@unchainedshop/core-orders';
-import {
-  DeliveryPricingSheet,
-  OrderPricingDiscount,
-  OrderPricingSheet,
-  PaymentPricingSheet,
-  ProductPricingSheet,
-} from '../directors/index.js';
-import { Modules } from '../modules.js';
-
-export async function discountedEntitiesService(
-  this: Modules,
-  order: Order,
-  orderDiscount: OrderDiscount,
-): Promise<OrderPricingDiscount[]> {
-  // Delivery discounts
-  const orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId!,
-  });
-
-  const deliveryPricingSheet = DeliveryPricingSheet({
-    calculation: orderDelivery!.calculation || [],
-    currencyCode: order.currencyCode,
-  });
-  const orderDeliveryDiscounts = deliveryPricingSheet
-    .discountPrices(orderDiscount._id)
-    .map((discount) => ({
-      delivery: orderDelivery!,
-      ...discount,
-    }));
-
-  // Payment discounts
-  const orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId!,
-  });
-  const paymentPricingSheet = PaymentPricingSheet({
-    calculation: orderPayment!.calculation || [],
-    currencyCode: order.currencyCode,
-  });
-  const orderPaymentDiscounts = paymentPricingSheet
-    .discountPrices(orderDiscount._id)
-    .map((discount) => ({
-      payment: orderPayment!,
-      ...discount,
-    }));
-
-  // Position discounts
-  const orderPositions = await this.orders.positions.findOrderPositions({
-    orderId: order._id,
-  });
-  const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
-    ProductPricingSheet({
-      calculation: orderPosition.calculation,
-      currencyCode: order.currencyCode,
-      quantity: orderPosition.quantity,
-    })
-      .discountPrices(orderDiscount._id)
-      .map((discount) => ({
-        item: orderPosition,
-        ...discount,
-      })),
-  );
-
-  // order discounts
-  const orderDiscounts = OrderPricingSheet({
-    calculation: order.calculation || [],
-    currencyCode: order.currencyCode,
-  })
-    .discountPrices(orderDiscount._id)
-    .map((discount) => ({ order, ...discount }));
-
-  // All discounts
-  const discounted = [
-    ...orderPaymentDiscounts,
-    ...orderDeliveryDiscounts,
-    ...orderPositionDiscounts,
-    ...orderDiscounts,
-  ].filter(Boolean);
-
-  return discounted;
-}

package/src/services/ercMetadata.ts

@@ -1,25 +0,0 @@
-import { TokenSurrogate, WarehousingProviderType } from '@unchainedshop/core-warehousing';
-import { Product } from '@unchainedshop/core-products';
-import { WarehousingDirector } from '../directors/WarehousingDirector.js';
-import { Modules } from '../modules.js';
-
-export async function ercMetadataService(
-  this: Modules,
-  { product, token, locale }: { product: Product; token: TokenSurrogate; locale: Intl.Locale },
-) {
-  const virtualProviders = (await this.warehousing.allProviders()).filter(
-    ({ type }) => type === WarehousingProviderType.VIRTUAL,
-  );
-
-  return await WarehousingDirector.tokenMetadata(
-    virtualProviders,
-    {
-      product,
-      token,
-      locale,
-      quantity: token?.quantity || 1,
-      referenceDate: new Date(),
-    },
-    { modules: this },
-  );
-}

package/src/services/findOrInitCart.ts

@@ -1,28 +0,0 @@
-import { User } from '@unchainedshop/core-users';
-import { Modules } from '../modules.js';
-import { nextUserCartService } from './nextUserCart.js';
-
-export async function findOrInitCartService(
-  this: Modules,
-  {
-    user,
-    countryCode,
-    orderId,
-  }: {
-    user: User;
-    countryCode: string;
-    orderId?: string;
-  },
-) {
-  if (orderId) {
-    const order = await this.orders.findOrder({ orderId });
-    if (!order) return null;
-    return order;
-  }
-
-  return nextUserCartService.bind(this)({
-    user,
-    countryCode,
-    forceCartCreation: true,
-  });
-}

package/src/services/fullfillQuotation.ts

@@ -1,14 +0,0 @@
-import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
-import { Modules } from '../modules.js';
-import { processQuotationService } from './processQuotation.js';
-
-export async function fullfillQuotationService(this: Modules, quotation: Quotation, info) {
-  if (quotation.status === QuotationStatus.FULLFILLED) return quotation;
-
-  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
-    status: QuotationStatus.FULLFILLED,
-    info: JSON.stringify(info),
-  });
-
-  return processQuotationService.bind(this)(updatedQuotation!, {});
-}

package/src/services/generateOrderFromEnrollment.ts

@@ -1,54 +0,0 @@
-import { Modules } from '../modules.js';
-import { Enrollment, EnrollmentOrderPositionTemplate } from '@unchainedshop/core-enrollments';
-import { updateCalculationService } from './updateCalculation.js';
-import { checkoutOrderService } from './checkoutOrder.js';
-
-export async function generateOrderFromEnrollmentService(
-  this: Modules,
-  enrollment: Enrollment,
-  {
-    orderPositionTemplates,
-    orderContext,
-  }: {
-    orderPositionTemplates: EnrollmentOrderPositionTemplate[];
-    orderContext?: any;
-  },
-) {
-  if (!enrollment.payment || !enrollment.delivery) return null;
-
-  const order = await this.orders.create({
-    userId: enrollment.userId,
-    currencyCode: enrollment.currencyCode,
-    countryCode: enrollment.countryCode,
-    contact: enrollment.contact,
-    billingAddress: enrollment.billingAddress,
-    originEnrollmentId: enrollment._id,
-    context: orderContext,
-  });
-  const orderId = order._id;
-
-  await Promise.all(
-    orderPositionTemplates.map((orderPositionTemplate) =>
-      this.orders.positions.addProductItem({
-        ...orderPositionTemplate,
-        orderId: order._id,
-      }),
-    ),
-  );
-
-  const { paymentProviderId, context: paymentContext } = enrollment.payment;
-  if (paymentProviderId) {
-    await this.orders.setPaymentProvider(orderId, paymentProviderId);
-  }
-
-  const { deliveryProviderId, context: deliveryContext } = enrollment.delivery;
-  if (deliveryProviderId) {
-    await this.orders.setDeliveryProvider(orderId, deliveryProviderId);
-  }
-
-  await updateCalculationService.bind(this)(orderId);
-  return checkoutOrderService.bind(this)(order._id, {
-    deliveryContext,
-    paymentContext,
-  });
-}

package/src/services/index.ts

@@ -1,173 +0,0 @@
-import { Modules } from '../modules.js';
-import { migrateUserDataService } from './migrateUserData.js';
-import { updateUserAvatarAfterUploadService } from './updateUserAvatarAfterUpload.js';
-import { linkFileService } from './linkFileService.js';
-import { createSignedURLService } from './createSignedURL.js';
-import { uploadFileFromURLService } from './uploadFileFromURL.js';
-import { uploadFileFromStreamService } from './uploadFileFromStream.js';
-import { removeFilesService } from './removeFiles.js';
-import { createDownloadStreamService } from './createDownloadStream.js';
-import { migrateBookmarksService } from './migrateBookmarks.js';
-import { migrateOrderCartsService } from './migrateOrderCart.js';
-import { nextUserCartService } from './nextUserCart.js';
-import { removeProductService } from './removeProduct.js';
-import { initCartProvidersService } from './initCartProviders.js';
-import { updateCalculationService } from './updateCalculation.js';
-import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.js';
-import { deleteUserService } from './deleteUser.js';
-import { supportedPaymentProvidersService } from './supportedPaymentProviders.js';
-import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
-import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.js';
-import { searchAssortmentsService } from './searchAssortments.js';
-import { searchProductsService } from './searchProducts.js';
-import { calculateDiscountTotalService } from './calculateDiscountTotal.js';
-import { registerPaymentCredentialsService } from './registerPaymentCredentials.js';
-import { processOrderService } from './processOrder.js';
-import { checkoutOrderService } from './checkoutOrder.js';
-import { confirmOrderService } from './confirmOrder.js';
-import { rejectOrderService } from './rejectOrder.js';
-import { discountedEntitiesService } from './discountedEntities.js';
-import { createManualOrderDiscountService } from './createManualOrderDiscount.js';
-import { initializeEnrollmentService } from './initializeEnrollment.js';
-import { activateEnrollmentService } from './activateEnrollment.js';
-import { terminateEnrollmentService } from './terminateEnrollment.js';
-import { invalidateFilterCacheService } from './invalidateFilterCache.js';
-import { fullfillQuotationService } from './fullfillQuotation.js';
-import { processQuotationService } from './processQuotation.js';
-import { proposeQuotationService } from './proposeQuotation.js';
-import { rejectQuotationService } from './rejectQuotation.js';
-import { verifyQuotationService } from './verifyQuotation.js';
-import { loadFiltersService } from './loadFilters.js';
-import { loadFilterOptionsService } from './loadFilterOptions.js';
-import { ercMetadataService } from './ercMetadata.js';
-import { simulateProductPricingService } from './simulateProductPricing.js';
-import { simulateProductDispatchingService } from './simulateProductDispatching.js';
-import { simulateProductInventoryService } from './simulateProductInventory.js';
-import { findOrInitCartService } from './findOrInitCart.js';
-import { addMessageService } from './addMessage.js';
-import { generateOrderFromEnrollmentService } from './generateOrderFromEnrollment.js';
-
-// Auto-Inject Unchained API as last parameter
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
-
-function bindMethodsToModules(modules: Modules) {
-  return {
-    get(target, prop, receiver) {
-      const value = target[prop];
-      if (value instanceof Function) {
-        return value.bind(modules);
-      } else if (value instanceof Object) {
-        return new Proxy(value, bindMethodsToModules(modules));
-      }
-      return Reflect.get(target, prop, receiver);
-    },
-  };
-}
-
-export type ServiceInterface = (this: Modules, ...args: any[]) => Promise<any> | any;
-
-export type Bound<T extends ServiceInterface> = OmitThisParameter<T>;
-
-export type CustomServices = Record<string, ServiceInterface | Record<string, ServiceInterface>>;
-
-export default function initServices(modules: Modules, customServices: CustomServices = {}) {
-  const services = {
-    bookmarks: {
-      migrateBookmarks: migrateBookmarksService as Bound<typeof migrateBookmarksService>,
-    },
-    files: {
-      linkFile: linkFileService as Bound<typeof linkFileService>,
-      createSignedURL: createSignedURLService as Bound<typeof createSignedURLService>,
-      uploadFileFromURL: uploadFileFromURLService as Bound<typeof uploadFileFromURLService>,
-      uploadFileFromStream: uploadFileFromStreamService as Bound<typeof uploadFileFromStreamService>,
-      removeFiles: removeFilesService as Bound<typeof removeFilesService>,
-      createDownloadStream: createDownloadStreamService as Bound<typeof createDownloadStreamService>,
-    },
-    orders: {
-      registerPaymentCredentials: registerPaymentCredentialsService as Bound<
-        typeof registerPaymentCredentialsService
-      >,
-      calculateDiscountTotal: calculateDiscountTotalService as Bound<
-        typeof calculateDiscountTotalService
-      >,
-      migrateOrderCarts: migrateOrderCartsService as Bound<typeof migrateOrderCartsService>,
-      nextUserCart: nextUserCartService as Bound<typeof nextUserCartService>,
-      findOrInitCart: findOrInitCartService as Bound<typeof findOrInitCartService>,
-      initCartProviders: initCartProvidersService as Bound<typeof initCartProvidersService>,
-      updateCalculation: updateCalculationService as Bound<typeof updateCalculationService>,
-      supportedDeliveryProviders: supportedDeliveryProvidersService as Bound<
-        typeof supportedDeliveryProvidersService
-      >,
-      supportedPaymentProviders: supportedPaymentProvidersService as Bound<
-        typeof supportedPaymentProvidersService
-      >,
-      supportedWarehousingProviders: supportedWarehousingProvidersService as Bound<
-        typeof supportedWarehousingProvidersService
-      >,
-      processOrder: processOrderService as Bound<typeof processOrderService>,
-      checkoutOrder: checkoutOrderService as Bound<typeof checkoutOrderService>,
-      confirmOrder: confirmOrderService as Bound<typeof confirmOrderService>,
-      rejectOrder: rejectOrderService as Bound<typeof rejectOrderService>,
-      discountedEntities: discountedEntitiesService as Bound<typeof discountedEntitiesService>,
-      createManualOrderDiscount: createManualOrderDiscountService as Bound<
-        typeof createManualOrderDiscountService
-      >,
-    },
-    products: {
-      simulateProductPricing: simulateProductPricingService as Bound<
-        typeof simulateProductPricingService
-      >,
-      simulateProductDispatching: simulateProductDispatchingService as Bound<
-        typeof simulateProductDispatchingService
-      >,
-      simulateProductInventory: simulateProductInventoryService as Bound<
-        typeof simulateProductInventoryService
-      >,
-      removeProduct: removeProductService as Bound<typeof removeProductService>,
-    },
-    users: {
-      migrateUserData: migrateUserDataService as Bound<typeof migrateUserDataService>,
-      updateUserAvatarAfterUpload: updateUserAvatarAfterUploadService as Bound<
-        typeof updateUserAvatarAfterUploadService
-      >,
-      deleteUser: deleteUserService as Bound<typeof deleteUserService>,
-    },
-    enrollments: {
-      createEnrollmentFromCheckout: createEnrollmentFromCheckoutService as Bound<
-        typeof createEnrollmentFromCheckoutService
-      >,
-      generateOrderFromEnrollment: generateOrderFromEnrollmentService as Bound<
-        typeof generateOrderFromEnrollmentService
-      >,
-      processEnrollment: processOrderService as Bound<typeof processOrderService>,
-      initializeEnrollment: initializeEnrollmentService as Bound<typeof initializeEnrollmentService>,
-      activateEnrollment: activateEnrollmentService as Bound<typeof activateEnrollmentService>,
-      terminateEnrollment: terminateEnrollmentService as Bound<typeof terminateEnrollmentService>,
-    },
-    quotations: {
-      fullfillQuotation: fullfillQuotationService as Bound<typeof fullfillQuotationService>,
-      processQuotation: processQuotationService as Bound<typeof processQuotationService>,
-      proposeQuotation: proposeQuotationService as Bound<typeof proposeQuotationService>,
-      rejectQuotation: rejectQuotationService as Bound<typeof rejectQuotationService>,
-      verifyQuotation: verifyQuotationService as Bound<typeof verifyQuotationService>,
-    },
-    filters: {
-      searchAssortments: searchAssortmentsService as Bound<typeof searchAssortmentsService>,
-      searchProducts: searchProductsService as Bound<typeof searchProductsService>,
-      invalidateFilterCache: invalidateFilterCacheService as Bound<typeof invalidateFilterCacheService>,
-      loadFilters: loadFiltersService as Bound<typeof loadFiltersService>,
-      loadFilterOptions: loadFilterOptionsService as Bound<typeof loadFilterOptionsService>,
-    },
-    warehousing: {
-      ercMetadata: ercMetadataService as Bound<typeof ercMetadataService>,
-    },
-    worker: {
-      addMessage: addMessageService as Bound<typeof addMessageService>,
-    },
-  };
-
-  // This Proxy Binds all services to the Modules Object
-  return new Proxy<typeof services>({ ...services, ...customServices }, bindMethodsToModules(modules));
-}
-
-export type Services = ReturnType<typeof initServices>;

package/src/services/initCartProviders.ts

@@ -1,84 +0,0 @@
-import { Order } from '@unchainedshop/core-orders';
-import { deliverySettings } from '@unchainedshop/core-delivery';
-import { paymentSettings } from '@unchainedshop/core-payment';
-import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.js';
-import { supportedPaymentProvidersService } from './supportedPaymentProviders.js';
-import { Modules } from '../modules.js';
-
-export async function initCartProvidersService(this: Modules, order: Order) {
-  let updatedOrder = order;
-
-  // Init delivery provider
-  const supportedDeliveryProviders = await supportedDeliveryProvidersService.bind(this)({
-    order: updatedOrder,
-  });
-
-  const orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: updatedOrder.deliveryId!,
-  });
-  const deliveryProviderId = orderDelivery?.deliveryProviderId;
-
-  const isAlreadyInitializedWithSupportedDeliveryProvider = supportedDeliveryProviders?.some(
-    (provider) => {
-      return provider._id === deliveryProviderId;
-    },
-  );
-
-  if (supportedDeliveryProviders?.length > 0 && !isAlreadyInitializedWithSupportedDeliveryProvider) {
-    const defaultOrderDeliveryProvider = await deliverySettings.determineDefaultProvider(
-      {
-        providers: supportedDeliveryProviders,
-        order: updatedOrder,
-      },
-      { modules: this },
-    );
-    if (defaultOrderDeliveryProvider) {
-      updatedOrder =
-        (await this.orders.setDeliveryProvider(updatedOrder._id, defaultOrderDeliveryProvider._id)) ||
-        updatedOrder;
-    }
-  }
-
-  // Init payment provider
-  const supportedPaymentProviders = await supportedPaymentProvidersService.bind(this)({
-    order: updatedOrder,
-  });
-
-  const orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: updatedOrder.paymentId!,
-  });
-  const paymentProviderId = orderPayment?.paymentProviderId;
-
-  const isAlreadyInitializedWithSupportedPaymentProvider = supportedPaymentProviders?.some(
-    (provider) => {
-      return provider._id === paymentProviderId;
-    },
-  );
-
-  if (supportedPaymentProviders?.length > 0 && !isAlreadyInitializedWithSupportedPaymentProvider) {
-    const paymentCredentials = await this.payment.paymentCredentials.findPaymentCredentials(
-      { userId: updatedOrder.userId, isPreferred: true },
-      {
-        sort: {
-          created: -1,
-        },
-      },
-    );
-
-    const defaultOrderPaymentProvider = await paymentSettings.determineDefaultProvider(
-      {
-        providers: supportedPaymentProviders,
-        order: updatedOrder,
-        paymentCredentials,
-      },
-      { modules: this },
-    );
-
-    if (defaultOrderPaymentProvider) {
-      updatedOrder =
-        (await this.orders.setPaymentProvider(updatedOrder._id, defaultOrderPaymentProvider._id)) ||
-        updatedOrder;
-    }
-  }
-  return updatedOrder;
-}

package/src/services/initializeEnrollment.ts

@@ -1,41 +0,0 @@
-import { Enrollment } from '@unchainedshop/core-enrollments';
-import { EnrollmentDirector } from '../core-index.js';
-import { processEnrollmentService } from './processEnrollment.js';
-import { Modules } from '../modules.js';
-import { addMessageService } from './addMessage.js';
-
-export async function initializeEnrollmentService(
-  this: Modules,
-  enrollment: Enrollment,
-  params: { orderIdForFirstPeriod?: string; reason: string },
-) {
-  const product = await this.products.findProduct({
-    productId: enrollment.productId,
-  });
-
-  const director = await EnrollmentDirector.actions(
-    { enrollment, product: product! },
-    { modules: this },
-  );
-  const period = await director.nextPeriod();
-
-  let updatedEnrollment = enrollment;
-  if (period && (params.orderIdForFirstPeriod || period.isTrial)) {
-    updatedEnrollment = (await this.enrollments.addEnrollmentPeriod(enrollment._id, {
-      ...period,
-      orderId: params.orderIdForFirstPeriod,
-    })) as Enrollment;
-  }
-
-  const processedEnrollment = 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: processedEnrollment._id,
-  });
-
-  return processedEnrollment;
-}

package/src/services/invalidateFilterCache.ts

@@ -1,16 +0,0 @@
-import { Modules } from '../modules.js';
-import { FilterDirector } from '../core-index.js';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:core');
-
-export async function invalidateFilterCacheService(this: Modules) {
-  logger.debug('Filters: Start invalidating filter caches');
-
-  const filters = await this.filters.findFilters({ includeInactive: true });
-
-  await filters.reduce(async (lastPromise, filter) => {
-    await lastPromise;
-    return FilterDirector.invalidateProductIdCache(filter, { modules: this });
-  }, Promise.resolve(undefined));
-}

package/src/services/linkFileService.ts

@@ -1,24 +0,0 @@
-import { FileDirector } from '@unchainedshop/file-upload';
-import { Modules } from '../modules.js';
-
-export async function linkFileService(
-  this: Modules,
-  { fileId, size, type }: { fileId: string; size?: number; type?: string },
-) {
-  const file = await this.files.findFile({ fileId });
-  if (!file) return null;
-
-  await this.files.update(file._id, {
-    size: size || file.size,
-    type: type || file.type,
-  });
-  await this.files.unexpire(file._id);
-  if (file?.expires) {
-    const callback = FileDirector.getFileUploadCallback(file.path);
-    if (callback) {
-      await callback(file, { modules: this });
-    }
-    return this.files.findFile({ fileId });
-  }
-  return file;
-}

package/src/services/loadFilterOptions.ts

@@ -1,49 +0,0 @@
-import { FilterType, Filter, SearchQuery } from '@unchainedshop/core-filters';
-import { Modules } from '../modules.js';
-import { FilterDirector, parseQueryArray } from '../directors/FilterDirector.js';
-
-export async function loadFilterOptionsService(
-  this: Modules,
-  filter: Filter,
-  params: {
-    searchQuery: SearchQuery;
-    forceLiveCollection: boolean;
-    productIdSet: Set<string>;
-  },
-) {
-  const { forceLiveCollection, productIdSet, searchQuery } = params;
-
-  const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
-  const values = filterQueryParsed[filter.key];
-
-  const allOptions = (filter.type === FilterType.SWITCH && ['true', 'false']) || filter.options || [];
-  const mappedOptions = await Promise.all(
-    allOptions.map(async (value) => {
-      const filterOptionProductIds = await FilterDirector.filterProductIds(
-        filter,
-        {
-          values: [value],
-          forceLiveCollection,
-        },
-        { modules: this },
-      );
-      const filteredProductIdSet = productIdSet.intersection(new Set(filterOptionProductIds));
-
-      const normalizedValues = values && this.filters.parse(filter, values, [value]);
-      const isSelected = normalizedValues && normalizedValues.indexOf(value) !== -1;
-
-      if (!filteredProductIdSet.size && !isSelected) {
-        return null;
-      }
-
-      return {
-        filteredProductIdSet,
-        searchQuery,
-        value,
-        filter,
-        isSelected,
-      };
-    }),
-  );
-  return mappedOptions.filter(Boolean);
-}