@nxtedition/lib 26.5.0 → 26.7.0

package/http.js

@@ -35,6 +35,9 @@ function onTimeout() {
   this.destroy((timeoutError ??= new createError.RequestTimeout()))
 }
 
+const pending = (globalThis.__nxt_lib_http_pending = [])
+const kPendingIndex = Symbol('pendingIndex')
+
 // TODO (fix): Make custom ServerRequest class with the properties
 // that is currently deprecated by Context.
 
@@ -45,7 +48,9 @@ export class Context {
   #ac
   #logger
   #query
-  #target
+  #target;
+
+  [kPendingIndex] = -1
 
   constructor(req, res, logger) {
     assert(req)
@@ -210,6 +215,8 @@ export async function requestMiddleware(ctx, next) {
   if (stats?.pending != null) {
     stats.pending++
   }
+
+  ctx[kPendingIndex] = pending.push(ctx) - 1
   try {
     const isHealthcheck = req.url === '/healthcheck' || req.url === '/_up'
     if (!isHealthcheck) {
@@ -364,6 +371,16 @@ export async function requestMiddleware(ctx, next) {
       res.destroy()
       ctx.logger?.warn('request destroyed')
     }
+
+    {
+      const idx = ctx[kPendingIndex]
+      const tmp = pending.pop()
+      if (tmp !== ctx) {
+        pending[idx] = tmp
+        pending[idx][kPendingIndex] = idx
+        tmp[kPendingIndex] = -1
+      }
+    }
   }
 }
 

package/package.json

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

package/shared.js

@@ -1,3 +1,6 @@
+import stream from 'node:stream'
+import assert from 'node:assert'
+
 // By placing the read and write indices far apart (multiples of a common
 // cache line size, 64 bytes), we prevent "false sharing". This is a
 // low-level CPU optimization where two cores writing to different variables
@@ -91,12 +94,16 @@ export function reader({ sharedState, sharedBuffer }) {
         // Instead, we pass a "view" into the shared buffer.
         data.offset = dataPos
         data.length = dataLen
-        next(data)
+        const cont = next(data)
 
         if (readPos === writePos) {
           // If we reach the end of the buffer, we must re-check the writer's position.
           writePos = Atomics.load(state, WRITE_INDEX) | 0
         }
+
+        if (cont === false) {
+          break
+        }
       }
     }
 
@@ -296,7 +303,7 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
    * @param {number} len The maximum expected length of the payload.
    * @param {({ buffer, view, offset, length }) => number} fn The callback that writes the data.
    */
-  function write(len, fn) {
+  function writeSync(len, fn) {
     if (len < 0) {
       throw new Error(`Length ${len} is negative`)
     }
@@ -325,6 +332,30 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     }
   }
 
+  function tryWrite(len, fn) {
+    if (len < 0) {
+      throw new Error(`Length ${len} is negative`)
+    }
+    if (len >= 2 ** 31 || len > size - 8) {
+      throw new Error(`Length ${len} exceeds maximum allowed size`)
+    }
+
+    if (!_acquire(len)) {
+      readPos = Atomics.load(state, READ_INDEX) | 0
+      if (!_acquire(len)) {
+        return false
+      }
+    }
+
+    _write(len, fn)
+
+    if (writePos === readPos) {
+      throw new Error(`Write position ${writePos} cannot equal read position ${readPos}`)
+    }
+
+    return true
+  }
+
   function _flush() {
     if (pending > 0) {
       Atomics.store(state, WRITE_INDEX, writePos)
@@ -341,5 +372,120 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     }
   }
 
-  return { write, cork }
+  return { tryWrite, writeSync, cork }
+}
+
+export class Writable extends stream.Writable {
+  #writer
+  #retries = 0
+  #timeout = null
+
+  #chunk
+  #encoding
+  #callback
+
+  constructor({ state, ...options }) {
+    super({ ...options })
+    this.#writer = writer(state)
+  }
+
+  _write(chunk, encoding, callback) {
+    if (chunk.byteLength === 0) {
+      callback(null)
+      return
+    }
+
+    assert(!this.#timeout)
+
+    this.#chunk = chunk
+    this.#encoding = encoding
+    this.#callback = callback
+    this._writeSome()
+  }
+
+  _final(callback) {
+    this.#chunk = Buffer.allocUnsafe(0)
+    this.#encoding = null
+    this.#callback = callback
+    this._writeSome()
+  }
+
+  _writeSome = () => {
+    this.#timeout = null
+
+    if (this.#writer.tryWrite(this.#chunk.byteLength, this._doWrite)) {
+      const callback = this.#callback
+      this.#retries = 0
+      this.#chunk = null
+      this.#encoding = null
+      this.#callback = null
+      callback(null)
+    } else {
+      this.#retries += 1
+      this.#timeout = setTimeout(this._writeSome, Math.min(10, this.#retries))
+    }
+  }
+
+  _doWrite = (data) => {
+    const written =
+      typeof this.#chunk === 'string'
+        ? data.buffer.write(this.#chunk, data.offset, data.length, this.#encoding)
+        : this.#chunk.copy(data.buffer, data.offset, 0, this.#chunk.length)
+    return data.offset + written
+  }
+
+  _destroy(err, callback) {
+    if (this.#timeout != null) {
+      clearTimeout(this.#timeout)
+      this.#timeout = null
+    }
+    callback(err)
+  }
+}
+
+export class Readable extends stream.Readable {
+  #reader
+  #retries = 0
+  #timeout
+
+  constructor({ state, ...options }) {
+    super(options)
+    this.#reader = reader(state)
+  }
+
+  _read() {
+    assert(!this.#timeout)
+
+    this._readSome()
+  }
+
+  _readSome = () => {
+    this.#timeout = null
+
+    const count = this.#reader.readSome((data) => {
+      if (data.length === 0) {
+        this.push(null)
+        return false
+      }
+
+      const chunk = Buffer.allocUnsafe(data.length)
+      data.buffer.copy(chunk, 0, data.offset, data.offset + data.length)
+      return this.push(chunk)
+    })
+
+    if (count > 0 || this.readableEnded) {
+      this.#retries = 0
+    } else {
+      this.#retries += 1
+      this.#timeout = setTimeout(this._readSome, Math.min(10, this.#retries))
+    }
+  }
+
+  _destroy(err, callback) {
+    if (this.#timeout != null) {
+      clearTimeout(this.#timeout)
+      this.#timeout = null
+    }
+    callback(err)
+  }
 }