@graphql-hive/logger/dist/index.cjs

'use strict';

function getDefaultExportFromCjs (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

function tryStringify (o) {
  try { return JSON.stringify(o) } catch(e) { return '"[Circular]"' }
}

var quickFormatUnescaped = format;

function format(f, args, opts) {
  var ss = (opts && opts.stringify) || tryStringify;
  var offset = 1;
  if (typeof f === 'object' && f !== null) {
    var len = args.length + offset;
    if (len === 1) return f
    var objects = new Array(len);
    objects[0] = ss(f);
    for (var index = 1; index < len; index++) {
      objects[index] = ss(args[index]);
    }
    return objects.join(' ')
  }
  if (typeof f !== 'string') {
    return f
  }
  var argLen = args.length;
  if (argLen === 0) return f
  var str = '';
  var a = 1 - offset;
  var lastPos = -1;
  var flen = (f && f.length) || 0;
  for (var i = 0; i < flen;) {
    if (f.charCodeAt(i) === 37 && i + 1 < flen) {
      lastPos = lastPos > -1 ? lastPos : 0;
      switch (f.charCodeAt(i + 1)) {
        case 100: // 'd'
        case 102: // 'f'
          if (a >= argLen)
            break
          if (args[a] == null)  break
          if (lastPos < i)
            str += f.slice(lastPos, i);
          str += Number(args[a]);
          lastPos = i + 2;
          i++;
          break
        case 105: // 'i'
          if (a >= argLen)
            break
          if (args[a] == null)  break
          if (lastPos < i)
            str += f.slice(lastPos, i);
          str += Math.floor(Number(args[a]));
          lastPos = i + 2;
          i++;
          break
        case 79: // 'O'
        case 111: // 'o'
        case 106: // 'j'
          if (a >= argLen)
            break
          if (args[a] === undefined) break
          if (lastPos < i)
            str += f.slice(lastPos, i);
          var type = typeof args[a];
          if (type === 'string') {
            str += '\'' + args[a] + '\'';
            lastPos = i + 2;
            i++;
            break
          }
          if (type === 'function') {
            str += args[a].name || '<anonymous>';
            lastPos = i + 2;
            i++;
            break
          }
          str += ss(args[a]);
          lastPos = i + 2;
          i++;
          break
        case 115: // 's'
          if (a >= argLen)
            break
          if (lastPos < i)
            str += f.slice(lastPos, i);
          str += String(args[a]);
          lastPos = i + 2;
          i++;
          break
        case 37: // '%'
          if (lastPos < i)
            str += f.slice(lastPos, i);
          str += '%';
          lastPos = i + 2;
          i++;
          a--;
          break
      }
      ++a;
    }
    ++i;
  }
  if (lastPos === -1)
    return f
  else if (lastPos < flen) {
    str += f.slice(lastPos);
  }

  return str
}

var format$1 = /*@__PURE__*/getDefaultExportFromCjs(quickFormatUnescaped);

var fastSafeStringify = stringify;
stringify.default = stringify;
stringify.stable = deterministicStringify;
stringify.stableStringify = deterministicStringify;

var LIMIT_REPLACE_NODE = '[...]';
var CIRCULAR_REPLACE_NODE = '[Circular]';

var arr = [];
var replacerStack = [];

function defaultOptions () {
  return {
    depthLimit: Number.MAX_SAFE_INTEGER,
    edgesLimit: Number.MAX_SAFE_INTEGER
  }
}

// Regular stringify
function stringify (obj, replacer, spacer, options) {
  if (typeof options === 'undefined') {
    options = defaultOptions();
  }

  decirc(obj, '', 0, [], undefined, 0, options);
  var res;
  try {
    if (replacerStack.length === 0) {
      res = JSON.stringify(obj, replacer, spacer);
    } else {
      res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
    }
  } catch (_) {
    return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]')
  } finally {
    while (arr.length !== 0) {
      var part = arr.pop();
      if (part.length === 4) {
        Object.defineProperty(part[0], part[1], part[3]);
      } else {
        part[0][part[1]] = part[2];
      }
    }
  }
  return res
}

