@unchainedshop/plugins 4.6.0 → 4.6.2

package/lib/payment/payrexx/adapter.js

@@ -0,0 +1,161 @@
+import { createLogger } from '@unchainedshop/logger';
+import { mapOrderDataToGatewayObject, mapUserToGatewayObject } from "./payrexx.js";
+import createPayrexxAPI, { GatewayObjectStatus } from "./api/index.js";
+import { OrderPricingSheet, PaymentAdapter, PaymentError, } from '@unchainedshop/core';
+const logger = createLogger('unchained:payrexx');
+export const Payrexx = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.payment.payrexx',
+    label: 'Payrexx',
+    version: '1.0.0',
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const { modules } = context;
+        const instance = config.find((c) => c.key === 'instance')?.value;
+        const adapterActions = {
+            ...PaymentAdapter.actions(config, context),
+            configurationError() {
+                if (!process.env.PAYREXX_SECRET) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                if (!instance) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            isActive: () => {
+                if (adapterActions.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            sign: async (transactionContext = {}) => {
+                const { orderPayment, userId, order } = context;
+                if (!order)
+                    throw new Error('No order in context, can only sign with order context');
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                if (orderPayment) {
+                    const pricing = OrderPricingSheet({
+                        calculation: order.calculation,
+                        currencyCode: order.currencyCode,
+                    });
+                    const gatewayObject = mapOrderDataToGatewayObject({ order, orderPayment, pricing }, transactionContext);
+                    const gateway = await api.createGateway(gatewayObject);
+                    return JSON.stringify(gateway);
+                }
+                const user = userId && (await modules.users.findUserById(userId));
+                if (!user)
+                    throw new Error('User not found, can only sign registrations with user context');
+                const emailAddress = modules.users.primaryEmail(user)?.address;
+                const gateway = await api.createGateway(mapUserToGatewayObject({
+                    userId,
+                    emailAddress,
+                    currencyCode: order?.currencyCode,
+                }));
+                return JSON.stringify(gateway);
+            },
+            async register() {
+                throw new Error('Not implemented');
+                return null;
+            },
+            async confirm() {
+                const { orderPayment } = context;
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                const gatewayObject = await api.getGateway(transactionId);
+                if (!gatewayObject) {
+                    return false;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.reserved) {
+                    const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+                    await Promise.all(allTransactions.map(async (transaction) => api.chargePreAuthorized(transaction.id, { referenceId: '__IGNORE_WEBHOOK__' })));
+                    return true;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.confirmed) {
+                    return true;
+                }
+                return false;
+            },
+            async cancel() {
+                const { orderPayment } = context;
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                const gatewayObject = await api.getGateway(transactionId);
+                if (!gatewayObject) {
+                    return false;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.reserved) {
+                    const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+                    await Promise.all(allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)));
+                    return true;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.confirmed) {
+                    return false;
+                }
+                return true;
+            },
+            charge: async ({ gatewayId, paymentCredentials }) => {
+                if (!gatewayId && !paymentCredentials) {
+                    throw new Error('You have to provide gatewayId or paymentCredentials');
+                }
+                const { order, orderPayment } = context;
+                if (!order)
+                    throw new Error('No order in context, can only charge with order context');
+                if (!orderPayment)
+                    throw new Error('Order payment not found');
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                const gatewayObject = await api.getGateway(gatewayId);
+                if (!gatewayObject) {
+                    throw new Error('Could not load gateway from the Payrexx API');
+                }
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const { currencyCode, amount } = pricing.total({ useNetPrice: false });
+                if (gatewayObject.status === 'reserved' ||
+                    gatewayObject.status === 'confirmed') {
+                    try {
+                        if (gatewayObject.currency !== currencyCode.toUpperCase() ||
+                            gatewayObject.amount !== Math.round(amount)) {
+                            throw new Error('The price has changed since the intent has been created');
+                        }
+                        if (gatewayObject.referenceId !== orderPayment?._id) {
+                            throw new Error('The order payment is different from the initiating intent');
+                        }
+                        logger.info(`Mark as charged, status is ${gatewayObject.status}`, {
+                            orderPaymentId: gatewayObject.referenceId,
+                        });
+                        return {
+                            transactionId: gatewayId,
+                            gatewayObject,
+                        };
+                    }
+                    catch (e) {
+                        if (gatewayObject.status === GatewayObjectStatus.reserved) {
+                            const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+                            await Promise.all(allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)));
+                        }
+                        throw e;
+                    }
+                }
+                logger.info('Charge not possible', {
+                    orderPaymentId: gatewayObject.referenceId,
+                    status: gatewayObject.status,
+                });
+                throw new Error(`Gateway Status ${gatewayObject.status} does not allow checkout`);
+            },
+        };
+        return adapterActions;
+    },
+};

