@graphql-hive/logger 0.0.0

package/dist/index.cjs

@@ -0,0 +1,761 @@
+'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);
+
+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, 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 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() || ""
+  );
+}
+
+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 jsonStringify(val, pretty) {
+  return fastSafeStringify$1(val, void 0, pretty ? 2 : void 0);
+}
+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()];
+  }
+  /** 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) {
+    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,
+        // 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: { ...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") {
+      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;
+  });
+}
+
+exports.ConsoleLogWriter = ConsoleLogWriter;
+exports.JSONLogWriter = JSONLogWriter;
+exports.LegacyLogger = LegacyLogger;
+exports.Logger = Logger;
+exports.MemoryLogWriter = MemoryLogWriter;
+exports.jsonStringify = jsonStringify;