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

package/lib/bulk-exporter/handlers/exportUsersHandler.js

@@ -71,6 +71,7 @@ const USER_CSV_SCHEMA = {
         'userId',
         'quotationNumber',
         'productId',
+        'quantity',
         'status',
         'price',
         'expires',

package/lib/directors/BasePricingSheet.d.ts

@@ -3,6 +3,8 @@ export interface PricingDiscount {
     discountId: string;
     amount: number;
     currencyCode: string;
+    isTaxable: boolean;
+    isNetPrice: boolean;
 }
 export interface IPricingSheet<Calculation extends PricingCalculation> extends IBasePricingSheet<Calculation> {
     discountPrices: (discountId?: string) => PricingDiscount[];

package/lib/directors/DeliveryPricingSheet.js

@@ -28,10 +28,12 @@ export const DeliveryPricingSheet = (params) => {
                 meta,
             });
         },
-        addTax({ amount, rate, meta }) {
+        addTax({ amount, rate, baseCategory, discountId, meta }) {
             basePricingSheet.calculation.push({
                 amount,
                 category: DeliveryPricingRowCategory.Tax,
+                baseCategory,
+                discountId,
                 isNetPrice: false,
                 isTaxable: false,
                 meta,
@@ -54,17 +56,20 @@ export const DeliveryPricingSheet = (params) => {
                 .filter(Boolean);
             return [...new Set(discountIds)]
                 .map((discountId) => {
-                const { currencyCode, amount } = basePricingSheet.total({
-                    category: DeliveryPricingRowCategory.Discount,
+                const taxAmount = pricingSheet.taxSum({
+                    baseCategory: DeliveryPricingRowCategory.Discount,
                     discountId,
                 });
+                const amount = pricingSheet.sum({ category: DeliveryPricingRowCategory.Discount, discountId }) + taxAmount;
                 if (!amount) {
                     return null;
                 }
                 return {
                     discountId,
                     amount: Math.round(amount),
-                    currencyCode,
+                    currencyCode: pricingSheet.currencyCode,
+                    isTaxable: taxAmount !== 0,
+                    isNetPrice: false,
                 };
             })
                 .filter(Boolean);

package/lib/directors/EnrollmentAdapter.d.ts

@@ -2,6 +2,7 @@ import { type IBaseAdapter } from '@unchainedshop/utils';
 import { type Enrollment, type EnrollmentOrderPositionTemplate, type EnrollmentPeriod, type EnrollmentPlan } from '@unchainedshop/core-enrollments';
 import type { Product, ProductPlan } from '@unchainedshop/core-products';
 import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
 export interface EnrollmentContext {
     enrollment: Enrollment;
     product: Product;
@@ -16,11 +17,20 @@ export interface EnrollmentAdapterActions {
     isOverdue: () => Promise<boolean>;
     isValidForActivation: () => Promise<boolean>;
     nextPeriod: () => Promise<EnrollmentPeriod | null>;
+    terminationDate: (params: {
+        referenceDate: Date;
+    }) => Promise<Date | null>;
+    transformPlanToNewPlan: (params: {
+        plan: EnrollmentPlan;
+    }) => Promise<EnrollmentPlan | null>;
 }
 export type IEnrollmentAdapter = IBaseAdapter & {
+    orderIndex?: number;
     isActivatedFor: (productPlan?: ProductPlan) => boolean;
     transformOrderItemToEnrollmentPlan: (orderPosition: OrderPosition, unchainedAPI: any) => Promise<EnrollmentPlan>;
-    actions: (params: EnrollmentContext) => EnrollmentAdapterActions;
+    actions: (params: EnrollmentContext & {
+        modules: Modules;
+    }) => EnrollmentAdapterActions;
 };
 export declare const periodForReferenceDate: (referenceDate: Date, intervalCount?: number, interval?: string) => {
     start: Date;

package/lib/directors/EnrollmentAdapter.js

@@ -56,11 +56,17 @@ export const EnrollmentAdapter = {
                     }
                     return acc;
                 }, referenceDate);
-                return {
+                const period = {
                     ...periodForReferenceDate(lastEnd, plan.billingIntervalCount, plan.billingInterval),
                     isTrial: false,
                 };
+                if (enrollment?.expires && period.start.getTime() >= new Date(enrollment.expires).getTime()) {
+                    return null;
+                }
+                return period;
             },
+            terminationDate: async ({ referenceDate }) => referenceDate,
+            transformPlanToNewPlan: async () => null,
         };
     },
 };

package/lib/directors/EnrollmentDirector.d.ts

@@ -1,7 +1,7 @@
 import type { IBaseDirector } from '@unchainedshop/utils';
 import type { EnrollmentAdapterActions, EnrollmentContext, IEnrollmentAdapter } from './EnrollmentAdapter.ts';
 import type { OrderPosition } from '@unchainedshop/core-orders';
-import type { Product } from '@unchainedshop/core-products';
+import type { Product, ProductPlan } from '@unchainedshop/core-products';
 import type { Enrollment } from '@unchainedshop/core-enrollments';
 import type { Modules } from '../modules.ts';
 export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
@@ -9,6 +9,7 @@ export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
         orderPosition: OrderPosition;
         product: Product;
     }, doc: Omit<Enrollment, 'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'>, unchainedAPI: any) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> & Pick<Partial<Enrollment>, '_id' | 'created'>>;
+    findSupportedAdapter: (productPlan?: ProductPlan) => IEnrollmentAdapter | null;
     actions: (enrollmentContext: EnrollmentContext, unchainedAPI: {
         modules: Modules;
     }) => Promise<EnrollmentAdapterActions>;

package/lib/directors/EnrollmentDirector.js

@@ -1,6 +1,7 @@
 import { EnrollmentAdapter } from "./EnrollmentAdapter.js";
 import { createLogger } from '@unchainedshop/logger';
 import { registryDirector } from "./registryDirector.js";
+import { createServiceError } from "../errors.js";
 const logger = createLogger('unchained:core');
 const findAppropriateAdapters = (productPlan) => EnrollmentDirector.getAdapters({
     adapterFilter: (Adapter) => {
@@ -13,10 +14,11 @@ const findAppropriateAdapters = (productPlan) => EnrollmentDirector.getAdapters(
 });
 export const EnrollmentDirector = {
     ...registryDirector(EnrollmentAdapter.adapterType),
+    findSupportedAdapter: (productPlan) => findAppropriateAdapters(productPlan)?.[0] || null,
     transformOrderItemToEnrollment: async ({ orderPosition, product }, doc, unchainedAPI) => {
-        const Adapter = findAppropriateAdapters(product.plan)?.[0];
+        const Adapter = EnrollmentDirector.findSupportedAdapter(product.plan);
         if (!Adapter) {
-            throw new Error('No suitable enrollment plugin available for this item');
+            throw createServiceError('EnrollmentPlanNotSupportedError', 'No suitable enrollment plugin available for this item');
         }
         const enrollmentPlan = await Adapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
         return {
@@ -27,9 +29,9 @@ export const EnrollmentDirector = {
     },
     actions: async (enrollmentContext, unchainedAPI) => {
         const context = { ...enrollmentContext, ...unchainedAPI };
-        const Adapter = findAppropriateAdapters(enrollmentContext.product.plan)?.[0];
+        const Adapter = EnrollmentDirector.findSupportedAdapter(enrollmentContext.product.plan);
         if (!Adapter) {
-            throw new Error('No suitable enrollment plugin available for this plan configuration');
+            throw createServiceError('EnrollmentPlanNotSupportedError', 'No suitable enrollment plugin available for this plan configuration');
         }
         const adapter = Adapter.actions(context);
         return adapter;

package/lib/directors/OrderPricingSheet.js

@@ -81,14 +81,11 @@ export const OrderPricingSheet = (params) => {
                 .filter(Boolean);
             return [...new Set(discountIds)]
                 .map((discountId) => {
-                const amount = pricingSheet.sum({
-                    category: OrderPricingRowCategory.Discounts,
+                const taxAmount = pricingSheet.taxSum({
+                    baseCategory: OrderPricingRowCategory.Discounts,
                     discountId,
-                }) +
-                    pricingSheet.taxSum({
-                        baseCategory: OrderPricingRowCategory.Discounts,
-                        discountId,
-                    });
+                });
+                const amount = pricingSheet.sum({ category: OrderPricingRowCategory.Discounts, discountId }) + taxAmount;
                 if (!amount) {
                     return null;
                 }
@@ -96,6 +93,8 @@ export const OrderPricingSheet = (params) => {
                     discountId,
                     amount: Math.round(amount),
                     currencyCode: pricingSheet.currencyCode,
+                    isTaxable: taxAmount !== 0,
+                    isNetPrice: false,
                 };
             })
                 .filter(Boolean);

package/lib/directors/PaymentPricingSheet.js

@@ -29,10 +29,12 @@ export const PaymentPricingSheet = (params) => {
                 meta,
             });
         },
-        addTax({ amount, rate, meta }) {
+        addTax({ amount, rate, baseCategory, discountId, meta }) {
             basePricingSheet.calculation.push({
                 category: PaymentPricingRowCategory.Tax,
                 amount,
+                baseCategory,
+                discountId,
                 isTaxable: false,
                 isNetPrice: false,
                 rate,
@@ -55,17 +57,20 @@ export const PaymentPricingSheet = (params) => {
                 .filter(Boolean);
             return [...new Set(discountIds)]
                 .map((discountId) => {
-                const amount = basePricingSheet.sum({
-                    category: PaymentPricingRowCategory.Discount,
+                const taxAmount = pricingSheet.taxSum({
+                    baseCategory: PaymentPricingRowCategory.Discount,
                     discountId,
                 });
+                const amount = pricingSheet.sum({ category: PaymentPricingRowCategory.Discount, discountId }) + taxAmount;
                 if (!amount) {
                     return null;
                 }
                 return {
                     discountId,
                     amount: Math.round(amount),
-                    currencyCode: basePricingSheet.currencyCode,
+                    currencyCode: pricingSheet.currencyCode,
+                    isTaxable: taxAmount !== 0,
+                    isNetPrice: false,
                 };
             })
                 .filter(Boolean);

package/lib/directors/ProductPricingAdapter.d.ts

@@ -10,6 +10,7 @@ export interface ProductPricingAdapterContext extends BasePricingAdapterContext
     product: Product;
     quantity: number;
     configuration: ProductConfiguration[] | null;
+    quotationId?: string;
     order?: Order;
     user?: User;
 }

package/lib/directors/ProductPricingDirector.js

@@ -28,6 +28,7 @@ export const ProductPricingDirector = {
                 product: product,
                 quantity,
                 configuration: item.configuration ?? null,
+                quotationId: item.quotationId,
                 user: user,
             };
         }

package/lib/directors/ProductPricingSheet.js

@@ -1,4 +1,4 @@
-import { BasePricingSheet } from "./BasePricingSheet.js";
+import { BasePricingSheet, } from "./BasePricingSheet.js";
 export const ProductPricingRowCategory = {
     Item: 'ITEM',
     Discount: 'DISCOUNT',
@@ -62,17 +62,20 @@ export const ProductPricingSheet = (params) => {
                 .filter(Boolean);
             return [...new Set(discountIds)]
                 .map((discountId) => {
-                const amount = basePricingSheet.sum({
-                    category: ProductPricingRowCategory.Discount,
+                const taxAmount = pricingSheet.taxSum({
+                    baseCategory: ProductPricingRowCategory.Discount,
                     discountId,
                 });
+                const amount = pricingSheet.sum({ category: ProductPricingRowCategory.Discount, discountId }) + taxAmount;
                 if (!amount) {
                     return null;
                 }
                 return {
                     discountId,
                     amount: Math.round(amount),
-                    currencyCode: basePricingSheet.currencyCode,
+                    currencyCode: pricingSheet.currencyCode,
+                    isTaxable: taxAmount !== 0,
+                    isNetPrice: false,
                 };
             })
                 .filter(Boolean);

package/lib/directors/QuotationAdapter.js

@@ -12,7 +12,7 @@ export const QuotationAdapter = {
     isActivatedFor: () => {
         return false;
     },
-    actions: () => {
+    actions: (params) => {
         return {
             configurationError: () => {
                 return QuotationError.NOT_IMPLEMENTED;
@@ -36,7 +36,10 @@ export const QuotationAdapter = {
                 return true;
             },
             transformItemConfiguration: async ({ quantity, configuration }) => {
-                return { quantity, configuration };
+                const quotedQuantity = params?.quotation?.quantity;
+                if (quotedQuantity && (!quantity || quantity % quotedQuantity !== 0))
+                    return null;
+                return { quantity, configuration: params?.quotation?.configuration ?? configuration };
             },
         };
     },

package/lib/factory/registerEnrollment.d.ts

@@ -2,8 +2,9 @@ import type { EnrollmentOrderPositionTemplate, EnrollmentPeriod, EnrollmentPlan
 import type { ProductPlan } from '@unchainedshop/core-products';
 import type { OrderPosition } from '@unchainedshop/core-orders';
 import { type EnrollmentContext, type IPlugin } from '../core-index.ts';
-export default function registerEnrollment({ adapterId, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, }: {
+export default function registerEnrollment({ adapterId, orderIndex, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, terminationDate, transformPlanToNewPlan, }: {
     adapterId: string;
+    orderIndex?: number;
     isActivatedFor?: (productPlan?: ProductPlan) => boolean;
     transformOrderItem?: (orderPosition: OrderPosition, unchainedAPI: any) => Promise<EnrollmentPlan>;
     configurationForOrder: (params: {
@@ -15,4 +16,10 @@ export default function registerEnrollment({ adapterId, isActivatedFor, transfor
     isOverdue?: (context: EnrollmentContext) => Promise<boolean>;
     isValidForActivation?: (context: EnrollmentContext) => Promise<boolean>;
     nextPeriod?: (context: EnrollmentContext) => Promise<EnrollmentPeriod | null>;
+    terminationDate?: (context: EnrollmentContext, params: {
+        referenceDate: Date;
+    }) => Promise<Date | null>;
+    transformPlanToNewPlan?: (context: EnrollmentContext, params: {
+        plan: EnrollmentPlan;
+    }) => Promise<EnrollmentPlan | null>;
 }): IPlugin;

package/lib/factory/registerEnrollment.js

@@ -1,11 +1,12 @@
 import { EnrollmentAdapter, } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerEnrollment({ adapterId, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, }) {
+export default function registerEnrollment({ adapterId, orderIndex, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, terminationDate, transformPlanToNewPlan, }) {
     const adapter = {
         ...EnrollmentAdapter,
         key: `shop.unchained.enrollment.${adapterId}`,
         label: 'Enrollment: ' + adapterId,
         version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
         isActivatedFor: (productPlan) => {
             return isActivatedFor ? isActivatedFor(productPlan) : true;
         },
@@ -15,20 +16,17 @@ export default function registerEnrollment({ adapterId, isActivatedFor, transfor
                 : EnrollmentAdapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
         },
         actions: (context) => {
+            const base = EnrollmentAdapter.actions(context);
             return {
-                ...EnrollmentAdapter.actions(context),
-                configurationForOrder: async (params) => {
-                    return configurationForOrder(params, context);
-                },
-                isOverdue: async () => {
-                    return isOverdue ? isOverdue(context) : false;
-                },
-                isValidForActivation: async () => {
-                    return isValidForActivation ? isValidForActivation(context) : false;
-                },
-                nextPeriod: async () => {
-                    return nextPeriod ? nextPeriod(context) : EnrollmentAdapter.actions(context).nextPeriod();
-                },
+                ...base,
+                configurationForOrder: (params) => configurationForOrder(params, context),
+                isOverdue: () => (isOverdue ? isOverdue(context) : base.isOverdue()),
+                isValidForActivation: () => isValidForActivation ? isValidForActivation(context) : base.isValidForActivation(),
+                nextPeriod: () => (nextPeriod ? nextPeriod(context) : base.nextPeriod()),
+                terminationDate: (params) => terminationDate ? terminationDate(context, params) : base.terminationDate(params),
+                transformPlanToNewPlan: (params) => transformPlanToNewPlan
+                    ? transformPlanToNewPlan(context, params)
+                    : base.transformPlanToNewPlan(params),
             };
         },
     };

package/lib/factory/registerQuotation.d.ts

@@ -1,7 +1,8 @@
 import type { QuotationItemConfiguration, QuotationProposal } from '@unchainedshop/core-quotations';
 import { type QuotationContext, type IPlugin } from '../core-index.ts';
-export default function registerQuotation({ adapterId, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }: {
+export default function registerQuotation({ adapterId, orderIndex, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }: {
     adapterId: string;
+    orderIndex?: number;
     isManualRequestVerificationRequired?: boolean;
     isManualProposalRequired?: boolean;
     quote?: (context: QuotationContext) => Promise<QuotationProposal>;

package/lib/factory/registerQuotation.js

@@ -1,11 +1,12 @@
 import { QuotationAdapter, } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerQuotation({ adapterId, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }) {
+export default function registerQuotation({ adapterId, orderIndex, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }) {
     const adapter = {
         ...QuotationAdapter,
         key: `shop.unchained.quotation.${adapterId}`,
         label: 'Quotation: ' + adapterId,
         version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
         isActivatedFor: () => {
             return true;
         },
@@ -36,7 +37,7 @@ export default function registerQuotation({ adapterId, isManualRequestVerificati
                 transformItemConfiguration: async (params) => {
                     return transformItemConfiguration
                         ? transformItemConfiguration(params, context)
-                        : { quantity: params.quantity, configuration: params.configuration };
+                        : QuotationAdapter.actions(context).transformItemConfiguration(params);
                 },
             };
         },

package/lib/plugins/PluginRegistry.d.ts

@@ -37,7 +37,7 @@ declare class PluginRegistry {
     getAdapters(adapterType: symbol): IBaseAdapter[];
     getAllAdapters(): IBaseAdapter[];
     hasPlugin(key: string): boolean;
-    clear(): void;
+    clear(): () => void;
 }
 export declare const pluginRegistry: PluginRegistry;
 export {};

package/lib/plugins/PluginRegistry.js

@@ -114,9 +114,15 @@ class PluginRegistry {
         return this.plugins.has(key);
     }
     clear() {
-        this.plugins.clear();
+        const { plugins, moduleFactories, skippedPlugins } = this;
+        this.plugins = new Map();
         this.moduleFactories = [];
-        this.skippedPlugins.clear();
+        this.skippedPlugins = new Set();
+        return () => {
+            this.plugins = plugins;
+            this.moduleFactories = moduleFactories;
+            this.skippedPlugins = skippedPlugins;
+        };
     }
 }
 export const pluginRegistry = new PluginRegistry();

package/lib/services/addCartQuotation.d.ts

@@ -1,16 +1,12 @@
-import type { OrderPosition } from '@unchainedshop/core-orders';
-import type { User } from '@unchainedshop/core-users';
+import { type Order, type OrderPosition } from '@unchainedshop/core-orders';
+import { type Quotation } from '@unchainedshop/core-quotations';
 import type { Modules } from '../modules.ts';
-export interface AddCartQuotationParams {
-    orderId?: string;
-    quotationId: string;
-    quantity: number;
-    configuration: {
+export declare function addCartQuotationService(this: Modules, { order, quotation, quantity, configuration, }: {
+    order: Order;
+    quotation: Quotation;
+    quantity?: number | null;
+    configuration?: {
         key: string;
         value: string;
-    }[];
-    user: User;
-    countryCode: string;
-    context: unknown;
-}
-export declare function addCartQuotationService(this: Modules, params: AddCartQuotationParams): Promise<OrderPosition>;
+    }[] | null;
+}, unchainedAPI?: Record<string, any>): Promise<OrderPosition>;

package/lib/services/addCartQuotation.js

@@ -1,52 +1,57 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
 import { QuotationStatus } from '@unchainedshop/core-quotations';
 import { QuotationDirector } from "../directors/QuotationDirector.js";
-import { updateCalculationService } from "./updateCalculation.js";
-import { findOrInitCartService } from "./findOrInitCart.js";
-import { OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, QuotationNotFoundError, QuotationWrongStatusError, QuotationItemConfigurationError, } from "../errors/index.js";
-export async function addCartQuotationService(params) {
-    const { orderId, quotationId, quantity, configuration, user, countryCode, context } = params;
-    if (quantity < 1) {
-        throw new OrderQuantityTooLowError({ quantity });
-    }
-    const quotation = await this.quotations.findQuotation({ quotationId });
-    if (!quotation) {
-        throw new QuotationNotFoundError({ quotationId });
-    }
+import { createServiceError } from "../errors.js";
+import { isQuotationReserved } from "./reserveOrderQuotationsForCheckout.js";
+export async function addCartQuotationService({ order, quotation, quantity, configuration, }, unchainedAPI = {}) {
+    const context = { ...unchainedAPI, modules: this };
     if (quotation.status !== QuotationStatus.PROPOSED) {
-        throw new QuotationWrongStatusError({ status: quotation.status });
+        throw createServiceError('QuotationWrongStatusError', `Quotation ${quotation._id} is ${quotation.status}, not PROPOSED`);
     }
-    const order = await findOrInitCartService.bind(this)({
-        orderId,
-        user,
-        countryCode,
-    });
-    if (!order) {
-        throw new OrderNotFoundError({ orderId: orderId || null });
+    if (quotation.currencyCode !== order.currencyCode) {
+        throw createServiceError('QuotationInvalidError', `Quotation ${quotation._id} is not in the currency of order ${order._id}`);
     }
-    if (!this.orders.isCart(order)) {
-        throw new OrderWrongStatusError({ status: order.status });
+    if (await isQuotationReserved.call(this, quotation._id, { exceptOrderId: order._id })) {
+        throw createServiceError('QuotationInvalidError', `Quotation ${quotation._id} is reserved by another order`);
     }
-    if (!(await this.products.productExists({ productId: quotation.productId }))) {
-        throw new ProductNotFoundError({ productId: quotation.productId });
+    const product = await this.products.findProduct({ productId: quotation.productId });
+    if (!product) {
+        throw createServiceError('ProductNotFoundError', `Product not found: ${quotation.productId}`);
     }
+    const existingPosition = (await this.orders.positions.findOrderPositions({ orderId: order._id })).find((position) => position.quotationId === quotation._id);
+    const existingQuantity = existingPosition?.quantity || 0;
+    const requestedQuantity = existingQuantity + (quantity ?? quotation.quantity ?? 1);
     const director = await QuotationDirector.actions({ quotation }, context);
     const quotationConfiguration = await director.transformItemConfiguration({
-        quantity,
-        configuration,
+        quantity: requestedQuantity,
+        configuration: configuration ?? existingPosition?.configuration ?? [],
     });
     if (!quotationConfiguration) {
-        throw new QuotationItemConfigurationError({ configuration });
+        throw createServiceError('QuotationItemConfigurationError', `Quotation ${quotation._id} does not take quantity ${requestedQuantity}`);
     }
-    const updatedOrderPosition = await this.orders.positions.addProductItem({
-        quantity: quotationConfiguration.quantity || 1,
+    const lineQuantity = quotationConfiguration.quantity || requestedQuantity;
+    await ordersSettings.validateOrderPosition({
+        order,
+        product,
         configuration: quotationConfiguration.configuration,
-        quotationId,
-        productId: quotation.productId,
-        originalProductId: quotation.productId,
-        orderId: order._id,
-    });
-    await updateCalculationService.bind(this)(order._id);
-    return (await this.orders.positions.findOrderPosition({
-        itemId: updatedOrderPosition._id,
-    }));
+        quantityDiff: lineQuantity - existingQuantity,
+    }, context);
+    const position = existingPosition
+        ? await this.orders.positions.updateProductItem({
+            orderPositionId: existingPosition._id,
+            quantity: lineQuantity,
+            configuration: quotationConfiguration.configuration ?? null,
+        })
+        : await this.orders.positions.addProductItem({
+            quantity: lineQuantity,
+            configuration: quotationConfiguration.configuration,
+            quotationId: quotation._id,
+            productId: quotation.productId,
+            originalProductId: quotation.productId,
+            orderId: order._id,
+        });
+    if (!position) {
+        throw createServiceError('OrderItemNotFoundError', `Order item not found: ${existingPosition?._id}`);
+    }
+    return position;
 }

package/lib/services/calculateDiscountTotal.d.ts

@@ -1,6 +1,10 @@
 import type { Order, OrderDiscount } from '@unchainedshop/core-orders';
 import type { Modules } from '../modules.ts';
-export declare function calculateDiscountTotalService(this: Modules, order: Order, orderDiscount: OrderDiscount): Promise<{
+export declare function calculateDiscountTotalService(this: Modules, order: Order, orderDiscount: OrderDiscount, { useNetPrice }?: {
+    useNetPrice?: boolean;
+}): Promise<{
     amount: number;
     currencyCode: string;
+    isTaxable: boolean;
+    isNetPrice: boolean;
 }>;