@unchainedshop/plugins 4.6.1 → 4.7.2

package/lib/payment/stripe/handler-express.js

@@ -1,121 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { stripe } from "./stripe.js";
-const logger = createLogger('unchained:stripe:handler');
-export const WebhookEventTypes = {
-    PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
-    SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
-};
-export const stripeHandler = async (request, response) => {
-    const resolvedContext = request.unchainedContext;
-    const { modules, services } = resolvedContext;
-    let event;
-    try {
-        const sig = request.headers['stripe-signature'];
-        if (!sig) {
-            throw new Error('stripe-signature header was not provided for webhook');
-        }
-        if (!process.env.STRIPE_ENDPOINT_SECRET) {
-            throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
-        }
-        event = stripe.webhooks.constructEvent(request.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
-    }
-    catch (err) {
-        logger.error(`Error constructing event: ${err.message}`);
-        response.status(400).send({
-            message: err.message,
-            name: err.name,
-        });
-        return;
-    }
-    if (!Object.values(WebhookEventTypes).includes(event.type)) {
-        logger.info(`unhandled event type`, {
-            type: event.type,
-        });
-        response.status(200).send({
-            ignored: true,
-            message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
-        });
-        return;
-    }
-    const environmentInMetadata = event.data?.object?.metadata?.environment || '';
-    const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
-    if (environmentInMetadata !== environmentInEnv) {
-        logger.info(`unhandled event environment`, {
-            type: event.type,
-            environment: environmentInMetadata,
-        });
-        response.status(200).send({
-            ignored: true,
-            message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
-        });
-        return;
-    }
-    logger.info(`Processing event`, {
-        type: event.type,
-    });
-    try {
-        if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
-            const paymentIntent = event.data.object;
-            const { orderPaymentId } = paymentIntent.metadata || {};
-            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`, {
-                type: event.type,
-            });
-            await modules.orders.payments.logEvent(orderPaymentId, event);
-            const orderPayment = await modules.orders.payments.findOrderPayment({
-                orderPaymentId,
-            });
-            if (!orderPayment) {
-                throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
-            }
-            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                paymentContext: {
-                    paymentIntentId: paymentIntent.id,
-                },
-            });
-            if (!order)
-                throw new Error(`Order with id ${orderPayment.orderId} not found`);
-            logger.info(`checkout successful`, {
-                orderPaymentId,
-                orderId: order._id,
-                type: event.type,
-            });
-            response.status(200).send({
-                message: 'checkout successful',
-                orderId: order._id,
-            });
-        }
-        else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
-            const setupIntent = event.data.object;
-            const { paymentProviderId, userId } = setupIntent.metadata || {};
-            logger.info(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
-                type: event.type,
-                userId,
-            });
-            const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, {
-                transactionContext: {
-                    setupIntentId: setupIntent.id,
-                },
-                userId,
-            });
-            logger.info(`payment credentials registration successful`, {
-                userId,
-                paymentProviderId,
-                paymentCredentialsId: paymentCredentials?._id,
-                type: event.type,
-            });
-            response.status(200).send({
-                message: 'payment credentials registration successful',
-                paymentCredentialsId: paymentCredentials?._id,
-            });
-        }
-    }
-    catch (error) {
-        logger.error(error, {
-            type: event.type,
-        });
-        response.status(500).send({
-            message: error.message,
-            name: error.name,
-        });
-    }
-};

package/lib/payment/stripe/handler-fastify.d.ts

@@ -1,6 +0,0 @@
-import type { RouteHandlerMethod } from 'fastify';
-export declare const WebhookEventTypes: {
-    PAYMENT_INTENT_SUCCEEDED: string;
-    SETUP_INTENT_SUCCEEDED: string;
-};
-export declare const stripeHandler: RouteHandlerMethod;

package/lib/payment/stripe/handler-fastify.js

@@ -1,131 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { stripe } from "./stripe.js";
-const logger = createLogger('unchained:stripe:handler');
-export const WebhookEventTypes = {
-    PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
-    SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
-};
-export const stripeHandler = async (req, reply) => {
-    const resolvedContext = req.unchainedContext;
-    const { modules, services } = resolvedContext;
-    let event;
-    try {
-        const sig = req.headers['stripe-signature'];
-        if (!process.env.STRIPE_ENDPOINT_SECRET) {
-            throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
-        }
-        if (!sig) {
-            throw new Error('stripe-signature header was not provided for webhook');
-        }
-        event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
-    }
-    catch (err) {
-        logger.error(`Error constructing event: ${err.message}`);
-        reply.status(400);
-        return reply.send({
-            success: false,
-            message: err.message,
-            name: err.name,
-        });
-    }
-    if (!Object.values(WebhookEventTypes).includes(event.type)) {
-        logger.info(`unhandled event type`, {
-            type: event.type,
-        });
-        reply.status(200);
-        return reply.send({
-            success: false,
-            ignored: true,
-            name: 'UNHANDLED_EVENT_TYPE',
-            message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
-        });
-    }
-    const environmentInMetadata = event.data?.object?.metadata?.environment || '';
-    const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
-    if (environmentInMetadata !== environmentInEnv) {
-        logger.info(`unhandled event environment`, {
-            type: event.type,
-            environment: environmentInMetadata,
-        });
-        reply.status(200);
-        return reply.send({
-            success: false,
-            ignored: true,
-            name: 'UNHANDLED_EVENT_ENVIRONMENT',
-            message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
-        });
-    }
-    logger.info(`Processing event`, {
-        type: event.type,
-    });
-    try {
-        if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
-            const paymentIntent = event.data.object;
-            const { orderPaymentId } = paymentIntent.metadata || {};
-            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`, {
-                type: event.type,
-            });
-            await modules.orders.payments.logEvent(orderPaymentId, event);
-            const orderPayment = await modules.orders.payments.findOrderPayment({
-                orderPaymentId,
-            });
-            if (!orderPayment) {
-                throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
-            }
-            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                paymentContext: {
-                    paymentIntentId: paymentIntent.id,
-                },
-            });
-            if (!order)
-                throw new Error(`Order with id ${orderPayment.orderId} not found`);
-            logger.info(`checkout successful`, {
-                orderPaymentId,
-                orderId: order._id,
-                type: event.type,
-            });
-            reply.status(200);
-            return reply.send({
-                success: true,
-                orderId: order._id,
-            });
-        }
-        else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
-            const setupIntent = event.data.object;
-            const { paymentProviderId, userId } = setupIntent.metadata || {};
-            logger.info(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
-                type: event.type,
-                userId,
-            });
-            const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, {
-                transactionContext: {
-                    setupIntentId: setupIntent.id,
-                },
-                userId,
-            });
-            logger.info(`payment credentials registration successful`, {
-                userId,
-                paymentProviderId,
-                paymentCredentialsId: paymentCredentials?._id,
-                type: event.type,
-            });
-            reply.status(200);
-            return reply.send({
-                success: true,
-                message: 'payment credentials registration successful',
-                paymentCredentialsId: paymentCredentials?._id,
-            });
-        }
-    }
-    catch (error) {
-        logger.error(error, {
-            type: event.type,
-        });
-        reply.status(500);
-        return reply.send({
-            success: false,
-            message: error.message,
-            name: error.name,
-        });
-    }
-};

