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

const DisposableSymbols = {
    get asyncDispose() {
        return Symbol.asyncDispose || Symbol.for('asyncDispose');
    },
};

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

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);

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);

const logLevel = {
  trace: 0,
  debug: 1,
  info: 2,
  warn: 3,
  error: 4
};
function shouldLog(setLevel, loggingLevel) {
  setLevel = typeof setLevel === "function" ? setLevel() : setLevel;
  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 parseAttrs(attrs, functionUnwrapDepth = 0) {
  if (functionUnwrapDepth > 3) {
    throw new Error("Too much recursion while unwrapping function attributes");
  }
  if (!attrs) {
    return void 0;
  }
  if (typeof attrs === "function") {
    return parseAttrs(attrs(), functionUnwrapDepth + 1);
  }
  if (Array.isArray(attrs)) {
    return attrs.map((val) => unwrapAttrVal(val));
  }
  if (isPlainObject(attrs)) {
    const unwrapped = {};
    for (const key of Object.keys(attrs)) {
      const val = attrs[key];
      unwrapped[key] = unwrapAttrVal(val);
    }
    return unwrapped;
  }
  return objectifyClass(attrs);
}
function unwrapAttrVal(attr, visited = /* @__PURE__ */ new WeakSet()) {
  if (!attr) {
    return attr;
  }
  if (isPrimitive(attr)) {
    return attr;
  }
  if (typeof attr === "function") {
    return `[Function: ${attr.name || "(anonymous)"}]`;
  }
  if (visited.has(attr)) {
    return "[Circular]";
  }
  visited.add(attr);
  if (Array.isArray(attr)) {
    return attr.map((val) => unwrapAttrVal(val));
  }
  if (isPlainObject(attr)) {
    const unwrapped = {};
    for (const key of Object.keys(attr)) {
      const val = attr[key];
      unwrapped[key] = unwrapAttrVal(val, visited);
    }
    return unwrapped;
  }
  return objectifyClass(attr);
}
function isPrimitive(val) {
  return val !== Object(val);
}
const nodejsCustomInspectSy = Symbol.for("nodejs.util.inspect.custom");
function objectifyClass(val) {
  if (
    // simply empty
    !val || // Object.create(null)
    Object(val).__proto__ == null
  ) {
    return {};
  }
  if (typeof val === "object" && "toJSON" in val && typeof val.toJSON === "function") {
    return val.toJSON();
  }
  if (typeof val === "object" && nodejsCustomInspectSy in val && typeof val[nodejsCustomInspectSy] === "function") {
    return {
      [nodejsCustomInspectSy.toString()]: unwrapAttrVal(
        val[nodejsCustomInspectSy](Infinity, {})
      ),
      class: val.constructor.name
    };
  }
  const props = {};
  for (const propName of Object.getOwnPropertyNames(val)) {
    props[propName] = unwrapAttrVal(val[propName]);
  }
  for (const protoPropName of Object.getOwnPropertyNames(
    Object.getPrototypeOf(val)
  )) {
    const propVal = val[protoPropName];
    if (typeof propVal === "function") {
      continue;
    }
    props[protoPropName] = unwrapAttrVal(propVal);
  }
  return {
    ...props,
    class: val.constructor.name
  };
}
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() || ""
  );
}
function shallowMergeAttributes(target, source) {
  switch (true) {
    case (Array.isArray(source) && Array.isArray(target)):
      return [...target, ...source];
    case Array.isArray(source):
      return target ? [target, ...source] : source;
    case Array.isArray(target):
      return source ? [...target, source] : target;
    case !!(target || source):
      return { ...target, ...source };
    default:
      return void 0;
  }
}
function isPlainObject(val) {
  return Object(val).constructor === Object && Object.getPrototypeOf(val) === Object.prototype;
}

