@unchainedshop/plugins 4.3.4 → 4.4.0

package/src/payment/stripe/handler-express.ts

@@ -1,135 +0,0 @@
-import { Context } from '@unchainedshop/api';
-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 as Context;
-  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/src/payment/stripe/handler-fastify.ts

@@ -1,151 +0,0 @@
-import { Context } from '@unchainedshop/api';
-import { createLogger } from '@unchainedshop/logger';
-import { FastifyRequest, RouteHandlerMethod } from 'fastify';
-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: RouteHandlerMethod = async (
-  req: FastifyRequest & {
-    unchainedContext: Context;
-  },
-  reply,
-) => {
-  const resolvedContext = req.unchainedContext as Context;
-  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 as string, 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/src/payment/stripe/index.ts

@@ -1,163 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { stripe, createOrderPaymentIntent, createRegistrationIntent } from './stripe.js';
-import {
-  OrderPricingSheet,
-  IPaymentAdapter,
-  PaymentAdapter,
-  PaymentDirector,
-  PaymentError,
-} from '@unchainedshop/core';
-
-const logger = createLogger('unchained:stripe');
-
-const Stripe: IPaymentAdapter = {
-  ...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_options: setupIntent.payment_method_options,
-            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,
-                // payment_method_options: paymentCredentials.meta?.payment_method_options, // eslint-disable-line
-              },
-            );
-
-        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;
-  },
-};
-
-PaymentDirector.registerAdapter(Stripe);

package/src/payment/stripe/readme.md

@@ -1,12 +0,0 @@
-## Test Webhooks:
-
-```
-brew install stripe/stripe-cli/stripe
-stripe login --api-key sk_....
-stripe listen --forward-to http://localhost:4010/payment/stripe
-stripe trigger payment_intent.succeeded
-```
-
-## Configure the Payment Statements:
-
-Payment Provider configuration: `[{ key: "descriptorPrefix", value: "Book Shop" }]`

package/src/payment/stripe/stripe.ts

@@ -1,137 +0,0 @@
-import type { Stripe } from 'stripe';
-import type { IOrderPricingSheet } from '@unchainedshop/core';
-import { Order, OrderPayment } from '@unchainedshop/core-orders';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:stripe');
-
-const { STRIPE_SECRET, STRIPE_WEBHOOK_ENVIRONMENT, EMAIL_WEBSITE_NAME } = process.env;
-
-export let stripe: Stripe;
-const environment = STRIPE_WEBHOOK_ENVIRONMENT ?? null;
-
-try {
-  if (!STRIPE_SECRET) {
-    logger.warn('STRIPE_SECRET is not set, skipping initialization');
-  }
-  const { default: Stripe } = await import('stripe');
-  stripe = new Stripe(STRIPE_SECRET as string, {
-    apiVersion: '2025-11-17.clover',
-  });
-} catch {
-  logger.warn(`optional peer npm package 'stripe' not installed, stripe adapter will not work`);
-}
-
-export const upsertCustomer = async ({ userId, name, email }): Promise<string> => {
-  try {
-    const { data } = await stripe.customers.search({ query: `metadata["userId"]:"${userId}"` });
-    const existingCustomer = data[0];
-
-    if (
-      existingCustomer.name !== name ||
-      existingCustomer.email !== email ||
-      existingCustomer.metadata.environment !== environment
-    ) {
-      const updatedCustomer = await stripe.customers.update(existingCustomer.id, {
-        metadata: {
-          userId,
-          environment,
-        },
-        name,
-        email,
-      });
-      return updatedCustomer.id;
-    }
-
-    return existingCustomer.id;
-  } catch {
-    const customer = await stripe.customers.create({
-      metadata: {
-        userId,
-        environment: STRIPE_WEBHOOK_ENVIRONMENT ?? null,
-      },
-      name,
-      email,
-    });
-    return customer.id;
-  }
-};
-
-export const createRegistrationIntent = async (
-  {
-    userId,
-    name,
-    email,
-    paymentProviderId,
-    descriptorPrefix,
-  }: {
-    userId: string;
-    name: string;
-    email: string;
-    paymentProviderId: string;
-    descriptorPrefix?: string;
-  },
-  options: Record<string, any> = {},
-) => {
-  const customer = options?.customer || (await upsertCustomer({ userId, name, email }));
-  const description =
-    `${options?.description || descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
-
-  const setupIntent = await stripe.setupIntents.create({
-    description,
-    customer,
-    metadata: {
-      userId,
-      paymentProviderId,
-      environment,
-    },
-    usage: 'off_session',
-    ...options,
-  });
-  return setupIntent;
-};
-
-export const createOrderPaymentIntent = async (
-  {
-    userId,
-    name,
-    email,
-    order,
-    orderPayment,
-    pricing,
-    descriptorPrefix,
-  }: {
-    userId: string;
-    name: string;
-    email: string;
-    order: Order;
-    orderPayment: OrderPayment;
-    pricing: IOrderPricingSheet;
-    descriptorPrefix?: string;
-  },
-  options: Record<string, any> = {},
-) => {
-  const description =
-    `${options?.description || descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
-  const customer = options?.customer || (await upsertCustomer({ userId, name, email }));
-
-  const { currencyCode, amount } = pricing.total({ useNetPrice: false });
-
-  const paymentIntent = await stripe.paymentIntents.create({
-    amount: Math.round(amount),
-    currency: currencyCode.toLowerCase(),
-    description,
-    statement_descriptor_suffix: `${order._id.substring(0, 4)}..${order._id.substring(order._id.length - 4)}`,
-    setup_future_usage: 'off_session', // Verify your integration in this guide by including this parameter
-    customer,
-    receipt_email: order.contact?.emailAddress,
-    metadata: {
-      orderPaymentId: orderPayment._id,
-      orderId: order._id,
-      userId,
-      environment,
-    },
-    ...options,
-  });
-  return paymentIntent;
-};

package/src/presets/all-express.ts

@@ -1,51 +0,0 @@
-import express from 'express';
-import { UnchainedCore } from '@unchainedshop/core';
-
-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: express.Express, { unchainedAPI }: { unchainedAPI: UnchainedCore }) => {
-  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();
-};