@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/pino/lib/tools.js

@@ -0,0 +1,394 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const format = require('quick-format-unescaped')
+const { mapHttpRequest, mapHttpResponse } = require('pino-std-serializers')
+const SonicBoom = require('sonic-boom')
+const onExit = require('on-exit-leak-free')
+const {
+  lsCacheSym,
+  chindingsSym,
+  writeSym,
+  serializersSym,
+  formatOptsSym,
+  endSym,
+  stringifiersSym,
+  stringifySym,
+  stringifySafeSym,
+  wildcardFirstSym,
+  nestedKeySym,
+  formattersSym,
+  messageKeySym,
+  errorKeySym,
+  nestedKeyStrSym,
+  msgPrefixSym
+} = require('./symbols')
+const { isMainThread } = require('worker_threads')
+const transport = require('./transport')
+
+function noop () {
+}
+
+function genLog (level, hook) {
+  if (!hook) return LOG
+
+  return function hookWrappedLog (...args) {
+    hook.call(this, args, LOG, level)
+  }
+
+  function LOG (o, ...n) {
+    if (typeof o === 'object') {
+      let msg = o
+      if (o !== null) {
+        if (o.method && o.headers && o.socket) {
+          o = mapHttpRequest(o)
+        } else if (typeof o.setHeader === 'function') {
+          o = mapHttpResponse(o)
+        }
+      }
+      let formatParams
+      if (msg === null && n.length === 0) {
+        formatParams = [null]
+      } else {
+        msg = n.shift()
+        formatParams = n
+      }
+      // We do not use a coercive check for `msg` as it is
+      // measurably slower than the explicit checks.
+      if (typeof this[msgPrefixSym] === 'string' && msg !== undefined && msg !== null) {
+        msg = this[msgPrefixSym] + msg
+      }
+      this[writeSym](o, format(msg, formatParams, this[formatOptsSym]), level)
+    } else {
+      let msg = o === undefined ? n.shift() : o
+
+      // We do not use a coercive check for `msg` as it is
+      // measurably slower than the explicit checks.
+      if (typeof this[msgPrefixSym] === 'string' && msg !== undefined && msg !== null) {
+        msg = this[msgPrefixSym] + msg
+      }
+      this[writeSym](null, format(msg, n, this[formatOptsSym]), level)
+    }
+  }
+}
+
+// magically escape strings for json
+// relying on their charCodeAt
+// everything below 32 needs JSON.stringify()
+// 34 and 92 happens all the time, so we
+// have a fast case for them
+function asString (str) {
+  let result = ''
+  let last = 0
+  let found = false
+  let point = 255
+  const l = str.length
+  if (l > 100) {
+    return JSON.stringify(str)
+  }
+  for (var i = 0; i < l && point >= 32; i++) {
+    point = str.charCodeAt(i)
+    if (point === 34 || point === 92) {
+      result += str.slice(last, i) + '\\'
+      last = i
+      found = true
+    }
+  }
+  if (!found) {
+    result = str
+  } else {
+    result += str.slice(last)
+  }
+  return point < 32 ? JSON.stringify(str) : '"' + result + '"'
+}
+
+function asJson (obj, msg, num, time) {
+  const stringify = this[stringifySym]
+  const stringifySafe = this[stringifySafeSym]
+  const stringifiers = this[stringifiersSym]
+  const end = this[endSym]
+  const chindings = this[chindingsSym]
+  const serializers = this[serializersSym]
+  const formatters = this[formattersSym]
+  const messageKey = this[messageKeySym]
+  const errorKey = this[errorKeySym]
+  let data = this[lsCacheSym][num] + time
+
+  // we need the child bindings added to the output first so instance logged
+  // objects can take precedence when JSON.parse-ing the resulting log line
+  data = data + chindings
+
+  let value
+  if (formatters.log) {
+    obj = formatters.log(obj)
+  }
+  const wildcardStringifier = stringifiers[wildcardFirstSym]
+  let propStr = ''
+  for (const key in obj) {
+    value = obj[key]
+    if (Object.prototype.hasOwnProperty.call(obj, key) && value !== undefined) {
+      if (serializers[key]) {
+        value = serializers[key](value)
+      } else if (key === errorKey && serializers.err) {
+        value = serializers.err(value)
+      }
+
+      const stringifier = stringifiers[key] || wildcardStringifier
+
+      switch (typeof value) {
+        case 'undefined':
+        case 'function':
+          continue
+        case 'number':
+          /* eslint no-fallthrough: "off" */
+          if (Number.isFinite(value) === false) {
+            value = null
+          }
+        // this case explicitly falls through to the next one
+        case 'boolean':
+          if (stringifier) value = stringifier(value)
+          break
+        case 'string':
+          value = (stringifier || asString)(value)
+          break
+        default:
+          value = (stringifier || stringify)(value, stringifySafe)
+      }
+      if (value === undefined) continue
+      const strKey = asString(key)
+      propStr += ',' + strKey + ':' + value
+    }
+  }
+
+  let msgStr = ''
+  if (msg !== undefined) {
+    value = serializers[messageKey] ? serializers[messageKey](msg) : msg
+    const stringifier = stringifiers[messageKey] || wildcardStringifier
+
+    switch (typeof value) {
+      case 'function':
+        break
+      case 'number':
+        /* eslint no-fallthrough: "off" */
+        if (Number.isFinite(value) === false) {
+          value = null
+        }
+      // this case explicitly falls through to the next one
+      case 'boolean':
+        if (stringifier) value = stringifier(value)
+        msgStr = ',"' + messageKey + '":' + value
+        break
+      case 'string':
+        value = (stringifier || asString)(value)
+        msgStr = ',"' + messageKey + '":' + value
+        break
+      default:
+        value = (stringifier || stringify)(value, stringifySafe)
+        msgStr = ',"' + messageKey + '":' + value
+    }
+  }
+
+  if (this[nestedKeySym] && propStr) {
+    // place all the obj properties under the specified key
+    // the nested key is already formatted from the constructor
+    return data + this[nestedKeyStrSym] + propStr.slice(1) + '}' + msgStr + end
+  } else {
+    return data + propStr + msgStr + end
+  }
+}
+
+function asChindings (instance, bindings) {
+  let value
+  let data = instance[chindingsSym]
+  const stringify = instance[stringifySym]
+  const stringifySafe = instance[stringifySafeSym]
+  const stringifiers = instance[stringifiersSym]
+  const wildcardStringifier = stringifiers[wildcardFirstSym]
+  const serializers = instance[serializersSym]
+  const formatter = instance[formattersSym].bindings
+  bindings = formatter(bindings)
+
+  for (const key in bindings) {
+    value = bindings[key]
+    const valid = key !== 'level' &&
+      key !== 'serializers' &&
+      key !== 'formatters' &&
+      key !== 'customLevels' &&
+      bindings.hasOwnProperty(key) &&
+      value !== undefined
+    if (valid === true) {
+      value = serializers[key] ? serializers[key](value) : value
+      value = (stringifiers[key] || wildcardStringifier || stringify)(value, stringifySafe)
+      if (value === undefined) continue
+      data += ',"' + key + '":' + value
+    }
+  }
+  return data
+}
+
+function hasBeenTampered (stream) {
+  return stream.write !== stream.constructor.prototype.write
+}
+
+const hasNodeCodeCoverage = process.env.NODE_V8_COVERAGE || process.env.V8_COVERAGE
+
+function buildSafeSonicBoom (opts) {
+  const stream = new SonicBoom(opts)
+  stream.on('error', filterBrokenPipe)
+  // If we are sync: false, we must flush on exit
+  // We must disable this if there is node code coverage due to
+  // https://github.com/nodejs/node/issues/49344#issuecomment-1741776308.
+  if (!hasNodeCodeCoverage && !opts.sync && isMainThread) {
+    onExit.register(stream, autoEnd)
+
+    stream.on('close', function () {
+      onExit.unregister(stream)
+    })
+  }
+  return stream
+
+  function filterBrokenPipe (err) {
+    // Impossible to replicate across all operating systems
+    /* istanbul ignore next */
+    if (err.code === 'EPIPE') {
+      // If we get EPIPE, we should stop logging here
+      // however we have no control to the consumer of
+      // SonicBoom, so we just overwrite the write method
+      stream.write = noop
+      stream.end = noop
+      stream.flushSync = noop
+      stream.destroy = noop
+      return
+    }
+    stream.removeListener('error', filterBrokenPipe)
+    stream.emit('error', err)
+  }
+}
+
+function autoEnd (stream, eventName) {
+  // This check is needed only on some platforms
+  /* istanbul ignore next */
+  if (stream.destroyed) {
+    return
+  }
+
+  if (eventName === 'beforeExit') {
+    // We still have an event loop, let's use it
+    stream.flush()
+    stream.on('drain', function () {
+      stream.end()
+    })
+  } else {
+    // For some reason istanbul is not detecting this, but it's there
+    /* istanbul ignore next */
+    // We do not have an event loop, so flush synchronously
+    stream.flushSync()
+  }
+}
+
+function createArgsNormalizer (defaultOptions) {
+  return function normalizeArgs (instance, caller, opts = {}, stream) {
+    // support stream as a string
+    if (typeof opts === 'string') {
+      stream = buildSafeSonicBoom({ dest: opts })
+      opts = {}
+    } else if (typeof stream === 'string') {
+      if (opts && opts.transport) {
+        throw Error('only one of option.transport or stream can be specified')
+      }
+      stream = buildSafeSonicBoom({ dest: stream })
+    } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
+      stream = opts
+      opts = {}
+    } else if (opts.transport) {
+      if (opts.transport instanceof SonicBoom || opts.transport.writable || opts.transport._writableState) {
+        throw Error('option.transport do not allow stream, please pass to option directly. e.g. pino(transport)')
+      }
+      if (opts.transport.targets && opts.transport.targets.length && opts.formatters && typeof opts.formatters.level === 'function') {
+        throw Error('option.transport.targets do not allow custom level formatters')
+      }
+
+      let customLevels
+      if (opts.customLevels) {
+        customLevels = opts.useOnlyCustomLevels ? opts.customLevels : Object.assign({}, opts.levels, opts.customLevels)
+      }
+      stream = transport({ caller, ...opts.transport, levels: customLevels })
+    }
+    opts = Object.assign({}, defaultOptions, opts)
+    opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers)
+    opts.formatters = Object.assign({}, defaultOptions.formatters, opts.formatters)
+
+    if (opts.prettyPrint) {
+      throw new Error('prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)')
+    }
+
+    const { enabled, onChild } = opts
+    if (enabled === false) opts.level = 'silent'
+    if (!onChild) opts.onChild = noop
+    if (!stream) {
+      if (!hasBeenTampered(process.stdout)) {
+        // If process.stdout.fd is undefined, it means that we are running
+        // in a worker thread. Let's assume we are logging to file descriptor 1.
+        stream = buildSafeSonicBoom({ fd: process.stdout.fd || 1 })
+      } else {
+        stream = process.stdout
+      }
+    }
+    return { opts, stream }
+  }
+}
+
+function stringify (obj, stringifySafeFn) {
+  try {
+    return JSON.stringify(obj)
+  } catch (_) {
+    try {
+      const stringify = stringifySafeFn || this[stringifySafeSym]
+      return stringify(obj)
+    } catch (_) {
+      return '"[unable to serialize, circular reference is too complex to analyze]"'
+    }
+  }
+}
+
+function buildFormatters (level, bindings, log) {
+  return {
+    level,
+    bindings,
+    log
+  }
+}
+
+/**
+ * Convert a string integer file descriptor to a proper native integer
+ * file descriptor.
+ *
+ * @param {string} destination The file descriptor string to attempt to convert.
+ *
+ * @returns {Number}
+ */
+function normalizeDestFileDescriptor (destination) {
+  const fd = Number(destination)
+  if (typeof destination === 'string' && Number.isFinite(fd)) {
+    return fd
+  }
+  // destination could be undefined if we are in a worker
+  if (destination === undefined) {
+    // This is stdout in UNIX systems
+    return 1
+  }
+  return destination
+}
+
+module.exports = {
+  noop,
+  buildSafeSonicBoom,
+  asChindings,
+  asJson,
+  genLog,
+  createArgsNormalizer,
+  stringify,
+  buildFormatters,
+  normalizeDestFileDescriptor
+}

