@nxtedition/lib 21.0.19 → 21.1.1

package/http.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+import assert from 'node:assert'
 import createError from 'http-errors'
 import { performance } from 'perf_hooks'
 import requestTarget from 'request-target'
@@ -8,6 +9,8 @@ import http from 'http'
 import fp from 'lodash/fp.js'
 import tp from 'timers/promises'
 
+const kAbortController = Symbol('abortController')
+
 const ERR_HEADER_EXPR =
   /^(content-length|content-type|te|host|upgrade|trailers|connection|keep-alive|http2-settings|transfer-encoding|proxy-connection|proxy-authenticate|proxy-authorization)$/i
 
@@ -30,6 +33,175 @@ function onTimeout() {
   this.destroy((timeoutError ??= new createError.RequestTimeout()))
 }
 
+export class Context {
+  #id
+  #req
+  #res
+  #ac
+  #url
+  #logger
+  #headers
+  #query
+
+  constructor(req, res, logger) {
+    assert(req)
+    assert(res)
+    assert(logger)
+
+    this.#id = req.headers['request-id'] || genReqId()
+    this.#req = req
+    this.#res = res
+    this.#logger = logger.child({ req: { id: req.id, url: req.url } })
+    this.#headers = {
+      'request-id': this.#id,
+    }
+  }
+
+  setHeader(name, value) {
+    this.#headers[name.toLowerCase()] = value
+  }
+
+  removeHeader(name) {
+    delete this.#headers[name.toLowerCase()]
+  }
+
+  get [kAbortController]() {
+    return this.#ac
+  }
+
+  get signal() {
+    this.#ac ??= new AbortController()
+    return this.#ac.signal
+  }
+
+  get url() {
+    this.#url ??= requestTarget(this.#req)
+    return this.#url
+  }
+
+  set url(value) {
+    this.#req.url = value
+    this.#url = null
+  }
+
+  get query() {
+    this.#query ??= this.url.search.length > 1 ? querystring.parse(this.url.search.slice(1)) : {}
+    return this.#query
+  }
+
+  get logger() {
+    return this.#logger
+  }
+
+  get req() {
+    return this.#req
+  }
+
+  get res() {
+    return this.#res
+  }
+
+  get method() {
+    return this.#req.method
+  }
+
+  get headers() {
+    this.#headers ??= {}
+    return this.#headers
+  }
+}
+
+export async function request2(ctx, next) {
+  const { req, res, logger } = ctx
+  const startTime = performance.now()
+
+  try {
+    if (req.method === 'GET' || req.method === 'HEAD') {
+      req.resume() // Dump the body if there is one.
+    }
+
+    const isHealthcheck = req.url === '/healthcheck' || req.url === '/_up'
+
+    if (!isHealthcheck) {
+      logger.debug({ req }, 'request started')
+    }
+
+    const thenable = next()
+
+    if (thenable?.then) {
+      await thenable
+    }
+
+    const elapsedTime = Math.ceil(performance.now() - startTime)
+
+    if (isHealthcheck) {
+      // Do nothing...
+    } else if (!res.writableEnded) {
+      logger.debug({ res, elapsedTime }, 'request aborted')
+    } else if (res.statusCode >= 500) {
+      logger.error({ res, elapsedTime }, 'request error')
+    } else if (res.statusCode >= 400) {
+      logger.warn({ res, elapsedTime }, 'request failed')
+    } else {
+      logger.debug({ res, elapsedTime }, 'request completed')
+    }
+  } catch (err) {
+    ctx[kAbortController]?.abort(err)
+
+    const statusCode = err.statusCode || err.$metadata?.httpStatusCode || 500
+    const responseTime = Math.ceil(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.write(JSON.stringify(err.body))
+      }
+
+      if (statusCode < 500) {
+        logger.warn({ req, res, err, responseTime }, 'request failed')
+      } else {
+        logger.error({ req, res, err, responseTime }, 'request error')
+      }
+
+      res.end()
+    } else {
+      if (req.aborted || !res.writableEnded || err.name === 'AbortError') {
+        logger.debug({ req, res, err, responseTime }, 'request aborted')
+      } else if (statusCode < 500) {
+        logger.warn({ req, res, err, responseTime }, 'request failed')
+      } else {
+        logger.error({ req, res, err, responseTime }, 'request error')
+      }
+
+      if (!res.writableEnded) {
+        res.destroy()
+      }
+    }
+  }
+}
+
 export async function request(ctx, next) {
   const { req, res, logger } = ctx
   const startTime = performance.now()
@@ -65,12 +237,16 @@ export async function request(ctx, next) {
       reqLogger.debug('request started')
     }
 
-    await Promise.all([
-      next(),
-      new Promise((resolve, reject) => {
-        res.on('timeout', onTimeout).on('error', reject).on('close', resolve)
-      }),
-    ])
+    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 = Math.ceil(performance.now() - startTime)
 

package/package.json

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