Stripe webhook 作为中间件

Question

In my Nodejs/Express API, when the user checks out and the stripe checkout is successful, I want to send them some success responses and call some functions.

I have tried to access the checkout.session.completed event with the webhook to determine if the checkout process was complete and then send a response but the problem is that the webhook route and checkout route are different from each other and I have no idea how I can implement the webhook functionality as a middleware so that the checkout.session.completed event gets cheked in the same checkout route.

This is the checkout functionality which goes into the checkout route (cartsRouter.post("/:cart_id/checkout", checkoutCart) :

// Checkout
const checkoutCart = async (req, res, next) => {
  const user_id = req.user.user_id;

  try {
    // Check if cart isn't empty
    const cart = await db.query(selectCartProducts, [user_id]);
    if (!cart.rows.length) {
      res.status(200).json({ message: "Cart Is Empty" });
    } else {
      // Check if shipping address has been provided in the user info
      const address = await db.query(checkAddress, [user_id]);
      if (!address.rows.length) {
        missingAddressError(next);
      } else {
        // Stripe
        const session = await stripe.checkout.sessions.create({
          line_items: cart.rows.map((product) => {
            return {
              price_data: {
                currency: "usd",
                product_data: {
                  name: product.name,
                  images: product.img_urls,
                },
                unit_amount: product.price * 100,
              },
              quantity: product.quantity,
            };
          }),
          mode: "payment",
          success_url: process.env.ADDRESS2,
          cancel_url: process.env.ADDRESS1,
        });

        res.status(200).json(session.url);
      }
    }
  } catch (err) {
    next(err);
  }
};

And this is the webhook route:

cartsRouter.post(
  "/checkout/webhook",
  express.raw({ type: "application/json" }),
  async (req, res, next) => {
    const cart_id = req.user.cart_id;
    const user_id = req.user.user_id;

    const sig = req.headers["stripe-signature"];

    let event;

    try {
      event = stripe.webhooks.constructEvent(
        req.body,
        sig,
        process.env.ENDPOINT_SECRET
      );
    } catch (err) {
      res.status(400).send(`Webhook Error: ${err.message}`);
      return;
    }

    // Handle the checkout.session.completed event
    if (event.type === "checkout.session.completed") {
      // Fulfill the purchase...
      try {
        // Get cart
        const cart = await db.query(selectCartProducts, [user_id]);

        // Calculate the total price of the products based on their quantity
        const total_price = cart.rows
          .reduce((acc, item) => {
            return acc + parseFloat(item.price) * item.quantity;
          }, 0)
          .toFixed(2);

        // Create new order
        const order = await db.query(insertOrder, [
          user_id,
          total_price,
          "Complete",
        ]);
        const order_id = order.rows[0].order_id;

        // Move products from cart to order history
        await Promise.all(
          cart.rows.map(async (product) => {
            await db.query(insertProductIntoOrder, [
              order_id,
              product.product_id,
              product.quantity,
              product.color,
            ]);
            // Delete products from cart after adding them to order history (empty cart)
            await db.query(deleteProductFromCart, [
              cart_id,
              product.product_id,
            ]);
          })
        );

        return res.status(201).json({
          message: "Order Submitted Successfully",
          order: {
            order_number: order.rows[0].order_number,
            total_price: order.rows[0].total_price,
            status: order.rows[0].status,
          },
        });
      } catch (err) {
        console.error(err.message);
        return next(err);
      }
    }

    // Return a 200 response to acknowledge receipt of the event
    res.send();
  }
);

I'm looking for a way to combine these two routes so that while still being on the checkout route, the checkout.session.completed event in the webhook gets checked and appropriate responses get sent to the client.

Is there any way to do this?

Answer 1

After a successful payment or completion, your customer is redirected back from Checkout to your success_url that you configured. At that point, you can confirm that they paid successfully without waiting for the webhook itself. Or you can poll your server until it's done processing the webhook otherwise.

This is outlined in Checkout's main documentation here where they explain that redirect. While it just shows a basic success page, you can do fulfillment here too as long as you securely check that they completed the Session. The idea would be to use a cookie to recognize them after a redirect for example and then use the Retrieve Session API to check its status.

Make sure to always have the webhook as a fallback though since it's possible for the customer to close the tab before the redirect completes.