function setReplace (replace, val, k, parent) {
  var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
  if (propertyDescriptor.get !== undefined) {
    if (propertyDescriptor.configurable) {
      Object.defineProperty(parent, k, { value: replace });
      arr.push([parent, k, val, propertyDescriptor]);
    } else {
      replacerStack.push([val, k, replace]);
    }
  } else {
    parent[k] = replace;
    arr.push([parent, k, val]);
  }
}

function decirc (val, k, edgeIndex, stack, parent, depth, options) {
  depth += 1;
  var i;
  if (typeof val === 'object' && val !== null) {
    for (i = 0; i < stack.length; i++) {
      if (stack[i] === val) {
        setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
        return
      }
    }

    if (
      typeof options.depthLimit !== 'undefined' &&
      depth > options.depthLimit
    ) {
      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
      return
    }

    if (
      typeof options.edgesLimit !== 'undefined' &&
      edgeIndex + 1 > options.edgesLimit
    ) {
      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
      return
    }

    stack.push(val);
    // Optimize for Arrays. Big arrays could kill the performance otherwise!
    if (Array.isArray(val)) {
      for (i = 0; i < val.length; i++) {
        decirc(val[i], i, i, stack, val, depth, options);
      }
    } else {
      var keys = Object.keys(val);
      for (i = 0; i < keys.length; i++) {
        var key = keys[i];
        decirc(val[key], key, i, stack, val, depth, options);
      }
    }
    stack.pop();
  }
}

// Stable-stringify
function compareFunction (a, b) {
  if (a < b) {
    return -1
  }
  if (a > b) {
    return 1
  }
  return 0
}

function deterministicStringify (obj, replacer, spacer, options) {
  if (typeof options === 'undefined') {
    options = defaultOptions();
  }

  var tmp = deterministicDecirc(obj, '', 0, [], undefined, 0, options) || obj;
  var res;
  try {
    if (replacerStack.length === 0) {
      res = JSON.stringify(tmp, replacer, spacer);
    } else {
      res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
    }
  } catch (_) {
    return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]')
  } finally {
    // Ensure that we restore the object as it was.
    while (arr.length !== 0) {
      var part = arr.pop();
      if (part.length === 4) {
        Object.defineProperty(part[0], part[1], part[3]);
      } else {
        part[0][part[1]] = part[2];
      }
    }
  }
  return res
}

function deterministicDecirc (val, k, edgeIndex, stack, parent, depth, options) {
  depth += 1;
  var i;
  if (typeof val === 'object' && val !== null) {
    for (i = 0; i < stack.length; i++) {
      if (stack[i] === val) {
        setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
        return
      }
    }
    try {
      if (typeof val.toJSON === 'function') {
        return
      }
    } catch (_) {
      return
    }

    if (
      typeof options.depthLimit !== 'undefined' &&
      depth > options.depthLimit
    ) {
      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
      return
    }

    if (
      typeof options.edgesLimit !== 'undefined' &&
      edgeIndex + 1 > options.edgesLimit
    ) {
      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
      return
    }

    stack.push(val);
    // Optimize for Arrays. Big arrays could kill the performance otherwise!
    if (Array.isArray(val)) {
      for (i = 0; i < val.length; i++) {
        deterministicDecirc(val[i], i, i, stack, val, depth, options);
      }
    } else {
      // Create a temporary object in the required way
      var tmp = {};
      var keys = Object.keys(val).sort(compareFunction);
      for (i = 0; i < keys.length; i++) {
        var key = keys[i];
        deterministicDecirc(val[key], key, i, stack, val, depth, options);
        tmp[key] = val[key];
      }
      if (typeof parent !== 'undefined') {
        arr.push([parent, k, val]);
        parent[k] = tmp;
      } else {
        return tmp
      }
    }
    stack.pop();
  }
}

