@nxtedition/lib 19.1.6 → 19.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "19.1.6",
+  "version": "19.3.0",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",

package/s3.js

@@ -3,10 +3,73 @@ import stream from 'node:stream'
 import tp from 'node:timers/promises'
 import AWS from '@aws-sdk/client-s3'
 import PQueue from 'p-queue'
+import { NodeHttpHandler } from '@smithy/node-http-handler'
+import undici from 'undici'
 
 const QUEUE = new PQueue({ concurrency: 8 })
 const MD5_HEX_EXPR = /^[A-F0-9]{32}$/i
 
+/**
+ * @typedef {import('undici').Dispatcher} Dispatcher
+ * @typedef {import('@aws-sdk/client-s3').S3ClientConfig & {dispatcher?: Dispatcher}} S3ClientConfig
+ */
+
+export class S3Client extends AWS.S3Client {
+  /**
+   * @param {S3ClientConfig} config
+   */
+  constructor(config) {
+    const { dispatcher, ...options } = config
+    super({
+      requestHandler: new UndiciRequestHandler(dispatcher),
+      ...options,
+    })
+  }
+}
+
+class UndiciRequestHandler extends NodeHttpHandler {
+  #dispatcher
+
+  /**
+   * @param {Dispatcher=} dispatcher
+   */
+  constructor(dispatcher) {
+    super()
+    this.#dispatcher = dispatcher
+  }
+
+  /**
+   * @param {import('@smithy/protocol-http').HttpRequest} request
+   * @param {import('@smithy/types').HttpHandlerOptions=} options
+   */
+  async handle(request, options) {
+    const abortSignal = options?.abortSignal
+
+    const { protocol, hostname, port, path, ...requestOptions } = request
+    // NOTE: Expect header is not supported by undici
+    const { Expect, ...headers } = request.headers
+    const typedMethod = /** @type {import('undici').Dispatcher.HttpMethod} */ (request.method)
+
+    const url = `${request.protocol}//${request.hostname}${request.port ? `:${request.port}` : ''}${request.path}`
+
+    const response = await undici.request(url, {
+      ...requestOptions,
+      method: typedMethod,
+      signal: abortSignal,
+      dispatcher: this.#dispatcher,
+      headers,
+      body: request.body,
+    })
+
+    return {
+      response: {
+        ...response,
+        headers: getTransformedHeaders(response.headers),
+      },
+    }
+  }
+}
+
 /**
  * Uploads a file to S3 using multipart upload.
  *
@@ -241,3 +304,25 @@ export async function upload({
     signal?.removeEventListener('abort', onAbort)
   }
 }
+
+/**
+ * @see https://github.com/smithy-lang/smithy-typescript/blob/main/packages/node-http-handler/src/get-transformed-headers.ts
+ *
+ * @param {import('http2').IncomingHttpHeaders} headers
+ * @returns {import('@smithy/types').HeaderBag}
+ */
+function getTransformedHeaders(headers) {
+  /**
+   * @type {import('@smithy/types').HeaderBag}
+   */
+  const transformedHeaders = {}
+
+  for (const name of Object.keys(headers)) {
+    const headerValues = headers[name]
+    transformedHeaders[name] = Array.isArray(headerValues)
+      ? headerValues.join(',')
+      : headerValues ?? ''
+  }
+
+  return transformedHeaders
+}

package/serializers.js

@@ -90,6 +90,10 @@ export default {
   },
 }
 
+// TODO (fix): Merge with errros/serializeError.
+// Note that 'data' here should be string while in "serializeError" it should be object.
+// Maybe we should rename serializeError to makeErrorObject or somehting??
+
 // Based on: https://github.com/pinojs/pino-std-serializers
 
 const seen = Symbol('circular-ref-tag')
@@ -136,17 +140,13 @@ Object.defineProperty(pinoErrProto, rawSymbol, {
 
 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
+    return err.length === 0 ? undefined : errSerializer({ message: '', errors: err })
+  } else if (!isErrorLike(err)) {
+    return undefined
+  } else if (err.message === '' && Array.isArray(err.errors) && err.errors.length === 0) {
+    return undefined
+  } else if (err.message === '' && Array.isArray(err.errors) && err.errors.length === 1) {
+    return errSerializer(err.errors[0])
   }
 
   err[seen] = undefined // tag to prevent re-looking at this
@@ -171,20 +171,34 @@ function errSerializer(err) {
         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 {
+      } else if (val != null) {
         _err[key] = val
       }
     }
   }
 
+  if (_err.data != null && typeof _err.data !== 'string') {
+    _err.data = JSON.stringify(_err.data, undefined, 2)
+  }
+
+  if (_err.code != null && typeof _err.code !== 'string') {
+    _err.code = String(_err.code)
+  }
+
+  if (_err.statusCode == null && _err.status != null) {
+    _err.statusCode = Number(_err.status) ?? undefined
+  }
+
+  if (_err.signalCode == null && _err.signal != null) {
+    _err.signalCode = SIGNALS[_err._signal] ?? _err._signal
+  } else if (_err.signalCode != null) {
+    _err.signalCode = SIGNALS[_err.signalCode] ?? _err.signalCode
+  }
+
+  if (_err.exitCode == null && _err.code != null && /^([A-Z]+|[a-z]+|[0-9]+)$/.test(_err.code)) {
+    _err.exitCode = String(_err.code)
+  }
+
   delete err[seen] // clean up tag in case err is serialized again later
   _err.raw = err
   return _err