@unchainedshop/plugins 4.6.1 → 4.7.2

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

@@ -1 +1,4 @@
-export {};
+import type { IPlugin } from '@unchainedshop/core';
+export declare const PayrexxPlugin: IPlugin;
+export default PayrexxPlugin;
+export { Payrexx } from './adapter.ts';

package/lib/payment/payrexx/index.js

@@ -1,162 +1,23 @@
-import { createLogger } from '@unchainedshop/logger';
-import { mapOrderDataToGatewayObject, mapUserToGatewayObject } from "./payrexx.js";
-import createPayrexxAPI, { GatewayObjectStatus } from "./api/index.js";
-import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
-const logger = createLogger('unchained:payrexx');
-const Payrexx = {
-    ...PaymentAdapter,
+import { Payrexx } from "./adapter.js";
+import { payrexxWebhookHandler } from "./api.js";
+const { PAYREXX_WEBHOOK_PATH = '/payment/payrexx' } = process.env;
+export const PayrexxPlugin = {
     key: 'shop.unchained.payment.payrexx',
-    label: 'Payrexx',
+    label: 'Payrexx Payment Plugin',
     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;
+    adapters: [Payrexx],
+    routes: [
+        {
+            path: PAYREXX_WEBHOOK_PATH,
+            method: 'POST',
+            handler: payrexxWebhookHandler,
+        },
+    ],
+    onRegister: () => {
+        if (!process.env.PAYREXX_SECRET) {
+            throw new Error('PAYREXX_SECRET not set');
+        }
     },
 };
-PaymentDirector.registerAdapter(Payrexx);
+export default PayrexxPlugin;
+export { Payrexx } from "./adapter.js";

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

@@ -1,2 +1,7 @@
+import type { IPlugin } from '@unchainedshop/core';
+export declare const PostfinanceCheckoutPlugin: IPlugin;
+export default PostfinanceCheckoutPlugin;
+export { PostfinanceCheckout } from './adapter.ts';
 export * from './types.ts';
 export * from './api-types.ts';
+export * from './utils.ts';