Support for aggregate errors (#87)

* feat: support for aggregate errors

* chore: using global aggregate error

* chore: minor refactor

* chore: explicitly send arguments to serializer

* chore: check for infinite recursion

* chore: package.json change reverted

* chore: remove recursion check

lib/err.js

@@ -23,6 +23,11 @@ const pinoErrProto = Object.create({}, {
     writable: true,
     value: undefined
   },
+  aggregateErrors: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
   raw: {
     enumerable: false,
     get: function () {
@@ -50,6 +55,11 @@ function errSerializer (err) {
     : err.name
   _err.message = messageWithCauses(err)
   _err.stack = stackWithCauses(err)
+
+  if (global.AggregateError !== undefined && err instanceof global.AggregateError && Array.isArray(err.errors)) {
+    _err.aggregateErrors = err.errors.map(err => errSerializer(err))
+  }
+
   for (const key in err) {
     if (_err[key] === undefined) {
       const val = err[key]

test/err.test.js

@@ -177,3 +177,20 @@ test('can wrap err serializers', function (t) {
   t.notOk(serialized.foo)
   t.is(serialized.bar, 'bar')
 })
+
+test('serializes aggregate errors', { skip: !global.AggregateError }, function (t) {
+  t.plan(8)
+  const foo = new Error('foo')
+  const bar = new Error('bar')
+  const aggregate = new AggregateError([foo, bar], 'aggregated message') // eslint-disable-line no-undef
+
+  const serialized = serializer(aggregate)
+  t.equal(serialized.type, 'AggregateError')
+  t.equal(serialized.message, 'aggregated message')
+  t.equal(serialized.aggregateErrors.length, 2)
+  t.equal(serialized.aggregateErrors[0].message, 'foo')
+  t.equal(serialized.aggregateErrors[1].message, 'bar')
+  t.match(serialized.aggregateErrors[0].stack, /^Error: foo/)
+  t.match(serialized.aggregateErrors[1].stack, /^Error: bar/)
+  t.match(serialized.stack, /err\.test\.js:/)
+})