@unchainedshop/plugins 4.6.1 → 4.7.2

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

@@ -1,192 +1,31 @@
-import { createLogger } from '@unchainedshop/logger';
-import { OrderPricingSheet, PaymentAdapter, PaymentDirector, 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;
-};
-const PostfinanceCheckout = {
-    ...PaymentAdapter,
+import { PostfinanceCheckout } from "./adapter.js";
+import { postfinanceCheckoutWebhookHandler } from "./webhook.js";
+const { PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout' } = process.env;
+export const PostfinanceCheckoutPlugin = {
     key: 'shop.unchained.payment.postfinance-checkout',
-    label: 'Postfinance Checkout',
+    label: 'Postfinance Checkout Payment Plugin',
     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;
+    adapters: [PostfinanceCheckout],
+    routes: [
+        {
+            path: PFCHECKOUT_WEBHOOK_PATH,
+            method: 'POST',
+            handler: postfinanceCheckoutWebhookHandler,
+        },
+    ],
+    onRegister: () => {
+        const { PFCHECKOUT_SPACE_ID, PFCHECKOUT_USER_ID, PFCHECKOUT_SECRET, PFCHECKOUT_SUCCESS_URL, PFCHECKOUT_FAILED_URL, } = process.env;
+        if (!PFCHECKOUT_SPACE_ID ||
+            !PFCHECKOUT_USER_ID ||
+            !PFCHECKOUT_SECRET ||
+            !PFCHECKOUT_SUCCESS_URL ||
+            !PFCHECKOUT_FAILED_URL) {
+            throw new Error('Postfinance Checkout environment variables not fully configured');
+        }
     },
 };
-PaymentDirector.registerAdapter(PostfinanceCheckout);
+export default PostfinanceCheckoutPlugin;
+export { PostfinanceCheckout } from "./adapter.js";
 export * from "./types.js";
 export * from "./api-types.js";
+export * from "./utils.js";

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/adapter.js

@@ -1,7 +1,7 @@
 import { mongodb } from '@unchainedshop/mongodb';
 import { SaferpayClient } from "./api/index.js";
 import { buildSignature } from "./buildSignature.js";
-import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
+import { OrderPricingSheet, PaymentAdapter, PaymentError, } from '@unchainedshop/core';
 const newSaferpayError = ({ code, message }) => {
     const error = new Error(message || code);
     error.name = `SAFERPAY_${code}`;
@@ -187,4 +187,3 @@ export const WordlineSaferpay = {
         return adapter;
     },
 };
-PaymentDirector.registerAdapter(WordlineSaferpay);

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

@@ -1,4 +1,5 @@
-export * from './adapter.ts';
-import saferpayTransactionsModule, { type SaferpayTransactionsModule } from './module.ts';
-export type { SaferpayTransactionsModule };
-export default saferpayTransactionsModule;
+import type { IPlugin } from '@unchainedshop/core';
+export declare const SaferpayPlugin: IPlugin;
+export default SaferpayPlugin;
+export { WordlineSaferpay } from './adapter.ts';
+export { type SaferpayTransactionsModule } from './module.ts';

package/lib/payment/saferpay/index.js

@@ -1,3 +1,29 @@
-export * from "./adapter.js";
-import saferpayTransactionsModule, {} from "./module.js";
-export default saferpayTransactionsModule;
+import { WordlineSaferpay } from "./adapter.js";
+import saferpayModules from "./module.js";
+import { saferpayWebhookHandler } from "./webhook.js";
+const { SAFERPAY_WEBHOOK_PATH = '/payment/saferpay/webhook' } = process.env;
+export const SaferpayPlugin = {
+    key: 'shop.unchained.payment.saferpay',
+    label: 'Wordline Saferpay Payment Plugin',
+    version: '1.0.0',
+    adapters: [WordlineSaferpay],
+    module: ({ db }) => ({
+        saferpayTransactions: saferpayModules.saferpayTransactions.configure({ db }),
+    }),
+    routes: [
+        {
+            path: SAFERPAY_WEBHOOK_PATH,
+            method: 'GET',
+            handler: saferpayWebhookHandler,
+        },
+    ],
+    onRegister: () => {
+        const { SAFERPAY_CUSTOMER_ID, SAFERPAY_TERMINAL_ID, SAFERPAY_API_USER, SAFERPAY_API_PASSWORD } = process.env;
+        if (!SAFERPAY_CUSTOMER_ID || !SAFERPAY_TERMINAL_ID || !SAFERPAY_API_USER || !SAFERPAY_API_PASSWORD) {
+            throw new Error('Saferpay environment variables not fully configured');
+        }
+    },
+};
+export default SaferpayPlugin;
+export { WordlineSaferpay } from "./adapter.js";
+export {} from "./module.js";

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;

package/lib/payment/stripe/adapter.js

@@ -0,0 +1,121 @@
+import { createLogger } from '@unchainedshop/logger';
+import { stripe, createOrderPaymentIntent, createRegistrationIntent } from "./stripe.js";
+import { OrderPricingSheet, PaymentAdapter, PaymentError, } from '@unchainedshop/core';
+const logger = createLogger('unchained:stripe');
+export const Stripe = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.payment.stripe',
+    label: 'Stripe',
+    version: '2.0.0',
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const { modules } = context;
+        const descriptorPrefix = config.find(({ key }) => key === 'descriptorPrefix')?.value || '';
+        const assertUserData = async (forcedUserId) => {
+            const userId = forcedUserId || context?.userId;
+            const user = await modules.users.findUserById(userId);
+            if (!user)
+                throw new Error('User not found');
+            const email = modules.users.primaryEmail(user)?.address;
+            const name = user.profile?.displayName || user.username || email;
+            return {
+                email,
+                name,
+                userId,
+            };
+        };
+        const adapterActions = {
+            ...PaymentAdapter.actions(config, context),
+            configurationError() {
+                if (!stripe)
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                return null;
+            },
+            isActive: () => {
+                if (adapterActions.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            validate: async ({ token }) => {
+                const paymentMethod = await stripe.paymentMethods.retrieve(token);
+                return !!paymentMethod;
+            },
+            register: async ({ setupIntentId }) => {
+                if (!setupIntentId) {
+                    throw new Error('You have to provide a setupIntentId');
+                }
+                const setupIntent = await stripe.setupIntents.retrieve(setupIntentId);
+                if (setupIntent.status === 'succeeded') {
+                    return {
+                        token: setupIntent.payment_method,
+                        customer: setupIntent.customer,
+                        payment_method_types: setupIntent.payment_method_types,
+                        usage: setupIntent.usage,
+                    };
+                }
+                logger.warn('Registration declined', setupIntentId);
+                return null;
+            },
+            sign: async (transactionContext = {}) => {
+                const { orderPayment, order, paymentProvider } = context;
+                const { userId, name, email } = await assertUserData(order?.userId);
+                if (orderPayment) {
+                    if (!order)
+                        throw new Error('order not found in context');
+                    const pricing = OrderPricingSheet({
+                        calculation: order?.calculation,
+                        currencyCode: order?.currencyCode,
+                    });
+                    const paymentIntent = await createOrderPaymentIntent({ userId, name, email, order, orderPayment, pricing, descriptorPrefix }, transactionContext);
+                    return paymentIntent.client_secret;
+                }
+                const paymentIntent = await createRegistrationIntent({ userId, name, email, paymentProviderId: paymentProvider._id, descriptorPrefix }, transactionContext);
+                return paymentIntent.client_secret;
+            },
+            charge: async ({ paymentIntentId, paymentCredentials }) => {
+                if (!paymentIntentId && !paymentCredentials) {
+                    throw new Error('You have to provide paymentIntentId or paymentCredentials');
+                }
+                const { order, orderPayment } = context;
+                if (!order)
+                    throw new Error('order not found in context');
+                if (!orderPayment)
+                    throw new Error('orderPayment not found in context');
+                const { userId, name, email } = await assertUserData(order?.userId);
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const paymentIntentObject = paymentIntentId
+                    ? await stripe.paymentIntents.retrieve(paymentIntentId)
+                    : await createOrderPaymentIntent({ userId, name, email, orderPayment, order, pricing, descriptorPrefix }, {
+                        customer: paymentCredentials.meta?.customer,
+                        confirm: true,
+                        payment_method: paymentCredentials.token,
+                        payment_method_types: paymentCredentials.meta?.payment_method_types,
+                    });
+                const { currencyCode, amount } = pricing.total({ useNetPrice: false });
+                if (paymentIntentObject.currency !== currencyCode.toLowerCase() ||
+                    paymentIntentObject.amount !== Math.round(amount)) {
+                    throw new Error('The price has changed since the intent has been created');
+                }
+                if (paymentIntentObject.metadata?.orderPaymentId !== orderPayment?._id) {
+                    throw new Error('The order payment is different from the initiating intent');
+                }
+                if (paymentIntentObject.status === 'succeeded') {
+                    return paymentIntentObject;
+                }
+                logger.info('Charge postponed because paymentIntent has wrong status', {
+                    orderPaymentId: paymentIntentObject.id,
+                });
+                return false;
+            },
+        };
+        return adapterActions;
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare const WebhookEventTypes: {
+    PAYMENT_INTENT_SUCCEEDED: string;
+    SETUP_INTENT_SUCCEEDED: string;
+};
+export declare function stripeWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;