webhoster 0.3.2 → 0.3.3

package/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish Package
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  id-token: write  # Required for OIDC
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      # Ensure npm 11.5.1 or later is installed
+      - name: Update npm
+        run: npm install -g npm@latest
+      - run: npm ci
+      - run: npm run build --if-present
+      - run: npm test
+      - run: npm publish

package/helpers/HttpListener.js

@@ -148,6 +148,7 @@ export default class HttpListener {
 
         this.httpServer.keepAliveTimeout = 5000;
         this.httpServer.requestTimeout = 300_000;
+        // @ts-expect-error Missing types
         this.httpServer.setTimeout(120_000, (socket) => {
           if (!socket) {
             console.warn('HTTP socket (unknown) timed out.');
@@ -163,6 +164,7 @@ export default class HttpListener {
           // console.error('HTTP server error', err);
         });
         this.httpServer.addListener('clientError', this.#httpClientErrorListener = (error, socket) => {
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             // console.warn('HTTP client connection reset.');
             return;
@@ -194,6 +196,7 @@ export default class HttpListener {
 
         this.httpsServer.keepAliveTimeout = 5000;
         this.httpsServer.requestTimeout = 300_000;
+        // @ts-expect-error Missing types
         this.httpsServer.setTimeout(120_000, (socket) => {
           if (!socket) {
             // console.warn('HTTPS socket (unknown) timed out.');
@@ -208,6 +211,7 @@ export default class HttpListener {
           // console.error('HTTPS server error', err);
         });
         this.httpsServer.addListener('clientError', this.#httpsClientErrorListener = (error, socket) => {
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             console.warn('HTTPS client connection reset.');
             return;
@@ -237,77 +241,7 @@ export default class HttpListener {
         host: this.secureHost,
       }, () => {
         this.http2Server.removeListener('error', reject);
-
-        /** @type {Set<WeakRef<Http2Session>>} */
-        const sessions = new Set();
-        /** @type {WeakMap<Http2Session, {timestamp:number, identity:string}>} */
-        const sessionMetadata = new WeakMap();
-        /** @type {Set<WeakRef<Http2Stream>>} */
-        const streams = new Set();
-        /** @type {WeakMap<Http2Stream, {timestamp:number, identity:string, path:string}>} */
-        const streamMetadata = new WeakMap();
-        /** @return {void} */
-        function logUsage() {
-          if (global.gc) {
-            console.debug('Perfoming garbage collection.');
-            global.gc();
-          }
-          for (const reference of sessions) {
-            const session = reference.deref();
-            if (!session) {
-              sessions.delete(reference);
-              continue;
-            }
-            const metadata = sessionMetadata.get(session);
-            if (session.destroyed) {
-              console.warn('SESSION destroyed from', metadata.identity, 'since', metadata.timestamp);
-            } else {
-              console.debug('SESSION alive from', metadata.identity, 'since', metadata.timestamp);
-            }
-          }
-          for (const reference of streams) {
-            const stream = reference.deref();
-            if (!stream) {
-              streams.delete(reference);
-              continue;
-            }
-            const metadata = streamMetadata.get(stream);
-            if (stream.destroyed) {
-              console.warn('STREAM destroyed from', metadata.identity, 'since', metadata.timestamp, 'for', metadata.path);
-            } else {
-              console.debug('STREAM alive from', metadata.identity, 'since', metadata.timestamp, 'for', metadata.path);
-            }
-          }
-          if (sessions.size) {
-            console.debug('Active sessions:', sessions.size);
-          }
-          if (streams.size) {
-            console.debug('Active streams:', streams.size);
-          }
-          if ('process' in globalThis) {
-            if ('getActiveResourcesInfo' in globalThis.process) {
-              console.dir('Active Resources', globalThis.process.getActiveResourcesInfo());
-            }
-            if ('_getActiveRequests' in globalThis.process) {
-              console.dir('Active Requests', globalThis.process._getActiveRequests());
-            }
-            if ('_getActiveHandles' in globalThis.process) {
-              const handles = globalThis.process._getActiveHandles();
-              for (const handle of handles) {
-                if (handle instanceof Socket) {
-                  console.debug('Active Handle (Socket)', `${handle.localAddress}:${handle.localPort} <=> ${handle.remoteAddress}:${handle.remotePort}`);
-                } else if (handle instanceof Server) {
-                  console.debug('Active Handle (Server)', `${handle.address()?.port}`);
-                } else {
-                  console.debug('Active Handle (unknown)', handle);
-                }
-              }
-            }
-          }
-        }
-        // setInterval(logUsage, 300_000);
-        // logUsage();
-
+        // @ts-expect-error Missing types
         this.http2Server.setTimeout(120_000, (socket) => {
           if (!socket) {
             console.warn('HTTP2 socket (unknown) timed out.');
@@ -325,6 +259,7 @@ export default class HttpListener {
         this.http2Server.addListener('clientError', this.#http2ClientErrorListener = (error, socket) => {
           // No clear way to signal back to client why a socket has failed because
           // it's unsure if it's HTTP1 or HTTP2. Just destroy and log server-side.
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             // console.warn('HTTP/2 client connection reset.');
           } else {
@@ -333,6 +268,7 @@ export default class HttpListener {
           if (!socket.destroyed) socket.destroy(error);
         });
         this.http2Server.addListener('sessionError', this.#http2SessionErrorListener = (error, session) => {
+          // @ts-expect-error Missing types
           if (error?.code === 'ECONNRESET') {
             // console.warn('HTTP/2 client connection reset.');
           } else if (error?.message === 'SOCKET_TIMEOUT') {
@@ -344,12 +280,7 @@ export default class HttpListener {
         });
 
         this.http2Server.addListener('session', this.#http2SessionListener = (session) => {
-          sessions.add(new WeakRef(session));
           const identity = `${session.socket.remoteFamily}:${session.socket.remoteAddress}:${session.socket.remotePort}`;
-          sessionMetadata.set(session, {
-            timestamp: performance.now(),
-            identity,
-          });
           session.setTimeout(60_000, () => {
             // console.warn(`HTTP/2 session ${identity} timed out.`);
             session.destroy(new Error('SESSION_TIMEOUT'));
@@ -361,6 +292,7 @@ export default class HttpListener {
               session.ping((error) => {
                 if (!error) return;
                 if (session.destroyed) return;
+                // @ts-expect-error Missing types
                 if (error.code === 'ERR_HTTP2_PING_CANCEL') return;
                 console.error(`Ping to ${identity} failed.`, error);
               });
@@ -373,49 +305,42 @@ export default class HttpListener {
 
         // Logic handlers
         this.http2Server.addListener('stream', this.#http2StreamListener = (stream, headers) => {
-          streams.add(new WeakRef(stream));
-          streamMetadata.set(stream, {
-            timestamp: performance.now(),
-            identity: `${stream.session?.socket.remoteFamily}:${stream.session?.socket.remoteAddress}:${stream.session?.socket.remotePort}`,
-            path: headers[':path'],
-          });
-
           stream.setTimeout(300_000, () => {
             stream.destroy(new Error('SOCKET_TIMEOUT'));
           });
           stream.addListener('error', (error) => {
+            // @ts-expect-error Missing types
             if (error?.code === 'ECONNRESET') {
               // console.warn('HTTP/2 stream connection reset.', headers[':path']);
             } else {
               console.error('HTTP/2 stream error', headers, error);
             }
           });
+          // @ts-expect-error Missing types
           this.httpHandler.handleHttp2Stream(stream, headers).catch((error) => {
             console.error('HTTP2 handler failed.', error);
           });
         });
-        this.http2Server.addListener('request', this.#http2RequestListener = (request, res) => {
+        this.http2Server.addListener('request', this.#http2RequestListener = (request, response) => {
           if (request.httpVersionMajor >= 2) return;
-          // @ts-ignore Ignore typings
+          // @ts-expect-error Missing types
           request.setTimeout(300_000, (socket) => {
             if (!socket) {
               // console.warn('HTTP1 in HTTP2 request (unknown) timed out.');
               return;
             }
-            // const identity = `${socket.remoteFamily}:${socket.remoteAddress}:${socket.remotePort}`;
-            // console.warn(`HTTP1 in HTTP2 request ${identity} timed out.`);
             socket.destroy(new Error('SOCKET_TIMEOUT'));
           });
-          res.setTimeout(300_000, (socket) => {
+          // @ts-expect-error Missing types
+          response.setTimeout(300_000, (socket) => {
             if (!socket) {
               // console.warn('HTTP1 in HTTP2 response (unknown) timed out.');
               return;
             }
-            const identity = `${socket.remoteFamily}:${socket.remoteAddress}:${socket.remotePort}`;
-            // console.warn(`HTTP1 in HTTP2 response ${identity} timed out.`);
             socket.destroy(new Error('SOCKET_TIMEOUT'));
           });
           request.addListener('error', (error) => {
+            // @ts-expect-error Missing types
             if (error?.code === 'ECONNRESET') {
               // console.warn('Request stream connection reset.', req.url);
             } else {
@@ -425,17 +350,18 @@ export default class HttpListener {
               request.destroy(error);
             }
           });
-          res.addListener('error', (error) => {
+          response.addListener('error', (error) => {
+            // @ts-expect-error Missing types
             if (error?.code === 'ECONNRESET') {
               // console.warn('Response stream connection reset.', req.url);
             } else {
               console.error('Response stream error', request.url, request.headers, error);
             }
-            if (!res.destroyed) {
-              res.destroy(error);
+            if (!response.destroyed) {
+              response.destroy(error);
             }
           });
-          this.httpHandler.handleHttp1Request(request, res).catch((error) => {
+          this.httpHandler.handleHttp1Request(request, response).catch((error) => {
             console.error('HTTP1 in HTTP2 handler failed.', error);
           });
         });

package/helpers/RequestReader.js

@@ -2,7 +2,6 @@
 
 import { TextDecoder } from 'node:util';
 import AsyncObject from '../utils/AsyncObject.js';
-import { noop } from '../utils/function.js';
 import RequestHeaders from './RequestHeaders.js';
 
 /**
@@ -11,7 +10,6 @@ import RequestHeaders from './RequestHeaders.js';
  */
 
 const BUFFER_SIZE = 4096;
-const STREAM_WAIT_MS = 0;
 
 /** @type {WeakMap<HttpRequest, RequestReader>} */
 const cache = new WeakMap();
@@ -45,8 +43,6 @@ export default class RequestReader {
     const hp = new RequestHeaders(this.request);
     let data = Buffer.allocUnsafe(Math.min(BUFFER_SIZE, hp.contentLength || BUFFER_SIZE));
     let bytesWritten = 0;
-    /** @type {NodeJS.Timeout} */
-    let sendPingTimeout = null;
     this.request.stream.on('readable', () => {
       let chunk;
       // eslint-disable-next-line no-cond-assign
@@ -70,15 +66,8 @@ export default class RequestReader {
         }
         bytesWritten += buffer.copy(data, bytesWritten);
       }
-      clearTimeout(sendPingTimeout);
-      if (this.request.canPing) {
-        sendPingTimeout = setTimeout(() => {
-          this.request.ping().catch(noop);
-        }, STREAM_WAIT_MS);
-      }
     });
     this.request.stream.on('end', () => {
-      clearTimeout(sendPingTimeout);
       if (data.length > bytesWritten) {
         // Must partition to clear unsafe allocation
         data = data.subarray(0, bytesWritten);

package/lib/HttpHandler.js

@@ -145,6 +145,7 @@ export default class HttpHandler {
 
     // Check if error handler
     const isErrorHandler = (typeof middleware === 'object'
+      && 'onError' in middleware
       && typeof middleware.onError === 'function');
 
     let value = middleware;
@@ -186,6 +187,7 @@ export default class HttpHandler {
           }
 
           // Sync operation returned Promise
+          // @ts-expect-error TS improperly thinks result can be null
           if (typeof result === 'object' && typeof result.then === 'function') {
             if (isErrorHandler) transaction.error = null;
             result = await result;
@@ -216,6 +218,7 @@ export default class HttpHandler {
           const { treeIndex } = transaction.state;
           treeIndex.push(-1);
           const { length } = value;
+          // eslint-disable-next-line no-plusplus
           for (let index = 0; index < length; index++) {
             const innerMiddleware = value[index];
             treeIndex[treeIndex.length - 1] += 1;
@@ -333,6 +336,7 @@ export default class HttpHandler {
 
     const request = new HttpRequest({
       headers,
+      // @ts-expect-error JSDoc syntax limitation
       method,
       stream: incomingMessage,
 
@@ -428,7 +432,7 @@ export default class HttpHandler {
       }
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    // eslint-disable-next-line @typescript-eslint/no-this-alias, unicorn/no-this-assignment
     const context = this;
 
     /** @type {Promise<any>[]} */
@@ -436,6 +440,7 @@ export default class HttpHandler {
 
     const request = new HttpRequest({
       headers,
+      // @ts-expect-error JSDoc syntax limitation
       method,
       stream,
 
@@ -492,7 +497,7 @@ export default class HttpHandler {
           'cache-control',
         ]) {
           if (passedHeader in headers) {
-            // @ts-ignore Coerce
+            // @ts-expect-error Coerce
             newHeaders[passedHeader] = headers[passedHeader];
           }
         }
@@ -500,10 +505,15 @@ export default class HttpHandler {
         // Build promise function
         const promiseFunction = async () => {
           try {
+            /** @type {import('node:http2').ServerHttp2Stream} */
             const pushStream = await new Promise((resolve, reject) => {
-              stream.pushStream(newHeaders, ((error, newStream) => (error ? reject(error) : resolve(newStream))));
+              stream.pushStream(
+                newHeaders,
+                ((error, newStream) => (error ? reject(error) : resolve(newStream))),
+              );
             });
             pushStream.addListener('error', (error) => {
+              // @ts-expect-error Missing types
               if (error?.code === 'ECONNRESET') {
                 console.warn('HTTP/2 stream connection reset.', headers[':path']);
               } else {

package/lib/HttpRequest.js

@@ -140,7 +140,9 @@ export default class HttpRequest {
     if (this.#readable === undefined) {
       if (this.method === 'GET' || this.method === 'HEAD') {
         this.#readable = null;
+      // @ts-expect-error Missing types
       } else if (Readable.toWeb) {
+        // @ts-expect-error Missing types
         this.#readable = Readable.toWeb(this.stream);
         this.#bodyUsed = true;
       } else {
@@ -226,7 +228,7 @@ export default class HttpRequest {
   }
 
   /**
-   * @return {Promise<ArrayBuffer>}
+   * @return {Promise<ArrayBufferLike>}
    */
   async arrayBuffer() {
     try {
@@ -264,7 +266,7 @@ export default class HttpRequest {
       try {
         const module = await import('node:buffer');
         if ('Blob' in module === false) throw new Error('NOT_SUPPORTED');
-        BlobClass = module.Blob;
+        BlobClass = /** @type {typeof Blob} */ (module.Blob);
       } catch {
         BlobClass = null;
       }
@@ -389,6 +391,7 @@ export default class HttpRequest {
     }
   }
 
+  // eslint-disable-next-line class-methods-use-this
   async formData() {
     throw new Error('UNSUPPORTED_MEDIA_TYPE');
   }

package/lib/HttpResponse.js

@@ -124,6 +124,7 @@ export default class HttpResponse {
   async sendRaw(body) {
     this.body = body;
     await new Promise((resolve, reject) => {
+      // @ts-expect-error Error is any
       this.stream.end(body, (error) => (error ? reject(error) : resolve()));
     });
     return 0;
@@ -135,7 +136,7 @@ export default class HttpResponse {
   }
 
   /**
-   * @param {Transform} stream
+   * @param {import('stream').Transform} stream
    * @return {this}
    */
   addUpstream(stream) {
@@ -162,6 +163,7 @@ export default class HttpResponse {
       // Called directly by user and needs finalizer calls
 
       this.isStreaming = true;
+      // eslint-disable-next-line no-plusplus
       for (let index = 0; index < this.finalizers.length; index++) {
         const process = this.finalizers[index];
         const result = process(this);
@@ -183,11 +185,13 @@ export default class HttpResponse {
       ];
     }
 
-    this.#pipeline = array[0];
-    // @ts-ignore Bad typings
+    // eslint-disable-next-line prefer-destructuring
+    this.#pipeline = /** @type {Writable} */ (array[0]);
+    // @ts-expect-error Bad typings
     pipeline(array, (error) => {
       this.#pipelineComplete = true;
       let nextCallback;
+      // eslint-disable-next-line no-cond-assign
       while ((nextCallback = this.#pipelineCallbacks.shift()) != null) {
         nextCallback(error);
       }
@@ -282,6 +286,7 @@ export default class HttpResponse {
     /** @type {void|Promise<boolean|void>} */
     let pendingPromise;
     let index;
+    // eslint-disable-next-line no-plusplus
     for (index = 0; index < this.finalizers.length; index++) {
       const process = this.finalizers[index];
       if (needsAsync) {
@@ -303,6 +308,7 @@ export default class HttpResponse {
     if (pendingPromise) {
       pendingPromise.then(async (initialResult) => {
         if (initialResult !== false) {
+          // eslint-disable-next-line no-plusplus
           for (index = 0; index < pendingProcessors.length; index++) {
             const process = pendingProcessors[index];
             const result = process(this);

package/middleware/ContentDecoderMiddleware.js

@@ -1,5 +1,6 @@
 import { Transform } from 'node:stream';
 import {
+  // @ts-expect-error Bad typings
   BrotliDecompress, Gunzip, Inflate,
 } from 'node:zlib';
 
@@ -69,17 +70,20 @@ export default class ContentDecoderMiddleware {
     const gzipOptions = { chunkSize: this.chunkSize };
     const newDownstream = new Transform({
 
-      read: (...args) => {
+      read: (...arguments_) => {
         if (!initialized) {
           /** @type {import("zlib").Gzip} */
           switch (contentEncoding) {
             case 'deflate':
+              // @ts-expect-error Bad typings
               gzipStream = new Inflate(gzipOptions);
               break;
             case 'gzip':
+              // @ts-expect-error Bad typings
               gzipStream = new Gunzip(gzipOptions);
               break;
             case 'br':
+              // @ts-expect-error Bad typings
               gzipStream = new BrotliDecompress(gzipOptions);
               break;
             default:
@@ -89,7 +93,7 @@ export default class ContentDecoderMiddleware {
           // To newDownstream <= gzipStream < =inputStream
 
           // Forward errors
-          gzipStream.on('error', (err) => inputStream.emit('error', err));
+          gzipStream.on('error', (error) => inputStream.emit('error', error));
           gzipStream.on('data', (chunk) => newDownstream.push(chunk));
 
           inputStream.on('end', () => gzipStream.end());
@@ -104,12 +108,13 @@ export default class ContentDecoderMiddleware {
           initialized = true;
         }
 
-        Transform.prototype._read.call(this, ...args);
+        // eslint-disable-next-line no-underscore-dangle
+        Transform.prototype._read.call(this, ...arguments_);
       },
       transform: (chunk, chunkEncoding, callback) => {
-        gzipStream.write(chunk, (err) => {
-          if (err) console.error(err);
-          callback(err);
+        gzipStream.write(chunk, (error) => {
+          if (error) console.error(error);
+          callback(error);
         });
       },
       flush: (callback) => {
@@ -129,7 +134,6 @@ export default class ContentDecoderMiddleware {
       },
     });
 
-    newDownstream.tag = 'ContentDecoder';
     inputStream = request.addDownstream(newDownstream, { autoPause: true });
 
     return CONTINUE;

package/middleware/ContentEncoderMiddleware.js

@@ -75,8 +75,9 @@ export default class ContentEncoderMiddleware {
     let encoding = COMPATIBLE_ENCODINGS[0];
     const allowWildcards = (encodings.get('*')?.q !== 0);
     const encodingEntries = [...encodings.entries()];
-    // @ts-expect-error Cannot cast to COMPATIBLE_ENCODINGS
-    encoding = (encodingEntries.find(([value, spec]) => spec.q !== 0 && COMPATIBLE_ENCODINGS.includes(value))?.[0]);
+    encoding = /** @type {COMPATIBLE_ENCODING} */ (encodingEntries
+      .find(([value, spec]) => spec.q !== 0
+        && COMPATIBLE_ENCODINGS.includes(/** @type {COMPATIBLE_ENCODING} */ (value)))?.[0]);
     if (allowWildcards && (encoding === '*' || !encoding)) {
       // Server preference
       // Get first compatible encoding not specified
@@ -154,7 +155,7 @@ export default class ContentEncoderMiddleware {
       encoding = getContentEncoding().toLowerCase?.();
     }
 
-    const isEventStream = response.headers['content-type']?.includes('text/event-stream');
+    const isEventStream = /** @type {string|null} */ (response.headers['content-type'])?.includes('text/event-stream');
 
     let newStream;
     switch (encoding) {

package/package.json

@@ -24,7 +24,16 @@
     "node": ">v16.13"
   },
   "exports": {
-    "./*": "./*"
+    "./data/*": "./data/*",
+    "./errata/*": "./errata/*",
+    "./examples/*": "./examples/*",
+    "./helpers/*": "./helpers/*",
+    "./lib/*": "./lib/*",
+    "./middlewares/*": "./middlewares/*",
+    "./polyfills/*": "./polyfills/*",
+    "./templates/*": "./templates/*",
+    "./types/*": "./types/*",
+    "./utils/*": "./utils/*"
   },
   "keywords": [
     "http",
@@ -42,6 +51,7 @@
   "scripts": {
     "debug-test": "ava --serial",
     "test": "c8 ava",
+    "prepublishOnly": "rm -Rf typings && tsc --emitDeclarationOnly",
     "pretestallsync": "rimraf coverage",
     "testallsync": "scripts/test-all-sync.sh",
     "posttestallsync": "c8 report",
@@ -50,5 +60,6 @@
     "posttestall": "c8 report"
   },
   "type": "module",
-  "version": "0.3.2"
-}
+  "types": "typings/index.d.ts",
+  "version": "0.3.3"
+}

package/tsconfig.json

@@ -1,12 +1,30 @@
 {
   "compilerOptions": {
+    "allowJs": true,
     "checkJs": true,
     "noImplicitAny": true,
+    "declaration": true,
+    "declarationMap": true,
+    "declarationDir": "typings",
+    "outDir": "/dev/null",
     "target": "es2022",
     "module": "esnext",
     "moduleResolution": "node"
   },
+  "include": [
+    "./data/*",
+    "./errata/*",
+    "./examples/*",
+    "./helpers/*",
+    "./lib/*",
+    "./middlewares/*",
+    "./polyfills/*",
+    "./templates/*",
+    "./types/*",
+    "./utils/*"
+  ],
   "exclude": [
-    "**/node_modules/*"
+    "**/node_modules/*",
+    "**/test/*"
   ]
 }

package/types/index.js

@@ -16,7 +16,7 @@
 
 /** @typedef {import('node:stream').Duplex} Duplex */
 
-/** @typedef {import('./typings').Middleware} Middleware */
+/** @typedef {import('./typings.js').Middleware} Middleware */
 
 /** @typedef {true|false|0} MiddlewareFlowInstruction */