9pay-integrate 1.0.0

package/dist/next/index.cjs

@@ -0,0 +1,278 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  handle9PayIpn: () => handle9PayIpn,
+  handlePaymentStatus: () => handlePaymentStatus,
+  verifyNinePayCallback: () => verifyNinePayCallback
+});
+module.exports = __toCommonJS(next_exports);
+
+// src/next/handlers.ts
+var import_server = require("next/server");
+
+// src/core/verification.ts
+var crypto = __toESM(require("crypto"), 1);
+function verifyChecksum(result, checksum, checksumKey) {
+  if (!result || !checksum) {
+    return { valid: false, data: null, error: "Missing result or checksum" };
+  }
+  const expected = crypto.createHash("sha256").update(result + checksumKey).digest("hex").toUpperCase();
+  if (expected !== checksum) {
+    return { valid: false, data: null, error: "Checksum mismatch" };
+  }
+  try {
+    const decoded = JSON.parse(
+      Buffer.from(result, "base64").toString("utf-8")
+    );
+    return { valid: true, data: decoded };
+  } catch {
+    return { valid: false, data: null, error: "Failed to decode result" };
+  }
+}
+
+// src/core/verify-callback.ts
+function verifyCallback(searchParams, config) {
+  const result = searchParams.get("result") || "";
+  const checksum = searchParams.get("checksum") || "";
+  const verification = verifyChecksum(result, checksum, config.checksumKey);
+  if (!verification.valid || !verification.data) {
+    return {
+      success: false,
+      rawParams: {},
+      error: verification.error || "Invalid callback payload"
+    };
+  }
+  const paymentInfo = verification.data;
+  const invoiceNo = paymentInfo.invoice_no;
+  const orderId = typeof invoiceNo === "string" && invoiceNo.trim().length > 0 ? invoiceNo : typeof invoiceNo === "number" ? String(invoiceNo) : null;
+  if (!orderId) {
+    return {
+      success: false,
+      rawParams: paymentInfo,
+      error: "Missing invoice_no in callback payload"
+    };
+  }
+  return {
+    success: true,
+    orderId,
+    amount: Number(paymentInfo.amount ?? 0),
+    currency: String(paymentInfo.currency ?? ""),
+    status: Number(paymentInfo.status ?? 0),
+    rawParams: paymentInfo
+  };
+}
+
+// src/core/constants.ts
+var NINEPAY_STATUS = {
+  PENDING: 1,
+  PROCESSING: 2,
+  CANCELLED: 3,
+  REFUNDED: 4,
+  SUCCESS: 5,
+  FAILED: 6
+};
+var SUCCESS_STATUS = NINEPAY_STATUS.SUCCESS;
+
+// src/core/ipn-processor.ts
+async function processIpn(payload, options) {
+  const { config, orderRepository, notifications } = options;
+  const verification = verifyChecksum(
+    payload.result,
+    payload.checksum,
+    config.checksumKey
+  );
+  if (!verification.valid || !verification.data) {
+    return {
+      success: false,
+      message: verification.error || "Invalid checksum",
+      statusCode: 403
+    };
+  }
+  const paymentInfo = verification.data;
+  const invoiceNo = paymentInfo.invoice_no;
+  const orderId = typeof invoiceNo === "string" && invoiceNo.trim().length > 0 ? invoiceNo : typeof invoiceNo === "number" ? String(invoiceNo) : null;
+  if (!orderId) {
+    return {
+      success: false,
+      message: "Missing invoice_no in IPN payload",
+      statusCode: 400
+    };
+  }
+  const isSuccess = Number(paymentInfo.status) === SUCCESS_STATUS;
+  const amount = Number(paymentInfo.amount ?? 0);
+  const currency = String(paymentInfo.currency ?? "");
+  if (isSuccess) {
+    try {
+      await orderRepository.updateOrderStatus(orderId, "completed");
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to update order: ${error instanceof Error ? error.message : String(error)}`,
+        statusCode: 500,
+        orderId
+      };
+    }
+    if (notifications?.onSuccess) {
+      try {
+        await notifications.onSuccess({
+          orderId,
+          status: "completed",
+          amount,
+          currency,
+          paymentMethod: "9pay",
+          metadata: paymentInfo
+        });
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      message: "Order updated successfully",
+      statusCode: 200,
+      orderId
+    };
+  }
+  try {
+    await orderRepository.updateOrderStatus(orderId, "failed");
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to update order: ${error instanceof Error ? error.message : String(error)}`,
+      statusCode: 500,
+      orderId
+    };
+  }
+  if (notifications?.onFailure) {
+    try {
+      await notifications.onFailure({
+        orderId,
+        status: "failed",
+        amount,
+        currency,
+        paymentMethod: "9pay",
+        metadata: paymentInfo
+      });
+    } catch {
+    }
+  }
+  return {
+    success: false,
+    message: "Payment failed",
+    statusCode: 200,
+    orderId
+  };
+}
+
+// src/core/ipn.ts
+function extractIpnFromFormData(formData) {
+  return {
+    result: String(formData.get("result") || ""),
+    checksum: String(formData.get("checksum") || "")
+  };
+}
+function extractIpnFromUrlEncoded(body) {
+  const params = new URLSearchParams(body);
+  return {
+    result: params.get("result") || "",
+    checksum: params.get("checksum") || ""
+  };
+}
+
+// src/next/handlers.ts
+function verifyNinePayCallback(request, config) {
+  const { searchParams } = new URL(request.url);
+  return verifyCallback(searchParams, config);
+}
+async function parseIpnRequest(request) {
+  const contentType = request.headers.get("content-type") || "";
+  if (contentType.includes("multipart/form-data")) {
+    const formData = await request.formData();
+    const extracted = extractIpnFromFormData(formData);
+    return extracted;
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const body = await request.text();
+    const extracted = extractIpnFromUrlEncoded(body);
+    return extracted;
+  }
+  throw new Error(`Unsupported IPN content-type: ${contentType || "unknown"}`);
+}
+async function handle9PayIpn(request, options) {
+  try {
+    const payload = await parseIpnRequest(request);
+    const result = await processIpn(payload, {
+      config: options.config,
+      orderRepository: options.orderRepository,
+      notifications: options.notifications
+    });
+    return import_server.NextResponse.json(
+      { success: result.success, message: result.message },
+      { status: result.statusCode }
+    );
+  } catch {
+    return import_server.NextResponse.json(
+      { success: false, message: "Unsupported or invalid form payload" },
+      { status: 400 }
+    );
+  }
+}
+async function handlePaymentStatus(request, options) {
+  const { searchParams } = new URL(request.url);
+  const orderId = searchParams.get("orderId");
+  if (!orderId) {
+    return import_server.NextResponse.json(
+      { success: false, message: "Missing orderId" },
+      { status: 400 }
+    );
+  }
+  try {
+    const status = await options.orderRepository.getOrderStatus(orderId);
+    if (status === null) {
+      return import_server.NextResponse.json(
+        { success: false, message: "Order not found" },
+        { status: 404 }
+      );
+    }
+    return import_server.NextResponse.json({ success: true, status });
+  } catch {
+    return import_server.NextResponse.json(
+      { success: false, message: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle9PayIpn,
+  handlePaymentStatus,
+  verifyNinePayCallback
+});

package/dist/next/index.d.cts

@@ -0,0 +1,101 @@
+import { NextResponse } from 'next/server';
+
+/**
+ * Core type definitions for 9Pay integration.
+ * Framework-agnostic — no Next.js, React, or Express dependencies.
+ */
+interface NinePayConfig {
+    merchantKey: string;
+    secretKey: string;
+    checksumKey: string;
+    baseUrl?: string;
+    returnUrl: string;
+    cancelUrl?: string;
+}
+interface VerifyCallbackResult {
+    success: boolean;
+    orderId?: string;
+    amount?: number;
+    currency?: string;
+    status?: number;
+    /** Raw decoded payload for consumer access */
+    rawParams: Record<string, unknown>;
+    error?: string;
+}
+type OrderStatus = "neworder" | "pending" | "completed" | "failed";
+interface CreateOrderParams {
+    orderId?: string;
+    totalAmount: number;
+    currency: string;
+    paymentMethod: string;
+    metadata?: Record<string, unknown>;
+}
+interface OrderRepository<TOrder = unknown> {
+    createOrder(params: CreateOrderParams): Promise<TOrder>;
+    getOrderStatus(orderId: string): Promise<OrderStatus | null>;
+    updateOrderStatus(orderId: string, status: "completed" | "failed"): Promise<TOrder | null>;
+}
+interface NotificationContext {
+    orderId: string;
+    status: "completed" | "failed";
+    amount: number;
+    currency: string;
+    paymentMethod: string;
+    metadata?: Record<string, unknown>;
+}
+type NotificationHandler = (ctx: NotificationContext) => Promise<void> | void;
+interface NotificationHooks {
+    onSuccess?: NotificationHandler;
+    onFailure?: NotificationHandler;
+}
+
+/**
+ * Verify 9Pay browser redirect callback (GET /api/checkout/9pay/callback).
+ *
+ * Returns a result object — consumer decides the redirect target.
+ * This is Option B: package does NOT redirect, only verifies and returns data.
+ *
+ * Example consumer usage:
+ *   const result = verifyNinePayCallback(request, config);
+ *   if (!result.success) return NextResponse.redirect(new URL("/payment/error", request.url));
+ *   return NextResponse.redirect(new URL(`/payment/process?orderId=${result.orderId}`, request.url));
+ */
+declare function verifyNinePayCallback(request: Request, config: NinePayConfig): VerifyCallbackResult;
+/**
+ * Handle 9Pay IPN webhook (POST /api/checkout/9pay/ipn).
+ *
+ * This is Option C: the handler encapsulates all 6 steps:
+ *  1. Parse request (content-type detection + extraction)
+ *  2. Verify checksum (via core)
+ *  3. Decode payment info
+ *  4. Call orderRepository.updateOrderStatus()
+ *  5. Call notification hooks
+ *  6. Return NextResponse with appropriate status code
+ *
+ * Consumer usage:
+ *   export async function POST(request: Request) {
+ *     return handle9PayIpn(request, {
+ *       config,
+ *       orderRepository: repo,
+ *       notifications: { onSuccess, onFailure },
+ *     });
+ *   }
+ */
+declare function handle9PayIpn(request: Request, options: {
+    config: NinePayConfig;
+    orderRepository: OrderRepository;
+    notifications?: NotificationHooks;
+}): Promise<NextResponse>;
+/**
+ * Handle payment status polling (GET /api/payment/status).
+ *
+ * Consumer usage:
+ *   export async function GET(request: Request) {
+ *     return handlePaymentStatus(request, { orderRepository: repo });
+ *   }
+ */
+declare function handlePaymentStatus(request: Request, options: {
+    orderRepository: OrderRepository;
+}): Promise<NextResponse>;
+
+export { type NinePayConfig, type NotificationHooks, type OrderRepository, type VerifyCallbackResult, handle9PayIpn, handlePaymentStatus, verifyNinePayCallback };

package/dist/next/index.d.ts

@@ -0,0 +1,101 @@
+import { NextResponse } from 'next/server';
+
+/**
+ * Core type definitions for 9Pay integration.
+ * Framework-agnostic — no Next.js, React, or Express dependencies.
+ */
+interface NinePayConfig {
+    merchantKey: string;
+    secretKey: string;
+    checksumKey: string;
+    baseUrl?: string;
+    returnUrl: string;
+    cancelUrl?: string;
+}
+interface VerifyCallbackResult {
+    success: boolean;
+    orderId?: string;
+    amount?: number;
+    currency?: string;
+    status?: number;
+    /** Raw decoded payload for consumer access */
+    rawParams: Record<string, unknown>;
+    error?: string;
+}
+type OrderStatus = "neworder" | "pending" | "completed" | "failed";
+interface CreateOrderParams {
+    orderId?: string;
+    totalAmount: number;
+    currency: string;
+    paymentMethod: string;
+    metadata?: Record<string, unknown>;
+}
+interface OrderRepository<TOrder = unknown> {
+    createOrder(params: CreateOrderParams): Promise<TOrder>;
+    getOrderStatus(orderId: string): Promise<OrderStatus | null>;
+    updateOrderStatus(orderId: string, status: "completed" | "failed"): Promise<TOrder | null>;
+}
+interface NotificationContext {
+    orderId: string;
+    status: "completed" | "failed";
+    amount: number;
+    currency: string;
+    paymentMethod: string;
+    metadata?: Record<string, unknown>;
+}
+type NotificationHandler = (ctx: NotificationContext) => Promise<void> | void;
+interface NotificationHooks {
+    onSuccess?: NotificationHandler;
+    onFailure?: NotificationHandler;
+}
+
+/**
+ * Verify 9Pay browser redirect callback (GET /api/checkout/9pay/callback).
+ *
+ * Returns a result object — consumer decides the redirect target.
+ * This is Option B: package does NOT redirect, only verifies and returns data.
+ *
+ * Example consumer usage:
+ *   const result = verifyNinePayCallback(request, config);
+ *   if (!result.success) return NextResponse.redirect(new URL("/payment/error", request.url));
+ *   return NextResponse.redirect(new URL(`/payment/process?orderId=${result.orderId}`, request.url));
+ */
+declare function verifyNinePayCallback(request: Request, config: NinePayConfig): VerifyCallbackResult;
+/**
+ * Handle 9Pay IPN webhook (POST /api/checkout/9pay/ipn).
+ *
+ * This is Option C: the handler encapsulates all 6 steps:
+ *  1. Parse request (content-type detection + extraction)
+ *  2. Verify checksum (via core)
+ *  3. Decode payment info
+ *  4. Call orderRepository.updateOrderStatus()
+ *  5. Call notification hooks
+ *  6. Return NextResponse with appropriate status code
+ *
+ * Consumer usage:
+ *   export async function POST(request: Request) {
+ *     return handle9PayIpn(request, {
+ *       config,
+ *       orderRepository: repo,
+ *       notifications: { onSuccess, onFailure },
+ *     });
+ *   }
+ */
+declare function handle9PayIpn(request: Request, options: {
+    config: NinePayConfig;
+    orderRepository: OrderRepository;
+    notifications?: NotificationHooks;
+}): Promise<NextResponse>;
+/**
+ * Handle payment status polling (GET /api/payment/status).
+ *
+ * Consumer usage:
+ *   export async function GET(request: Request) {
+ *     return handlePaymentStatus(request, { orderRepository: repo });
+ *   }
+ */
+declare function handlePaymentStatus(request: Request, options: {
+    orderRepository: OrderRepository;
+}): Promise<NextResponse>;
+
+export { type NinePayConfig, type NotificationHooks, type OrderRepository, type VerifyCallbackResult, handle9PayIpn, handlePaymentStatus, verifyNinePayCallback };