package/.output/server/node_modules/pino/lib/transport-stream.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const { realImport, realRequire } = require('real-require')
+
+module.exports = loadTransportStreamBuilder
+
+/**
+ * Loads & returns a function to build transport streams
+ * @param {string} target
+ * @returns {Promise<function(object): Promise<import('node:stream').Writable>>}
+ * @throws {Error} In case the target module does not export a function
+ */
+async function loadTransportStreamBuilder (target) {
+  let fn
+  try {
+    const toLoad = target.startsWith('file://') ? target : 'file://' + target
+
+    if (toLoad.endsWith('.ts') || toLoad.endsWith('.cts')) {
+      // TODO: add support for the TSM modules loader ( https://github.com/lukeed/tsm ).
+      if (process[Symbol.for('ts-node.register.instance')]) {
+        realRequire('ts-node/register')
+      } else if (process.env && process.env.TS_NODE_DEV) {
+        realRequire('ts-node-dev')
+      }
+      // TODO: Support ES imports once tsc, tap & ts-node provide better compatibility guarantees.
+      fn = realRequire(decodeURIComponent(target))
+    } else {
+      fn = (await realImport(toLoad))
+    }
+  } catch (error) {
+    // See this PR for details: https://github.com/pinojs/thread-stream/pull/34
+    if ((error.code === 'ENOTDIR' || error.code === 'ERR_MODULE_NOT_FOUND')) {
+      fn = realRequire(target)
+    } else if (error.code === undefined || error.code === 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING') {
+      // When bundled with pkg, an undefined error is thrown when called with realImport
+      // When bundled with pkg and using node v20, an ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING error is thrown when called with realImport
+      // More info at: https://github.com/pinojs/thread-stream/issues/143
+      try {
+        fn = realRequire(decodeURIComponent(target))
+      } catch {
+        throw error
+      }
+    } else {
+      throw error
+    }
+  }
+
+  // Depending on how the default export is performed, and on how the code is
+  // transpiled, we may find cases of two nested "default" objects.
+  // See https://github.com/pinojs/pino/issues/1243#issuecomment-982774762
+  if (typeof fn === 'object') fn = fn.default
+  if (typeof fn === 'object') fn = fn.default
+  if (typeof fn !== 'function') throw Error('exported worker is not a function')
+
+  return fn
+}

