@unchainedshop/plugins 4.7.2 → 4.8.0

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

@@ -0,0 +1,59 @@
+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

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

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

@@ -0,0 +1,62 @@
+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/saferpay/index.d.ts

@@ -1,5 +1,4 @@
-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';
+export * from './adapter.ts';
+import saferpayTransactionsModule, { type SaferpayTransactionsModule } from './module.ts';
+export type { SaferpayTransactionsModule };
+export default saferpayTransactionsModule;

package/lib/payment/saferpay/index.js

@@ -1,29 +1,3 @@
-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";
+export * from "./adapter.js";
+import saferpayTransactionsModule, {} from "./module.js";
+export default saferpayTransactionsModule;

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

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

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

@@ -0,0 +1,121 @@
+import { createLogger } from '@unchainedshop/logger';
+import { stripe } from "./stripe.js";
+const logger = createLogger('unchained:stripe:handler');
+export const WebhookEventTypes = {
+    PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
+    SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
+};
+export const stripeHandler = async (request, response) => {
+    const resolvedContext = request.unchainedContext;
+    const { modules, services } = resolvedContext;
+    let event;
+    try {
+        const sig = request.headers['stripe-signature'];
+        if (!sig) {
+            throw new Error('stripe-signature header was not provided for webhook');
+        }
+        if (!process.env.STRIPE_ENDPOINT_SECRET) {
+            throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+        }
+        event = stripe.webhooks.constructEvent(request.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
+    }
+    catch (err) {
+        logger.error(`Error constructing event: ${err.message}`);
+        response.status(400).send({
+            message: err.message,
+            name: err.name,
+        });
+        return;
+    }
+    if (!Object.values(WebhookEventTypes).includes(event.type)) {
+        logger.info(`unhandled event type`, {
+            type: event.type,
+        });
+        response.status(200).send({
+            ignored: true,
+            message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+        });
+        return;
+    }
+    const environmentInMetadata = event.data?.object?.metadata?.environment || '';
+    const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
+    if (environmentInMetadata !== environmentInEnv) {
+        logger.info(`unhandled event environment`, {
+            type: event.type,
+            environment: environmentInMetadata,
+        });
+        response.status(200).send({
+            ignored: true,
+            message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+        });
+        return;
+    }
+    logger.info(`Processing event`, {
+        type: event.type,
+    });
+    try {
+        if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
+            const paymentIntent = event.data.object;
+            const { orderPaymentId } = paymentIntent.metadata || {};
+            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`, {
+                type: event.type,
+            });
+            await modules.orders.payments.logEvent(orderPaymentId, event);
+            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: {
+                    paymentIntentId: paymentIntent.id,
+                },
+            });
+            if (!order)
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            logger.info(`checkout successful`, {
+                orderPaymentId,
+                orderId: order._id,
+                type: event.type,
+            });
+            response.status(200).send({
+                message: 'checkout successful',
+                orderId: order._id,
+            });
+        }
+        else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
+            const setupIntent = event.data.object;
+            const { paymentProviderId, userId } = setupIntent.metadata || {};
+            logger.info(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
+                type: event.type,
+                userId,
+            });
+            const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, {
+                transactionContext: {
+                    setupIntentId: setupIntent.id,
+                },
+                userId,
+            });
+            logger.info(`payment credentials registration successful`, {
+                userId,
+                paymentProviderId,
+                paymentCredentialsId: paymentCredentials?._id,
+                type: event.type,
+            });
+            response.status(200).send({
+                message: 'payment credentials registration successful',
+                paymentCredentialsId: paymentCredentials?._id,
+            });
+        }
+    }
+    catch (error) {
+        logger.error(error, {
+            type: event.type,
+        });
+        response.status(500).send({
+            message: error.message,
+            name: error.name,
+        });
+    }
+};

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

@@ -0,0 +1,6 @@
+import type { RouteHandlerMethod } from 'fastify';
+export declare const WebhookEventTypes: {
+    PAYMENT_INTENT_SUCCEEDED: string;
+    SETUP_INTENT_SUCCEEDED: string;
+};
+export declare const stripeHandler: RouteHandlerMethod;

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

@@ -0,0 +1,131 @@
+import { createLogger } from '@unchainedshop/logger';
+import { stripe } from "./stripe.js";
+const logger = createLogger('unchained:stripe:handler');
+export const WebhookEventTypes = {
+    PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
+    SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
+};
+export const stripeHandler = async (req, reply) => {
+    const resolvedContext = req.unchainedContext;
+    const { modules, services } = resolvedContext;
+    let event;
+    try {
+        const sig = req.headers['stripe-signature'];
+        if (!process.env.STRIPE_ENDPOINT_SECRET) {
+            throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+        }
+        if (!sig) {
+            throw new Error('stripe-signature header was not provided for webhook');
+        }
+        event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
+    }
+    catch (err) {
+        logger.error(`Error constructing event: ${err.message}`);
+        reply.status(400);
+        return reply.send({
+            success: false,
+            message: err.message,
+            name: err.name,
+        });
+    }
+    if (!Object.values(WebhookEventTypes).includes(event.type)) {
+        logger.info(`unhandled event type`, {
+            type: event.type,
+        });
+        reply.status(200);
+        return reply.send({
+            success: false,
+            ignored: true,
+            name: 'UNHANDLED_EVENT_TYPE',
+            message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+        });
+    }
+    const environmentInMetadata = event.data?.object?.metadata?.environment || '';
+    const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
+    if (environmentInMetadata !== environmentInEnv) {
+        logger.info(`unhandled event environment`, {
+            type: event.type,
+            environment: environmentInMetadata,
+        });
+        reply.status(200);
+        return reply.send({
+            success: false,
+            ignored: true,
+            name: 'UNHANDLED_EVENT_ENVIRONMENT',
+            message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+        });
+    }
+    logger.info(`Processing event`, {
+        type: event.type,
+    });
+    try {
+        if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
+            const paymentIntent = event.data.object;
+            const { orderPaymentId } = paymentIntent.metadata || {};
+            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`, {
+                type: event.type,
+            });
+            await modules.orders.payments.logEvent(orderPaymentId, event);
+            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: {
+                    paymentIntentId: paymentIntent.id,
+                },
+            });
+            if (!order)
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            logger.info(`checkout successful`, {
+                orderPaymentId,
+                orderId: order._id,
+                type: event.type,
+            });
+            reply.status(200);
+            return reply.send({
+                success: true,
+                orderId: order._id,
+            });
+        }
+        else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
+            const setupIntent = event.data.object;
+            const { paymentProviderId, userId } = setupIntent.metadata || {};
+            logger.info(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
+                type: event.type,
+                userId,
+            });
+            const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, {
+                transactionContext: {
+                    setupIntentId: setupIntent.id,
+                },
+                userId,
+            });
+            logger.info(`payment credentials registration successful`, {
+                userId,
+                paymentProviderId,
+                paymentCredentialsId: paymentCredentials?._id,
+                type: event.type,
+            });
+            reply.status(200);
+            return reply.send({
+                success: true,
+                message: 'payment credentials registration successful',
+                paymentCredentialsId: paymentCredentials?._id,
+            });
+        }
+    }
+    catch (error) {
+        logger.error(error, {
+            type: event.type,
+        });
+        reply.status(500);
+        return reply.send({
+            success: false,
+            message: error.message,
+            name: error.name,
+        });
+    }
+};

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

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

