onepay-sdk/dist/index.mjs

A simple payment gateway for Node.js

var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
  if (typeof require !== "undefined") return require.apply(this, arguments);
  throw Error('Dynamic require of "' + x + '" is not supported');
});

// src/functions.ts
import Stripe from "stripe";
import Razorpay from "razorpay";
var OnePay = class {
  gatewayInstances = {};
  apiSecrets = {};
  constructor(keys) {
    if (!keys || keys.length === 0) {
      throw new Error("At least one payment gateway configuration is required");
    }
    keys.forEach(({ gateway, apiKey, apiSecret }) => {
      if (!apiKey) {
        throw new Error(`API key is required for ${gateway}`);
      }
      switch (gateway) {
        case "stripe":
          this.gatewayInstances.stripe = new Stripe(apiKey);
          break;
        case "razorpay":
          if (!apiSecret) {
            throw new Error("API secret is required for Razorpay");
          }
          this.gatewayInstances.razorpay = new Razorpay({
            key_id: apiKey,
            key_secret: apiSecret
          });
          this.apiSecrets.razorpay = apiSecret;
          break;
        default:
          console.warn(`Unsupported gateway: ${gateway}`);
      }
    });
    if (Object.keys(this.gatewayInstances).length === 0) {
      throw new Error("No valid payment gateway configurations provided");
    }
  }
  async validateGateway(gateway) {
    switch (gateway) {
      case "stripe":
        return this.validateStripe();
      case "razorpay":
        return this.validateRazorpay();
      default:
        return { success: false, message: `Unsupported gateway: ${gateway}` };
    }
  }
  async validateStripe() {
    const stripe = this.gatewayInstances.stripe;
    if (!stripe) {
      return { success: false, message: "Stripe not initialized" };
    }
    try {
      const account = await stripe.accounts.retrieve();
      return { success: true, gateway: "stripe", account };
    } catch (error) {
      return {
        success: false,
        gateway: "stripe",
        message: error.message || "Failed to validate Stripe",
        type: error.type
      };
    }
  }
  async validateRazorpay() {
    const razorpay = this.gatewayInstances.razorpay;
    if (!razorpay) {
      return { success: false, message: "Razorpay not initialized" };
    }
    try {
      const payments = await razorpay.payments.all({ count: 1 });
      return {
        success: true,
        gateway: "razorpay",
        account: {
          validated: true,
          hasPayments: payments.items.length > 0
        }
      };
    } catch (error) {
      return {
        success: false,
        gateway: "razorpay",
        message: error.message || "Failed to validate Razorpay"
      };
    }
  }
  /**
   * Create a payment with the specified gateway
   */
  async createPayment(payload) {
    if (!payload || !payload.gateway) {
      return { success: false, gateway: "stripe", message: "Invalid payment payload" };
    }
    if (!payload.amount || payload.amount <= 0) {
      return { success: false, gateway: payload.gateway, message: "Invalid payment amount" };
    }
    if (!payload.currency) {
      return { success: false, gateway: payload.gateway, message: "Currency is required" };
    }
    try {
      switch (payload.gateway) {
        case "razorpay":
          return await this.createRazorpayPayment(payload);
        case "stripe":
          return await this.createStripePayment(payload);
        default:
          return { success: false, gateway: payload.gateway, message: "Unsupported gateway" };
      }
    } catch (error) {
      return {
        success: false,
        gateway: payload.gateway,
        message: error.message || "Failed to create payment",
        error
      };
    }
  }
  /**
   * Create a payment intent with Razorpay
   */
  async createRazorpayPayment(payload) {
    const razorpay = this.gatewayInstances.razorpay;
    if (!razorpay) {
      return { success: false, gateway: "razorpay", message: "Razorpay not initialized" };
    }
    try {
      const orderOptions = {
        amount: payload.amount * 100,
        // Razorpay requires amount in paise (cents)
        currency: payload.currency.toUpperCase(),
        receipt: payload.receiptId || "receipt_" + Math.floor(Math.random() * 1e4),
        payment_capture: true,
        notes: payload.metadata || {}
      };
      const order = await razorpay.orders.create(orderOptions);
      return {
        success: true,
        gateway: "razorpay",
        order,
        orderId: order.id
      };
    } catch (error) {
      return {
        success: false,
        gateway: "razorpay",
        message: error.message || "Failed to create Razorpay payment",
        error
      };
    }
  }
  /**
   * Create a payment intent with Stripe
   */
  async createStripePayment(payload) {
    const stripe = this.gatewayInstances.stripe;
    if (!stripe) {
      return { success: false, gateway: "stripe", message: "Stripe not initialized" };
    }
    try {
      const paymentIntentOptions = {
        amount: Math.round(payload.amount * 100),
        // Stripe requires amount in cents
        currency: payload.currency.toLowerCase(),
        description: payload.description,
        receipt_email: payload.customerEmail,
        metadata: payload.metadata
      };
      if (payload.paymentMethodTypes && payload.paymentMethodTypes.length > 0) {
        paymentIntentOptions.payment_method_types = payload.paymentMethodTypes;
      }
      if (payload.customerId) {
        paymentIntentOptions.customer = payload.customerId;
      }
      const paymentIntent = await stripe.paymentIntents.create(paymentIntentOptions);
      return {
        success: true,
        gateway: "stripe",
        clientSecret: paymentIntent.client_secret || void 0,
        paymentIntentId: paymentIntent.id
      };
    } catch (error) {
      return {
        success: false,
        gateway: "stripe",
        message: error.message || "Failed to create Stripe payment",
        error
      };
    }
  }
  /**
   * Verify a payment
   */
  async verifyPayment(payload) {
    if (!payload.paymentId) {
      return { success: false, gateway: payload.gateway, message: "Payment ID is required" };
    }
    try {
      switch (payload.gateway) {
        case "razorpay":
          return await this.verifyRazorpayPayment(payload);
        case "stripe":
          return await this.verifyStripePayment(payload);
        default:
          return { success: false, gateway: payload.gateway, message: "Unsupported gateway" };
      }
    } catch (error) {
      return {
        success: false,
        gateway: payload.gateway,
        message: error.message || "Failed to verify payment",
        error
      };
    }
  }
  async verifyRazorpayPayment(payload) {
    const razorpay = this.gatewayInstances.razorpay;
    const apiSecret = this.apiSecrets.razorpay;
    if (!razorpay) {
      return { success: false, gateway: "razorpay", message: "Razorpay not initialized" };
    }
    if (!apiSecret) {
      return { success: false, gateway: "razorpay", message: "Razorpay API secret not available" };
    }
    if (!payload.orderId || !payload.signature) {
      return { success: false, gateway: "razorpay", message: "Order ID and signature are required for Razorpay verification" };
    }
    try {
      const generated_signature = __require("crypto").createHmac("sha256", apiSecret).update(payload.orderId + "|" + payload.paymentId).digest("hex");
      if (generated_signature !== payload.signature) {
        return { success: false, gateway: "razorpay", message: "Invalid signature" };
      }
      const payment = await razorpay.payments.fetch(payload.paymentId);
      return {
        success: true,
        gateway: "razorpay",
        order: payment
      };
    } catch (error) {
      return {
        success: false,
        gateway: "razorpay",
        message: error.message || "Failed to verify Razorpay payment",
        error
      };
    }
  }
  async verifyStripePayment(payload) {
    const stripe = this.gatewayInstances.stripe;
    if (!stripe) {
      return { success: false, gateway: "stripe", message: "Stripe not initialized" };
    }
    try {
      const paymentIntent = await stripe.paymentIntents.retrieve(payload.paymentId);
      if (paymentIntent.status === "succeeded") {
        return {
          success: true,
          gateway: "stripe",
          clientSecret: paymentIntent.client_secret || void 0,
          paymentIntentId: paymentIntent.id
        };
      } else {
        return {
          success: false,
          gateway: "stripe",
          message: `Payment not completed. Status: ${paymentIntent.status}`,
          clientSecret: paymentIntent.client_secret || void 0,
          paymentIntentId: paymentIntent.id
        };
      }
    } catch (error) {
      return {
        success: false,
        gateway: "stripe",
        message: error.message || "Failed to verify Stripe payment",
        error
      };
    }
  }
  /**
   * Refund a payment
   */
  async refundPayment(gateway, paymentId, amount) {
    if (!paymentId) {
      return { success: false, gateway, message: "Payment ID is required" };
    }
    try {
      switch (gateway) {
        case "razorpay":
          return await this.refundRazorpayPayment(paymentId, amount);
        case "stripe":
          return await this.refundStripePayment(paymentId, amount);
        default:
          return { success: false, gateway, message: "Unsupported gateway" };
      }
    } catch (error) {
      return {
        success: false,
        gateway,
        message: error.message || "Failed to refund payment",
        error
      };
    }
  }
  async refundRazorpayPayment(paymentId, amount) {
    const razorpay = this.gatewayInstances.razorpay;
    if (!razorpay) {
      return { success: false, gateway: "razorpay", message: "Razorpay not initialized" };
    }
    try {
      const refundOptions = {};
      if (amount) {
        refundOptions.amount = amount * 100;
      }
      const refund = await razorpay.payments.refund(paymentId, refundOptions);
      return {
        success: true,
        gateway: "razorpay",
        order: refund
      };
    } catch (error) {
      return {
        success: false,
        gateway: "razorpay",
        message: error.message || "Failed to refund Razorpay payment",
        error
      };
    }
  }
  async refundStripePayment(paymentId, amount) {
    const stripe = this.gatewayInstances.stripe;
    if (!stripe) {
      return { success: false, gateway: "stripe", message: "Stripe not initialized" };
    }
    try {
      const refundOptions = {
        payment_intent: paymentId
      };
      if (amount) {
        refundOptions.amount = Math.round(amount * 100);
      }
      const refund = await stripe.refunds.create(refundOptions);
      return {
        success: true,
        gateway: "stripe",
        clientSecret: refund.id
      };
    } catch (error) {
      return {
        success: false,
        gateway: "stripe",
        message: error.message || "Failed to refund Stripe payment",
        error
      };
    }
  }
  /**
   * Get payment details
   */
  async getPaymentDetails(gateway, paymentId) {
    if (!paymentId) {
      return { success: false, gateway, message: "Payment ID is required" };
    }
    try {
      switch (gateway) {
        case "razorpay":
          return await this.getRazorpayPaymentDetails(paymentId);
        case "stripe":
          return await this.getStripePaymentDetails(paymentId);
        default:
          return { success: false, gateway, message: "Unsupported gateway" };
      }
    } catch (error) {
      return {
        success: false,
        gateway,
        message: error.message || "Failed to get payment details",
        error
      };
    }
  }
  async getRazorpayPaymentDetails(paymentId) {
    const razorpay = this.gatewayInstances.razorpay;
    if (!razorpay) {
      return { success: false, gateway: "razorpay", message: "Razorpay not initialized" };
    }
    try {
      const payment = await razorpay.payments.fetch(paymentId);
      return {
        success: true,
        gateway: "razorpay",
        order: payment
      };
    } catch (error) {
      return {
        success: false,
        gateway: "razorpay",
        message: error.message || "Failed to get Razorpay payment details",
        error
      };
    }
  }
  async getStripePaymentDetails(paymentId) {
    const stripe = this.gatewayInstances.stripe;
    if (!stripe) {
      return { success: false, gateway: "stripe", message: "Stripe not initialized" };
    }
    try {
      const paymentIntent = await stripe.paymentIntents.retrieve(paymentId);
      return {
        success: true,
        gateway: "stripe",
        clientSecret: paymentIntent.client_secret || void 0,
        paymentIntentId: paymentIntent.id
      };
    } catch (error) {
      return {
        success: false,
        gateway: "stripe",
        message: error.message || "Failed to get Stripe payment details",
        error
      };
    }
  }
};
export {
  OnePay
};