@unchainedshop/plugins 4.6.2 → 4.7.2

package/lib/payment/cryptopay/plugin.js

@@ -1,159 +0,0 @@
-import { PaymentAdapter, PaymentDirector, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-import {} from "./module.js";
-import deriveBtcAddress from "./derive-btc-address.js";
-import deriveEthAddress from "./derive-eth-address.js";
-import denoteAmount from "./denote-amount.js";
-const logger = createLogger('unchained:cryptopay');
-const { CRYPTOPAY_SECRET, CRYPTOPAY_BTC_XPUB, CRYPTOPAY_ETH_XPUB } = process.env;
-const CryptopayCurrencies = {
-    BTC: 'BTC',
-    ETH: 'ETH',
-};
-const Cryptopay = {
-    ...PaymentAdapter,
-    key: 'shop.unchained.payment.cryptopay',
-    label: 'Cryptopay',
-    version: '1.0.0',
-    typeSupported(type) {
-        return type === 'GENERIC';
-    },
-    actions: (config, context) => {
-        const { modules } = context;
-        const setConversionRates = async (currencyCode, existingAddresses) => {
-            const originCurrencyObj = await modules.currencies.findCurrency({ isoCode: currencyCode });
-            if (!originCurrencyObj?.isActive)
-                throw new Error('Origin currency is not supported');
-            const updatedAddresses = await Promise.all(existingAddresses.map(async (addressData) => {
-                const targetCurrencyObj = await modules.currencies.findCurrency({
-                    isoCode: addressData.currencyCode,
-                });
-                if (!targetCurrencyObj?.isActive)
-                    return null;
-                const rateData = await modules.products.prices.rates.getRate(originCurrencyObj, targetCurrencyObj);
-                return {
-                    ...addressData,
-                    currencyConversionRate: rateData?.rate,
-                    currencyConversionExpiryDate: rateData?.expiresAt,
-                };
-            }));
-            return updatedAddresses.filter(Boolean);
-        };
-        const updateTransactionsWithOrderPaymentId = async (orderPaymentId, cryptoAddresses) => {
-            for (const cryptoAddress of cryptoAddresses) {
-                const { address, currencyCode } = cryptoAddress;
-                await modules.cryptopay.mapOrderPaymentToWalletAddress({
-                    address,
-                    currencyCode,
-                    orderPaymentId,
-                });
-            }
-        };
-        const adapterActions = {
-            ...PaymentAdapter.actions(config, context),
-            configurationError() {
-                if (!CRYPTOPAY_SECRET) {
-                    return PaymentError.INCOMPLETE_CONFIGURATION;
-                }
-                if (!CRYPTOPAY_BTC_XPUB && !CRYPTOPAY_ETH_XPUB) {
-                    return PaymentError.INCOMPLETE_CONFIGURATION;
-                }
-                return null;
-            },
-            isActive() {
-                if (adapterActions.configurationError() !== null)
-                    return false;
-                if (!context.order)
-                    return true;
-                return true;
-            },
-            isPayLaterAllowed() {
-                return false;
-            },
-            sign: async () => {
-                const { orderPayment, order } = context;
-                if (!orderPayment)
-                    throw new Error('Payment Credential Registration is not yet supported for Cryptopay');
-                if (!order)
-                    throw new Error('Order context is required for signing with Cryptopay');
-                const existingAddresses = await modules.cryptopay.getWalletAddressesByOrderPaymentId(orderPayment._id);
-                if (existingAddresses.length) {
-                    const existingAddressesWithNewExpiration = await setConversionRates(order.currencyCode, existingAddresses.map(({ _id, currencyCode }) => ({
-                        address: _id,
-                        currencyCode,
-                    })));
-                    return JSON.stringify(existingAddressesWithNewExpiration);
-                }
-                const cryptoAddresses = [];
-                if (CRYPTOPAY_BTC_XPUB) {
-                    const btcDerivationNumber = await modules.cryptopay.getNextDerivationNumber(CryptopayCurrencies.BTC);
-                    const address = deriveBtcAddress(CRYPTOPAY_BTC_XPUB, btcDerivationNumber);
-                    cryptoAddresses.push({
-                        currencyCode: CryptopayCurrencies.BTC,
-                        address,
-                    });
-                }
-                if (CRYPTOPAY_ETH_XPUB) {
-                    const ethDerivationNumber = await modules.cryptopay.getNextDerivationNumber(CryptopayCurrencies.ETH);
-                    const address = deriveEthAddress(CRYPTOPAY_ETH_XPUB, ethDerivationNumber);
-                    cryptoAddresses.push({
-                        currencyCode: CryptopayCurrencies.ETH,
-                        address,
-                    });
-                }
-                const cryptoAddressesWithExpiration = await setConversionRates(order.currencyCode, cryptoAddresses);
-                await updateTransactionsWithOrderPaymentId(orderPayment._id, cryptoAddresses);
-                return JSON.stringify(cryptoAddressesWithExpiration);
-            },
-            charge: async () => {
-                const { order, orderPayment } = context;
-                if (!orderPayment)
-                    throw new Error('Order Payment context is required for charging with Cryptopay');
-                if (!order)
-                    throw new Error('Order context is required for charging with Cryptopay');
-                const foundWalletsWithBalances = await modules.cryptopay.getWalletAddressesByOrderPaymentId(orderPayment._id);
-                const walletForOrderPayment = foundWalletsWithBalances.find((wallet) => BigInt(wallet.amount.toString()) > 0n);
-                const pricing = OrderPricingSheet({
-                    calculation: order.calculation,
-                    currencyCode: order.currencyCode,
-                });
-                const totalAmount = BigInt(pricing?.total({ useNetPrice: false }).amount);
-                if (walletForOrderPayment && walletForOrderPayment.currencyCode !== order.currencyCode) {
-                    const baseCurrency = await modules.currencies.findCurrency({
-                        isoCode: walletForOrderPayment.currencyCode,
-                    });
-                    if (!baseCurrency)
-                        throw new Error('Base currency not found');
-                    const quoteCurrency = await modules.currencies.findCurrency({ isoCode: order.currencyCode });
-                    if (!quoteCurrency)
-                        throw new Error('Quote currency not found');
-                    const rate = await modules.products.prices.rates.getRateRange(baseCurrency, quoteCurrency, order.confirmed || new Date());
-                    if (!rate)
-                        throw new Error('No conversion rate found');
-                    const convertedAmount = denoteAmount(walletForOrderPayment.amount.toString(), walletForOrderPayment.decimals);
-                    const maxAmount = parseFloat(convertedAmount.toString()) * rate.max * 1.001;
-                    if (maxAmount && maxAmount >= totalAmount) {
-                        return {
-                            transactionId: walletForOrderPayment._id,
-                        };
-                    }
-                    logger.info(`Cryptopay Plugin: Wallet ${walletForOrderPayment._id} balance too low (yet): ${maxAmount} < ${totalAmount}`);
-                }
-                if (walletForOrderPayment) {
-                    const convertedAmount = denoteAmount(walletForOrderPayment.amount.toString(), walletForOrderPayment.decimals);
-                    if (convertedAmount && convertedAmount >= totalAmount) {
-                        return {
-                            transactionId: walletForOrderPayment._id,
-                        };
-                    }
-                    logger.info(`Cryptopay Plugin: Wallet ${walletForOrderPayment._id} balance too low (yet): ${convertedAmount} < ${totalAmount}`);
-                }
-                logger.info(`Cryptopay Plugin: No confirmed payments found for currency ${order.currencyCode} and addresses ${JSON.stringify(foundWalletsWithBalances)}`);
-                return false;
-            },
-        };
-        return adapterActions;
-    },
-};
-PaymentDirector.registerAdapter(Cryptopay);
-export default Cryptopay;

package/lib/payment/datatrans-v2/handler-express.d.ts

@@ -1 +0,0 @@
-export declare const datatransHandler: (req: any, res: any) => Promise<void>;

package/lib/payment/datatrans-v2/handler-express.js

@@ -1,71 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import generateSignature, { Security } from "./generateSignature.js";
-const { DATATRANS_SIGN_KEY, DATATRANS_SIGN2_KEY, DATATRANS_SECURITY = Security.DYNAMIC_SIGN, } = process.env;
-const logger = createLogger('unchained:datatrans:handler');
-export const datatransHandler = async (req, res) => {
-    const resolvedContext = req.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const signature = req.headers['datatrans-signature'];
-    if (!DATATRANS_SIGN_KEY && !DATATRANS_SIGN2_KEY) {
-        logger.warn('No sign key configured');
-        res.status(404).end();
-        return;
-    }
-    if (req.method === 'POST' && signature) {
-        const [rawTimestamp, rawHash] = signature.split(',');
-        const [, hash] = rawHash.split('=');
-        const [, timestamp] = rawTimestamp.split('=');
-        const comparableSignature = await generateSignature({
-            security: DATATRANS_SECURITY,
-            signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
-        })(timestamp, req.body);
-        if (hash !== comparableSignature) {
-            logger.error(`hash mismatch: ${signature} / ${comparableSignature}`);
-            res.status(403).send('Hash mismatch');
-            return;
-        }
-        const transaction = JSON.parse(req.body);
-        logger.info(`received request`, {
-            type: transaction.type,
-        });
-        if (transaction.status === 'authorized') {
-            const userId = transaction.refno2;
-            const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
-            try {
-                if (transaction.type === 'card_check') {
-                    const paymentProviderId = referenceId;
-                    const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, { userId, transactionContext: { transactionId: transaction.transactionId } });
-                    logger.info(`registered payment credentials for ${userId}`, {
-                        userId,
-                    });
-                    res.status(200).send(paymentCredentials);
-                    return;
-                }
-                if (transaction.type === 'payment') {
-                    const orderPaymentId = referenceId;
-                    const orderPayment = await modules.orders.payments.findOrderPayment({
-                        orderPaymentId,
-                    });
-                    if (!orderPayment)
-                        throw new Error(`Order Payment with id ${orderPaymentId} not found`);
-                    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                        paymentContext: { userId, transactionId: transaction.transactionId },
-                    });
-                    if (!order)
-                        throw new Error(`Order with id ${orderPayment.orderId} not found`);
-                    logger.info(`confirmed checkout for order ${order.orderNumber}`, {
-                        orderId: order._id,
-                    });
-                    res.status(200).send(order);
-                    return;
-                }
-            }
-            catch (e) {
-                logger.error(`rejected to checkout: ${e.name} - ${e.message}`);
-                res.status(500).send({ name: e.name, code: e.code, message: e.message });
-                return;
-            }
-        }
-    }
-    res.status(404).end();
-};