function jsonStringify(val, pretty) {
  return fastSafeStringify$1(val, void 0, pretty ? 2 : void 0);
}

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
  key: "\x1B[35m",
  // magenta
  reset: "\x1B[0m"
  // reset
};
class ConsoleLogWriter {
  #console;
  #noColor;
  #noTimestamp;
  constructor(opts = {}) {
    const {
      console = globalThis.console,
      // no color if we're running in browser-like (edge) environments
      noColor = typeof process === "undefined" || // or no color if https://no-color.org/
      truthyEnv("NO_COLOR"),
      noTimestamp = false
    } = opts;
    this.#console = console;
    this.#noColor = noColor;
    this.#noTimestamp = noTimestamp;
  }
  color(style, text) {
    if (!text) {
      return text;
    }
    if (this.#noColor) {
      return text;
    }
    return asciMap[style] + text + asciMap.reset;
  }
  write(level, attrs, msg) {
    this.#console[level === "trace" ? "debug" : level](
      [
        !this.#noTimestamp && this.color("timestamp", (/* @__PURE__ */ new Date()).toISOString()),
        this.color(level, logLevelToString(level)),
        this.color("message", msg),
        attrs && this.stringifyAttrs(attrs)
      ].filter(Boolean).join(" ")
    );
  }
  stringifyAttrs(attrs) {
    let log = "\n";
    for (const line of jsonStringify(attrs, true).split("\n")) {
      if (line === "{" || line === "}" || line === "[" || line === "]") {
        continue;
      }
      let formattedLine = line;
      formattedLine = formattedLine.replace(
        /"([^"]+)":/,
        this.color("key", "$1:")
      );
      let indentationSize = line.match(/^\s*/)?.[0]?.length || 0;
      if (indentationSize) indentationSize++;
      formattedLine = formattedLine.replaceAll(
        /\\n/g,
        "\n" + [...Array(indentationSize)].join(" ")
      );
      formattedLine = formattedLine.replace(/,$/, "");
      formattedLine = formattedLine.replace(
        /(\[|\{|\]|\})$/,
        this.color("key", "$1")
      );
      log += formattedLine + "\n";
    }
    log = log.slice(0, -1);
    return log;
  }
}

class JSONLogWriter {
  write(level, attrs, msg) {
    console.log(
      jsonStringify(
        {
          ...attrs,
          level,
          ...msg ? { msg } : {},
          timestamp: (/* @__PURE__ */ new Date()).toISOString()
        },
        truthyEnv("LOG_JSON_PRETTY")
      )
    );
  }
}

class MemoryLogWriter {
  logs = [];
  write(level, attrs, msg) {
    this.logs.push({
      level,
      ...msg ? { msg } : {},
      ...attrs ? { attrs } : {}
    });
  }
}

class Logger {
  #level;
  #prefix;
  #attrs;
  #writers;
  #pendingWrites;
  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 ?? (truthyEnv("LOG_JSON") ? [new JSONLogWriter()] : [new ConsoleLogWriter()]);
  }
  /** The prefix that's prepended to each log message. */
  get prefix() {
    return this.#prefix;
  }
  /**
   * The attributes that are added to each log. If the log itself contains
   * attributes with keys existing in {@link attrs}, the log's attributes will
   * override.
   */
  get attrs() {
    return this.#attrs;
  }
  /** The current {@link LogLevel} of the logger. You can change the level using the {@link setLevel} method. */
  get level() {
    return typeof this.#level === "function" ? this.#level() : this.#level;
  }
  /**
   * Sets the new {@link LogLevel} of the logger. All subsequent logs, and {@link child child loggers} whose
   * level did not change, will respect the new level.
   */
  setLevel(level) {
    this.#level = level;
  }
  write(level, attrs, msg) {
    for (const w of this.#writers) {
      const write$ = w.write(level, attrs, msg);
      if (isPromise(write$)) {
        this.#pendingWrites ??= /* @__PURE__ */ new Set();
        this.#pendingWrites.add(write$);
        write$.then(() => {
          this.#pendingWrites.delete(write$);
        }).catch((e) => {
          console.error("Failed to write async log", e);
        });
      }
    }
  }
  flush() {
    if (this.#pendingWrites?.size) {
      const errs = [];
      return Promise.allSettled(
        Array.from(this.#pendingWrites).map(
          (w) => w.catch((err) => errs.push(err))
        )
      ).then(() => {
        this.#pendingWrites.clear();
        if (errs.length) {
          throw new AggregateError(
            errs,
            `Failed to flush ${errs.length} writes`
          );
        }
      });
    }
    return;
  }
  async [DisposableSymbols.asyncDispose]() {
    return this.flush();
  }
  child(prefixOrAttrs, prefix) {
    if (typeof prefixOrAttrs === "string") {
      return new Logger({
        level: () => this.level,
        // inherits the parent level (yet can be changed on child only when using setLevel)
        prefix: (this.#prefix || "") + prefixOrAttrs,
        attrs: this.#attrs,
        writers: this.#writers
      });
    }
    return new Logger({
      level: () => this.level,
      // inherits the parent level (yet can be changed on child only when using setLevel)
      prefix: (this.#prefix || "") + (prefix || "") || void 0,
      attrs: shallowMergeAttributes(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 = shallowMergeAttributes(parseAttrs(this.#attrs), parseAttrs(attrs));
    msg = msg && rest.length ? format$1(msg, rest, { stringify: fastSafeStringify$1 }) : 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") {
      if (restArgs.length) {
        this.#logger.log(level, restArgs, maybeMsgOrArg);
      } else {
        this.#logger.log(level, 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) + // append space if object is strigified to space out the prefix
    (typeof name === "object" ? " " : "");
    if (this.#logger.prefix === 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;
  });
}

export { ConsoleLogWriter, JSONLogWriter, LegacyLogger, Logger, MemoryLogWriter, jsonStringify };