@unchainedshop/core 5.0.0-alpha.1 → 5.0.0-alpha.10

package/lib/services/checkoutOrder.js

@@ -2,6 +2,7 @@ import { OrderStatus } from '@unchainedshop/core-orders';
 import { nextUserCartService } from "./nextUserCart.js";
 import { validateOrderService } from "./validateOrder.js";
 import { processOrderService } from "./processOrder.js";
+import { reserveOrderDiscountsForCheckout } from "./reserveOrderDiscountsForCheckout.js";
 export async function checkoutOrderService(orderId, transactionContext) {
     const order = await this.orders.findOrder({ orderId });
     if (!order)
@@ -10,7 +11,9 @@ export async function checkoutOrderService(orderId, transactionContext) {
         return order;
     await validateOrderService.bind(this)(order);
     const lock = await this.orders.acquireLock(order._id, 'checkout');
+    let discounts;
     try {
+        discounts = await reserveOrderDiscountsForCheckout.call(this, order);
         const processedOrder = await processOrderService.bind(this)(order, transactionContext);
         if (processedOrder.billingAddress) {
             await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
@@ -27,6 +30,7 @@ export async function checkoutOrderService(orderId, transactionContext) {
         return processedOrder;
     }
     finally {
+        await discounts?.release();
         await lock.release();
     }
 }

package/lib/services/createFilter.d.ts

@@ -0,0 +1,3 @@
+import type { Filter } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export declare function createFilterService(this: Modules, filter: Parameters<Modules['filters']['create']>[0]): Promise<Filter>;

package/lib/services/createFilter.js

@@ -0,0 +1,6 @@
+import { FilterDirector } from "../core-index.js";
+export async function createFilterService(filter) {
+    const newFilter = await this.filters.create(filter);
+    await FilterDirector.invalidateProductIdCache(newFilter, { modules: this });
+    return newFilter;
+}

package/lib/services/createFilterOption.d.ts

@@ -0,0 +1,5 @@
+import type { Filter } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export declare function createFilterOptionService(this: Modules, filterId: string, { value }: {
+    value: string;
+}): Promise<Filter | null>;

package/lib/services/createFilterOption.js

@@ -0,0 +1,8 @@
+import { FilterDirector } from "../core-index.js";
+export async function createFilterOptionService(filterId, { value }) {
+    const filter = await this.filters.createFilterOption(filterId, { value });
+    if (filter) {
+        await FilterDirector.invalidateProductIdCache(filter, { modules: this });
+    }
+    return filter;
+}

package/lib/services/createSignedURL.js

@@ -1,12 +1,13 @@
 import { getFileFromFileData } from '@unchainedshop/core-files';
 import { getFileAdapter } from "../utils/getFileAdapter.js";
+import { createServiceError } from "../errors.js";
 export async function createSignedURLService({ directoryName, fileName, meta }) {
     const fileUploadAdapter = getFileAdapter();
     const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {
         modules: this,
     });
     if (!preparedFileData)
-        throw new Error('Could not prepare signed URL');
+        throw createServiceError('SignedURLPreparationError', 'Could not prepare signed URL');
     const fileData = getFileFromFileData(preparedFileData, meta);
     const fileId = await this.files.create(fileData);
     const file = await this.files.findFile({ fileId });

package/lib/services/deleteCart.d.ts

@@ -0,0 +1,2 @@
+import type { Modules } from '../modules.ts';
+export declare function deleteCartService(this: Modules, orderId: string): Promise<number>;

package/lib/services/deleteCart.js

@@ -0,0 +1,7 @@
+export async function deleteCartService(orderId) {
+    await this.orders.positions.deleteOrderPositions(orderId);
+    await this.orders.payments.deleteOrderPayments(orderId);
+    await this.orders.deliveries.deleteOrderDeliveries(orderId);
+    await this.orders.discounts.deleteOrderDiscounts(orderId);
+    return this.orders.delete(orderId);
+}

package/lib/services/deleteDeadCarts.d.ts

@@ -0,0 +1,2 @@
+import type { Modules } from '../modules.ts';
+export declare function deleteDeadCartsService(this: Modules): Promise<number>;

package/lib/services/deleteDeadCarts.js

@@ -0,0 +1,17 @@
+import { deleteCartService } from "./deleteCart.js";
+export async function deleteDeadCartsService() {
+    const cartUserIds = (await this.orders.findCartUserIds()).filter(Boolean);
+    if (!cartUserIds.length)
+        return 0;
+    const existingUserIds = new Set(await this.users.findExistingUserIds({ userIds: cartUserIds }));
+    const deadUserIds = cartUserIds.filter((userId) => !existingUserIds.has(userId));
+    if (!deadUserIds.length)
+        return 0;
+    const deadCarts = await this.orders.findCarts({ userIds: deadUserIds }, { projection: { _id: 1 } });
+    let deletedCount = 0;
+    await Array.fromAsync(deadCarts, async (cart) => {
+        await deleteCartService.bind(this)(cart._id);
+        deletedCount += 1;
+    });
+    return deletedCount;
+}

package/lib/services/deleteUser.js

@@ -1,3 +1,4 @@
+import { deleteCartService } from "./deleteCart.js";
 export async function deleteUserService({ userId }) {
     const user = await this.users.markDeleted(userId);
     if (!user)
@@ -11,11 +12,7 @@ export async function deleteUserService({ userId }) {
     }
     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);
+        await deleteCartService.bind(this)(userCart._id);
     });
     const ordersCount = await this.orders.count({ userId, includeCarts: true });
     const quotationsCount = await this.quotations.count({ userId });

package/lib/services/index.d.ts

@@ -15,6 +15,7 @@ import { initCartProvidersService } from './initCartProviders.ts';
 import { updateCalculationService } from './updateCalculation.ts';
 import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.ts';
 import { deleteUserService } from './deleteUser.ts';
+import { deleteCartService } from './deleteCart.ts';
 import { supportedPaymentProvidersService } from './supportedPaymentProviders.ts';
 import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.ts';
 import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.ts';
@@ -23,6 +24,7 @@ import { searchProductsService } from './searchProducts.ts';
 import { calculateDiscountTotalService } from './calculateDiscountTotal.ts';
 import { registerPaymentCredentialsService } from './registerPaymentCredentials.ts';
 import { processOrderService } from './processOrder.ts';
+import { processEnrollmentService } from './processEnrollment.ts';
 import { checkoutOrderService } from './checkoutOrder.ts';
 import { confirmOrderService } from './confirmOrder.ts';
 import { rejectOrderService } from './rejectOrder.ts';
@@ -40,6 +42,10 @@ import { verifyQuotationService } from './verifyQuotation.ts';
 import { loadFiltersService } from './loadFilters.ts';
 import { loadFilterOptionsService } from './loadFilterOptions.ts';
 import { removeFilterService } from './removeFilter.ts';
+import { createFilterService } from './createFilter.ts';
+import { updateFilterService } from './updateFilter.ts';
+import { createFilterOptionService } from './createFilterOption.ts';
+import { removeFilterOptionService } from './removeFilterOption.ts';
 import { removeCartDiscountService } from './removeCartDiscount.ts';
 import { addMultipleCartProductsService } from './addMultipleCartProducts.ts';
 import { ercMetadataService } from './ercMetadata.ts';
@@ -57,6 +63,11 @@ import { simulateConfigurablePriceRangeService } from './simulateConfigurablePri
 import { createFileDownloadURLService } from './createFileDownloadURL.ts';
 import { resolveTokenStatusService } from './resolveTokenStatus.ts';
 import { isTokenInvalidateableService } from './isTokenInvalidateable.ts';
+import { bulkRemoveProductsService } from './bulkRemoveProducts.ts';
+import { bulkRemoveFiltersService } from './bulkRemoveFilters.ts';
+import { bulkDeleteUsersService } from './bulkDeleteUsers.ts';
+import { bulkSetFilterActiveService } from './bulkSetFilterActive.ts';
+import { bulkAssignProductsToAssortmentService } from './bulkAssignProductsToAssortment.ts';
 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>>;
@@ -77,6 +88,7 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         registerPaymentCredentials: Bound<typeof registerPaymentCredentialsService>;
         calculateDiscountTotal: Bound<typeof calculateDiscountTotalService>;
         migrateOrderCarts: Bound<typeof migrateOrderCartsService>;
+        deleteCart: Bound<typeof deleteCartService>;
         nextUserCart: Bound<typeof nextUserCartService>;
         findOrInitCart: Bound<typeof findOrInitCartService>;
         initCartProviders: Bound<typeof initCartProvidersService>;
@@ -99,18 +111,23 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         simulateProductDispatching: Bound<typeof simulateProductDispatchingService>;
         simulateProductInventory: Bound<typeof simulateProductInventoryService>;
         removeProduct: Bound<typeof removeProductService>;
+        bulkRemoveProducts: Bound<typeof bulkRemoveProductsService>;
         findProductSiblings: Bound<typeof findProductSiblingsService>;
         simulateConfigurablePriceRange: Bound<typeof simulateConfigurablePriceRangeService>;
     };
