@nxtedition/lib 19.1.3 → 19.1.6

package/errors.js

@@ -42,12 +42,16 @@ export function parseError(error) {
 const kSeen = Symbol('kSeen')
 
 export function serializeError(error) {
+  return _serializeError(error, { depth: 0 })
+}
+
+function _serializeError(error, { depth }) {
   if (!error) {
     return null
   }
 
   if (typeof error === 'string') {
-    return [serializeError({ message: error })]
+    return [_serializeError({ message: error }, { depth })]
   }
 
   if (Buffer.isBuffer(error)) {
@@ -55,13 +59,17 @@ export function serializeError(error) {
   }
 
   if (Array.isArray(error)) {
-    return error.map(serializeError).filter(Boolean)
+    return error.map((x) => _serializeError(x, { depth })).filter(Boolean)
   }
 
   if (Object.prototype.hasOwnProperty.call(error, kSeen)) {
     return null
   }
 
+  if (depth > 8) {
+    return [{ messages: 'Maximum error serialization depth exceeded' }]
+  }
+
   error[kSeen] = undefined
 
   const type =
@@ -104,8 +112,10 @@ export function serializeError(error) {
     signalCode = SIGNALS[signalCode] ?? signalCode
   }
 
-  errors = Array.isArray(errors) ? errors.map(serializeError).filter(Boolean) : undefined
-  cause = cause ? serializeError(cause) : undefined
+  errors = Array.isArray(errors)
+    ? errors.map((x) => _serializeError(x, { depth: depth + 1 })).filter(Boolean)
+    : undefined
+  cause = cause ? _serializeError(cause, { depth: depth + 1 }) : undefined
 
   delete error[kSeen]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "19.1.3",
+  "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/s3.js

@@ -4,7 +4,8 @@ import tp from 'node:timers/promises'
 import AWS from '@aws-sdk/client-s3'
 import PQueue from 'p-queue'
 
-const queue = new PQueue({ concurrency: 8 })
+const QUEUE = new PQueue({ concurrency: 8 })
+const MD5_HEX_EXPR = /^[A-F0-9]{32}$/i
 
 /**
  * Uploads a file to S3 using multipart upload.
@@ -14,6 +15,7 @@ const queue = new PQueue({ concurrency: 8 })
  * @param {AbortSignal} options.signal - The signal to abort the upload.
  * @param {Object} options.logger - The logger to use.
  * @param {number} [options.partSize=16e6] - The size of each part in the multipart upload.
+ * @param {PQueue} [options.queue] - The queue to use for part uploads.
  * @param {Object} options.params - The parameters for the upload.
  * @param {Buffer|NodeJS.ReadStream} options.params.Body - The data to upload.
  * @param {string} options.params.Key - The key of the object.
@@ -22,7 +24,14 @@ const queue = new PQueue({ concurrency: 8 })
  * @param {number} [options.params.ContentLength] - The length of the object.
  * @returns {Promise<Object>} The result of the upload.
  */
-export async function upload({ client: s3, signal, logger, partSize = 16e6, params }) {
+export async function upload({
+  client: s3,
+  queue = QUEUE,
+  signal,
+  logger,
+  partSize = 16e6,
+  params,
+}) {
   if (s3 == null) {
     throw new Error('Invalid client')
   }
@@ -35,9 +44,18 @@ export async function upload({ client: s3, signal, logger, partSize = 16e6, para
     throw new Error('Invalid params')
   }
 
-  const { Body, Key, Bucket, ContentMD5, ContentLength } = params ?? {}
+  const { Body, Key, Bucket, ContentMD5, ContentLength } = params
 
-  // TODO (fix): Valdate ContentMD & ContentLength
+  const size = ContentLength != null ? Number(ContentLength) : null
+
+  if (size != null && (!Number.isFinite(size) || size < 0)) {
+    throw new Error('Invalid params.ContentLength')
+  }
+
+  const hash = ContentMD5 != null ? Buffer.from(ContentMD5, 'base64').toString('hex') : null
+  if (hash != null && !MD5_HEX_EXPR.test(hash)) {
+    throw new Error('Invalid params.ContentMD5')
+  }
 
   const promises = []
 
@@ -123,7 +141,7 @@ export async function upload({ client: s3, signal, logger, partSize = 16e6, para
                 } catch (err) {
                   logger?.warn({ err }, 'part upload failed')
 
-                  if (retryCount < 3) {
+                  if (retryCount < 5) {
                     logger?.debug({ retryCount }, 'part upload retry')
                     await tp.setTimeout(1e3, undefined, { signal: uploader.signal })
                   } else {
@@ -196,9 +214,6 @@ export async function upload({ client: s3, signal, logger, partSize = 16e6, para
       parts,
     }
 
-    const size = ContentLength != null ? Number(ContentLength) : null
-    const hash = ContentMD5 ? Buffer.from(ContentMD5, 'base64').toString('hex') : null
-
     if (size != null && size !== result.size) {
       throw new Error(`Expected size ${size} but got ${result.size}`)
     }

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'
+}