package/lib/payment/datatrans-v2/handler-fastify.d.ts

@@ -1,2 +0,0 @@
-import type { RouteHandlerMethod } from 'fastify';
-export declare const datatransHandler: RouteHandlerMethod;

package/lib/payment/datatrans-v2/handler-fastify.js

@@ -1,71 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import generateSignature, { Security } from "./generateSignature.js";
-const { DATATRANS_SIGN_KEY, DATATRANS_SIGN2_KEY, DATATRANS_SECURITY = Security.DYNAMIC_SIGN, } = process.env;
-const logger = createLogger('unchained:datatrans:handler');
-export const datatransHandler = async (req, reply) => {
-    const resolvedContext = req.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const signature = req.headers['datatrans-signature'];
-    if (!DATATRANS_SIGN_KEY && !DATATRANS_SIGN2_KEY) {
-        logger.warn('No sign key configured');
-        return reply.send({ success: false, message: 'No sign key configured', name: 'NO_SIGN_KEY' });
-    }
-    if (signature) {
-        const [rawTimestamp, rawHash] = signature.split(',');
-        const [, hash] = rawHash.split('=');
-        const [, timestamp] = rawTimestamp.split('=');
-        const comparableSignature = await generateSignature({
-            security: DATATRANS_SECURITY,
-            signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
-        })(timestamp, req.body);
-        if (hash !== comparableSignature) {
-            logger.error(`hash mismatch: ${signature} / ${comparableSignature}`);
-            reply.status(403);
-            return reply.send({ success: false, message: 'Invalid Signature', name: 'HASH_MISMATCH' });
-        }
-        const transaction = JSON.parse(req.body);
-        logger.info(`received request`, {
-            type: transaction.type,
-        });
-        if (transaction.status === 'authorized') {
-            const userId = transaction.refno2;
-            const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
-            try {
-                if (transaction.type === 'card_check') {
-                    const paymentProviderId = referenceId;
-                    const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, { userId, transactionContext: { transactionId: transaction.transactionId } });
-                    logger.info(`registered payment credentials for ${userId}`, {
-                        userId,
-                    });
-                    reply.status(200);
-                    return reply.send(paymentCredentials);
-                }
-                if (transaction.type === 'payment') {
-                    const orderPaymentId = referenceId;
-                    const orderPayment = await modules.orders.payments.findOrderPayment({
-                        orderPaymentId,
-                    });
-                    if (!orderPayment)
-                        throw new Error(`Order Payment with id ${orderPaymentId} not found`);
-                    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                        paymentContext: { userId, transactionId: transaction.transactionId },
-                    });
-                    if (!order)
-                        throw new Error(`Order with id ${orderPayment.orderId} not found`);
-                    reply.status(200);
-                    logger.info(`confirmed checkout for order ${order.orderNumber}`, {
-                        orderId: order._id,
-                    });
-                    return reply.send(order);
-                }
-            }
-            catch (e) {
-                logger.error(e);
-                reply.status(500);
-                return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
-            }
-        }
-    }
-    reply.status(404);
-    return reply.send();
-};