// wraps replacer function to handle values we couldn't replace
// and mark them as replaced value
function replaceGetterValues (replacer) {
  replacer =
    typeof replacer !== 'undefined'
      ? replacer
      : function (k, v) {
        return v
      };
  return function (key, val) {
    if (replacerStack.length > 0) {
      for (var i = 0; i < replacerStack.length; i++) {
        var part = replacerStack[i];
        if (part[1] === key && part[0] === val) {
          val = part[2];
          replacerStack.splice(i, 1);
          break
        }
      }
    }
    return replacer.call(this, key, val)
  }
}

var fastSafeStringify$1 = /*@__PURE__*/getDefaultExportFromCjs(fastSafeStringify);

const logLevel = {
  trace: 0,
  debug: 1,
  info: 2,
  warn: 3,
  error: 4
};
function shouldLog(setLevel, loggingLevel) {
  return setLevel !== false && // logging is not disabled
  logLevel[setLevel] <= logLevel[loggingLevel];
}
function logLevelToString(level) {
  switch (level) {
    case "trace":
      return "TRC";
    case "debug":
      return "DBG";
    case "info":
      return "INF";
    case "warn":
      return "WRN";
    case "error":
      return "ERR";
    default:
      throw new Error(`Unknown log level "${level}"`);
  }
}
function isPromise(val) {
  const obj = Object(val);
  return typeof obj.then === "function" && typeof obj.catch === "function" && typeof obj.finally === "function";
}
function jsonStringify(val, pretty) {
  return fastSafeStringify$1(
    val,
    (_key, val2) => {
      if (val2 instanceof Error) {
        return objectifyError(val2);
      }
      return val2;
    },
    pretty ? 2 : void 0
  );
}
function parseAttrs(attrs, depth = 0) {
  if (depth > 10) {
    throw new Error("Too much recursion while unwrapping function attributes");
  }
  if (typeof attrs === "function") {
    return parseAttrs(attrs(), depth + 1);
  }
  if (Array.isArray(attrs)) {
    return attrs.map((val) => unwrapAttrVal(val, depth + 1));
  }
  if (Object.prototype.toString.call(attrs) === "[object Object]") {
    const unwrapped = {};
    for (const key of Object.keys(attrs)) {
      const val = attrs[key];
      unwrapped[key] = unwrapAttrVal(val, depth + 1);
    }
    return unwrapped;
  }
  return objectifyClass(attrs);
}
function unwrapAttrVal(attr, depth = 0) {
  if (depth > 10) {
    throw new Error(
      "Too much recursion while unwrapping function attribute values"
    );
  }
  if (!attr) {
    return attr;
  }
  if (isPrimitive(attr)) {
    return attr;
  }
  if (typeof attr === "function") {
    return unwrapAttrVal(attr(), depth + 1);
  }
  if (Array.isArray(attr)) {
    return attr.map((val) => unwrapAttrVal(val, depth + 1));
  }
  if (Object.prototype.toString.call(attr) === "[object Object]") {
    const unwrapped = {};
    for (const key of Object.keys(attr)) {
      const val = attr[key];
      unwrapped[key] = unwrapAttrVal(val, depth + 1);
    }
    return unwrapped;
  }
  return objectifyClass(attr);
}
function isPrimitive(val) {
  return val !== Object(val);
}
function objectifyClass(val) {
  if (!val) {
    return {};
  }
  const props = {};
  for (const propName of Object.getOwnPropertyNames(val)) {
    props[propName] = val[propName];
  }
  for (const protoPropName of Object.getOwnPropertyNames(
    Object.getPrototypeOf(val)
  )) {
    const propVal = val[protoPropName];
    if (typeof propVal === "function") {
      continue;
    }
    props[protoPropName] = propVal;
  }
  return {
    ...props,
    class: val.constructor.name
  };
}
function objectifyError(err) {
  return objectifyClass(err);
}
function getEnv(key) {
  return globalThis.process?.env?.[key] || // @ts-expect-error can exist in wrangler and maybe other runtimes
  globalThis.env?.[key] || // @ts-expect-error can exist in deno
  globalThis.Deno?.env?.get(key) || // @ts-expect-error could be
  globalThis[key];
}
function truthyEnv(key) {
  return ["1", "t", "true", "y", "yes"].includes(
    getEnv(key)?.toLowerCase() || ""
  );
}

