@nxtedition/lib 23.3.18 → 23.3.20

package/app.js

@@ -272,7 +272,9 @@ export function makeApp(appConfig, onTerminate) {
   try {
     fs.mkdirSync('./.nxt', { recursive: true })
   } catch (err) {
-    logger.warn({ err }, 'failed to create ./nxt dir')
+    if (err.code !== 'EACCES') {
+      logger.warn({ err }, 'failed to create ./nxt dir')
+    }
   }
 
   let toobusy

package/http.js

@@ -65,12 +65,10 @@ export class Context {
     return this.#userAgent
   }
 
-  /** @deprecated */
   get method() {
     return this.#req.method
   }
 
-  /** @deprecated */
   get url() {
     if (this.#url === undefined) {
       this.#url = requestTarget(this.#req)
@@ -78,8 +76,11 @@ export class Context {
     return this.#url
   }
 
-  /** @deprecated */
   set url(value) {
+    if (value instanceof URL) {
+      value = value.toString()
+    }
+
     if (typeof value !== 'string') {
       throw new Error('url must be a string')
     }
@@ -89,14 +90,16 @@ export class Context {
     this.#query = undefined
   }
 
-  /** @deprecated */
   get query() {
     if (this.#query === undefined) {
-      this.#query = this.url.search.length > 1 ? querystring.parse(this.url.search.slice(1)) : {}
+      this.#query =
+        this.url.search.length > 1 ? Object.freeze(querystring.parse(this.url.search.slice(1))) : {}
     }
     return this.#query
   }
 
+  set query(value) {}
+
   get logger() {
     return this.#logger
   }
@@ -251,135 +254,6 @@ export async function requestMiddleware(ctx, next) {
   }
 }
 
-export async function request(ctx, next) {
-  const { req, res, logger } = ctx
-  const startTime = performance.now()
-
-  const ac = ctx.signal !== undefined ? null : new AbortController()
-
-  let reqLogger = logger
-
-  pendingSet.add(ctx)
-  try {
-    ctx.url = requestTarget(req)
-    if (!ctx.url) {
-      throw new createError.BadRequest('invalid url')
-    }
-
-    ctx.id = req.id = res.id = req.headers['request-id'] || genReqId()
-    ctx.userAgent = req['user-agent'] || req['User-Agent'] || ''
-    ctx.method = req.method
-    ctx.query = ctx.url.search.length > 1 ? querystring.parse(ctx.url.search.slice(1)) : {}
-    ctx.logger =
-      req.log =
-      res.log =
-        logger.child({ req: { id: req.id, url: req.url, userAgent: ctx.userAgent } })
-
-    if (ac) {
-      ctx.signal = ac.signal
-    }
-
-    if (req.method === 'GET' || req.method === 'HEAD') {
-      req.resume() // Dump the body if there is one.
-    }
-
-    res.setHeader('request-id', req.id)
-
-    const isHealthcheck = ctx.url.pathname === '/healthcheck' || ctx.url.pathname === '/_up'
-
-    reqLogger = logger.child({ req })
-    if (!isHealthcheck) {
-      reqLogger.debug('request started')
-    }
-
-    const nextPromise = next()
-    const responsePromise = new Promise((resolve, reject) => {
-      res.on('timeout', onTimeout).on('error', reject).on('close', resolve)
-    })
-
-    if (nextPromise) {
-      await Promise.all([nextPromise, responsePromise])
-    } else if (!res.closed) {
-      await responsePromise
-    }
-
-    const elapsedTime = performance.now() - startTime
-
-    if (isHealthcheck) {
-      // Do nothing...
-    } else if (!res.writableEnded) {
-      reqLogger.debug({ res, elapsedTime }, 'request aborted')
-    } else if (res.statusCode >= 500) {
-      reqLogger.error({ res, elapsedTime }, 'request error')
-    } else if (res.statusCode >= 400) {
-      reqLogger.warn({ res, elapsedTime }, 'request failed')
-    } else {
-      reqLogger.debug({ res, elapsedTime }, 'request completed')
-    }
-  } catch (err) {
-    ac?.abort(err)
-
-    const statusCode = err.statusCode || err.$metadata?.httpStatusCode || 500
-    const elapsedTime = performance.now() - startTime
-
-    if (!res.headersSent && !res.destroyed) {
-      res.statusCode = statusCode
-
-      let reqId = req?.id || err.id
-      for (const name of res.getHeaderNames()) {
-        if (!reqId && name === 'request-id') {
-          reqId = res.getHeader(name)
-        }
-        res.removeHeader(name)
-      }
-
-      if (reqId) {
-        res.setHeader('request-id', reqId)
-      }
-
-      if (fp.isPlainObject(err.headers)) {
-        for (const [key, val] of Object.entries(err.headers)) {
-          if (!ERR_HEADER_EXPR.test(key)) {
-            res.setHeader(key, val)
-          }
-        }
-      }
-
-      if (fp.isPlainObject(err.body)) {
-        res.setHeader('content-type', 'application/json')
-        res.end(JSON.stringify(err.body))
-      } else if (typeof err.body === 'string') {
-        res.end(err.body)
-      } else if (Buffer.isBuffer(err.body)) {
-        res.end(err.body)
-      } else {
-        res.end()
-      }
-
-      if (statusCode < 500) {
-        reqLogger.warn({ res, err, elapsedTime }, 'request failed')
-      } else {
-        reqLogger.error({ res, err, elapsedTime }, 'request error')
-      }
-    } else {
-      if (req.aborted || !res.writableEnded || err.name === 'AbortError') {
-        reqLogger.debug({ res, err, elapsedTime }, 'request aborted')
-      } else if (statusCode < 500) {
-        reqLogger.warn({ res, err, elapsedTime }, 'request failed')
-      } else {
-        reqLogger.error({ res, err, elapsedTime }, 'request error')
-      }
-    }
-  } finally {
-    pendingSet.delete(ctx)
-
-    if (!res.writableEnded) {
-      res.destroy()
-      logger.debug('request destroyed')
-    }
-  }
-}
-
 export class ServerResponse extends http.ServerResponse {
   #created = 0
   #bytesWritten = 0
@@ -570,6 +444,137 @@ export class Http2ServerResponse extends http2.Http2ServerResponse {
   }
 }
 
+/** @deprecated */
+export async function request(ctx, next) {
+  const { req, res, logger } = ctx
+  const startTime = performance.now()
+
+  const ac = ctx.signal !== undefined ? null : new AbortController()
+
+  let reqLogger = logger
+
+  pendingSet.add(ctx)
+  try {
+    ctx.url = requestTarget(req)
+    if (!ctx.url) {
+      throw new createError.BadRequest('invalid url')
+    }
+
+    ctx.id = req.id = res.id = req.headers['request-id'] || genReqId()
+    ctx.userAgent = req['user-agent'] || req['User-Agent'] || ''
+    ctx.method = req.method
+    ctx.query = ctx.url.search.length > 1 ? querystring.parse(ctx.url.search.slice(1)) : {}
+    ctx.logger =
+      req.log =
+      res.log =
+        logger.child({ req: { id: req.id, url: req.url, userAgent: ctx.userAgent } })
+
+    if (ac) {
+      ctx.signal = ac.signal
+    }
+
+    if (req.method === 'GET' || req.method === 'HEAD') {
+      req.resume() // Dump the body if there is one.
+    }
+
+    res.setHeader('request-id', req.id)
+
+    const isHealthcheck = ctx.url.pathname === '/healthcheck' || ctx.url.pathname === '/_up'
+
+    reqLogger = logger.child({ req })
+    if (!isHealthcheck) {
+      reqLogger.debug('request started')
+    }
+
+    const nextPromise = next()
+    const responsePromise = new Promise((resolve, reject) => {
+      res.on('timeout', onTimeout).on('error', reject).on('close', resolve)
+    })
+
+    if (nextPromise) {
+      await Promise.all([nextPromise, responsePromise])
+    } else if (!res.closed) {
+      await responsePromise
+    }
+
+    const elapsedTime = performance.now() - startTime
+
+    if (isHealthcheck) {
+      // Do nothing...
+    } else if (!res.writableEnded) {
+      reqLogger.debug({ res, elapsedTime }, 'request aborted')
+    } else if (res.statusCode >= 500) {
+      reqLogger.error({ res, elapsedTime }, 'request error')
+    } else if (res.statusCode >= 400) {
+      reqLogger.warn({ res, elapsedTime }, 'request failed')
+    } else {
+      reqLogger.debug({ res, elapsedTime }, 'request completed')
+    }
+  } catch (err) {
+    ac?.abort(err)
+
+    const statusCode = err.statusCode || err.$metadata?.httpStatusCode || 500
+    const elapsedTime = performance.now() - startTime
+
+    if (!res.headersSent && !res.destroyed) {
+      res.statusCode = statusCode
+
+      let reqId = req?.id || err.id
+      for (const name of res.getHeaderNames()) {
+        if (!reqId && name === 'request-id') {
+          reqId = res.getHeader(name)
+        }
+        res.removeHeader(name)
+      }
+
+      if (reqId) {
+        res.setHeader('request-id', reqId)
+      }
+
+      if (fp.isPlainObject(err.headers)) {
+        for (const [key, val] of Object.entries(err.headers)) {
+          if (!ERR_HEADER_EXPR.test(key)) {
+            res.setHeader(key, val)
+          }
+        }
+      }
+
+      if (fp.isPlainObject(err.body)) {
+        res.setHeader('content-type', 'application/json')
+        res.end(JSON.stringify(err.body))
+      } else if (typeof err.body === 'string') {
+        res.end(err.body)
+      } else if (Buffer.isBuffer(err.body)) {
+        res.end(err.body)
+      } else {
+        res.end()
+      }
+
+      if (statusCode < 500) {
+        reqLogger.warn({ res, err, elapsedTime }, 'request failed')
+      } else {
+        reqLogger.error({ res, err, elapsedTime }, 'request error')
+      }
+    } else {
+      if (req.aborted || !res.writableEnded || err.name === 'AbortError') {
+        reqLogger.debug({ res, err, elapsedTime }, 'request aborted')
+      } else if (statusCode < 500) {
+        reqLogger.warn({ res, err, elapsedTime }, 'request failed')
+      } else {
+        reqLogger.error({ res, err, elapsedTime }, 'request error')
+      }
+    }
+  } finally {
+    pendingSet.delete(ctx)
+
+    if (!res.writableEnded) {
+      res.destroy()
+      logger.debug('request destroyed')
+    }
+  }
+}
+
+/** @deprecated */
 export function createServer(options, ctx, middleware) {
   middleware = Array.isArray(middleware) ? middleware : [middleware]
   middleware = fp.values(middleware)
@@ -598,6 +603,7 @@ export function createServer(options, ctx, middleware) {
   return server
 }
 
+/** @deprecated */
 export async function upgrade(ctx, next) {
   const { req, res, socket = res, logger } = ctx
 
@@ -674,6 +680,7 @@ export async function upgrade(ctx, next) {
   }
 }
 
+/** @deprecated */
 export function isConnectionError(err) {
   // AWS compat.
   const statusCode = err?.statusCode ?? err?.$metadata?.httpStatusCode
@@ -696,6 +703,7 @@ export function isConnectionError(err) {
     : false
 }
 
+/** @deprecated */
 export function defaultDelay(err, retryCount, options) {
   const { signal, logger = null } = options ?? {}
   if (isConnectionError(err)) {
@@ -708,6 +716,7 @@ export function defaultDelay(err, retryCount, options) {
   }
 }
 
+/** @deprecated */
 export async function retry(fn, options) {
   const { maxRetries = 8, count = maxRetries, delay = defaultDelay, signal } = options ?? {}
 

package/package.json

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

package/rxjs/combineMap.d.ts

@@ -0,0 +1,6 @@
+import type { ObservableInput, OperatorFunction } from 'rxjs'
+
+export default function combineMap<T, R>(
+  project: (value: T) => ObservableInput<R>,
+  equals?: (a: T, b: T) => boolean,
+): OperatorFunction<T[], R[]>

package/serializers.js

@@ -217,11 +217,21 @@ Object.defineProperty(pinoErrProto, rawSymbol, {
 function errSerializer(err) {
   if (Array.isArray(err)) {
     return err.length === 0 ? undefined : errSerializer({ message: '', errors: err })
-  } else if (!isErrorLike(err)) {
+  }
+
+  if (!isErrorLike(err)) {
     return undefined
-  } else if (err.message === '' && Array.isArray(err.errors) && err.errors.length === 0) {
+  }
+
+  const errors = Array.isArray(err?.errors)
+    ? err.errors.map((err) => errSerializer(err)).filter(Boolean)
+    : null
+
+  if (err.message === '' && errors != null && errors.length === 0) {
     return undefined
-  } else if (err.message === '' && Array.isArray(err.errors) && err.errors.length === 1) {
+  }
+
+  if (err.message === '' && errors != null && errors.length === 1) {
     return errSerializer(err.errors[0])
   }
 
@@ -233,8 +243,8 @@ function errSerializer(err) {
   _err.message = err.message
   _err.stack = err.stack
 
-  if (Array.isArray(err.errors)) {
-    _err.aggregateErrors = err.errors.map((err) => errSerializer(err))
+  if (errors != null) {
+    _err.aggregateErrors = errors
   }
 
   if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {

package/trace.js

@@ -1,5 +1,5 @@
 import { threadId } from 'node:worker_threads'
-import { Pool } from 'undici'
+import { request, Pool } from '@nxtedition/nxt-undici'
 import fp from 'lodash/fp.js'
 
 const maxInt = 2147483647
@@ -23,20 +23,20 @@ export function makeTrace({
 
   let pending = 0
 
+  const flushInterval = setInterval(flushTraces, 10e3)
+
   const client = new Pool(Array.isArray(url) ? url[0] : url, {
     keepAliveTimeout: 10 * 60e3,
     pipelining: 4,
     connections: 4,
   })
 
-  const flushInterval = setInterval(flushTraces, 10e3)
-
   destroyers?.push(async () => {
     clearInterval(flushInterval)
+    await client.close()
     while (traceData) {
       await flushTraces()
     }
-    await client.close()
   })
 
   let traceData = ''
@@ -50,18 +50,16 @@ export function makeTrace({
 
     try {
       pending += data.length
-      await client
-        .request({
-          throwOnError: true,
-          path: '/_bulk',
-          method: 'POST',
-          idempotent: true,
-          headers: HEADERS,
-          headersTimeout: 60e3,
-          bodyTimeout: 60e3,
-          body: data,
-        })
-        .then(({ body }) => body.dump())
+      request({
+        path: '/_bulk',
+        method: 'POST',
+        idempotent: true,
+        headers: HEADERS,
+        headersTimeout: 60e3,
+        bodyTimeout: 60e3,
+        body: data,
+        dispatcher: client,
+      }).then(({ body }) => body.dump())
     } catch (err) {
       logger.error({ err }, 'trace failed')
     } finally {