@unchainedshop/plugins 4.6.1 → 4.7.2

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

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

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

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

package/lib/payment/invoice.d.ts

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

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

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

package/lib/payment/paypal-checkout.js

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

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

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

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

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

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

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

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

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

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

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

package/lib/payment/postfinance-checkout/handler-express.js

@@ -1,37 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { getTransaction, getTransactionCompletion } from "./api.js";
-const logger = createLogger('unchained:postfinance-checkout:handler');
-export const postfinanceCheckoutHandler = async (req, res) => {
-    const context = req.unchainedContext;
-    const { services, modules } = context;
-    const data = req.body;
-    if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
-        try {
-            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`);
-            res.status(200).send(`Order marked as paid: ${order.orderNumber}`);
-        }
-        catch (e) {
-            logger.error(e);
-            res.status(500).send({ name: e.name, code: e.code, message: e.message });
-        }
-    }
-    else {
-        logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
-        res.status(404).end();
-    }
-};

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

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

package/lib/payment/postfinance-checkout/handler-fastify.js

@@ -1,40 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { getTransaction, getTransactionCompletion } from "./api.js";
-const logger = createLogger('unchained:postfinance-checkout:handler');
-export const postfinanceCheckoutHandler = async (req, reply) => {
-    const context = req.unchainedContext;
-    const { services, modules } = context;
-    const data = req.body;
-    if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
-        try {
-            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: transaction.id,
-                },
-            });
-            if (!order)
-                throw new Error(`Order with id ${orderPayment.orderId} not found`);
-            logger.info(`Transaction ${transaction.id} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`);
-            reply.status(200);
-            return reply.send({ success: true, orderNumber: order.orderNumber });
-        }
-        catch (e) {
-            logger.error(e);
-            reply.status(500);
-            return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
-        }
-    }
-    else {
-        logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
-        reply.status(404);
-        return reply.send();
-    }
-};

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

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

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

@@ -1,59 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { buildSignature } from "./buildSignature.js";
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const logger = createLogger('unchained:saferpay:handler');
-export const saferpayHandler = async (request, response) => {
-    const resolvedContext = request.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const { orderPaymentId, signature, transactionId } = request.query;
-    const isValidRequest = typeof orderPaymentId === 'string' &&
-        typeof signature === 'string' &&
-        typeof transactionId === 'string' &&
-        orderPaymentId &&
-        transactionId &&
-        signature;
-    if ((request.method !== 'GET' && request.method !== 'HEAD') || !isValidRequest) {
-        logger.warn(`unhandled http method ${request.method} or orderPaymentId missing in query`);
-        response.status(404).end();
-        return;
-    }
-    try {
-        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,
-        });
-        response.status(200).send({
-            message: 'checkout successful',
-            orderPaymentId,
-            orderId: order._id,
-        });
-    }
-    catch (error) {
-        logger.error(error, {
-            orderPaymentId,
-            transactionId,
-        });
-        response.status(500).send({
-            message: error.message,
-            name: error.name,
-        });
-    }
-};

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

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

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

@@ -1,62 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { buildSignature } from "./buildSignature.js";
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const logger = createLogger('unchained:saferpay:handler');
-export const saferpayHandler = async (request, reply) => {
-    const resolvedContext = request.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const { orderPaymentId, signature, transactionId } = request.query;
-    const isValidRequest = typeof orderPaymentId === 'string' &&
-        typeof signature === 'string' &&
-        typeof transactionId === 'string' &&
-        orderPaymentId &&
-        transactionId &&
-        signature;
-    if (!isValidRequest) {
-        logger.warn(`orderPaymentId missing in query`);
-        reply.status(404);
-        return reply.send();
-    }
-    try {
-        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,
-        });
-        reply.status(200);
-        return reply.send({
-            success: true,
-            orderPaymentId,
-            orderId: order._id,
-        });
-    }
-    catch (error) {
-        logger.error(error, {
-            orderPaymentId,
-            transactionId,
-        });
-        reply.status(500);
-        return reply.send({
-            success: false,
-            message: error.message,
-            name: error.name,
-        });
-    }
-};

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

@@ -1,5 +0,0 @@
-export declare const WebhookEventTypes: {
-    PAYMENT_INTENT_SUCCEEDED: string;
-    SETUP_INTENT_SUCCEEDED: string;
-};
-export declare const stripeHandler: (request: any, response: any) => Promise<void>;