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

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,12 +24,15 @@ 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';
 import { discountedEntitiesService } from './discountedEntities.ts';
 import { createManualOrderDiscountService } from './createManualOrderDiscount.ts';
 import { initializeEnrollmentService } from './initializeEnrollment.ts';
+import { suspendEnrollmentService } from './suspendEnrollment.ts';
+import { updateEnrollmentPlanService } from './updateEnrollmentPlan.ts';
 import { activateEnrollmentService } from './activateEnrollment.ts';
 import { terminateEnrollmentService } from './terminateEnrollment.ts';
 import { invalidateFilterCacheService } from './invalidateFilterCache.ts';
@@ -40,8 +44,14 @@ 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 { addCartQuotationService } from './addCartQuotation.ts';
+import { updateCartItemService } from './updateCartItem.ts';
 import { ercMetadataService } from './ercMetadata.ts';
 import { simulateProductPricingService } from './simulateProductPricing.ts';
 import { simulateProductDispatchingService } from './simulateProductDispatching.ts';
@@ -57,6 +67,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 +92,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>;
@@ -93,27 +109,36 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         resolveOrderItemDispatches: Bound<typeof resolveOrderItemDispatchesService>;
         removeCartDiscount: Bound<typeof removeCartDiscountService>;
         addMultipleCartProducts: Bound<typeof addMultipleCartProductsService>;
