@multiplatform.one/typegraphql/lib/chunk-BD4RFFYJ.js

typegraphql for multiplatform.one

import {
  __name
} from "./chunk-SHUYVCID.js";

// src/axios.ts
import axios, { AxiosError } from "axios";
import httpStatus from "http-status";
import { LogLevel } from "multiplatform.one";
var registeredAxiosInterceptors = false;
function initializeAxiosLogger(options, logger) {
  options = {
    data: false,
    errorLogLevel: LogLevel.Error,
    headers: false,
    kind: true,
    method: true,
    requestLogLevel: LogLevel.Debug,
    responseLogLevel: LogLevel.Debug,
    secretMask: true,
    status: true,
    url: true,
    ...options
  };
  if (!registeredAxiosInterceptors) {
    axios.interceptors.request.use((request) => requestLogger(request, options, logger), (error) => errorLogger(error, options, logger));
    axios.interceptors.response.use((response) => responseLogger(response, options, logger), (error) => errorLogger(error, options, logger));
    registeredAxiosInterceptors = true;
  }
}
__name(initializeAxiosLogger, "initializeAxiosLogger");
function getLoggerMethod(level) {
  switch (level) {
    case LogLevel.Trace:
      return "trace";
    case LogLevel.Debug:
      return "debug";
    case LogLevel.Info:
      return "info";
    case LogLevel.Warn:
      return "warn";
    case LogLevel.Error:
      return "error";
    default:
      return "info";
  }
}
__name(getLoggerMethod, "getLoggerMethod");
function requestLogger(request, options, logger) {
  if (request.silent) return request;
  let message = `[Request]${options.method ? ` ${request.method?.toUpperCase()}` : ""}${options.url ? ` ${request.url}` : ""}`;
  if (typeof options.request === "function") {
    message = options.request(request, options);
  }
  const method = options.requestLogLevel ? getLoggerMethod(options.requestLogLevel) : "debug";
  logger[method]({
    ...options.data ? {
      data: request.data
    } : {},
    ...options.headers ? {
      headers: formatHeaders(request.headers, options.secretMask)
    } : {},
    ...options.kind ? {
      kind: "HTTP_REQUEST"
    } : {},
    ...options.method ? {
      method: request.method?.toUpperCase()
    } : {},
    ...options.url ? {
      url: request.url
    } : {}
  }, message);
  return request;
}
__name(requestLogger, "requestLogger");
function responseLogger(response, options, logger) {
  if (response?.config?.silent) return response;
  const url = response.request?.url || response.request?.res?.responseUrl;
  const statusName = httpStatus[response.status];
  let message = `[Response]${options.method ? ` ${response.request?.method?.toUpperCase()}` : ""}${options.url && url ? ` ${url}` : ""}${options.status ? ` ${response.status}` : ""}${statusName ? `:${statusName}` : ""}`;
  if (typeof options.response === "function") {
    message = options.response(response, options);
  }
  const method = options.responseLogLevel ? getLoggerMethod(options.responseLogLevel) : "debug";
  logger[method]({
    ...options.data ? {
      data: response.data
    } : {},
    ...options.headers ? {
      headers: formatHeaders(response.headers, options.secretMask)
    } : {},
    ...options.kind ? {
      kind: "HTTP_RESPONSE"
    } : {},
    ...options.method ? {
      method: response.request?.method?.toUpperCase()
    } : {},
    ...options.status ? {
      status: response.status
    } : {},
    ...options.url && url ? {
      url
    } : {}
  }, message);
  return response;
}
__name(responseLogger, "responseLogger");
function errorLogger(err, options, logger) {
  if (err?.config?.silent) throw err;
  let errOrStr = err;
  if (options.error) {
    errOrStr = options.error(errOrStr, options);
  }
  const error = typeof errOrStr === "object" ? errOrStr : new AxiosError(errOrStr);
  const url = error.request?.url || error.request?.res?.responseUrl;
  const method = options.errorLogLevel ? getLoggerMethod(options.errorLogLevel) : "error";
  logger[method]({
    ...options.data ? {
      data: error?.response?.data
    } : {},
    ...options.headers ? {
      headers: formatHeaders(error?.response?.headers, options.secretMask)
    } : {},
    ...options.kind ? {
      kind: "HTTP_ERROR"
    } : {},
    ...options.method ? {
      method: error?.request?.method?.toUpperCase()
    } : {},
    ...options.status ? {
      status: error?.response?.status
    } : {},
    ...options.url && url ? {
      url
    } : {}
  }, error);
  throw err;
}
__name(errorLogger, "errorLogger");
function formatHeaders(headers, secretMask = false) {
  headers = Object.entries(headers).reduce((headers2, [key, value]) => {
    if (!validHeader(key, value)) return headers2;
    if (typeof value === "object") {
      headers2 = Object.assign(headers2, {
        ...Object.entries(value).reduce((headers3, [key2, value2]) => {
          if (!validHeader(key2, value2)) return headers3;
          [key2, value2] = formatHeader(key2, value2, secretMask);
          headers3[key2] = value2;
          return headers3;
        }, {})
      });
    } else {
      [key, value] = formatHeader(key, value, secretMask);
      headers2[key] = value;
    }
    return headers2;
  }, {});
  if (Object.keys(headers).length) return headers;
  return void 0;
}
__name(formatHeaders, "formatHeaders");
function validHeader(key, value) {
  return typeof value === "string" && typeof key === "string" && value && key && Number.isNaN(Number.parseInt(key[0], 10));
}
__name(validHeader, "validHeader");
function formatHeader(key, value, secretMask = false) {
  key = key.replace(/(^|[\s_-])\S/g, (s) => s.toUpperCase());
  if (!secretMask) return [
    key,
    value
  ];
  if (typeof secretMask === "boolean") secretMask = "*****";
  if (key === "Authorization") {
    const valueArr = value.split(/ +/g);
    if (valueArr.length <= 1) {
      value = secretMask;
    } else if (valueArr.length === 2) {
      value = `${valueArr[0]} ${secretMask}`;
    }
  }
  return [
    key,
    value
  ];
}
__name(formatHeader, "formatHeader");

export {
  initializeAxiosLogger
};