@nxtedition/lib 19.1.5 → 19.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "19.1.5",
+  "version": "19.1.6",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -94,7 +94,6 @@
     "object-hash": "^3.0.0",
     "p-queue": "^8.0.1",
     "pino": "^8.20.0",
-    "pino-std-serializers": "^6.2.2",
     "qs": "^6.12.1",
     "request-target": "^1.0.2",
     "smpte-timecode": "^1.3.5",

package/serializers.js

@@ -1,4 +1,3 @@
-import serializers from 'pino-std-serializers'
 import { SIGNALS } from './platform.js'
 import { util } from 'undici'
 
@@ -25,41 +24,7 @@ function getHeaders(obj) {
 export default {
   data: (data) =>
     data != null && typeof data === 'object' ? JSON.stringify(data, undefined, 2) : data,
-  err: (err) => {
-    // TODO (fix): Merge with errors/serializeError?
-
-    if (Buffer.isBuffer(err)) {
-      err = new Error('unexpected buffer error')
-    }
-
-    if (Array.isArray(err)) {
-      err = err.length === 1 ? err[0] : new AggregateError(err)
-    }
-
-    if (err == null) {
-      return undefined
-    }
-
-    const ret = serializers.err(err)
-
-    if (ret == null) {
-      return undefined
-    }
-
-    if (ret.data !== null && typeof ret.data === 'object') {
-      ret.data = JSON.stringify(ret.data)
-    }
-
-    if (typeof ret.signal === 'number') {
-      ret.signal = SIGNALS[ret.signal] ?? String(ret.signal)
-    }
-
-    if (typeof ret.code === 'number') {
-      ret.code = String(ret.code)
-    }
-
-    return ret
-  },
+  err: (err) => errSerializer(err),
   res: (res) =>
     res && {
       id: res.id || res.req?.id || getHeader(res, 'request-id') || getHeader(res.req, 'request-id'),
@@ -124,3 +89,107 @@ export default {
     }
   },
 }
+
+// Based on: https://github.com/pinojs/pino-std-serializers
+
+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 (Array.isArray(err)) {
+    if (err.length === 0) {
+      return null
+    } else if (err.length === 1) {
+      return errSerializer(err[0])
+    } else {
+      return new AggregateError(err.map(errSerializer))
+    }
+  }
+
+  if (!isErrorLike(err)) {
+    return null
+  }
+
+  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 = err.message
+  _err.stack = err.stack
+
+  if (Array.isArray(err.errors)) {
+    _err.aggregateErrors = err.errors.map((err) => errSerializer(err))
+  }
+
+  if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
+    _err.cause = errSerializer(err.cause)
+  }
+
+  for (const key in err) {
+    if (_err[key] === undefined) {
+      const val = err[key]
+      if (isErrorLike(val)) {
+        if (!Object.prototype.hasOwnProperty.call(val, seen)) {
+          _err[key] = errSerializer(val)
+        }
+      } else if (val == null) {
+        // Do nothing...
+      } else if (key === 'data' && typeof val === 'object') {
+        _err[key] = JSON.stringify(val, undefined, 2)
+      } else if (key === 'code' && typeof val === 'number') {
+        _err[key] = String(val)
+      } else if (key === 'signal' && typeof val === 'number') {
+        _err[key] = SIGNALS[val] ?? String(val)
+      } else {
+        _err[key] = val
+      }
+    }
+  }
+
+  delete err[seen] // clean up tag in case err is serialized again later
+  _err.raw = err
+  return _err
+}
+
+const isErrorLike = (err) => {
+  return err && typeof err.message === 'string'
+}