openblox/dist/http/httpHandler/httpHandler.js

Roblox API Wrapper For Both Classic And OpenCloud APIs.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var httpHandler_exports = {};
__export(httpHandler_exports, {
  HttpHandler: () => HttpHandler,
  detectBEDEVVersionForUrl: () => detectBEDEVVersionForUrl,
  getParsedErrors: () => getParsedErrors,
  isOpenCloudUrl: () => isOpenCloudUrl
});
module.exports = __toCommonJS(httpHandler_exports);
var import_parse_roblox_errors = require("parse-roblox-errors");
var import_http = require("../http.utils");
var import_fetchHttpAdapter = require("../httpAdapters/fetchHttpAdapter");
var import_config = require("../../config");
var import_utils = require("../../utils/utils");
let savedCsrfToken = "";
const isOpenCloudUrl = (url) => url.startsWith("https://apis.roblox.com/cloud") || url.startsWith("https://apis.roblox.com/datastore") || url.startsWith("https://apis.roblox.com/messaging-service") || url.startsWith("https://apis.roblox.com/ordered-data-stores") || url.startsWith("https://apis.roblox.com/assets");
const detectBEDEVVersionForUrl = (url) => {
  const urlObject = new URL(url);
  if (urlObject.host == "apis.roblox.com") return 2;
  if (urlObject.host.endsWith(".roblox.com")) return 1;
  return void 0;
};
const getParsedErrors = async (response) => {
  const BEDEVVersion = detectBEDEVVersionForUrl(response.url);
  return BEDEVVersion == 1 ? await (0, import_parse_roblox_errors.parseBEDEV1ErrorFromStringAndHeaders)(JSON.stringify(response.body), response.headers) : BEDEVVersion == 2 ? await (0, import_parse_roblox_errors.parseBEDEV2ErrorFromStringAndHeaders)(JSON.stringify(response.body), response.headers) : void 0;
};
function stringToArrayBuffer(str) {
  const buf = new ArrayBuffer(str.length);
  const bufView = new Uint8Array(buf);
  for (let i = 0, strLen = str.length; i < strLen; i++) {
    bufView[i] = str.charCodeAt(i);
  }
  return buf;
}
const arrayBufferToString = (buf) => String.fromCharCode.apply(null, new Uint8Array(buf));
const exportPrivateKey = async (key) => btoa(arrayBufferToString(await crypto.subtle.exportKey("pkcs8", key)));
const exportPublicKey = async (key) => btoa(arrayBufferToString(await crypto.subtle.exportKey("spki", key)));
const importPrivateKey = async (key) => await crypto.subtle.importKey(
  "pkcs8",
  stringToArrayBuffer(atob(key)),
  { name: "ECDSA", namedCurve: "P-256" },
  true,
  ["sign"]
);
const importPublicKey = async (key) => await crypto.subtle.importKey(
  "spki",
  stringToArrayBuffer(atob(key)),
  { name: "ECDSA", namedCurve: "P-256" },
  true,
  []
);
const createHbaKeys = async () => {
  const keyPair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign"]);
  return {
    private: await exportPrivateKey(keyPair.privateKey),
    public: await exportPublicKey(keyPair.publicKey)
  };
};
const importHbaKeys = async (keys) => {
  return { privateKey: await importPrivateKey(keys.private), publicKey: await importPublicKey(keys.public) };
};
const HttpHandler = async ({ url, method, headers, body, formData }) => {
  const headerCookie = headers?.Cookie;
  const configHttp = import_config.config?.http;
  const adapter = configHttp?.adapter || import_fetchHttpAdapter.FetchAdapter;
  const maxCsrfAttempts = configHttp?.csrfMaxAttempts || 2;
  let currentCsrfAttempt = 1;
  const requestData = {
    url,
    method,
    body: body?.constructor == Object || Array.isArray(body) ? JSON.stringify(body) : body,
    formData
  };
  const requestDataHeaders = (0, import_utils.removeNullUndefined)({
    "Content-Type": headers?.["Content-Type"] || (!formData && "application/json" || null),
    ...headers
  });
  const handlerMain = async () => {
    try {
      const response = await adapter({ ...requestData, headers: { ...requestDataHeaders, "x-csrf-token": savedCsrfToken } });
      if (!response.success) throw response;
      return response;
    } catch (error) {
      if (!(error instanceof import_http.HttpResponse)) throw error;
      if (currentCsrfAttempt > maxCsrfAttempts) throw new import_http.HttpError("Csrf", error, await getParsedErrors(error));
      const responseCsrfToken = error.headers.get("x-csrf-token");
      if (error.statusCode != 403 || !responseCsrfToken) {
        throw new import_http.HttpError("Generic", error, await getParsedErrors(error));
      } else {
        if (headerCookie == import_config.config?.cookie) savedCsrfToken = responseCsrfToken;
        currentCsrfAttempt++;
        return handlerMain();
      }
    }
  };
  return await handlerMain();
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  HttpHandler,
  detectBEDEVVersionForUrl,
  getParsedErrors,
  isOpenCloudUrl
});