@nxtedition/lib 19.1.2 → 19.1.5

package/couch.js

@@ -930,6 +930,7 @@ class ErrorHandler extends undici.DecoratorHandler {
   #opts
   #handler
   #error
+  #headers
 
   constructor({ opts, handler }) {
     super(handler)
@@ -949,11 +950,11 @@ class ErrorHandler extends undici.DecoratorHandler {
     this.#statusText = statusText
 
     if (this.#statusCode < 200 || this.#statusCode > 300) {
-      headers = Array.isArray(headers) ? undiciUtil.parseHeaders(headers) : headers
+      this.#headers = Array.isArray(headers) ? undiciUtil.parseHeaders(headers) : headers
 
       this.#error = new Error(this.#statusText ?? this.#statusCode)
 
-      this.#contentType = parseContentType(headers['content-type'] ?? '')?.type
+      this.#contentType = parseContentType(this.#headers['content-type'] ?? '')?.type
       if (this.#contentType !== 'application/json' && this.#contentType !== 'plain/text') {
         throw this.#error
       }
@@ -1003,10 +1004,11 @@ class ErrorHandler extends undici.DecoratorHandler {
       } else if (this.#contentType === 'plain/text') {
         throw Object.assign(this.#error, {
           data: {
-            req: this.#opts,
-            res: {
+            ureq: this.#opts,
+            ures: {
               body: this.#str,
               statusCode: this.#statusCode,
+              headers: this.#headers,
             },
           },
         })

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.2",
+  "version": "19.1.5",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",

package/s3.js

@@ -4,12 +4,34 @@ import tp from 'node:timers/promises'
 import AWS from '@aws-sdk/client-s3'
 import PQueue from 'p-queue'
 
-const CONTENT_MD5_EXPR = /^[A-F0-9]{32}$/i
-const CONTENT_LENGTH_EXPR = /^\d+$/i
-
-const queue = new PQueue({ concurrency: 8 })
-
-export async function upload({ client: s3, signal, logger, partSize = 16e6, params }) {
+const QUEUE = new PQueue({ concurrency: 8 })
+const MD5_HEX_EXPR = /^[A-F0-9]{32}$/i
+
+/**
+ * Uploads a file to S3 using multipart upload.
+ *
+ * @param {Object} options - The options for the upload.
+ * @param {AWS.S3} options.client - The S3 client.
+ * @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.
+ * @param {string} options.params.Bucket - The name of the bucket.
+ * @param {string} [options.params.ContentMD5] - The MD5 hash of the object as base64 string.
+ * @param {number} [options.params.ContentLength] - The length of the object.
+ * @returns {Promise<Object>} The result of the upload.
+ */
+export async function upload({
+  client: s3,
+  queue = QUEUE,
+  signal,
+  logger,
+  partSize = 16e6,
+  params,
+}) {
   if (s3 == null) {
     throw new Error('Invalid client')
   }
@@ -22,14 +44,17 @@ 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
 
-  if (ContentMD5 != null && !CONTENT_MD5_EXPR.test(ContentMD5)) {
-    throw new Error(`Invalid ContentMD5: ${ContentMD5}`)
+  const size = ContentLength != null ? Number(ContentLength) : null
+
+  if (size != null && (!Number.isFinite(size) || size < 0)) {
+    throw new Error('Invalid params.ContentLength')
   }
 
-  if (ContentLength != null && !CONTENT_LENGTH_EXPR.test(ContentLength)) {
-    throw new Error(`Invalid ContentLength: ${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 = []
@@ -116,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 {
@@ -189,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
-
     if (size != null && size !== result.size) {
       throw new Error(`Expected size ${size} but got ${result.size}`)
     }