package/lib/presets/all-express.d.ts

@@ -1,6 +0,0 @@
-import express from 'express';
-import type { UnchainedCore } from '@unchainedshop/core';
-declare const _default: (app: express.Express, { unchainedAPI }: {
-    unchainedAPI: UnchainedCore;
-}) => void;
-export default _default;

package/lib/presets/all-express.js

@@ -1,26 +0,0 @@
-import express from 'express';
-import connectCryptoToExpress from "./crypto-express.js";
-import connectBaseToExpress from "./base-express.js";
-import { datatransHandler } from "../payment/datatrans-v2/handler-express.js";
-import { stripeHandler } from "../payment/stripe/handler-express.js";
-import { postfinanceCheckoutHandler } from "../payment/postfinance-checkout/handler-express.js";
-import { appleIAPHandler } from "../payment/apple-iap/handler-express.js";
-import { payrexxHandler } from "../payment/payrexx/handler-express.js";
-import { saferpayHandler } from "../payment/saferpay/handler-express.js";
-import { configureGenerateOrderAutoscheduling } from "../worker/enrollment-order-generator.js";
-const { STRIPE_WEBHOOK_PATH = '/payment/stripe', PAYREXX_WEBHOOK_PATH = '/payment/payrexx', PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout', DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook', APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap', SAFERPAY_WEBHOOK_PATH = '/payment/saferpay/webhook', } = process.env;
-export default (app, { unchainedAPI }) => {
-    connectBaseToExpress(app);
-    connectCryptoToExpress(app, unchainedAPI);
-    app.use(STRIPE_WEBHOOK_PATH, express.raw({ type: 'application/json' }), stripeHandler);
-    app.use(PFCHECKOUT_WEBHOOK_PATH, express.json(), postfinanceCheckoutHandler);
-    app.use(DATATRANS_WEBHOOK_PATH, express.text({
-        type: 'application/json',
-    }), datatransHandler);
-    app.use(APPLE_IAP_WEBHOOK_PATH, express.json({
-        strict: false,
-    }), appleIAPHandler);
-    app.use(PAYREXX_WEBHOOK_PATH, express.json({ type: 'application/json' }), payrexxHandler);
-    app.use(SAFERPAY_WEBHOOK_PATH, saferpayHandler);
-    configureGenerateOrderAutoscheduling();
-};

package/lib/presets/all-fastify.d.ts

@@ -1,6 +0,0 @@
-import type { UnchainedCore } from '@unchainedshop/core';
-import type { FastifyInstance } from 'fastify';
-declare const _default: (fastify: FastifyInstance, { unchainedAPI }: {
-    unchainedAPI: UnchainedCore;
-}) => void;
-export default _default;

package/lib/presets/all-fastify.js

@@ -1,49 +0,0 @@
-import connectCryptoToFastify from "./crypto-fastify.js";
-import connectBaseToFastify from "./base-fastify.js";
-import { stripeHandler } from "../payment/stripe/handler-fastify.js";
-import { postfinanceCheckoutHandler } from "../payment/postfinance-checkout/handler-fastify.js";
-import { datatransHandler } from "../payment/datatrans-v2/handler-fastify.js";
-import { appleIAPHandler } from "../payment/apple-iap/handler-fastify.js";
-import { payrexxHandler } from "../payment/payrexx/handler-fastify.js";
-import { saferpayHandler } from "../payment/saferpay/handler-fastify.js";
-import { configureGenerateOrderAutoscheduling } from "../worker/enrollment-order-generator.js";
-const { STRIPE_WEBHOOK_PATH = '/payment/stripe', PAYREXX_WEBHOOK_PATH = '/payment/payrexx', PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout', DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook', APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap', SAFERPAY_WEBHOOK_PATH = '/payment/saferpay/webhook', } = process.env;
-export default (fastify, { unchainedAPI }) => {
-    connectBaseToFastify(fastify);
-    connectCryptoToFastify(fastify, unchainedAPI);
-    fastify.register((s, opts, registered) => {
-        s.addContentTypeParser('application/json', { parseAs: 'string', bodyLimit: 1024 * 1024 }, s.defaultTextParser);
-        s.route({
-            url: STRIPE_WEBHOOK_PATH,
-            method: 'POST',
-            handler: stripeHandler,
-        });
-        s.route({
-            url: DATATRANS_WEBHOOK_PATH,
-            method: 'POST',
-            handler: datatransHandler,
-        });
-        registered();
-    });
-    fastify.route({
-        url: PFCHECKOUT_WEBHOOK_PATH,
-        method: 'POST',
-        handler: postfinanceCheckoutHandler,
-    });
-    fastify.route({
-        url: APPLE_IAP_WEBHOOK_PATH,
-        method: 'POST',
-        handler: appleIAPHandler,
-    });
-    fastify.route({
-        url: PAYREXX_WEBHOOK_PATH,
-        method: 'POST',
-        handler: payrexxHandler,
-    });
-    fastify.route({
-        url: SAFERPAY_WEBHOOK_PATH,
-        method: 'GET',
-        handler: saferpayHandler,
-    });
-    configureGenerateOrderAutoscheduling();
-};

package/lib/presets/base-express.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (app: any) => void;
-export default _default;

package/lib/presets/base-express.js

@@ -1,5 +0,0 @@
-import handler from "../files/gridfs/handler-express.js";
-const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
-export default (app) => {
-    app.use(GRIDFS_PUT_SERVER_PATH, handler);
-};

package/lib/presets/base-fastify.d.ts

@@ -1,3 +0,0 @@
-import type { FastifyInstance } from 'fastify';
-declare const _default: (fastify: FastifyInstance) => void;
-export default _default;

package/lib/presets/base-fastify.js

@@ -1,16 +0,0 @@
-import handler from "../files/gridfs/handler-fastify.js";
-const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
-export default (fastify) => {
-    fastify.register((s, opts, registered) => {
-        s.removeAllContentTypeParsers();
-        s.addContentTypeParser('*', function (req, payload, done) {
-            done(null);
-        });
-        s.route({
-            url: GRIDFS_PUT_SERVER_PATH + '/:directoryName/:fileName',
-            method: ['GET', 'PUT', 'OPTIONS'],
-            handler,
-        });
-        registered();
-    });
-};

package/lib/presets/crypto-express.d.ts

@@ -1,3 +0,0 @@
-import type { UnchainedCore } from '@unchainedshop/core';
-declare const _default: (app: any, unchainedAPI: UnchainedCore) => void;
-export default _default;

package/lib/presets/crypto-express.js

@@ -1,8 +0,0 @@
-import express from 'express';
-import handler from "../payment/cryptopay/handler-express.js";
-import { configureExportToken } from "../worker/export-token.js";
-const { CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay' } = process.env;
-export default (app, unchainedAPI) => {
-    app.use(CRYPTOPAY_WEBHOOK_PATH, express.json(), handler);
-    configureExportToken(unchainedAPI);
-};

package/lib/presets/crypto-fastify.d.ts

@@ -1,3 +0,0 @@
-import type { UnchainedCore } from '@unchainedshop/core';
-declare const _default: (fastify: any, unchainedAPI: UnchainedCore) => void;
-export default _default;

package/lib/presets/crypto-fastify.js

@@ -1,11 +0,0 @@
-import handler from "../payment/cryptopay/handler-fastify.js";
-import { configureExportToken } from "../worker/export-token.js";
-const { CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay' } = process.env;
-export default (fastify, unchainedAPI) => {
-    fastify.route({
-        url: CRYPTOPAY_WEBHOOK_PATH,
-        method: 'POST',
-        handler,
-    });
-    configureExportToken(unchainedAPI);
-};

package/lib/pricing/discount-half-price.d.ts

@@ -1,2 +0,0 @@
-import { type ProductDiscountConfiguration, type IDiscountAdapter } from '@unchainedshop/core';
-export declare const HalfPrice: IDiscountAdapter<ProductDiscountConfiguration>;

package/lib/pricing/discount-half-price.js

@@ -1,33 +0,0 @@
-import { OrderDiscountDirector, OrderDiscountAdapter, } from '@unchainedshop/core';
-export const HalfPrice = {
-    ...OrderDiscountAdapter,
-    key: 'shop.unchained.discount.half-price',
-    label: 'Half Price',
-    version: '1.0.0',
-    orderIndex: 10,
-    isManualAdditionAllowed: async () => {
-        return false;
-    },
-    isManualRemovalAllowed: async () => {
-        return false;
-    },
-    actions: async ({ context }) => ({
-        ...(await OrderDiscountAdapter.actions({ context })),
-        isValidForSystemTriggering: async () => {
-            const { order } = context;
-            const user = await context.modules.users.findUserById(order.userId);
-            const isUserEligibleForHalfPrice = user?.tags && user.tags.indexOf('half-price') !== -1;
-            return !!isUserEligibleForHalfPrice;
-        },
-        isValidForCodeTriggering: async () => {
-            return false;
-        },
-        discountForPricingAdapterKey({ pricingAdapterKey }) {
-            if (pricingAdapterKey === 'shop.unchained.pricing.product-discount') {
-                return { rate: 0.5 };
-            }
-            return null;
-        },
-    }),
-};
-OrderDiscountDirector.registerAdapter(HalfPrice);

package/lib/pricing/order-items-discount.d.ts

@@ -1,2 +0,0 @@
-import { type OrderDiscountConfiguration, type IOrderPricingAdapter } from '@unchainedshop/core';
-export declare const OrderItemsDiscount: IOrderPricingAdapter<OrderDiscountConfiguration>;

package/lib/pricing/order-items-discount.js

@@ -1,50 +0,0 @@
-import { ProductPricingSheet, OrderPricingDirector, OrderPricingAdapter, OrderPricingRowCategory, resolveRatioAndTaxDivisorForPricingSheet, } from '@unchainedshop/core';
-import { calculation as calcUtils } from '@unchainedshop/utils';
-export const OrderItemsDiscount = {
-    ...OrderPricingAdapter,
-    key: 'shop.unchained.pricing.order-items-discount',
-    version: '1.0.0',
-    label: 'Apply Discounts on Total Value Of Goods',
-    orderIndex: 30,
-    isActivatedFor: () => {
-        return true;
-    },
-    actions: (params) => {
-        const pricingAdapter = OrderPricingAdapter.actions(params);
-        const { order, orderPositions } = params.context;
-        return {
-            ...pricingAdapter,
-            calculate: async () => {
-                const totalAmountOfItems = params.calculationSheet.total({
-                    category: OrderPricingRowCategory.Items,
-                    useNetPrice: false,
-                }).amount;
-                const itemShares = orderPositions.map((orderPosition) => resolveRatioAndTaxDivisorForPricingSheet(ProductPricingSheet({
-                    calculation: orderPosition.calculation,
-                    currencyCode: order.currencyCode,
-                    quantity: orderPosition.quantity,
-                }), totalAmountOfItems));
-                let amountLeft = totalAmountOfItems;
-                params.discounts.forEach(({ configuration, discountId }) => {
-                    const leftInItemsToSplit = calcUtils.calculateAmountToSplit({ ...configuration }, totalAmountOfItems);
-                    const [itemsDiscountAmount, itemsTaxAmount] = calcUtils.applyDiscountToMultipleShares(itemShares, Math.max(0, Math.min(amountLeft, leftInItemsToSplit)));
-                    amountLeft -= itemsDiscountAmount;
-                    const discountAmount = itemsDiscountAmount * -1;
-                    const taxAmount = itemsTaxAmount * -1;
-                    if (discountAmount) {
-                        pricingAdapter.resultSheet().addDiscount({
-                            amount: discountAmount,
-                            taxAmount,
-                            discountId,
-                            meta: {
-                                adapter: OrderItemsDiscount.key,
-                            },
-                        });
-                    }
-                });
-                return pricingAdapter.calculate();
-            },
-        };
-    },
-};
-OrderPricingDirector.registerAdapter(OrderItemsDiscount);

package/lib/pricing/order-round.d.ts

@@ -1,10 +0,0 @@
-import { type IOrderPricingAdapter } from '@unchainedshop/core';
-interface PriceRoundSettings {
-    defaultPrecision: number;
-    roundTo: (value: number, precision: number, currencyCode: string) => number;
-}
-export declare const OrderPriceRound: IOrderPricingAdapter & {
-    configure: (params: PriceRoundSettings) => void;
-    settings: PriceRoundSettings;
-};
-export {};

package/lib/pricing/order-round.js

@@ -1,135 +0,0 @@
-import { OrderPricingAdapter, OrderPricingDirector, OrderPricingRowCategory, } from '@unchainedshop/core';
-const calculateDifference = (amount, currencyCode) => {
-    const roundedAmount = OrderPriceRound.settings.roundTo(amount, OrderPriceRound.settings.defaultPrecision, currencyCode);
-    return roundedAmount - amount;
-};
-export const OrderPriceRound = {
-    ...OrderPricingAdapter,
-    key: 'shop.unchained.pricing.order-round',
-    version: '1.0.0',
-    label: 'Round order price to the next precision number',
-    orderIndex: 90,
-    isActivatedFor: () => {
-        return true;
-    },
-    settings: {
-        defaultPrecision: 5,
-        roundTo: (value, precision) => precision !== 0 ? Math.round(value / precision) * precision : value,
-    },
-    configure({ defaultPrecision, roundTo }) {
-        if (defaultPrecision)
-            this.settings.defaultPrecision = defaultPrecision;
-        if (roundTo)
-            this.settings.roundTo = roundTo;
-    },
-    actions: (params) => {
-        const pricingAdapter = OrderPricingAdapter.actions(params);
-        return {
-            ...pricingAdapter,
-            calculate: async () => {
-                const { currencyCode } = params.context;
-                if (!currencyCode)
-                    return pricingAdapter.calculate();
-                const { amount: deliveryAmount } = params.calculationSheet.total({
-                    category: OrderPricingRowCategory.Delivery,
-                    useNetPrice: true,
-                });
-                if (deliveryAmount) {
-                    const taxes = params.calculationSheet.taxSum({
-                        baseCategory: OrderPricingRowCategory.Delivery,
-                    });
-                    const deliveryTaxRate = taxes / deliveryAmount;
-                    const deliveryDifference = calculateDifference(deliveryAmount, currencyCode);
-                    pricingAdapter.resultSheet().addDelivery({
-                        amount: deliveryDifference,
-                        taxAmount: deliveryTaxRate * deliveryDifference,
-                        meta: {
-                            adapter: OrderPriceRound.key,
-                        },
-                    });
-                }
-                const { amount: discountAmount } = params.calculationSheet.total({
-                    category: OrderPricingRowCategory.Discounts,
-                    useNetPrice: true,
-                });
-                if (discountAmount) {
-                    const taxes = params.calculationSheet.taxSum({
-                        baseCategory: OrderPricingRowCategory.Discounts,
-                    });
-                    const discountTaxRate = taxes / discountAmount;
-                    const discountsDifference = calculateDifference(discountAmount, currencyCode);
-                    pricingAdapter.resultSheet().addDiscount({
-                        amount: discountsDifference,
-                        taxAmount: discountsDifference * discountTaxRate,
-                        meta: {
-                            adapter: OrderPriceRound.key,
-                        },
-                        discountId: null,
-                    });
-                }
-                const { amount: itemsAmount } = params.calculationSheet.total({
-                    category: OrderPricingRowCategory.Items,
-                    useNetPrice: true,
-                });
-                if (itemsAmount) {
-                    const taxes = params.calculationSheet.taxSum({
-                        baseCategory: OrderPricingRowCategory.Items,
-                    });
-                    const itemTaxRate = taxes / itemsAmount;
-                    const itemsDifference = calculateDifference(itemsAmount, currencyCode);
-                    pricingAdapter.resultSheet().addItems({
-                        amount: itemsDifference,
-                        taxAmount: itemsDifference * itemTaxRate,
-                        meta: {
-                            adapter: OrderPriceRound.key,
-                        },
-                    });
-                }
-                const { amount: paymentAmount } = params.calculationSheet.total({
-                    category: OrderPricingRowCategory.Payment,
-                    useNetPrice: true,
-                });
-                if (paymentAmount) {
-                    const taxes = params.calculationSheet.taxSum({
-                        baseCategory: OrderPricingRowCategory.Payment,
-                    });
-                    const paymentTaxRate = taxes / paymentAmount;
-                    const paymentsDifference = calculateDifference(paymentAmount, currencyCode);
-                    pricingAdapter.resultSheet().addPayment({
-                        amount: paymentsDifference,
-                        taxAmount: paymentsDifference * paymentTaxRate,
-                        meta: {
-                            adapter: OrderPriceRound.key,
-                        },
-                    });
-                }
-                const priorTaxesAmount = params.calculationSheet.taxSum({
-                    category: OrderPricingRowCategory.Taxes,
-                });
-                const additionalRoundedTaxes = pricingAdapter.resultSheet().taxSum({
-                    category: OrderPricingRowCategory.Taxes,
-                });
-                const taxesAmount = priorTaxesAmount + additionalRoundedTaxes;
-                if (taxesAmount) {
-                    const taxDifference = calculateDifference(taxesAmount, currencyCode);
-                    pricingAdapter.resultSheet().calculation.push({
-                        category: OrderPricingRowCategory.Taxes,
-                        amount: taxDifference,
-                        meta: {
-                            adapter: OrderPriceRound.key,
-                        },
-                    });
-                    pricingAdapter.resultSheet().calculation.push({
-                        category: null,
-                        amount: taxDifference,
-                        meta: {
-                            adapter: OrderPriceRound.key,
-                        },
-                    });
-                }
-                return pricingAdapter.calculate();
-            },
-        };
-    },
-};
-OrderPricingDirector.registerAdapter(OrderPriceRound);

package/lib/pricing/product-catalog-price-options.d.ts

@@ -1,2 +0,0 @@
-import { type IProductPricingAdapter } from '@unchainedshop/core';
-export declare const ProductPriceOptions: IProductPricingAdapter;