class MemoryLogWriter {
  logs = [];
  write(level, attrs, msg) {
    this.logs.push({
      level,
      ...msg ? { msg } : {},
      ...attrs ? { attrs } : {}
    });
  }
  flush() {
  }
}
const asciMap = {
  timestamp: "\x1B[90m",
  // bright black
  trace: "\x1B[36m",
  // cyan
  debug: "\x1B[90m",
  // bright black
  info: "\x1B[32m",
  // green
  warn: "\x1B[33m",
  // yellow
  error: "\x1B[41;39m",
  // red; white
  message: "\x1B[1m",
  // bold
  reset: "\x1B[0m"
  // reset
};
class ConsoleLogWriter {
  #nocolor = (
    // no color if we're running in browser-like (edge) environments
    // TODO: is this the most accurate way to detect it?
    typeof process === "undefined" || // no color if https://no-color.org/
    truthyEnv("NO_COLOR")
  );
  color(style, text) {
    if (!text) {
      return text;
    }
    if (this.#nocolor) {
      return text;
    }
    return asciMap[style] + text + asciMap.reset;
  }
  write(level, attrs, msg) {
    console[level === "trace" ? "debug" : level](
      [
        this.color("timestamp", (/* @__PURE__ */ new Date()).toISOString()),
        this.color(level, logLevelToString(level)),
        this.color("message", msg),
        // we want to stringify because we want all properties (even nested ones)be properly displayed
        attrs ? jsonStringify(attrs, truthyEnv("LOG_JSON_PRETTY")) : void 0
      ].join(" ")
    );
  }
  flush() {
  }
}
class JSONLogWriter {
  write(level, attrs, msg) {
    console.log(
      jsonStringify(
        {
          ...attrs,
          level,
          ...msg ? { msg } : {},
          timestamp: (/* @__PURE__ */ new Date()).toISOString()
        },
        truthyEnv("LOG_JSON_PRETTY")
      )
    );
  }
  flush() {
  }
}

