@nxtedition/lib 21.0.18 → 21.1.0

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
 
@@ -24,22 +27,186 @@ export function genReqId() {
   return `req-${nextReqId.toString(36)}`
 }
 
-let reqTimeoutError
-let resTimeoutError
+let timeoutError
 
-function onRequestTimeout() {
-  this.destroy((reqTimeoutError ??= new createError.RequestTimeout()))
+function onTimeout() {
+  this.destroy((timeoutError ??= new createError.RequestTimeout()))
 }
 
-function onResponseTimeout() {
-  this.destroy((resTimeoutError ??= 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()
 
-  const ac = new AbortController()
+  const ac = ctx.signal !== undefined ? null : new AbortController()
 
   let reqLogger = logger
   try {
@@ -49,11 +216,14 @@ export async function request(ctx, next) {
     }
 
     ctx.id = req.id = res.id = req.headers['request-id'] || genReqId()
-    ctx.signal = ac.signal
     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 } })
 
+    if (ac) {
+      ctx.signal = ac.signal
+    }
+
     if (req.method === 'GET' || req.method === 'HEAD') {
       req.resume() // Dump the body if there is one.
     }
@@ -67,16 +237,15 @@ export async function request(ctx, next) {
       reqLogger.debug('request started')
     }
 
-    try {
-      await Promise.all([
-        next(),
-        new Promise((resolve, reject) => {
-          req.on('timeout', onRequestTimeout).on('error', reject)
-          res.on('timeout', onResponseTimeout).on('error', reject).on('close', resolve)
-        }),
-      ])
-    } finally {
-      ac.abort()
+    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)
@@ -93,6 +262,8 @@ export async function request(ctx, next) {
       reqLogger.debug({ res, elapsedTime }, 'request completed')
     }
   } catch (err) {
+    ac?.abort(err)
+
     const statusCode = err.statusCode || err.$metadata?.httpStatusCode || 500
     const responseTime = Math.ceil(performance.now() - startTime)
 
@@ -380,6 +551,8 @@ export async function upgrade(ctx, next) {
 
     reqLogger.debug('stream completed')
   } catch (err) {
+    ac?.abort(err)
+
     const statusCode = err.statusCode || 500
 
     if (aborted || err.name === 'AbortError' || err.code === 'ERR_STREAM_PREMATURE_CLOSE') {

package/package.json

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