+    assortments: {
+        bulkAssignProductsToAssortment: Bound<typeof bulkAssignProductsToAssortmentService>;
+    };
     users: {
         migrateUserData: Bound<typeof migrateUserDataService>;
         updateUserAvatarAfterUpload: Bound<typeof updateUserAvatarAfterUploadService>;
         deleteUser: Bound<typeof deleteUserService>;
+        bulkDeleteUsers: Bound<typeof bulkDeleteUsersService>;
     };
     enrollments: {
         createEnrollmentFromCheckout: Bound<typeof createEnrollmentFromCheckoutService>;
         generateOrderFromEnrollment: Bound<typeof generateOrderFromEnrollmentService>;
-        processEnrollment: Bound<typeof processOrderService>;
+        processEnrollment: Bound<typeof processEnrollmentService>;
         initializeEnrollment: Bound<typeof initializeEnrollmentService>;
         activateEnrollment: Bound<typeof activateEnrollmentService>;
         terminateEnrollment: Bound<typeof terminateEnrollmentService>;
@@ -129,6 +146,12 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         loadFilters: Bound<typeof loadFiltersService>;
         loadFilterOptions: Bound<typeof loadFilterOptionsService>;
         removeFilter: Bound<typeof removeFilterService>;
+        createFilter: Bound<typeof createFilterService>;
+        updateFilter: Bound<typeof updateFilterService>;
+        createFilterOption: Bound<typeof createFilterOptionService>;
+        removeFilterOption: Bound<typeof removeFilterOptionService>;
+        bulkRemoveFilters: Bound<typeof bulkRemoveFiltersService>;
+        bulkSetFilterActive: Bound<typeof bulkSetFilterActiveService>;
     };
     warehousing: {
         ercMetadata: Bound<typeof ercMetadataService>;

package/lib/services/index.js

@@ -14,6 +14,7 @@ import { initCartProvidersService } from "./initCartProviders.js";
 import { updateCalculationService } from "./updateCalculation.js";
 import { supportedDeliveryProvidersService } from "./supportedDeliveryProviders.js";
 import { deleteUserService } from "./deleteUser.js";
+import { deleteCartService } from "./deleteCart.js";
 import { supportedPaymentProvidersService } from "./supportedPaymentProviders.js";
 import { supportedWarehousingProvidersService } from "./supportedWarehousingProviders.js";
 import { createEnrollmentFromCheckoutService } from "./createEnrollmentFromCheckout.js";
@@ -22,6 +23,7 @@ import { searchProductsService } from "./searchProducts.js";
 import { calculateDiscountTotalService } from "./calculateDiscountTotal.js";
 import { registerPaymentCredentialsService } from "./registerPaymentCredentials.js";
 import { processOrderService } from "./processOrder.js";
+import { processEnrollmentService } from "./processEnrollment.js";
 import { checkoutOrderService } from "./checkoutOrder.js";
 import { confirmOrderService } from "./confirmOrder.js";
 import { rejectOrderService } from "./rejectOrder.js";
@@ -39,6 +41,10 @@ import { verifyQuotationService } from "./verifyQuotation.js";
 import { loadFiltersService } from "./loadFilters.js";
 import { loadFilterOptionsService } from "./loadFilterOptions.js";
 import { removeFilterService } from "./removeFilter.js";
+import { createFilterService } from "./createFilter.js";
+import { updateFilterService } from "./updateFilter.js";
+import { createFilterOptionService } from "./createFilterOption.js";
+import { removeFilterOptionService } from "./removeFilterOption.js";
 import { removeCartDiscountService } from "./removeCartDiscount.js";
 import { addMultipleCartProductsService } from "./addMultipleCartProducts.js";
 import { ercMetadataService } from "./ercMetadata.js";
@@ -56,6 +62,11 @@ import { simulateConfigurablePriceRangeService } from "./simulateConfigurablePri
 import { createFileDownloadURLService } from "./createFileDownloadURL.js";
 import { resolveTokenStatusService } from "./resolveTokenStatus.js";
 import { isTokenInvalidateableService } from "./isTokenInvalidateable.js";
+import { bulkRemoveProductsService } from "./bulkRemoveProducts.js";
+import { bulkRemoveFiltersService } from "./bulkRemoveFilters.js";
+import { bulkDeleteUsersService } from "./bulkDeleteUsers.js";
+import { bulkSetFilterActiveService } from "./bulkSetFilterActive.js";
+import { bulkAssignProductsToAssortmentService } from "./bulkAssignProductsToAssortment.js";
 function bindMethodsToModules(modules) {
     return {
         get(target, prop, receiver) {
@@ -88,6 +99,7 @@ export default function initServices(modules, customServices = {}) {
             registerPaymentCredentials: registerPaymentCredentialsService,
             calculateDiscountTotal: calculateDiscountTotalService,
             migrateOrderCarts: migrateOrderCartsService,
+            deleteCart: deleteCartService,
             nextUserCart: nextUserCartService,
             findOrInitCart: findOrInitCartService,
             initCartProviders: initCartProvidersService,
@@ -110,18 +122,23 @@ export default function initServices(modules, customServices = {}) {
             simulateProductDispatching: simulateProductDispatchingService,
             simulateProductInventory: simulateProductInventoryService,
             removeProduct: removeProductService,
+            bulkRemoveProducts: bulkRemoveProductsService,
             findProductSiblings: findProductSiblingsService,
             simulateConfigurablePriceRange: simulateConfigurablePriceRangeService,
         },
+        assortments: {
+            bulkAssignProductsToAssortment: bulkAssignProductsToAssortmentService,
+        },
         users: {
             migrateUserData: migrateUserDataService,
             updateUserAvatarAfterUpload: updateUserAvatarAfterUploadService,
             deleteUser: deleteUserService,
+            bulkDeleteUsers: bulkDeleteUsersService,
         },
         enrollments: {
             createEnrollmentFromCheckout: createEnrollmentFromCheckoutService,
             generateOrderFromEnrollment: generateOrderFromEnrollmentService,
-            processEnrollment: processOrderService,
+            processEnrollment: processEnrollmentService,
             initializeEnrollment: initializeEnrollmentService,
             activateEnrollment: activateEnrollmentService,
             terminateEnrollment: terminateEnrollmentService,
@@ -140,6 +157,12 @@ export default function initServices(modules, customServices = {}) {
             loadFilters: loadFiltersService,
             loadFilterOptions: loadFilterOptionsService,
             removeFilter: removeFilterService,
+            createFilter: createFilterService,
+            updateFilter: updateFilterService,
+            createFilterOption: createFilterOptionService,
+            removeFilterOption: removeFilterOptionService,
+            bulkRemoveFilters: bulkRemoveFiltersService,
+            bulkSetFilterActive: bulkSetFilterActiveService,
         },
         warehousing: {
             ercMetadata: ercMetadataService,

package/lib/services/initCartProviders.js

@@ -39,6 +39,7 @@ export async function initCartProvidersService(order) {
         const paymentCredentials = await this.payment.paymentCredentials.findPaymentCredentials({ userId: updatedOrder.userId, isPreferred: true }, {
             sort: {
                 created: -1,
+                _id: -1,
             },
         });
         const defaultOrderPaymentProvider = await paymentSettings.determineDefaultProvider({

package/lib/services/isTokenInvalidateable.d.ts

@@ -1,5 +1,7 @@
 import type { TokenSurrogate } from '@unchainedshop/core-warehousing';
+import type { Product } from '@unchainedshop/core-products';
 import type { Modules } from '../modules.ts';
-export declare function isTokenInvalidateableService(this: Modules, { token, }: {
+export declare function isTokenInvalidateableService(this: Modules, { token, product: providedProduct, }: {
     token: TokenSurrogate;
+    product?: Product;
 }): Promise<boolean>;

package/lib/services/isTokenInvalidateable.js

@@ -1,7 +1,7 @@
 import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { WarehousingDirector } from "../directors/WarehousingDirector.js";
-export async function isTokenInvalidateableService({ token, }) {
-    const product = await this.products.findProduct({ productId: token.productId });
+export async function isTokenInvalidateableService({ token, product: providedProduct, }) {
+    const product = providedProduct || (await this.products.findProduct({ productId: token.productId }));
     if (!product)
         return false;
     const virtualProviders = (await this.warehousing.allProviders()).filter(({ type }) => type === WarehousingProviderType.VIRTUAL);

package/lib/services/loadFilterOptions.js

@@ -1,10 +1,10 @@
-import { FilterType } from '@unchainedshop/core-filters';
+import { filterOptionValues } from '@unchainedshop/core-filters';
 import { FilterDirector, parseQueryArray } from "../directors/FilterDirector.js";
 export async function loadFilterOptionsService(filter, params) {
     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 allOptions = filterOptionValues(filter);
     const mappedOptions = await Promise.all(allOptions.map(async (value) => {
         const filterOptionProductIds = await FilterDirector.filterProductIds(filter, {
             values: [value],
@@ -12,7 +12,7 @@ export async function loadFilterOptionsService(filter, params) {
         }, { modules: this });
         const filteredProductIdSet = productIdSet.intersection(filterOptionProductIds);
         const normalizedValues = values && this.filters.parse(filter, values, [value]);
-        const isSelected = normalizedValues && normalizedValues.indexOf(value) !== -1;
+        const isSelected = Boolean(normalizedValues && normalizedValues.indexOf(value) !== -1);
         if (!filteredProductIdSet.size && !isSelected) {
             return null;
         }

package/lib/services/processEnrollment.js

@@ -1,12 +1,13 @@
 import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { EnrollmentDirector } from "../core-index.js";
+import { createServiceError } from "../errors.js";
 const findNextStatus = async (enrollment, modules) => {
     let status = enrollment.status;
     const product = await modules.products.findProduct({
         productId: enrollment.productId,
     });
     if (!product)
-        throw new Error('Product not found for enrollment');
+        throw createServiceError('ProductNotFoundError', 'Product not found for enrollment');
     const director = await EnrollmentDirector.actions({ enrollment, product }, { modules });
     if (status === EnrollmentStatus.INITIAL || status === EnrollmentStatus.PAUSED) {
         if (await director.isValidForActivation()) {

package/lib/services/processOrder.js

@@ -5,6 +5,7 @@ import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { WarehousingDirector, DeliveryDirector, PaymentDirector } from "../directors/index.js";
 import { fulfillQuotationService } from "./fulfillQuotation.js";
 import { createLogger } from '@unchainedshop/logger';
+import { createServiceError } from "../errors.js";
 const logger = createLogger('unchained:core:processOrder');
 const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modules) => {
     if (orderPayment.status !== OrderPaymentStatus.PAID) {
@@ -12,7 +13,7 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
             paymentProviderId: orderPayment.paymentProviderId,
         });
         if (!paymentProvider)
-            throw new Error(`Payment provider not found: ${orderPayment.paymentProviderId}`);
+            throw createServiceError('PaymentProviderNotFoundError', `Payment provider not found: ${orderPayment.paymentProviderId}`);
         const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
         if (!actions.isPayLaterAllowed())
             return false;
@@ -22,7 +23,7 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
             deliveryProviderId: orderDelivery.deliveryProviderId,
         });
         if (!deliveryProvider)
-            throw new Error(`Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
+            throw createServiceError('DeliveryProviderNotFoundError', `Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
         const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
         if (!director.isAutoReleaseAllowed())
             return false;

package/lib/services/processQuotation.js

@@ -1,9 +1,8 @@
 import { QuotationStatus } from '@unchainedshop/core-quotations';
 import { QuotationDirector } from "../core-index.js";
 import { addMessageService } from "./addMessage.js";
-const findNextStatus = async (quotation, modules) => {
+const findNextStatus = async (director, quotation) => {
     let status = quotation.status;
-    const director = await QuotationDirector.actions({ quotation }, { modules });
     if (status === QuotationStatus.REQUESTED) {
         if (!(await director.isManualRequestVerificationRequired())) {
             status = QuotationStatus.PROCESSING;
@@ -19,27 +18,26 @@ const findNextStatus = async (quotation, modules) => {
 export async function processQuotationService(initialQuotation, params) {
     const quotationId = initialQuotation._id;
     let quotation = initialQuotation;
-    let nextStatus = await findNextStatus(quotation, this);
     const director = await QuotationDirector.actions({ quotation }, { modules: this });
+    const runHook = async (hook) => {
+        await hook(params.quotationContext);
+        quotation = (await this.quotations.findQuotation({ quotationId }));
+        return findNextStatus(director, quotation);
+    };
+    let nextStatus = await findNextStatus(director, quotation);
     if (quotation.status === QuotationStatus.REQUESTED && nextStatus !== QuotationStatus.REQUESTED) {
-        await director.submitRequest(params.quotationContext);
+        nextStatus = await runHook(director.submitRequest);
     }
-    quotation = (await this.quotations.findQuotation({ quotationId }));
-    nextStatus = await findNextStatus(quotation, this);
     if (nextStatus !== QuotationStatus.PROCESSING) {
-        await director.verifyRequest(params.quotationContext);
+        nextStatus = await runHook(director.verifyRequest);
     }
-    quotation = (await this.quotations.findQuotation({ quotationId }));
-    nextStatus = await findNextStatus(quotation, this);
     if (nextStatus === QuotationStatus.REJECTED) {
-        await director.rejectRequest(params.quotationContext);
+        nextStatus = await runHook(director.rejectRequest);
     }
-    quotation = (await this.quotations.findQuotation({ quotationId }));
-    nextStatus = await findNextStatus(quotation, this);
     if (nextStatus === QuotationStatus.PROPOSED) {
         const proposal = await director.quote();
         quotation = (await this.quotations.updateProposal(quotation._id, proposal));
-        nextStatus = await findNextStatus(quotation, this);
+        nextStatus = await findNextStatus(director, quotation);
     }
     const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
         status: nextStatus,

package/lib/services/proposeQuotation.js

@@ -3,6 +3,9 @@ import { processQuotationService } from "./processQuotation.js";
 export async function proposeQuotationService(quotation, { quotationContext }) {
     if (quotation.status !== QuotationStatus.PROCESSING)
         return quotation;
+    if (quotationContext) {
+        await this.quotations.updateContext(quotation._id, { context: quotationContext });
+    }
     const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
         status: QuotationStatus.PROPOSED,
         info: 'proposed manually',

package/lib/services/removeFilterOption.d.ts

@@ -0,0 +1,6 @@
+import type { Filter } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export declare function removeFilterOptionService(this: Modules, { filterId, filterOptionValue }: {
+    filterId: string;
+    filterOptionValue: string;
+}): Promise<Filter | null>;

package/lib/services/removeFilterOption.js

@@ -0,0 +1,8 @@
+import { FilterDirector } from "../core-index.js";
+export async function removeFilterOptionService({ filterId, filterOptionValue }) {
+    const filter = await this.filters.removeFilterOption({ filterId, filterOptionValue });
+    if (filter) {
+        await FilterDirector.invalidateProductIdCache(filter, { modules: this });
+    }
+    return filter;
+}

package/lib/services/removeProduct.js

@@ -1,5 +1,6 @@
 import { ProductStatus } from '@unchainedshop/core-products';
 import { updateCalculationService } from "./updateCalculation.js";
+import { createServiceError } from "../errors.js";
 export async function removeProductService({ productId }) {
     const product = await this.products.findProduct({ productId });
     switch (product?.status) {
@@ -21,7 +22,7 @@ export async function removeProductService({ productId }) {
         case ProductStatus.DELETED:
             return false;
         default:
-            throw new Error(`Invalid status: ${product?.status}`);
+            throw createServiceError('ProductWrongStatusError', `Invalid status: ${product?.status}`);
     }
     return true;
 }

package/lib/services/reserveOrderDiscountsForCheckout.d.ts

@@ -0,0 +1,5 @@
+import type { Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function reserveOrderDiscountsForCheckout(this: Modules, order: Order): Promise<{
+    release: () => Promise<void>;
+}>;

package/lib/services/reserveOrderDiscountsForCheckout.js

@@ -0,0 +1,34 @@
+import { createLogger } from '@unchainedshop/logger';
+import { OrderDiscountDirector } from "../directors/OrderDiscountDirector.js";
+const logger = createLogger('unchained:core:checkoutOrder');
+export async function reserveOrderDiscountsForCheckout(order) {
+    const reservations = [];
+    const release = async () => {
+        const results = await Promise.allSettled(reservations.map((reservation) => reservation.release()));
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                logger.error(`Could not release a discount reservation of order ${order._id}`, {
+                    error: result.reason,
+                });
+            }
+        }
+    };
+    try {
+        const discounts = await this.orders.discounts.findOrderDiscounts({ orderId: order._id });
+        for (const orderDiscount of discounts) {
+            const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+            if (!Adapter)
+                continue;
+            const adapter = await Adapter.actions({
+                context: { order, orderDiscount, code: orderDiscount.code, modules: this },
+            });
+            if (adapter.reserveForCheckout)
+                reservations.push(await adapter.reserveForCheckout());
+        }
+        return { release };
+    }
+    catch (error) {
+        await release();
+        throw error;
+    }
+}

package/lib/services/simulateProductDispatching.d.ts

@@ -3,10 +3,12 @@ import type { Product } from '@unchainedshop/core-products';
 import { type EstimatedDispatch } from '../directors/WarehousingDirector.ts';
 import type { WarehousingContext } from '../directors/WarehousingAdapter.ts';
 import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
-export declare function simulateProductDispatchingService(this: Modules, { product, quantity, referenceDate, }: {
+import type { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export declare function simulateProductDispatchingService(this: Modules, { product, quantity, referenceDate, deliveryProviderType, }: {
     product: Product;
     quantity: number;
     referenceDate?: Date;
+    deliveryProviderType?: DeliveryProviderType | null;
 }): Promise<(WarehousingContext & EstimatedDispatch & {
     warehousingProvider: WarehousingProvider;
 })[]>;

package/lib/services/simulateProductDispatching.js

@@ -1,7 +1,7 @@
 import { supportedWarehousingProvidersService } from "./supportedWarehousingProviders.js";
 import { WarehousingDirector } from "../directors/WarehousingDirector.js";
-export async function simulateProductDispatchingService({ product, quantity, referenceDate, }) {
-    const deliveryProviders = await this.delivery.allProviders();
+export async function simulateProductDispatchingService({ product, quantity, referenceDate, deliveryProviderType, }) {
+    const deliveryProviders = (await this.delivery.allProviders()).filter(({ type }) => !deliveryProviderType || type === deliveryProviderType);
     return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
         const result = await oldResult;
         const warehousingProviders = await supportedWarehousingProvidersService.bind(this)({
@@ -25,6 +25,6 @@ export async function simulateProductDispatchingService({ product, quantity, ref
                 ...dispatch,
             };
         }));
-        return result.concat(result, mappedWarehousingProviders);
+        return result.concat(mappedWarehousingProviders);
     }, Promise.resolve([]));
 }

package/lib/services/simulateProductInventory.d.ts

@@ -2,9 +2,11 @@ import type { Modules } from '../modules.ts';
 import type { Product } from '@unchainedshop/core-products';
 import type { WarehousingContext } from '../directors/WarehousingAdapter.ts';
 import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
-export declare function simulateProductInventoryService(this: Modules, { product, referenceDate, }: {
+import type { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export declare function simulateProductInventoryService(this: Modules, { product, referenceDate, deliveryProviderType, }: {
     product: Product;
     referenceDate?: Date;
+    deliveryProviderType?: DeliveryProviderType | null;
 }): Promise<(WarehousingContext & {
     quantity?: number;
 } & {

package/lib/services/simulateProductInventory.js

@@ -1,7 +1,7 @@
 import { supportedWarehousingProvidersService } from "./supportedWarehousingProviders.js";
 import { WarehousingDirector } from "../directors/WarehousingDirector.js";
-export async function simulateProductInventoryService({ product, referenceDate, }) {
-    const deliveryProviders = await this.delivery.allProviders();
+export async function simulateProductInventoryService({ product, referenceDate, deliveryProviderType, }) {
+    const deliveryProviders = (await this.delivery.allProviders()).filter(({ type }) => !deliveryProviderType || type === deliveryProviderType);
     return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
         const result = await oldResult;
         const warehousingProviders = await supportedWarehousingProvidersService.bind(this)({
@@ -24,6 +24,6 @@ export async function simulateProductInventoryService({ product, referenceDate,
                 ...stock,
             };
         }));
-        return result.concat(result, mappedWarehousingProviders);
+        return result.concat(mappedWarehousingProviders);
     }, Promise.resolve([]));
 }

package/lib/services/supportedDeliveryProviders.js

@@ -1,8 +1,17 @@
 import { deliverySettings } from '@unchainedshop/core-delivery';
+import { createLogger } from '@unchainedshop/logger';
 import { DeliveryDirector } from "../directors/index.js";
+const logger = createLogger('unchained:core');
 export async function supportedDeliveryProvidersService(params) {
     const allProviders = await this.delivery.allProviders();
     const providers = (await Promise.all(allProviders.map(async (provider) => {
+        if (!DeliveryDirector.getAdapter(provider.adapterKey)) {
+            logger.warn('Delivery provider skipped, its adapter is not registered', {
+                deliveryProviderId: provider._id,
+                adapterKey: provider.adapterKey,
+            });
+            return [];
+        }
         const adapter = await DeliveryDirector.actions(provider, params, { modules: this });
         return adapter.isActive() ? [provider] : [];
     }))).flat();

package/lib/services/supportedPaymentProviders.js

@@ -1,8 +1,17 @@
 import { paymentSettings } from '@unchainedshop/core-payment';
+import { createLogger } from '@unchainedshop/logger';
 import { PaymentDirector } from "../directors/PaymentDirector.js";
+const logger = createLogger('unchained:core');
 export async function supportedPaymentProvidersService(params) {
     const allProviders = await this.payment.paymentProviders.allProviders();
     const providers = (await Promise.all(allProviders.map(async (provider) => {
+        if (!PaymentDirector.getAdapter(provider.adapterKey)) {
+            logger.warn('Payment provider skipped, its adapter is not registered', {
+                paymentProviderId: provider._id,
+                adapterKey: provider.adapterKey,
+            });
+            return [];
+        }
         const adapter = await PaymentDirector.actions(provider, params, { modules: this });
         return adapter.isActive() ? [provider] : [];
     }))).flat();