@nxtedition/lib 14.0.16 → 14.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "14.0.16",
+  "version": "14.0.18",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [
@@ -81,6 +81,7 @@
     "nconf": "^0.12.0",
     "nested-error-stacks": "^2.1.1",
     "object-hash": "^3.0.0",
+    "pino-std-serializers": "^6.2.2",
     "qs": "^6.11.1",
     "request-target": "^1.0.2",
     "smpte-timecode": "^1.3.3",

package/serializers.js

@@ -1,3 +1,5 @@
+const serializers = require('pino-std-serializers')
+
 function getHeader(obj, key) {
   return obj?.headers?.get?.(key) || obj?.getHeader?.(key) || obj?.headers?.[key]
 }
@@ -25,169 +27,8 @@ function getHeaders(obj) {
   )
 }
 
-const isErrorLike = (err) => {
-  return err && typeof err.message === 'string'
-}
-
-const getErrorCause = (err) => {
-  if (!err) {
-    return
-  }
-
-  const cause = err.cause
-
-  if (typeof cause === 'function') {
-    const causeResult = err.cause()
-    return isErrorLike(causeResult) ? causeResult : undefined
-  } else {
-    return isErrorLike(cause) ? cause : undefined
-  }
-}
-
-const _stackWithCauses = (err, seen) => {
-  if (!isErrorLike(err)) {
-    return ''
-  }
-
-  const stack = err.stack || ''
-
-  // Ensure we don't go circular or crazily deep
-  if (seen.has(err)) {
-    return stack + '\ncauses have become circular...'
-  }
-
-  const cause = getErrorCause(err)
-
-  if (cause) {
-    seen.add(err)
-    return stack + '\ncaused by: ' + _stackWithCauses(cause, seen)
-  } else {
-    return stack
-  }
-}
-
-const stackWithCauses = (err) => _stackWithCauses(err, new Set())
-
-const _messageWithCauses = (err, seen, skip) => {
-  if (!isErrorLike(err)) {
-    return ''
-  }
-
-  const message = skip ? '' : err.message || ''
-
-  // Ensure we don't go circular or crazily deep
-  if (seen.has(err)) {
-    return message + ': ...'
-  }
-
-  const cause = getErrorCause(err)
-
-  if (cause) {
-    seen.add(err)
-
-    const skipIfVErrorStyleCause = typeof err.cause === 'function'
-
-    return (
-      message +
-      (skipIfVErrorStyleCause ? '' : ': ') +
-      _messageWithCauses(cause, seen, skipIfVErrorStyleCause)
-    )
-  } else {
-    return message
-  }
-}
-
-const messageWithCauses = (err) => _messageWithCauses(err, new Set())
-
-const { toString } = Object.prototype
-const seen = Symbol('circular-ref-tag')
-const rawSymbol = Symbol('pino-raw-err-ref')
-const pinoErrProto = Object.create(
-  {},
-  {
-    type: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    message: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    stack: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    aggregateErrors: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    raw: {
-      enumerable: false,
-      get: function () {
-        return this[rawSymbol]
-      },
-      set: function (val) {
-        this[rawSymbol] = val
-      },
-    },
-  }
-)
-Object.defineProperty(pinoErrProto, rawSymbol, {
-  writable: true,
-  value: {},
-})
-
-function errSerializer(err) {
-  if (!err) {
-    return undefined
-  } else if (typeof err === 'string') {
-    err = new Error(err)
-  } else if (Array.isArray(err)) {
-    err = new AggregateError(err)
-  } else if (!isErrorLike(err)) {
-    err = Object.assign(new Error('invalid error object'), { data: JSON.stringify(err) })
-  }
-
-  err[seen] = undefined // tag to prevent re-looking at this
-  const _err = Object.create(pinoErrProto)
-  _err.type =
-    toString.call(err.constructor) === '[object Function]' ? err.constructor.name : err.name
-  _err.message = messageWithCauses(err)
-  _err.stack = stackWithCauses(err)
-
-  if (Array.isArray(err.errors)) {
-    _err.aggregateErrors = err.errors.map((err) => errSerializer(err))
-  }
-
-  for (const key in err) {
-    if (/^[A-Z_]+$/.test(key)) {
-      // Ignore constants.
-    } else if (_err[key] === undefined) {
-      const val = err[key]
-      if (isErrorLike(val)) {
-        // We append cause messages and stacks to _err, therefore skipping causes here
-        if (key !== 'cause' && !Object.prototype.hasOwnProperty.call(val, seen)) {
-          _err[key] = errSerializer(val)
-        }
-      } else if (key === 'data' && typeof val !== 'string') {
-        _err[key] = JSON.stringify(val)
-      } else {
-        _err[key] = val
-      }
-    }
-  }
-
-  delete err[seen] // clean up tag in case err is serialized again later
-  _err.raw = err
-  return _err
-}
-
 module.exports = {
-  err: (err) => errSerializer(err),
+  err: serializers.err,
   res: (res) =>
     res && {
       id: res.id || res.req?.id || getHeader(res, 'request-id') || getHeader(res.req, 'request-id'),

package/util/template/index.js

@@ -165,7 +165,16 @@ module.exports = ({ ds, proxify }) => {
         return (str, args$) => expr(args$)
       }
 
-      return (str, args$) => expr(args$).pipe(rx.map((body) => `${pre}${stringify(body)}${post}`))
+      return (str, args$) =>
+        rxjs
+          .combineLatest([
+            compileStringTemplate(pre)?.(str, args$) ?? rxjs.of(pre),
+            expr(args$),
+            compileStringTemplate(post)?.(str, args$) ?? rxjs.of(post),
+          ])
+          .pipe(
+            rx.map(([pre, body, post]) => (pre || post ? `${pre}${stringify(body)}${post}` : body))
+          )
     } else if (type === 'nxt') {
       const expr = compilers.nxt(body)