Need Help Setting Up Flutterwave with TypeScript, Express.js, Sequelize, and PostgreSQL

// src/types/flutterwave-node-v3.d.ts
declare module 'flutterwave-node-v3' {
    // TypeScript interfaces for the Flutterwave response and request types
    export interface PaymentInitiateResponse {
      status: string;
      message: string;
      data: {
        link: string;
      };
    }

    export interface TransactionVerifyResponse {
      status: string;
      message: string;
      data: {
        tx_ref: string;
        flw_ref: string;
        currency: string;
        status: string;
      };
    }

    export interface Flutterwave {
      initializePayment(
        payload: {
          tx_ref: string;
          amount: number;
          currency: string;
          redirect_url: string;
          customer: {
            email: string;
          };
        }
      ): Promise<PaymentInitiateResponse>;

      TransactionVerify(
        payload: { id: string }
      ): Promise<TransactionVerifyResponse>;
    }

    const Flutterwave: new (publicKey: string, secretKey: string) => Flutterwave;
    export = Flutterwave;
  }

import Flutterwave from "flutterwave-node-v3";
import { FLWPUBK, FLWSECK } from "../config";

const flw = new Flutterwave(FLWPUBK, FLWSECK);

export const initiatePayment = async (payload: {
  tx_ref: string;
  amount: number;
  currency: string;
  email: string;
  redirect_url: string;
}) => {
  try {
    const response = await flw.Charge.card({
      tx_ref: payload.tx_ref,
      amount: payload.amount,
      currency: payload.currency,
      redirect_url: payload.redirect_url,
      customer: {
        email: payload.email,
      },
      payment_options: "card", // Optional: specify payment options
    });

    if (response.status === "success") {
      return response.meta.authorization.redirect; // Payment link
    } else {
      throw new Error(response.message || "Failed to initiate payment.");
    }
  } catch (error) {
    console.error("Payment initiation error:", error);
    throw new Error("Failed to initiate payment.");
  }
};
export const verifyPayment = async (transactionId: string) => {
  try {
    const response = await flw.Transaction.verify({ id: transactionId });

    if (response.status === "success") {
      return response.data;
    } else {
      throw new Error("Payment verification failed.");
    }
  } catch (error) {
    console.error("Payment verification error:", error);
    throw new Error("Failed to verify payment.");
  }
};

const event = (await EventInstance.findOne({
  where: { id: eventId },
})) as unknown as EventAttribute;
if (!event) {
  return res.status(404).json({ error: "Event not found" });
}

if (new Date() > new Date(event.date)) {
  return res
    .status(400)
    .json({ error: "Cannot purchase tickets for expired events" });
}

const ticketPrice = event.ticketType[ticketType];
if (!ticketPrice) {
  return res.status(400).json({ error: "Invalid ticket type" });
}

const ticketId = uuidv4();

const qrCodeData = {
  ticketId,
  userId,
  eventId: event.id,
  ticketType,
  price: ticketPrice,
  purchaseDate: new Date(),
};
const qrCode = await QRCode.toDataURL(JSON.stringify(qrCodeData));

const newTicket = await TicketInstance.create({
  id: ticketId,
  eventId: event.id,
  userId,
  ticketType,
  price: ticketPrice,
  purchaseDate: new Date(),
  qrCode,
  paid: false,
  currency,
  validationStatus: "Invalid",
}) as unknown as TicketAttribute;

const notification = await NotificationInstance.create({
  id: uuidv4(),
  title: "Ticket Purchase Successful",
  message: `You have successfully purchased a ${ticketType} ticket for the event ${event.title}.`,
  userId,
  isRead: false,
});

const paymentLink = await initiatePayment({
  tx_ref: newTicket.id,
  amount: newTicket.price,
  currency: newTicket.currency,
  email: user.email,
  redirect_url: `${BASE_URL}/tickets/callback`,
});

return res.status(201).json({
  message: "Ticket created successfully",
  paymentLink,
  ticket: newTicket,
});

if (paymentData.tx_ref === tx_ref) {
  await TicketInstance.update(
    {
      paid: true,
      validationStatus: "Valid",
      flwRef: paymentData.flw_ref,
      currency: paymentData.currency,
    },
    {
      where: { id: tx_ref },
    }
  );

  const ticket = (await TicketInstance.findOne({
    where: { id: tx_ref },
  })) as unknown as TicketAttribute;
  const event = (await EventInstance.findOne({
    where: { id: ticket?.eventId },
  })) as unknown as EventAttribute;

  if (event) {
    if (event.quantity <= 0) {
      throw new Error("Event is sold out");
    }

    await EventInstance.update(
      {
        quantity: event.quantity - 1,
        sold: event.sold + 1,
      },
      { where: { id: ticket?.eventId } }
    );
  }

  res.redirect(`${FRONTEND_URL}/payment-success`);
} else {
  throw new Error("Transaction reference mismatch");
}