better-payment/dist/adapters/next-js.js

Unified payment gateway library for Turkish payment providers

'use strict';

var server = require('next/server');

// src/adapters/next-js.ts
function toNextJsHandler(handler) {
  const routeHandler = async (request) => {
    try {
      const betterPayRequest = {
        method: request.method,
        url: request.url,
        headers: Object.fromEntries(request.headers.entries()),
        body: await parseBody(request)
      };
      const response = await handler.handle(betterPayRequest);
      return server.NextResponse.json(response.body, {
        status: response.status,
        headers: response.headers
      });
    } catch (error) {
      return server.NextResponse.json(
        {
          error: true,
          message: error.message || "Internal server error"
        },
        { status: 500 }
      );
    }
  };
  return {
    GET: routeHandler,
    POST: routeHandler
  };
}
async function parseBody(request) {
  const contentType = request.headers.get("content-type") || "";
  if (request.method === "GET") {
    const searchParams = new URL(request.url).searchParams;
    const params = {};
    searchParams.forEach((value, key) => {
      params[key] = value;
    });
    return Object.keys(params).length > 0 ? params : void 0;
  }
  if (contentType.includes("application/json")) {
    try {
      return await request.json();
    } catch {
      return void 0;
    }
  }
  if (contentType.includes("application/x-www-form-urlencoded")) {
    const formData = await request.formData();
    const params = {};
    formData.forEach((value, key) => {
      params[key] = value;
    });
    return params;
  }
  try {
    const text = await request.text();
    return text || void 0;
  } catch {
    return void 0;
  }
}
function toNodeHandler(handler) {
  return async (req, res) => {
    try {
      const protocol = req.headers["x-forwarded-proto"] || "http";
      const host = req.headers["x-forwarded-host"] || req.headers.host;
      const url = `${protocol}://${host}${req.url}`;
      const betterPayRequest = {
        method: req.method || "GET",
        url,
        headers: req.headers,
        body: await parseNodeBody(req)
      };
      const response = await handler.handle(betterPayRequest);
      Object.entries(response.headers).forEach(([key, value]) => {
        res.setHeader(key, value);
      });
      res.status(response.status).json(response.body);
    } catch (error) {
      res.status(500).json({
        error: true,
        message: error.message || "Internal server error"
      });
    }
  };
}
async function parseNodeBody(req) {
  if (req.method === "GET") {
    return Object.keys(req.query).length > 0 ? req.query : void 0;
  }
  if (req.body && Object.keys(req.body).length > 0) {
    return req.body;
  }
  return new Promise((resolve) => {
    let body = "";
    req.on("data", (chunk) => {
      body += chunk.toString();
    });
    req.on("end", () => {
      try {
        resolve(body ? JSON.parse(body) : void 0);
      } catch {
        resolve(body || void 0);
      }
    });
  });
}

exports.toNextJsHandler = toNextJsHandler;
exports.toNodeHandler = toNodeHandler;
//# sourceMappingURL=next-js.js.map
//# sourceMappingURL=next-js.js.map