class Logger {
  #level;
  #prefix;
  #attrs;
  #writers;
  #pendingWrites = /* @__PURE__ */ new Set();
  constructor(opts = {}) {
    let logLevelEnv = getEnv("LOG_LEVEL");
    if (logLevelEnv && !(logLevelEnv in logLevel)) {
      throw new Error(
        `Invalid LOG_LEVEL environment variable "${logLevelEnv}". Must be one of: ${[...Object.keys(logLevel), "false"].join(",  ")}`
      );
    }
    this.#level = opts.level ?? logLevelEnv ?? (truthyEnv("DEBUG") ? "debug" : "info");
    this.#prefix = opts.prefix;
    this.#attrs = opts.attrs;
    this.#writers = opts.writers ?? [new ConsoleLogWriter()];
  }
  get prefix() {
    return this.#prefix;
  }
  get level() {
    return this.#level;
  }
  write(level, attrs, msg) {
    const pendingWrites = this.#writers.map((writer) => writer.write(level, attrs, msg)).filter(isPromise);
    for (const pendingWrite of pendingWrites) {
      this.#pendingWrites.add(pendingWrite);
      pendingWrite.catch(() => {
      });
      pendingWrite.finally(() => this.#pendingWrites.delete(pendingWrite));
    }
  }
  flush() {
    if (this.#pendingWrites.size) {
      return Promise.all(this.#pendingWrites).then(() => {
      });
    }
    return;
  }
  child(prefixOrAttrs, prefix) {
    if (typeof prefixOrAttrs === "string") {
      return new Logger({
        level: this.#level,
        prefix: (this.#prefix || "") + prefixOrAttrs,
        attrs: this.#attrs,
        writers: this.#writers
      });
    }
    return new Logger({
      level: this.#level,
      prefix: (this.#prefix || "") + (prefix || "") || void 0,
      attrs: { ...this.#attrs, ...prefixOrAttrs },
      writers: this.#writers
    });
  }
  log(level, maybeAttrsOrMsg, ...rest) {
    if (!shouldLog(this.#level, level)) {
      return;
    }
    let msg;
    let attrs;
    if (typeof maybeAttrsOrMsg === "string") {
      msg = maybeAttrsOrMsg;
    } else if (maybeAttrsOrMsg) {
      attrs = maybeAttrsOrMsg;
      if (typeof rest[0] === "string") {
        msg = rest.shift();
      }
    }
    if (this.#prefix) {
      msg = `${this.#prefix}${msg || ""}`.trim();
    }
    attrs = attrs ? parseAttrs(attrs) : attrs;
    attrs = this.#attrs ? { ...parseAttrs(this.#attrs), ...attrs } : attrs;
    msg = msg ? format$1(msg, rest) : msg;
    this.write(level, attrs, msg);
    if (truthyEnv("LOG_TRACE_LOGS")) {
      console.trace("\u{1F446}");
    }
  }
  trace(...args) {
    this.log(
      "trace",
      ...args
    );
  }
  debug(...args) {
    this.log(
      "debug",
      ...args
    );
  }
  info(...args) {
    this.log(
      "info",
      ...args
    );
  }
  warn(...args) {
    this.log(
      "warn",
      ...args
    );
  }
  error(...args) {
    this.log(
      "error",
      ...args
    );
  }
}

class LegacyLogger {
  #logger;
  constructor(logger) {
    this.#logger = logger;
  }
  static from(logger) {
    return new LegacyLogger(logger);
  }
  #log(level, ...[maybeMsgOrArg, ...restArgs]) {
    if (typeof maybeMsgOrArg === "string") {
      this.#logger.log(level, restArgs, maybeMsgOrArg);
    } else {
      if (restArgs.length) {
        this.#logger.log(level, [maybeMsgOrArg, ...restArgs]);
      } else {
        this.#logger.log(level, maybeMsgOrArg);
      }
    }
  }
  log(...args) {
    this.#log("info", ...args);
  }
  warn(...args) {
    this.#log("warn", ...args);
  }
  info(...args) {
    this.#log("info", ...args);
  }
  error(...args) {
    this.#log("error", ...args);
  }
  debug(...lazyArgs) {
    if (!shouldLog(this.#logger.level, "debug")) {
      return;
    }
    this.#log("debug", ...handleLazyMessage(lazyArgs));
  }
  child(name) {
    name = stringifyName(name);
    if (this.#logger.prefix?.includes(name)) {
      return this;
    }
    return LegacyLogger.from(this.#logger.child(name));
  }
  addPrefix(prefix) {
    prefix = stringifyName(prefix);
    if (this.#logger.prefix?.includes(prefix)) {
      return this;
    }
    return LegacyLogger.from(this.#logger.child(prefix));
  }
}
function stringifyName(name) {
  if (typeof name === "string" || typeof name === "number") {
    return `${name}`;
  }
  const names = [];
  for (const [key, value] of Object.entries(name)) {
    names.push(`${key}=${value}`);
  }
  return `${names.join(", ")}`;
}
function handleLazyMessage(lazyArgs) {
  return lazyArgs.flat(Infinity).flatMap((arg) => {
    if (typeof arg === "function") {
      return arg();
    }
    return arg;
  });
}

exports.ConsoleLogWriter = ConsoleLogWriter;
exports.JSONLogWriter = JSONLogWriter;
exports.LegacyLogger = LegacyLogger;
exports.Logger = Logger;
exports.MemoryLogWriter = MemoryLogWriter;