package/.output/server/node_modules/pino/lib/transport.js

@@ -0,0 +1,167 @@
+'use strict'
+
+const { createRequire } = require('module')
+const getCallers = require('./caller')
+const { join, isAbsolute, sep } = require('node:path')
+const sleep = require('atomic-sleep')
+const onExit = require('on-exit-leak-free')
+const ThreadStream = require('thread-stream')
+
+function setupOnExit (stream) {
+  // This is leak free, it does not leave event handlers
+  onExit.register(stream, autoEnd)
+  onExit.registerBeforeExit(stream, flush)
+
+  stream.on('close', function () {
+    onExit.unregister(stream)
+  })
+}
+
+function buildStream (filename, workerData, workerOpts, sync) {
+  const stream = new ThreadStream({
+    filename,
+    workerData,
+    workerOpts,
+    sync
+  })
+
+  stream.on('ready', onReady)
+  stream.on('close', function () {
+    process.removeListener('exit', onExit)
+  })
+
+  process.on('exit', onExit)
+
+  function onReady () {
+    process.removeListener('exit', onExit)
+    stream.unref()
+
+    if (workerOpts.autoEnd !== false) {
+      setupOnExit(stream)
+    }
+  }
+
+  function onExit () {
+    /* istanbul ignore next */
+    if (stream.closed) {
+      return
+    }
+    stream.flushSync()
+    // Apparently there is a very sporadic race condition
+    // that in certain OS would prevent the messages to be flushed
+    // because the thread might not have been created still.
+    // Unfortunately we need to sleep(100) in this case.
+    sleep(100)
+    stream.end()
+  }
+
+  return stream
+}
+
+function autoEnd (stream) {
+  stream.ref()
+  stream.flushSync()
+  stream.end()
+  stream.once('close', function () {
+    stream.unref()
+  })
+}
+
+function flush (stream) {
+  stream.flushSync()
+}
+
+function transport (fullOptions) {
+  const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions
+
+  const options = {
+    ...fullOptions.options
+  }
+
+  // Backwards compatibility
+  const callers = typeof caller === 'string' ? [caller] : caller
+
+  // This will be eventually modified by bundlers
+  const bundlerOverrides = '__bundlerPathsOverrides' in globalThis ? globalThis.__bundlerPathsOverrides : {}
+
+  let target = fullOptions.target
+
+  if (target && targets) {
+    throw new Error('only one of target or targets can be specified')
+  }
+
+  if (targets) {
+    target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js')
+    options.targets = targets.filter(dest => dest.target).map((dest) => {
+      return {
+        ...dest,
+        target: fixTarget(dest.target)
+      }
+    })
+    options.pipelines = targets.filter(dest => dest.pipeline).map((dest) => {
+      return dest.pipeline.map((t) => {
+        return {
+          ...t,
+          level: dest.level, // duplicate the pipeline `level` property defined in the upper level
+          target: fixTarget(t.target)
+        }
+      })
+    })
+  } else if (pipeline) {
+    target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js')
+    options.pipelines = [pipeline.map((dest) => {
+      return {
+        ...dest,
+        target: fixTarget(dest.target)
+      }
+    })]
+  }
+
+  if (levels) {
+    options.levels = levels
+  }
+
+  if (dedupe) {
+    options.dedupe = dedupe
+  }
+
+  options.pinoWillSendConfig = true
+
+  return buildStream(fixTarget(target), options, worker, sync)
+
+  function fixTarget (origin) {
+    origin = bundlerOverrides[origin] || origin
+
+    if (isAbsolute(origin) || origin.indexOf('file://') === 0) {
+      return origin
+    }
+
+    if (origin === 'pino/file') {
+      return join(__dirname, '..', 'file.js')
+    }
+
+    let fixTarget
+
+    for (const filePath of callers) {
+      try {
+        const context = filePath === 'node:repl'
+          ? process.cwd() + sep
+          : filePath
+
+        fixTarget = createRequire(context).resolve(origin)
+        break
+      } catch (err) {
+        // Silent catch
+        continue
+      }
+    }
+
+    if (!fixTarget) {
+      throw new Error(`unable to determine transport target for "${origin}"`)
+    }
+
+    return fixTarget
+  }
+}
+
+module.exports = transport