package/lib/payment/stripe/index.js

@@ -1,28 +1,122 @@
 import { createLogger } from '@unchainedshop/logger';
-import { Stripe } from "./adapter.js";
-import { stripeWebhookHandler } from "./api.js";
-const { STRIPE_WEBHOOK_PATH = '/payment/stripe/webhook' } = process.env;
+import { stripe, createOrderPaymentIntent, createRegistrationIntent } from "./stripe.js";
+import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
 const logger = createLogger('unchained:stripe');
-export const StripePlugin = {
+const Stripe = {
+    ...PaymentAdapter,
     key: 'shop.unchained.payment.stripe',
-    label: 'Stripe Payment Plugin',
+    label: 'Stripe',
     version: '2.0.0',
-    adapters: [Stripe],
-    routes: [
-        {
-            path: STRIPE_WEBHOOK_PATH,
-            method: 'POST',
-            handler: stripeWebhookHandler,
-        },
-    ],
-    onRegister: () => {
-        if (!process.env.STRIPE_SECRET) {
-            throw new Error('STRIPE_SECRET not set');
-        }
-        if (!process.env.STRIPE_ENDPOINT_SECRET) {
-            logger.warn('STRIPE_ENDPOINT_SECRET not set - webhooks will not work');
-        }
+    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;
     },
 };
-export default StripePlugin;
-export { Stripe } from "./adapter.js";
+PaymentDirector.registerAdapter(Stripe);

package/lib/payment/stripe/stripe.js

@@ -3,7 +3,10 @@ const logger = createLogger('unchained:stripe');
 const { STRIPE_SECRET, STRIPE_WEBHOOK_ENVIRONMENT, EMAIL_WEBSITE_NAME } = process.env;
 export let stripe;
 const environment = STRIPE_WEBHOOK_ENVIRONMENT ?? null;
-if (STRIPE_SECRET) {
+if (!STRIPE_SECRET) {
+    logger.warn('STRIPE_SECRET is not set, skipping initialization');
+}
+else {
     try {
         const { default: Stripe } = await import('stripe');
         stripe = new Stripe(STRIPE_SECRET, {

package/lib/presets/all-express.d.ts

@@ -0,0 +1,6 @@
+import express from 'express';
+import type { UnchainedCore } from '@unchainedshop/core';
+declare const _default: (app: express.Express, { unchainedAPI }: {
+    unchainedAPI: UnchainedCore;
+}) => void;
+export default _default;

package/lib/presets/all-express.js

@@ -0,0 +1,26 @@
+import express from 'express';
+import connectCryptoToExpress from "./crypto-express.js";
+import connectBaseToExpress from "./base-express.js";
+import { datatransHandler } from "../payment/datatrans-v2/handler-express.js";
+import { stripeHandler } from "../payment/stripe/handler-express.js";
+import { postfinanceCheckoutHandler } from "../payment/postfinance-checkout/handler-express.js";
+import { appleIAPHandler } from "../payment/apple-iap/handler-express.js";
+import { payrexxHandler } from "../payment/payrexx/handler-express.js";
+import { saferpayHandler } from "../payment/saferpay/handler-express.js";
+import { configureGenerateOrderAutoscheduling } from "../worker/enrollment-order-generator.js";
+const { STRIPE_WEBHOOK_PATH = '/payment/stripe', PAYREXX_WEBHOOK_PATH = '/payment/payrexx', PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout', DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook', APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap', SAFERPAY_WEBHOOK_PATH = '/payment/saferpay/webhook', } = process.env;
+export default (app, { unchainedAPI }) => {
+    connectBaseToExpress(app);
+    connectCryptoToExpress(app, unchainedAPI);
+    app.use(STRIPE_WEBHOOK_PATH, express.raw({ type: 'application/json' }), stripeHandler);
+    app.use(PFCHECKOUT_WEBHOOK_PATH, express.json(), postfinanceCheckoutHandler);
+    app.use(DATATRANS_WEBHOOK_PATH, express.text({
+        type: 'application/json',
+    }), datatransHandler);
+    app.use(APPLE_IAP_WEBHOOK_PATH, express.json({
+        strict: false,
+    }), appleIAPHandler);
+    app.use(PAYREXX_WEBHOOK_PATH, express.json({ type: 'application/json' }), payrexxHandler);
+    app.use(SAFERPAY_WEBHOOK_PATH, saferpayHandler);
+    configureGenerateOrderAutoscheduling();
+};

package/lib/presets/all-fastify.d.ts

@@ -0,0 +1,6 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+import type { FastifyInstance } from 'fastify';
+declare const _default: (fastify: FastifyInstance, { unchainedAPI }: {
+    unchainedAPI: UnchainedCore;
+}) => void;
+export default _default;