+        addCartQuotation: Bound<typeof addCartQuotationService>;
+        updateCartItem: Bound<typeof updateCartItemService>;
     };
     products: {
         simulateProductPricing: Bound<typeof simulateProductPricingService>;
         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>;
+        suspendEnrollment: Bound<typeof suspendEnrollmentService>;
+        updateEnrollmentPlan: Bound<typeof updateEnrollmentPlanService>;
     };
     quotations: {
         fulfillQuotation: Bound<typeof fulfillQuotationService>;
@@ -129,6 +154,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,12 +23,15 @@ 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";
 import { discountedEntitiesService } from "./discountedEntities.js";
 import { createManualOrderDiscountService } from "./createManualOrderDiscount.js";
 import { initializeEnrollmentService } from "./initializeEnrollment.js";
+import { suspendEnrollmentService } from "./suspendEnrollment.js";
+import { updateEnrollmentPlanService } from "./updateEnrollmentPlan.js";
 import { activateEnrollmentService } from "./activateEnrollment.js";
 import { terminateEnrollmentService } from "./terminateEnrollment.js";
 import { invalidateFilterCacheService } from "./invalidateFilterCache.js";
@@ -39,8 +43,14 @@ 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 { addCartQuotationService } from "./addCartQuotation.js";
+import { updateCartItemService } from "./updateCartItem.js";
 import { ercMetadataService } from "./ercMetadata.js";
 import { simulateProductPricingService } from "./simulateProductPricing.js";
 import { simulateProductDispatchingService } from "./simulateProductDispatching.js";
@@ -56,6 +66,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 +103,7 @@ export default function initServices(modules, customServices = {}) {
             registerPaymentCredentials: registerPaymentCredentialsService,
             calculateDiscountTotal: calculateDiscountTotalService,
             migrateOrderCarts: migrateOrderCartsService,
+            deleteCart: deleteCartService,
             nextUserCart: nextUserCartService,
             findOrInitCart: findOrInitCartService,
             initCartProviders: initCartProvidersService,
@@ -104,27 +120,36 @@ export default function initServices(modules, customServices = {}) {
             resolveOrderItemDispatches: resolveOrderItemDispatchesService,
             removeCartDiscount: removeCartDiscountService,
             addMultipleCartProducts: addMultipleCartProductsService,
+            addCartQuotation: addCartQuotationService,
+            updateCartItem: updateCartItemService,
         },
         products: {
             simulateProductPricing: simulateProductPricingService,
             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,
+            suspendEnrollment: suspendEnrollmentService,
+            updateEnrollmentPlan: updateEnrollmentPlanService,
         },
         quotations: {
             fulfillQuotation: fulfillQuotationService,
@@ -140,6 +165,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/initializeEnrollment.d.ts

@@ -1,4 +1,4 @@
-import type { Enrollment } from '@unchainedshop/core-enrollments';
+import { type Enrollment } from '@unchainedshop/core-enrollments';
 import type { Modules } from '../modules.ts';
 export declare function initializeEnrollmentService(this: Modules, enrollment: Enrollment, params: {
     orderIdForFirstPeriod?: string;

package/lib/services/initializeEnrollment.js

@@ -1,3 +1,4 @@
+import { addToDate } from '@unchainedshop/core-enrollments';
 import { EnrollmentDirector } from "../core-index.js";
 import { processEnrollmentService } from "./processEnrollment.js";
 import { addMessageService } from "./addMessage.js";
@@ -14,6 +15,16 @@ export async function initializeEnrollmentService(enrollment, params) {
             orderId: params.orderIdForFirstPeriod,
         }));
     }
+    const { minimumCommitmentPeriods, billingInterval, billingIntervalCount } = product?.plan || {};
+    if (minimumCommitmentPeriods && billingInterval) {
+        const contractStartDate = updatedEnrollment.periods.find(({ isTrial }) => !isTrial)?.start || new Date();
+        updatedEnrollment = (await this.enrollments.updateCommitment(enrollment._id, {
+            contractStartDate,
+            minimumCommitmentEnd: addToDate(contractStartDate, {
+                [billingInterval.toLowerCase()]: (billingIntervalCount || 1) * minimumCommitmentPeriods,
+            }),
+        }));
+    }
     const processedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
     const user = await this.users.findUserById(enrollment.userId);
     const locale = this.users.userLocale(user);

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/migrateOrderCart.js

@@ -12,10 +12,10 @@ export async function migrateOrderCartsService({ fromUserId, toUserId, shouldMer
         return toCart;
     }
     if (!toCart || !shouldMerge) {
-        this.orders.setCartOwner({ orderId: fromCart._id, userId: toUserId });
+        await this.orders.setCartOwner({ orderId: fromCart._id, userId: toUserId });
         return updateCalculationService.bind(this)(fromCart._id);
     }
-    this.orders.moveCartPositions({ fromOrderId: fromCart._id, toOrderId: toCart._id });
+    await this.orders.moveCartPositions({ fromOrderId: fromCart._id, toOrderId: toCart._id });
     if (fromCart.billingAddress && !toCart.billingAddress) {
         await this.orders.updateBillingAddress(toCart._id, fromCart.billingAddress);
     }

package/lib/services/migrateUserData.js

@@ -4,6 +4,9 @@ import { migrateOrderCartsService } from "./migrateOrderCart.js";
 export async function migrateUserDataService(userIdBeforeLogin, userId) {
     const user = await this.users.findUserById(userId);
     const userBeforeLogin = await this.users.findUserById(userIdBeforeLogin);
+    if (userBeforeLogin?.guest) {
+        await this.quotations.replaceUserIdOfOpenQuotations(userIdBeforeLogin, userId);
+    }
     await migrateOrderCartsService.bind(this)({
         fromUserId: userIdBeforeLogin,
         toUserId: userId,

package/lib/services/processEnrollment.js

@@ -1,12 +1,19 @@
 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;
+    if (modules.enrollments.isExpired(enrollment, {}))
+        return EnrollmentStatus.TERMINATED;
+    if (status === EnrollmentStatus.SUSPENDED) {
+        const resumeDue = enrollment.resumeAt && new Date(enrollment.resumeAt).getTime() <= Date.now();
+        return resumeDue ? EnrollmentStatus.ACTIVE : 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()) {
@@ -18,9 +25,6 @@ const findNextStatus = async (enrollment, modules) => {
             status = EnrollmentStatus.PAUSED;
         }
     }
-    else if (modules.enrollments.isExpired(enrollment, {})) {
-        status = EnrollmentStatus.TERMINATED;
-    }
     return status;
 };
 export async function processEnrollmentService(enrollment) {

package/lib/services/processOrder.js

@@ -5,15 +5,16 @@ 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) => {
+const isAutoConfirmationEnabled = async ({ order, orderPayment, orderDelivery, }, modules) => {
     if (orderPayment.status !== OrderPaymentStatus.PAID) {
         const paymentProvider = await modules.payment.paymentProviders.findProvider({
             paymentProviderId: orderPayment.paymentProviderId,
         });
         if (!paymentProvider)
-            throw new Error(`Payment provider not found: ${orderPayment.paymentProviderId}`);
-        const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
+            throw createServiceError('PaymentProviderNotFoundError', `Payment provider not found: ${orderPayment.paymentProviderId}`);
+        const actions = await PaymentDirector.actions(paymentProvider, { order, orderPayment, userId: order.userId }, { modules });
         if (!actions.isPayLaterAllowed())
             return false;
     }
@@ -22,8 +23,8 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
             deliveryProviderId: orderDelivery.deliveryProviderId,
         });
         if (!deliveryProvider)
-            throw new Error(`Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
-        const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
+            throw createServiceError('DeliveryProviderNotFoundError', `Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
+        const director = await DeliveryDirector.actions(deliveryProvider, { order, orderDelivery }, { modules });
         if (!director.isAutoReleaseAllowed())
             return false;
     }
@@ -49,7 +50,7 @@ const findNextStatus = async (status, order, modules) => {
     if (!orderDelivery)
         return status;
     if (status === OrderStatus.PENDING) {
-        if (await isAutoConfirmationEnabled({ orderPayment, orderDelivery }, modules)) {
+        if (await isAutoConfirmationEnabled({ order, orderPayment, orderDelivery }, modules)) {
             return OrderStatus.CONFIRMED;
         }
     }

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/reserveOrderQuotationsForCheckout.d.ts

@@ -0,0 +1,8 @@
+import { type Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function isQuotationReserved(this: Modules, quotationId: string, { exceptOrderId }?: {
+    exceptOrderId?: string;
+}): Promise<boolean>;
+export declare function reserveOrderQuotationsForCheckout(this: Modules, order: Order): Promise<{
+    release: () => Promise<void>;
+}>;

package/lib/services/reserveOrderQuotationsForCheckout.js

@@ -0,0 +1,49 @@
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { createServiceError } from "../errors.js";
+const RESERVATION_LOCK_TTL = 60000;
+export async function isQuotationReserved(quotationId, { exceptOrderId } = {}) {
+    const orderIds = (await this.orders.positions.findOrderPositions({ quotationId }))
+        .map(({ orderId }) => orderId)
+        .filter((orderId) => orderId !== exceptOrderId);
+    if (!orderIds.length)
+        return false;
+    const count = await this.orders.count({
+        orderIds,
+        status: [OrderStatus.PENDING, OrderStatus.CONFIRMED, OrderStatus.FULFILLED],
+    });
+    return count > 0;
+}
+export async function reserveOrderQuotationsForCheckout(order) {
+    const locks = [];
+    const release = async () => {
+        await Promise.all(locks.map((lock) => lock.release()));
+    };
+    try {
+        const positions = await this.orders.positions.findOrderPositions({ orderId: order._id });
+        const quotationIds = [
+            ...new Set(positions.map(({ quotationId }) => quotationId).filter(Boolean)),
+        ].sort();
+        for (const quotationId of quotationIds) {
+            try {
+                locks.push(await this.orders.acquireLock(quotationId, 'quotation', RESERVATION_LOCK_TTL));
+            }
+            catch (error) {
+                if (!error?.message?.startsWith('Could not acquire lock'))
+                    throw error;
+                throw createServiceError('QuotationInvalidError', 'Quotation is being ordered by another order');
+            }
+            const quotation = await this.quotations.findQuotation({ quotationId });
+            if (!quotation || !this.quotations.isProposalValid(quotation)) {
+                throw createServiceError('QuotationInvalidError', 'Quotation expired, fulfilled or not valid for this order, please request a new offer');
+            }
+            if (await isQuotationReserved.call(this, quotationId, { exceptOrderId: order._id })) {
+                throw createServiceError('QuotationInvalidError', 'Quotation is reserved by another order');
+            }
+        }
+        return { release };
+    }
+    catch (error) {
+        await release();
+        throw error;
+    }
+}

package/lib/services/simulateConfigurablePriceRange.js

@@ -22,7 +22,7 @@ export async function simulateConfigurablePriceRangeService({ product, currencyC
         return {
             ...unitPrice,
             isNetPrice: useNetPrice,
-            isTaxable: pricing.taxSum() > 0,
+            isTaxable: pricing.taxSum() !== 0,
             currencyCode: pricing.currencyCode,
         };
     }))).filter(Boolean);

package/lib/services/simulateDeliveryPricing.js

@@ -17,7 +17,7 @@ export async function simulateDeliveryPricingService(pricingContext, options = {
         amount: orderPrice.amount,
         currencyCode: orderPrice.currencyCode,
         countryCode: pricingContext.countryCode,
-        isTaxable: pricing.taxSum() > 0,
+        isTaxable: pricing.taxSum() !== 0,
         isNetPrice: options.useNetPrice || false,
     };
 }

package/lib/services/simulatePaymentPricing.js

@@ -17,7 +17,7 @@ export async function simulatePaymentPricingService(pricingContext, options = {}
         amount: orderPrice.amount,
         currencyCode: orderPrice.currencyCode,
         countryCode: pricingContext.countryCode,
-        isTaxable: pricing.taxSum() > 0,
+        isTaxable: pricing.taxSum() !== 0,
         isNetPrice: options.useNetPrice || false,
     };
 }

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;
 })[]>;