package/lib/payment/payrexx/api.d.ts

@@ -0,0 +1,2 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function payrexxWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/payrexx/api.js

@@ -0,0 +1,97 @@
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:payrexx');
+export async function payrexxWebhookHandler(request, context) {
+    try {
+        const { modules, services } = context;
+        const body = await request.json();
+        const { transaction } = body;
+        if (!transaction) {
+            logger.info('Unhandled event type', {
+                type: Object.keys(body).join(','),
+            });
+            return new Response(JSON.stringify({
+                ignored: true,
+                message: `Unhandled event type: ${Object.keys(body).join(',')}. Supported type: transaction`,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
+            logger.info(`Unhandled transaction state: ${transaction.status}`);
+            return new Response(JSON.stringify({
+                ignored: true,
+                message: `Unhandled transaction state: ${transaction.status}`,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        logger.info('Processing event', {
+            transactionId: transaction.id,
+        });
+        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,
+            });
+            return new Response(JSON.stringify({
+                message: 'registration successful',
+                paymentProviderId,
+                userId,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        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,
+            });
+            return new Response(JSON.stringify({
+                message: 'checkout successful',
+                orderId: order._id,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    }
+    catch (error) {
+        logger.error('Payrexx webhook error:', error);
+        return new Response(JSON.stringify({
+            message: error.message,
+            name: error.name,
+        }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}

package/lib/payment/postfinance-checkout/adapter.d.ts

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

package/lib/payment/postfinance-checkout/adapter.js

@@ -0,0 +1,189 @@
+import { createLogger } from '@unchainedshop/logger';
+import { OrderPricingSheet, PaymentAdapter, PaymentError, } from '@unchainedshop/core';
+import { confirmDeferredTransaction, createTransaction, getIframeJavascriptUrl, getLightboxJavascriptUrl, getPaymentPageUrl, getToken, getTransaction, refundTransaction, voidTransaction, } from "./api.js";
+import { orderIsPaid } from "./utils.js";
+import { CompletionModes, IntegrationModes } from "./types.js";
+import { LineItemType, TokenizationMode, TransactionCompletionBehavior, TransactionState, CreationEntityState, } from "./api-types.js";
+const { PFCHECKOUT_SPACE_ID, PFCHECKOUT_USER_ID, PFCHECKOUT_SECRET, PFCHECKOUT_SUCCESS_URL, PFCHECKOUT_FAILED_URL, } = process.env;
+const logger = createLogger('unchained:postfinance-checkout');
+const newError = ({ code, message }) => {
+    const error = new Error(message);
+    error.name = `POSTFINANCE_${code}`;
+    return error;
+};
+export const PostfinanceCheckout = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.payment.postfinance-checkout',
+    label: 'Postfinance Checkout',
+    version: '1.0.0',
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const adapter = {
+            ...PaymentAdapter.actions(config, context),
+            getCompletionMode() {
+                return (config.find((item) => item.key === 'completionMode')?.value ||
+                    CompletionModes.Deferred);
+            },
+            configurationError() {
+                if (!PFCHECKOUT_SPACE_ID ||
+                    !PFCHECKOUT_USER_ID ||
+                    !PFCHECKOUT_SECRET ||
+                    !PFCHECKOUT_SUCCESS_URL ||
+                    !PFCHECKOUT_FAILED_URL) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            isActive() {
+                if (adapter.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            async validate(credentials) {
+                if (!credentials.meta)
+                    return false;
+                const { linkedSpaceId } = credentials.meta;
+                const tokenData = await getToken(linkedSpaceId, credentials.token);
+                return tokenData.state === CreationEntityState.ACTIVE;
+            },
+            sign: async (transactionContext = {}) => {
+                const { orderPayment, order } = context;
+                if (!order)
+                    throw new Error('No order in context, can only sign with order context');
+                if (!orderPayment)
+                    throw new Error('No order payment in context, can only sign with order payment context');
+                const { integrationMode = IntegrationModes.PaymentPage } = transactionContext;
+                const completionMode = adapter.getCompletionMode();
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+                const transaction = {
+                    currency: order.currencyCode,
+                    metaData: {
+                        orderPaymentId: orderPayment._id,
+                    },
+                    successUrl: `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${orderPayment.orderId}`,
+                    failedUrl: `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${orderPayment.orderId}`,
+                    customerId: order?.userId || context?.userId,
+                    tokenizationMode: TokenizationMode.ALLOW_ONE_CLICK_PAYMENT,
+                };
+                if (completionMode === CompletionModes.Immediate) {
+                    transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
+                }
+                else if (completionMode === CompletionModes.Deferred) {
+                    transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_DEFERRED;
+                }
+                if (totalAmount) {
+                    const lineItemSum = {
+                        name: `Bestellung ${orderPayment.orderId}`,
+                        type: LineItemType.FEE,
+                        quantity: 1,
+                        uniqueId: orderPayment.orderId,
+                        amountIncludingTax: totalAmount / 100,
+                    };
+                    transaction.lineItems = [lineItemSum];
+                }
+                const transactionId = await createTransaction(transaction);
+                if (!transactionId)
+                    throw new Error('Could not create transaction');
+                let location = null;
+                if (integrationMode === IntegrationModes.PaymentPage) {
+                    location = await getPaymentPageUrl(transactionId);
+                }
+                else if (integrationMode === IntegrationModes.Lightbox) {
+                    location = await getLightboxJavascriptUrl(transactionId);
+                }
+                else if (integrationMode === IntegrationModes.iFrame) {
+                    location = await getIframeJavascriptUrl(transactionId);
+                }
+                const res = {
+                    transactionId,
+                    location,
+                };
+                return JSON.stringify(res);
+            },
+            charge: async ({ transactionId, paymentCredentials, }) => {
+                if (paymentCredentials && !transactionId) {
+                    throw new Error('Not implemented yet');
+                }
+                if (!transactionId)
+                    return false;
+                const transaction = await getTransaction(transactionId);
+                if (!transaction) {
+                    logger.error(`Transaction #${transactionId}: Transaction not found`);
+                    throw newError({
+                        code: `TRANSACTION_NOT_FOUND`,
+                        message: 'Payment declined',
+                    });
+                }
+                const { order, orderPayment } = context;
+                if (!orderPayment)
+                    throw new Error('No order payment in context, cannot charge payment');
+                if (!order)
+                    throw new Error('No order in context, can only sign with order context');
+                const isPaid = await orderIsPaid(order, transaction);
+                if (!isPaid) {
+                    logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
+                    throw newError({
+                        code: `STATE_${transaction.state?.toUpperCase()}`,
+                        message: 'Invalid state / Amount incorrect',
+                    });
+                }
+                if (transaction.metaData?.orderPaymentId !== orderPayment._id) {
+                    logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
+                    throw newError({
+                        code: `TRANSACTION_ALREADY_USED`,
+                        message: 'Transaction already used in previous checkout',
+                    });
+                }
+                const { id, ...tokenMeta } = transaction.token || {};
+                return {
+                    transaction,
+                    transactionId,
+                    credentials: id && {
+                        ...tokenMeta,
+                        token: id.toString(),
+                    },
+                };
+            },
+            cancel: async () => {
+                const { orderPayment, order } = context;
+                if (!order)
+                    throw new Error('No order in context, can only cancel with order context');
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const transaction = await getTransaction(transactionId);
+                const refund = transaction.state === TransactionState.FULFILL;
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+                return ((refund && refundTransaction(transactionId, order._id, totalAmount / 100)) ||
+                    voidTransaction(transactionId));
+            },
+            confirm: async () => {
+                const { orderPayment } = context;
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const transaction = await getTransaction(transactionId);
+                if (transaction.state === TransactionState.AUTHORIZED) {
+                    return confirmDeferredTransaction(transactionId);
+                }
+                return false;
+            },
+        };
+        return adapter;
+    },
+};

package/lib/payment/postfinance-checkout/webhook.d.ts

@@ -0,0 +1,2 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function postfinanceCheckoutWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/postfinance-checkout/webhook.js

@@ -0,0 +1,48 @@
+import { createLogger } from '@unchainedshop/logger';
+import { getTransaction, getTransactionCompletion } from "./api.js";
+const logger = createLogger('unchained:postfinance-checkout');
+export async function postfinanceCheckoutWebhookHandler(request, context) {
+    try {
+        const { services, modules } = context;
+        const data = (await request.json());
+        if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+            const transactionCompletion = await getTransactionCompletion(data.entityId);
+            const transaction = await getTransaction(transactionCompletion ? transactionCompletion.linkedTransaction : data.entityId);
+            const { orderPaymentId } = transaction.metaData;
+            const orderPayment = await modules.orders.payments.findOrderPayment({
+                orderPaymentId,
+            });
+            if (!orderPayment) {
+                throw new Error('Order Payment not found');
+            }
+            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                paymentContext: {
+                    transactionId: transactionCompletion.linkedTransaction,
+                },
+            });
+            if (!order) {
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            }
+            logger.info(`Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`);
+            return new Response(JSON.stringify({ orderNumber: order.orderNumber }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        else {
+            logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
+            return new Response(null, { status: 404 });
+        }
+    }
+    catch (error) {
+        logger.error('Postfinance Checkout webhook error:', error);
+        return new Response(JSON.stringify({
+            name: error.name,
+            code: error.code,
+            message: error.message,
+        }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}

package/lib/payment/saferpay/webhook.d.ts

@@ -0,0 +1,2 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function saferpayWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/saferpay/webhook.js

@@ -0,0 +1,64 @@
+import { createLogger } from '@unchainedshop/logger';
+import { timingSafeStringEqual } from '@unchainedshop/utils';
+import { buildSignature } from "./buildSignature.js";
+const logger = createLogger('unchained:saferpay');
+export async function saferpayWebhookHandler(request, context) {
+    try {
+        const { modules, services } = context;
+        const url = new URL(request.url);
+        const orderPaymentId = url.searchParams.get('orderPaymentId');
+        const signature = url.searchParams.get('signature');
+        const transactionId = url.searchParams.get('transactionId');
+        const isValidRequest = typeof orderPaymentId === 'string' &&
+            typeof signature === 'string' &&
+            typeof transactionId === 'string' &&
+            orderPaymentId &&
+            transactionId &&
+            signature;
+        if (!isValidRequest) {
+            logger.warn('Missing required query parameters');
+            return new Response(null, { status: 404 });
+        }
+        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}`);
+        }
+        const correctSignature = await buildSignature(transactionId, orderPaymentId);
+        if (!(await timingSafeStringEqual(correctSignature, signature))) {
+            throw new Error('Invalid signature');
+        }
+        const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+            paymentContext: {
+                transactionId,
+            },
+        });
+        if (!order) {
+            throw new Error(`Order with id ${orderPayment.orderId} not found`);
+        }
+        logger.info('Checkout successful', {
+            orderPaymentId,
+            orderId: order._id,
+        });
+        return new Response(JSON.stringify({
+            message: 'checkout successful',
+            orderPaymentId,
+            orderId: order._id,
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    catch (error) {
+        logger.error('Saferpay webhook error:', error);
+        return new Response(JSON.stringify({
+            message: error.message,
+            name: error.name,
+        }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}

package/lib/payment/stripe/adapter.d.ts

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