@unchainedshop/plugins 4.6.1 → 4.7.2

package/lib/payment/datatrans-v2/index.js

@@ -1,407 +1,24 @@
-import { createLogger } from '@unchainedshop/logger';
-import createDatatransAPI from "./api/index.js";
-import parseRegistrationData from "./parseRegistrationData.js";
-import roundedAmountFromOrder from "./roundedAmountFromOrder.js";
-import { PaymentAdapter, PaymentDirector, PaymentError, PaymentPricingRowCategory, PaymentPricingSheet, OrderPricingSheet, } from '@unchainedshop/core';
-const logger = createLogger('unchained:datatrans');
-const { DATATRANS_SECRET, DATATRANS_SIGN_KEY, DATATRANS_API_ENDPOINT = 'https://api.sandbox.datatrans.com', DATATRANS_MERCHANT_ID, } = process.env;
-const newDatatransError = ({ code, message }) => {
-    const error = new Error(message);
-    error.name = `DATATRANS_${code}`;
-    return error;
-};
-const throwIfResponseError = (result) => {
-    if (result.error) {
-        const rawError = result.error;
-        throw newDatatransError(rawError);
-    }
-};
-const getMarketplaceSplits = async ({ order, orderPayment, config, }) => {
-    const pricingForOrderPayment = PaymentPricingSheet({
-        calculation: orderPayment.calculation,
-        currencyCode: order.currencyCode,
-    });
-    const pricing = OrderPricingSheet({
-        calculation: order.calculation,
-        currencyCode: order.currencyCode,
-    });
-    const { amount: total } = pricing.total({ useNetPrice: false });
-    return Promise.all(config
-        .filter((item) => item.key === 'marketplaceSplit')
-        .map((item) => {
-        const [subMerchantId, staticDiscountId, sharePercentage] = item.value || ''.split(';').map((f) => f.trim());
-        const { amount: discountSum } = pricingForOrderPayment.total({
-            category: PaymentPricingRowCategory.Discount,
-            discountId: staticDiscountId,
-        });
-        const shareFactor = sharePercentage ? parseInt(sharePercentage, 10) / 100 : 1;
-        const amount = Math.round(total * shareFactor);
-        const commission = Math.round(discountSum * -1 * shareFactor);
-        return {
-            subMerchantId,
-            amount,
-            commission,
-        };
-    }));
-};
-const Datatrans = {
-    ...PaymentAdapter,
+import { Datatrans } from "./adapter.js";
+import { datatransWebhookHandler } from "./api.js";
+const { DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook' } = process.env;
+const { DATATRANS_SIGN_KEY, DATATRANS_SIGN2_KEY } = process.env;
+export const DatatransPlugin = {
     key: 'shop.unchained.datatrans',
-    label: 'Datatrans',
+    label: 'Datatrans Payment Plugin',
     version: '2.0.0',
-    initialConfiguration: [
+    adapters: [Datatrans],
+    routes: [
         {
-            key: 'merchantId',
-            value: null,
+            path: DATATRANS_WEBHOOK_PATH,
+            method: 'POST',
+            handler: datatransWebhookHandler,
         },
     ],
-    typeSupported(type) {
-        return type === 'GENERIC';
-    },
-    actions: (config, context) => {
-        const getMerchantId = () => {
-            return config.find((item) => item.key === 'merchantId')?.value || DATATRANS_MERCHANT_ID;
-        };
-        const api = () => {
-            const merchantId = getMerchantId();
-            if (!DATATRANS_SECRET)
-                throw new Error('Credential DATATRANS_SECRET not Set');
-            if (!merchantId)
-                throw new Error('Credential Merchant ID not configured');
-            if (!DATATRANS_API_ENDPOINT)
-                throw new Error('Credential DATATRANS_API_ENDPOINT not Set');
-            return createDatatransAPI(DATATRANS_API_ENDPOINT, merchantId, DATATRANS_SECRET);
-        };
-        const shouldSettleInUnchained = () => {
-            return config.reduce((current, item) => {
-                if (item.key === 'settleInUnchained')
-                    return Boolean(item.value);
-                return current;
-            }, true);
-        };
-        const authorize = async ({ paymentCredentials, ...arbitraryFields }) => {
-            const { order, orderPayment } = context;
-            if (!orderPayment)
-                throw new Error('Order Payment missing in context');
-            if (!order)
-                throw new Error('Order missing in context');
-            const refno = Buffer.from(orderPayment._id, 'hex').toString('base64');
-            const userId = order?.userId || context?.userId;
-            const refno2 = userId;
-            const { currencyCode, amount } = roundedAmountFromOrder(order);
-            const splits = await getMarketplaceSplits({
-                orderPayment,
-                order,
-                config,
-            });
-            const result = await api().authorize({
-                ...arbitraryFields,
-                amount,
-                currency: currencyCode,
-                refno,
-                refno2,
-                autoSettle: false,
-                customer: {
-                    id: userId,
-                },
-                marketplace: splits.length
-                    ? {
-                        splits,
-                    }
-                    : undefined,
-                [paymentCredentials.meta.objectKey]: JSON.parse(paymentCredentials.token),
-            });
-            throwIfResponseError(result);
-            return result.transactionId;
-        };
-        const authorizeAuth = async ({ transactionId, refno, refno2, ...arbitraryFields }) => {
-            const { order } = context;
-            if (!order)
-                throw new Error('Order missing in context');
-            const { currencyCode, amount } = roundedAmountFromOrder(order);
-            const result = await api().authorizeAuthenticated({
-                ...arbitraryFields,
-                transactionId,
-                amount,
-                currency: currencyCode,
-                refno,
-                refno2,
-                autoSettle: false,
-            });
-            throwIfResponseError(result);
-            return result.acquirerAuthorizationCode;
-        };
-        const isTransactionAmountValid = (transaction) => {
-            const { order } = context;
-            if (!order)
-                throw new Error('Order missing in context');
-            const { currencyCode, amount } = roundedAmountFromOrder(order);
-            if (transaction.currency !== currencyCode ||
-                transaction.detail.authorize?.amount !== amount) {
-                logger.info(`currency: ${transaction.currency} === ${currencyCode} => ${transaction.currency === currencyCode}, amount: ${transaction.detail.authorize?.amount} === ${amount} => ${transaction.detail.authorize?.amount === amount}`);
-                return false;
-            }
-            return true;
-        };
-        const checkIfTransactionAmountValid = (transactionId, transaction) => {
-            if (!isTransactionAmountValid(transaction)) {
-                logger.error(`Transaction declined / Transaction ID ${transactionId} because of amount/currency mismatch`);
-                throw newDatatransError({
-                    code: `YOU_HAVE_TO_PAY_THE_FULL_AMOUNT_DUDE`,
-                    message: 'Amount / Currency Mismatch with Cart',
-                });
-            }
-        };
-        const settle = async ({ transactionId, refno, refno2, extensions }) => {
-            const { order, orderPayment } = context;
-            if (!orderPayment)
-                throw new Error('Order Payment missing in context');
-            if (!order)
-                throw new Error('Order missing in context');
-            const { currencyCode, amount } = roundedAmountFromOrder(order);
-            const splits = await getMarketplaceSplits({
-                orderPayment,
-                order,
-                config,
-            });
-            const result = await api().settle({
-                transactionId,
-                amount,
-                refno,
-                refno2,
-                currency: currencyCode,
-                marketplace: splits.length
-                    ? {
-                        splits,
-                    }
-                    : undefined,
-                extensions,
-            });
-            throwIfResponseError(result);
-            return result;
-        };
-        const cancel = async ({ transactionId, refno }) => {
-            const result = await api().cancel({
-                transactionId,
-                refno,
-            });
-            throwIfResponseError(result);
-            return result;
-        };
-        const adapterActions = {
-            ...PaymentAdapter.actions(config, context),
-            configurationError() {
-                if (!getMerchantId() || !DATATRANS_SECRET || !DATATRANS_SIGN_KEY) {
-                    return PaymentError.INCOMPLETE_CONFIGURATION;
-                }
-                return null;
-            },
-            isActive() {
-                if (adapterActions.configurationError() === null)
-                    return true;
-                return false;
-            },
-            isPayLaterAllowed() {
-                return false;
-            },
-            async sign(transactionContext = {}) {
-                const { useSecureFields = false, ...arbitraryFields } = transactionContext || {};
-                const { orderPayment, paymentProvider, order } = context;
-                const refno = Buffer.from(orderPayment ? orderPayment._id : paymentProvider._id, 'hex').toString('base64');
-                const userId = order?.userId || context?.userId;
-                const refno2 = userId;
-                const price = order
-                    ? roundedAmountFromOrder(order)
-                    : {};
-                if (useSecureFields) {
-                    const result = await api().secureFields({
-                        ...arbitraryFields,
-                        currency: price.currencyCode || 'CHF',
-                        refno,
-                        refno2,
-                        customer: {
-                            id: userId,
-                        },
-                        amount: price.amount,
-                    });
-                    throwIfResponseError(result);
-                    return JSON.stringify(result);
-                }
-                const result = await api().init({
-                    ...arbitraryFields,
-                    currency: price.currencyCode || 'CHF',
-                    refno,
-                    refno2,
-                    customer: {
-                        id: userId,
-                    },
-                    amount: price.amount,
-                });
-                throwIfResponseError(result);
-                return JSON.stringify(result);
-            },
-            async validate(credentials) {
-                if (!credentials.meta)
-                    return false;
-                const { objectKey, currency } = credentials.meta;
-                const result = await api().validate({
-                    refno: Buffer.from(`valid-${new Date().getTime()}`, 'hex').toString('base64'),
-                    currency,
-                    [objectKey]: JSON.parse(credentials.token),
-                });
-                return Boolean(result?.transactionId);
-            },
-            async register(transactionResponse) {
-                const { transactionId } = transactionResponse;
-                const result = (await api().status({
-                    transactionId,
-                }));
-                if (result.transactionId) {
-                    return parseRegistrationData(result);
-                }
-                return null;
-            },
-            async confirm() {
-                if (!shouldSettleInUnchained())
-                    return false;
-                const { orderPayment, transactionContext } = context;
-                if (!orderPayment)
-                    throw new Error('Order Payment missing in context');
-                const { transactionId } = orderPayment;
-                const { extensions } = transactionContext || {};
-                if (!transactionId) {
-                    return false;
-                }
-                const transaction = (await api().status({
-                    transactionId,
-                }));
-                throwIfResponseError(transaction);
-                const { status } = transaction;
-                if (status === 'authorized') {
-                    await settle({
-                        transactionId,
-                        refno: transaction.refno,
-                        refno2: transaction.refno2,
-                        extensions,
-                    });
-                }
-                return true;
-            },
-            async cancel() {
-                if (!shouldSettleInUnchained())
-                    return false;
-                const { orderPayment } = context;
-                if (!orderPayment)
-                    throw new Error('Order Payment missing in context');
-                const { transactionId } = orderPayment;
-                if (!transactionId) {
-                    return false;
-                }
-                const transaction = (await api().status({
-                    transactionId,
-                }));
-                throwIfResponseError(transaction);
-                const { status } = transaction;
-                if (status === 'authorized') {
-                    await cancel({
-                        transactionId,
-                        refno: transaction.refno,
-                    });
-                }
-                return true;
-            },
-            async charge({ transactionId: rawTransactionId, paymentCredentials, authorizeAuthenticated, ...arbitraryFields }) {
-                if (!rawTransactionId && !paymentCredentials) {
-                    logger.warn('Not trying to charge because of missing payment authorization response, return false to provide later');
-                    return false;
-                }
-                const transactionId = rawTransactionId ||
-                    (await authorize({
-                        ...arbitraryFields,
-                        paymentCredentials,
-                    }));
-                const transaction = (await api().status({
-                    transactionId,
-                }));
-                throwIfResponseError(transaction);
-                if (!transaction) {
-                    throw newDatatransError({
-                        code: `TRANSACTION_NOT_FOUND`,
-                        message: 'Amount / Currency Mismatch with Cart',
-                    });
-                }
-                let { status } = transaction;
-                if (status === 'canceled' || status === 'failed') {
-                    logger.error(`Payment declined or canceled with Transaction ID ${transactionId} and status ${status}`);
-                    throw newDatatransError({
-                        code: `STATUS_${status.toUpperCase()}`,
-                        message: 'Payment declined or canceled',
-                    });
-                }
-                if (status === 'authenticated') {
-                    if (authorizeAuthenticated) {
-                        checkIfTransactionAmountValid(transactionId, transaction);
-                        await authorizeAuth({
-                            ...(authorizeAuthenticated || {}),
-                            transactionId,
-                            refno: transaction.refno,
-                            refno2: transaction.refno2,
-                        });
-                        status = 'authorized';
-                    }
-                    else {
-                        logger.error(`Transaction declined / Transaction ID ${transactionId} not authorized yet`);
-                        throw newDatatransError({
-                            code: `STATUS_${status.toUpperCase()}`,
-                            message: 'Payment authenticated but not authorized',
-                        });
-                    }
-                }
-                if (status === 'authorized' || status === 'settled') {
-                    let settledTransaction = transaction;
-                    let credentials;
-                    try {
-                        checkIfTransactionAmountValid(transactionId, settledTransaction);
-                        credentials = await parseRegistrationData(settledTransaction);
-                        const result = await api().status({
-                            transactionId,
-                        });
-                        if (result?.error) {
-                            settledTransaction = transaction;
-                        }
-                        else {
-                            settledTransaction = result;
-                        }
-                    }
-                    catch {
-                        await cancel({ transactionId, refno: settledTransaction.refno });
-                        logger.error(`Transaction declined / Transaction ID ${transactionId} authorization cancelled`);
-                        throw newDatatransError({
-                            code: `STATUS_${status.toUpperCase()}`,
-                            message: 'Payment cancelled server-side because of amount missmatch',
-                        });
-                    }
-                    return {
-                        transactionId,
-                        settledTransaction,
-                        arbitraryFields,
-                        credentials,
-                    };
-                }
-                if (status === 'initialized' ||
-                    status === 'challenge_required' ||
-                    status === 'challenge_ongoing' ||
-                    status === 'transmitted') {
-                    logger.error(`Transaction ID ${transactionId} in transit with status ${status}`);
-                    throw newDatatransError({
-                        code: `STATUS_${status.toUpperCase()}`,
-                        message: 'Transaction status invalid for checkout',
-                    });
-                }
-                return false;
-            },
-        };
-        return adapterActions;
+    onRegister: () => {
+        if (!DATATRANS_SIGN_KEY && !DATATRANS_SIGN2_KEY) {
+            throw new Error('DATATRANS_SIGN_KEY not set');
+        }
     },
 };
-PaymentDirector.registerAdapter(Datatrans);
+export default DatatransPlugin;
+export { Datatrans } from "./adapter.js";

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

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

package/lib/payment/{invoice.js → invoice/adapter.js}

@@ -1,6 +1,6 @@
-import { PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
+import { PaymentAdapter } from '@unchainedshop/core';
 import { PaymentProviderType } from '@unchainedshop/core-payment';
-const Invoice = {
+export const Invoice = {
     ...PaymentAdapter,
     key: 'shop.unchained.invoice',
     label: 'Invoice',
@@ -24,4 +24,3 @@ const Invoice = {
         };
     },
 };
-PaymentDirector.registerAdapter(Invoice);

package/lib/payment/invoice/index.d.ts

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

package/lib/payment/invoice/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { Invoice } from "./adapter.js";
+export const InvoicePlugin = {
+    key: 'shop.unchained.invoice',
+    label: 'Invoice Payment Plugin',
+    version: '1.0.0',
+    adapters: [Invoice],
+};
+export default InvoicePlugin;
+export { Invoice } from "./adapter.js";

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

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

package/lib/payment/{invoice-prepaid.js → invoice-prepaid/adapter.js}

@@ -1,6 +1,6 @@
-import { PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
+import { PaymentAdapter } from '@unchainedshop/core';
 import { PaymentProviderType } from '@unchainedshop/core-payment';
-const InvoicePrepaid = {
+export const InvoicePrepaid = {
     ...PaymentAdapter,
     key: 'shop.unchained.invoice-prepaid',
     label: 'Invoice pre-paid',
@@ -27,4 +27,3 @@ const InvoicePrepaid = {
         };
     },
 };
-PaymentDirector.registerAdapter(InvoicePrepaid);

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

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

package/lib/payment/invoice-prepaid/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { InvoicePrepaid } from "./adapter.js";
+export const InvoicePrepaidPlugin = {
+    key: 'shop.unchained.invoice-prepaid',
+    label: 'Invoice Prepaid Payment Plugin',
+    version: '1.0.0',
+    adapters: [InvoicePrepaid],
+};
+export default InvoicePrepaidPlugin;
+export { InvoicePrepaid } from "./adapter.js";

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

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

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>;