package/lib/payment/invoice-prepaid.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/payment/invoice-prepaid.js

@@ -1,30 +0,0 @@
-import { PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
-import { PaymentProviderType } from '@unchainedshop/core-payment';
-const InvoicePrepaid = {
-    ...PaymentAdapter,
-    key: 'shop.unchained.invoice-prepaid',
-    label: 'Invoice pre-paid',
-    version: '1.0.0',
-    initialConfiguration: [],
-    typeSupported: (type) => {
-        return type === PaymentProviderType.INVOICE;
-    },
-    actions: (config, context) => {
-        return {
-            ...PaymentAdapter.actions(config, context),
-            configurationError: () => {
-                return null;
-            },
-            isActive: () => {
-                return true;
-            },
-            isPayLaterAllowed: () => {
-                return false;
-            },
-            charge: async () => {
-                return false;
-            },
-        };
-    },
-};
-PaymentDirector.registerAdapter(InvoicePrepaid);

package/lib/payment/invoice.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/payment/invoice.js

@@ -1,27 +0,0 @@
-import { PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
-import { PaymentProviderType } from '@unchainedshop/core-payment';
-const Invoice = {
-    ...PaymentAdapter,
-    key: 'shop.unchained.invoice',
-    label: 'Invoice',
-    version: '1.0.0',
-    initialConfiguration: [],
-    typeSupported: (type) => {
-        return type === PaymentProviderType.INVOICE;
-    },
-    actions: (config, context) => {
-        return {
-            ...PaymentAdapter.actions(config, context),
-            configurationError: () => {
-                return null;
-            },
-            isActive: () => {
-                return true;
-            },
-            isPayLaterAllowed: () => {
-                return true;
-            },
-        };
-    },
-};
-PaymentDirector.registerAdapter(Invoice);

package/lib/payment/paypal-checkout.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/payment/paypal-checkout.js

@@ -1,87 +0,0 @@
-import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-const logger = createLogger('unchained:paypal-checkout');
-let checkoutNodeJssdk;
-try {
-    checkoutNodeJssdk = await import('@paypal/checkout-server-sdk');
-}
-catch {
-    logger.warn("npm dependency '@paypal/checkout-server-sdk' is not installed, paypal adapter will not work");
-}
-const { PAYPAL_CLIENT_ID, PAYPAL_SECRET, PAYPAL_ENVIRONMENT = 'sandbox' } = process.env;
-const environment = () => {
-    const clientId = PAYPAL_CLIENT_ID;
-    const clientSecret = PAYPAL_SECRET;
-    return PAYPAL_ENVIRONMENT !== 'live'
-        ? new checkoutNodeJssdk.core.SandboxEnvironment(clientId, clientSecret)
-        : new checkoutNodeJssdk.core.LiveEnvironment(clientId, clientSecret);
-};
-const roundToDecimals = (number, decimals) => {
-    const num = Math.pow(10, decimals);
-    return Math.round(number * num) / num;
-};
-const PaypalCheckout = {
-    ...PaymentAdapter,
-    key: 'shop.unchained.payment.paypal',
-    label: 'Paypal',
-    version: '1.0.1',
-    initialConfiguration: [],
-    typeSupported: (type) => {
-        return type === 'GENERIC';
-    },
-    actions: (config, context) => {
-        const adapter = {
-            ...PaymentAdapter.actions(config, context),
-            configurationError: () => {
-                const publicCredentialsValid = PAYPAL_CLIENT_ID && PAYPAL_SECRET;
-                if (!publicCredentialsValid) {
-                    return PaymentError.WRONG_CREDENTIALS;
-                }
-                return null;
-            },
-            isActive: () => {
-                if (adapter.configurationError() === null)
-                    return true;
-                return false;
-            },
-            isPayLaterAllowed: () => {
-                return false;
-            },
-            sign: async () => {
-                return PAYPAL_CLIENT_ID || null;
-            },
-            charge: async ({ orderID }) => {
-                const { order } = context;
-                if (!order)
-                    throw new Error('Order missing in payment context');
-                if (!orderID) {
-                    throw new Error('You have to provide orderID in paymentContext');
-                }
-                try {
-                    const request = new checkoutNodeJssdk.orders.OrdersGetRequest(orderID);
-                    const client = new checkoutNodeJssdk.core.PayPalHttpClient(environment());
-                    const paypalOrder = await client.execute(request);
-                    const pricing = OrderPricingSheet({
-                        calculation: order.calculation,
-                        currencyCode: order.currencyCode,
-                    });
-                    const ourTotal = roundToDecimals(pricing.total({ useNetPrice: false }).amount / 100, 2);
-                    const paypalTotal = roundToDecimals(paypalOrder.result.purchase_units[0].amount.value, 2);
-                    if (ourTotal === paypalTotal) {
-                        return order;
-                    }
-                    logger.warn('Missmatch PAYPAL ORDER', JSON.stringify(paypalOrder.result, null, 2));
-                    logger.debug('OUR ORDER', order);
-                    logger.debug('OUR PRICE', pricing);
-                    throw new Error(`Payment mismatch`);
-                }
-                catch (e) {
-                    logger.warn(e);
-                    throw new Error(e);
-                }
-            },
-        };
-        return adapter;
-    },
-};
-PaymentDirector.registerAdapter(PaypalCheckout);

package/lib/payment/payrexx/handler-express.d.ts

@@ -1 +0,0 @@
-export declare const payrexxHandler: (request: any, response: any) => Promise<void>;

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

@@ -1,85 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-const logger = createLogger('unchained:payrexx:handler');
-export const payrexxHandler = async (request, response) => {
-    const resolvedContext = request.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const { transaction } = request.body;
-    if (!transaction) {
-        logger.info(`unhandled event type`, {
-            type: Object.keys(request.body).join(','),
-        });
-        response.status(200).send({
-            ignored: true,
-            message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
-        });
-        return;
-    }
-    if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
-        logger.info(`unhandled transaction state: ${transaction.status}`);
-        response.status(200).send({
-            ignored: true,
-            message: `Unhandled transaction state: ${transaction.status}`,
-        });
-        return;
-    }
-    logger.info(`Processing event`, {
-        transactionId: transaction.id,
-    });
-    try {
-        if (transaction.preAuthorizationId) {
-            const { referenceId: paymentProviderId, invoice } = transaction;
-            const userId = '';
-            logger.info(`register credentials for: ${userId}`);
-            await services.orders.registerPaymentCredentials(paymentProviderId, {
-                userId,
-                transactionContext: { gatewayId: invoice.paymentRequestId },
-            });
-            logger.info(`registration successful`, {
-                paymentProviderId,
-                userId,
-            });
-            response.status(200).send({
-                message: 'registration successful',
-                paymentProviderId,
-                userId,
-            });
-        }
-        else {
-            const { referenceId: orderPaymentId, invoice } = transaction;
-            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
-            await modules.orders.payments.logEvent(orderPaymentId, {
-                transactionId: transaction.id,
-            });
-            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: {
-                    gatewayId: invoice.paymentRequestId,
-                },
-            });
-            if (!order)
-                throw new Error(`Order with id ${orderPayment.orderId} not found`);
-            logger.info(`checkout successful`, {
-                orderPaymentId,
-                orderId: order._id,
-            });
-            response.status(200).send({
-                message: 'checkout successful',
-                orderId: order._id,
-            });
-        }
-    }
-    catch (error) {
-        logger.error(error, {
-            transactionId: transaction.id,
-        });
-        response.status(500).send({
-            message: error.message,
-            name: error.name,
-        });
-    }
-};

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

@@ -1,2 +0,0 @@
-import type { RouteHandlerMethod } from 'fastify';
-export declare const payrexxHandler: RouteHandlerMethod;

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

@@ -1,91 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-const logger = createLogger('unchained:payrexx:handler');
-export const payrexxHandler = async (request, reply) => {
-    const resolvedContext = request.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const { transaction } = request.body;
-    if (!transaction) {
-        logger.info(`unhandled event type`, {
-            type: Object.keys(request.body).join(','),
-        });
-        reply.status(200);
-        return reply.send({
-            success: false,
-            ignored: true,
-            message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
-        });
-    }
-    if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
-        logger.info(`unhandled transaction state: ${transaction.status}`);
-        reply.status(200);
-        return reply.send({
-            success: false,
-            ignored: true,
-            message: `Unhandled transaction state: ${transaction.status}`,
-        });
-    }
-    logger.info(`Processing event`, {
-        transactionId: transaction.id,
-    });
-    try {
-        if (transaction.preAuthorizationId) {
-            const { referenceId: paymentProviderId, invoice } = transaction;
-            const userId = '';
-            logger.info(`register credentials for: ${userId}`);
-            await services.orders.registerPaymentCredentials(paymentProviderId, {
-                userId,
-                transactionContext: { gatewayId: invoice.paymentRequestId },
-            });
-            logger.info(`registration successful`, {
-                paymentProviderId,
-                userId,
-            });
-            reply.status(200);
-            return reply.send({
-                success: true,
-                paymentProviderId,
-                userId,
-            });
-        }
-        else {
-            const { referenceId: orderPaymentId, invoice } = transaction;
-            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
-            const orderPayment = await modules.orders.payments.findOrderPayment({
-                orderPaymentId,
-            });
-            if (!orderPayment) {
-                throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
-            }
-            await modules.orders.payments.logEvent(orderPaymentId, {
-                transactionId: transaction.id,
-            });
-            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                paymentContext: {
-                    gatewayId: invoice.paymentRequestId,
-                },
-            });
-            if (!order)
-                throw new Error(`Order with id ${orderPayment.orderId} not found`);
-            logger.info(`checkout successful`, {
-                orderPaymentId,
-                orderId: order._id,
-            });
-            reply.status(200);
-            return reply.send({
-                success: true,
-                orderId: order._id,
-            });
-        }
-    }
-    catch (error) {
-        logger.error(error, {
-            transactionId: transaction.id,
-        });
-        reply.status(500);
-        return reply.send({
-            success: false,
-            message: error.message,
-            name: error.name,
-        });
-    }
-};

package/lib/payment/postfinance-checkout/handler-express.d.ts

@@ -1 +0,0 @@
-export declare const postfinanceCheckoutHandler: (req: any, res: any) => Promise<void>;