webhoster 0.1.0 → 0.3.0

package/lib/HttpHandler.js

@@ -1,46 +1,34 @@
-import { PassThrough } from 'stream';
+import { posix } from 'node:path';
+import { promisify } from 'node:util';
 
-import AsyncObject from '../utils/AsyncObject.js';
-import { noop } from '../utils/function.js';
+import { isWritable } from '../utils/stream.js';
 
 import HttpRequest from './HttpRequest.js';
 import HttpResponse from './HttpResponse.js';
+import HttpTransaction from './HttpTransaction.js';
 
 /** @typedef {import('../types').Middleware} Middleware */
 /** @typedef {import('../types').MiddlewareErrorHandler} MiddlewareErrorHandler */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-/** @typedef {import('../types').MiddlewareFunctionResultType} MiddlewareFunctionResultType */
+/** @typedef {import('../types').MiddlewareFlowInstruction} MiddlewareFlowInstruction */
 /** @typedef {import('../types').RequestMethod} RequestMethod */
-/** @typedef {import('../types/index.js').HandlerState} HandlerState */
 
 /** @type {HttpHandler} */
 let defaultInstance = null;
 
-/**
- * @param {Middleware} middleware
- * @return {boolean}
- */
-function isErrorHandler(middleware) {
-  return !!middleware && typeof middleware === 'object' && 'onError' in middleware && middleware.onError != null;
-}
-
 /**
  * @typedef {Object} HttpHandlerOptions
- * @prop {Middleware[]} [preprocessors]
- * @prop {Set<Middleware>} [middleware]
+ * @prop {Middleware[]} [middleware]
  * @prop {MiddlewareErrorHandler[]} [errorHandlers]
  */
 export default class HttpHandler {
-  /** @param {HttpHandlerOptions} options */
-  constructor(options = {}) {
-    this.preprocessors = options.preprocessors || [];
-    this.middleware = options.middleware || new Set();
-    this.errorHandlers = options.errorHandlers || [];
-    this.handleRequest = this.handleRequest.bind(this);
-    this.handleHttp1Request = this.handleHttp1Request.bind(this);
-    this.handleHttp2Stream = this.handleHttp2Stream.bind(this);
-  }
+  /** @type {true} */
+  static CONTINUE = true;
+
+  /** @type {false} */
+  static BREAK = false;
+
+  /** @type {0} */
+  static END = 0;
 
   /** @return {HttpHandler} */
   static get defaultInstance() {
@@ -51,329 +39,511 @@ export default class HttpHandler {
   }
 
   /**
-   * @param {Object} params
-   * @param {HttpRequest} params.req
-   * @param {HttpResponse} params.res
-   * @return {Promise<HttpResponse>}
+   * @param {any} result
+   * @return {?MiddlewareFlowInstruction}
    */
-  handleRequest({ req, res }) {
-    /** @type {HandlerState} */
-    const state = { treeIndex: [] };
-    let isInErrorState = false;
-    /** @type {any} */
-    let caughtError = null;
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const context = this;
-    /**
-     * @param {Middleware} middleware
-     * @return {Promise<MiddlewareFunctionResult>}
-     */
-    function handleMiddleware(middleware) {
-      const isMiddlewareAnErrorHandler = isErrorHandler(middleware);
-      if (isInErrorState) {
-        if (isMiddlewareAnErrorHandler) {
-          isInErrorState = false;
-          /** @type {MiddlewareFunctionResult} */
-          let returnValue;
-          try {
-            returnValue = /** @type {MiddlewareErrorHandler} */ (middleware)
-              .onError({
-                req, res, state, err: caughtError,
-              });
-          } catch (err) {
-            isInErrorState = true;
-            caughtError = err;
-            returnValue = 'continue';
-          }
-          return Promise.resolve().then(() => returnValue);
-        }
-        if (middleware !== context.errorHandlers) {
-        // Consume and advance
-          return Promise.resolve();
-        }
-      } else if (isMiddlewareAnErrorHandler) {
-      // Don't run error handler if not in error state.
-        return Promise.resolve();
-      }
+  static ParseResultSync(result) {
+    // Fast return
+    switch (result) {
+      case true:
+      case null:
+      case undefined:
+      case HttpHandler.CONTINUE:
+        return HttpHandler.CONTINUE;
+      case false:
+      case HttpHandler.BREAK:
+        return HttpHandler.BREAK;
+      case 0:
+        return HttpHandler.END;
+      default:
+    }
+    return null;
+  }
 
-      if (typeof middleware === 'boolean') {
-        if (middleware === false) {
-          return Promise.resolve('break');
-        }
-        return Promise.resolve();
-      }
+  /**
+   * @param {string} scheme
+   * @param {string} authority
+   * @param {string} path
+   */
+  static parseURL(scheme, authority, path) {
+    let query = '';
+    let fragment = '';
 
-      switch (middleware) {
-        case 'break':
-          return Promise.resolve('break');
-        case 'end':
-          return Promise.resolve('end');
-        case 'continue':
-          return Promise.resolve();
-        default:
-      }
+    const authoritySplit = authority.split(':');
+    let pathname = '';
+    let search = '';
+    let hash = '';
+    const queryIndex = path.indexOf('?');
+    const fragmentIndex = path.indexOf('#');
+    const hasQuery = queryIndex !== -1;
+    const hasFragment = fragmentIndex !== -1;
 
-      if (middleware === null || typeof middleware === 'string' || typeof middleware === 'undefined') {
-        return Promise.resolve();
+    // URL variables
+    pathname = path;
+    if (hasQuery && hasFragment) {
+      // Both ? and # present
+      if (queryIndex < fragmentIndex) {
+        pathname = path.slice(0, queryIndex);
+        search = path.slice(queryIndex, fragmentIndex);
+        hash = path.slice(fragmentIndex);
+        query = search.slice(1);
+        fragment = hash.slice(1);
+      } else {
+        // # comes before ?, treat as no query
+        pathname = path.slice(0, fragmentIndex);
+        hash = path.slice(fragmentIndex);
+        fragment = hash.slice(1);
       }
+    } else if (hasQuery) {
+      pathname = path.slice(0, queryIndex);
+      search = path.slice(queryIndex);
+      query = search.slice(1);
+    } else if (hasFragment) {
+      pathname = path.slice(0, fragmentIndex);
+      hash = path.slice(fragmentIndex);
+      fragment = hash.slice(1);
+    } else {
+      pathname = path;
+    }
+    // Remove dot segments
+    pathname = posix.normalize(pathname);
+
+    return {
+      href: `${scheme}://${authority}${pathname}${search}${hash}`,
+      origin: `${scheme}://${authority}`,
+      protocol: `${scheme}:`,
+      username: '',
+      password: '',
+      host: authority,
+      hostname: authoritySplit[0],
+      port: authoritySplit[1] ?? '',
+      pathname,
+      search,
+      hash,
+      query,
+      fragment,
+      url: `${scheme}://${authority}${path}`,
+    };
+  }
 
-      if (middleware instanceof Map) {
-        return handleMiddleware(middleware.values());
+  /** @param {HttpHandlerOptions} options */
+  constructor(options = {}) {
+    this.middleware = options.middleware || [];
+    this.errorHandlers = options.errorHandlers || [];
+    this.handleTransaction = this.handleTransaction.bind(this);
+    this.handleHttp1Request = this.handleHttp1Request.bind(this);
+    this.handleHttp2Stream = this.handleHttp2Stream.bind(this);
+  }
+
+  /**
+   * @param {HttpTransaction} transaction
+   * @param {Middleware} middleware
+   * @return {Promise<MiddlewareFlowInstruction>}
+   */
+  async processMiddleware(transaction, middleware) {
+    if (middleware == null) return HttpHandler.CONTINUE;
+
+    // Check if error handler
+    const isErrorHandler = (typeof middleware === 'object'
+      && typeof middleware.onError === 'function');
+
+    let value = middleware;
+    if (transaction.error) {
+      if (isErrorHandler) {
+        value = middleware.onError;
+      } else if (!transaction.isErrorHandlerState()) {
+        if (middleware !== this.errorHandlers) return HttpHandler.CONTINUE;
+        transaction.setErrorHandlerState();
       }
+    } else if (isErrorHandler) {
+      return HttpHandler.CONTINUE;
+    }
+
+    let syncResult = HttpHandler.ParseResultSync(value);
+    if (syncResult != null) {
+      return syncResult;
+    }
 
-      if (Symbol.iterator in middleware) {
-        const iterator = (/** @type {Iterable<Middleware>} */ (middleware))[Symbol.iterator]();
+    /** @type {?MiddlewareFlowInstruction} */
+    let result;
+    switch (typeof value) {
+      case 'number':
+        transaction.response.status = value;
+        try {
+          return transaction.response.end();
+        } catch (error) {
+          transaction.error = error;
+          return HttpHandler.CONTINUE;
+        }
+      case 'function':
+        try {
+          result = value.constructor.name === 'AsyncFunction'
+            ? await value(transaction)
+            : value(transaction);
+          if (result == null) {
+            if (isErrorHandler) transaction.error = null;
+            return HttpHandler.CONTINUE;
+          }
 
-        /**
-         * @param {MiddlewareFunctionResult} [chainResult]
-         * @return {Promise<MiddlewareFunctionResult>}
-         */
-        const chainLoop = (chainResult) => {
-          if (chainResult === 'end') {
-            return Promise.resolve('end');
+          // Sync operation returned Promise
+          if (typeof result === 'object' && typeof result.then === 'function') {
+            if (isErrorHandler) transaction.error = null;
+            result = await result;
           }
-          if (chainResult === false || chainResult === 'break') {
-            return Promise.resolve();
+          syncResult = HttpHandler.ParseResultSync(result);
+          if (syncResult != null) {
+            if (isErrorHandler) transaction.error = null;
+            return syncResult;
           }
-          if (chainResult != null && chainResult !== true) {
-            return handleMiddleware(chainResult).then(chainLoop);
+
+          // Slip in support for functions that return an Array
+          if (Array.isArray(result)) {
+            result = transaction.response.end(result);
+            if (isErrorHandler) transaction.error = null;
+            return result;
           }
-          const chainIteration = iterator.next();
-          if (chainIteration.done) return Promise.resolve();
-          state.treeIndex[state.treeIndex.length - 1] += 1;
-          /** @type {Middleware} */
-          const innerMiddleware = chainIteration.value;
-          return handleMiddleware(innerMiddleware).then(chainLoop);
-        };
 
-        // Start looping
-        state.treeIndex.push(-1);
-        return chainLoop().then((result) => {
-          state.treeIndex.pop();
+          if (isErrorHandler) transaction.error = null;
+          result = await this.processMiddleware(transaction, result);
           return result;
-        });
-      }
+        } catch (error) {
+          // console.warn('Caught runtime error', err.message, err.stack);
+          transaction.error = error;
+          return HttpHandler.CONTINUE;
+        }
+      case 'object':
+        if (Array.isArray(value)) {
+          const { treeIndex } = transaction.state;
+          treeIndex.push(-1);
+          const { length } = value;
+          for (let index = 0; index < length; index++) {
+            const innerMiddleware = value[index];
+            treeIndex[treeIndex.length - 1] += 1;
+            if (innerMiddleware == null) continue;
+            result = HttpHandler.ParseResultSync(innerMiddleware);
+            if (result == null) {
+              // eslint-disable-next-line no-await-in-loop
+              result = await this.processMiddleware(transaction, innerMiddleware);
+            }
 
-      if (middleware && typeof middleware === 'object') {
-        if ('execute' in middleware) {
-          if (typeof middleware.execute === 'function') {
-            return handleMiddleware(middleware.execute.bind(middleware));
+            if (result === HttpHandler.END) {
+              break;
+            }
+            if (result === HttpHandler.BREAK) {
+              // Break from branch and continue in parent
+              result = HttpHandler.CONTINUE;
+              break;
+            }
+            // Continue in branch
           }
-          return handleMiddleware(middleware.execute);
+          treeIndex.pop();
+          return result;
         }
-        return handleMiddleware(Object.values(middleware));
-      }
 
-      if (typeof middleware !== 'function') {
-        console.warn('Unknown middleware', middleware);
-        return Promise.resolve();
-      }
-      return Promise.resolve().then(() => middleware({ req, res, state })).catch((err) => {
-        isInErrorState = true;
-        caughtError = err;
-        return /** @type {'continue'} */ ('continue');
-      });
+        if ('execute' in value && typeof value.execute === 'function') {
+          return await this.processMiddleware(transaction, value.execute.bind(value));
+        }
+        // Static caller
+        if ('Execute' in value && typeof value.Execute === 'function') {
+          return await this.processMiddleware(transaction, value.Execute);
+        }
+        if ('then' in value && typeof value.then === 'function') {
+          return await this.processMiddleware(transaction, await value);
+        }
+        // Fallthrough for Objects
+      case 'string':
+        try {
+          transaction.response.status ??= value ? 200 : 204;
+          return transaction.response.end(value);
+        } catch (error) {
+          transaction.error = error;
+          return HttpHandler.CONTINUE;
+        }
+      default:
+        console.warn('Unknown middleware', value);
+        return HttpHandler.CONTINUE;
     }
+  }
 
+  /**
+   * @param {HttpTransaction} transaction
+   * @return {Promise<HttpTransaction>}
+   */
+  async handleTransaction(transaction) {
     const allMiddleware = [
-      this.preprocessors,
       this.middleware,
       this.errorHandlers,
     ];
-    return handleMiddleware(allMiddleware).then(() => {
-      if (isInErrorState) {
-        isInErrorState = false;
-        throw caughtError;
+
+    const finalFinalResponse = await this.processMiddleware(transaction, allMiddleware);
+    if (finalFinalResponse !== HttpHandler.END) {
+      // console.warn(transaction.request.url, "Middleware resolution did not complete with 'end'");
+    } else if (!transaction.response.wasEndCalled()) {
+      transaction.response.end();
+    }
+    if (transaction.error) {
+      console.warn('Webhoster did not find error handler. Crash prevented.', transaction.request.path, transaction.error);
+      if (!transaction.response.wasEndCalled()) {
+        // Use generic error response and don't expose error
+        transaction.response.status = 500;
+        transaction.response.headers['content-type'] = 'text/plain';
+        transaction.response.end('Internal Server Error');
       }
-      return res;
-    });
+    }
+    return transaction;
   }
 
   /**
    * @param {import('http').IncomingMessage} incomingMessage
    * @param {import('http').ServerResponse} serverResponse
-   * @return {Promise<HttpResponse>}
+   * @return {Promise<HttpTransaction>}
    */
-  handleHttp1Request(incomingMessage, serverResponse) {
+  async handleHttp1Request(incomingMessage, serverResponse) {
+    /** @throws {Error} */
+    function onMalformed() {
+      const error = new Error('PROTOCOL_ERROR');
+      incomingMessage.destroy(error);
+      serverResponse.destroy(error);
+      throw error;
+    }
+
+    const {
+      method, headers, socket, url: path,
+    } = incomingMessage;
+
+    if (!method) onMalformed();
     // @ts-ignore If TLSSocketLike
-    const protocol = incomingMessage.socket.encrypted ? 'https:' : 'http:';
-
-    let url;
-    try {
-      url = new URL(`${protocol}//${incomingMessage.headers.host}${incomingMessage.url}`);
-    } catch (error) {
-      serverResponse.writeHead(400);
-      serverResponse.end();
-      return Promise.reject(error);
+    const scheme = socket.encrypted ? 'https' : 'http';
+    const authority = headers.host;
+    if (!authority) onMalformed();
+    if (authority.includes('@')) onMalformed();
+
+    let urlOptions;
+    if (method === 'CONNECT') {
+      if (scheme || path) onMalformed();
+    } else {
+      if (!scheme || !path) onMalformed();
+      if (path === '*') {
+        // asterisk-form
+        if (method !== 'OPTIONS') onMalformed();
+      } else {
+        urlOptions = HttpHandler.parseURL(scheme, authority, path);
+      }
     }
 
-    const req = new HttpRequest({
-      headers: incomingMessage.headers,
-      method: /** @type {RequestMethod} */ (incomingMessage.method?.toUpperCase()),
+    const request = new HttpRequest({
+      headers,
+      method,
       stream: incomingMessage,
-      socket: incomingMessage.socket,
-      url,
+
+      scheme,
+      authority,
+      path,
+
+      ...urlOptions,
     });
 
-    const res = new HttpResponse({
+    const response = new HttpResponse({
       stream: serverResponse,
-      socket: serverResponse.socket,
+      headers: {},
+      request,
       onHeadersSent() {
         return serverResponse.headersSent;
       },
-      onSendHeaders(flush) {
-        if (res.status == null) return Promise.reject(new Error('NO_STATUS'));
-        serverResponse.writeHead(res.status, this.headers);
-        if (flush) {
+      onSendHeaders(flush, end) {
+        if (response.status == null) {
+          throw new Error('NO_STATUS');
+        }
+        if (!isWritable(serverResponse)) return false;
+        serverResponse.writeHead(response.status, response.headers);
+        if (end) {
+          serverResponse.end();
+        } else if (flush) {
           serverResponse.flushHeaders();
         }
-        return Promise.resolve();
+        return true;
       },
     });
 
-    return this.handleRequest({ req, res }).then(() => {
-      if (!res.stream.writableEnded) {
-        console.warn('Response stream was not ended.');
-        res.stream.end();
-      }
-      return res;
+    const transaction = new HttpTransaction({
+      httpVersion: '2.0',
+      request,
+      response,
+      socket,
+      canPing: false,
+      canPushPath: false,
     });
+
+    await this.handleTransaction(transaction);
+
+    if (isWritable(serverResponse)) {
+      setTimeout(() => {
+        if (isWritable(serverResponse)) {
+          console.warn('Respond stream end lagging more than 60s. Did you forget to call `.end()`?', request.url);
+        }
+      }, 60_000);
+    }
+    return transaction;
   }
 
   /**
    * @param {import('http2').ServerHttp2Stream} stream
    * @param {import('http2').IncomingHttpHeaders} headers
-   * @param {Partial<import('./HttpResponse.js').HttpResponseOptions>} [responseOptions]
-   * @return {Promise<HttpResponse>}
+   * @param {Partial<import('./HttpTransaction.js').HttpTransactionOptions<unknown>>} [transactionOptions]
+   * @return {Promise<HttpTransaction>}
    */
-  handleHttp2Stream(stream, headers, responseOptions = {}) {
-    let url;
-    try {
-      url = new URL([
-        headers[':scheme'] ?? '',
-        '://',
-        headers[':authority'] ?? '',
-        headers[':path'] ?? '',
-      ].join(''));
-    } catch (error) {
-      stream.respond({ ':status': 400 }, { endStream: true });
-      return Promise.reject(error);
+  async handleHttp2Stream(stream, headers, transactionOptions = {}) {
+    /** @throws {Error} */
+    function onMalformed() {
+      const error = new Error('PROTOCOL_ERROR');
+      stream.destroy(error);
+      throw error;
+    }
+
+    const {
+      ':method': method,
+      ':scheme': scheme,
+      ':authority': authorityHeader,
+      host: hostHeader,
+    } = headers;
+
+    if (!method) onMalformed();
+    // HTTP/2 to HTTP/1 translation
+    const authority = /** @type {string} */ (authorityHeader || hostHeader);
+    if (!authority) onMalformed();
+    if (authority.includes('@')) onMalformed();
+
+    const path = headers[':path'];
+
+    let urlOptions;
+    if (method === 'CONNECT') {
+      if (scheme || path) onMalformed();
+    } else {
+      if (!scheme || !path) onMalformed();
+      if (path === '*') {
+        // asterisk-form
+        if (method !== 'OPTIONS') onMalformed();
+      } else {
+        urlOptions = HttpHandler.parseURL(scheme, authority, path);
+      }
     }
 
-    /** @type {Set<AsyncObject<any>>} */
-    const pendingPushSyncLocks = new Set();
-    const req = new HttpRequest({
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const context = this;
+
+    /** @type {Promise<any>[]} */
+    const pendingStreamLocks = [];
+
+    const request = new HttpRequest({
       headers,
-      url,
-      method: /** @type {RequestMethod} */ (headers[':method']),
+      method,
       stream,
-      socket: stream.session.socket,
-      canPing: true,
-      onPing() {
-        return new Promise((resolve, reject) => {
-          stream.session.ping((err, duration) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve(duration);
-          });
-        });
-      },
+
+      scheme,
+      authority,
+      path,
+
+      ...urlOptions,
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const context = this;
-    const res = new HttpResponse({
+    const response = new HttpResponse({
+      request,
       stream,
-      socket: stream.session.socket,
-      canPushPath: stream.pushAllowed,
       onHeadersSent() {
         return stream.headersSent;
       },
-      onSendHeaders() {
-        if (this.headers[':status'] == null) {
-          if (res.status == null) {
+      onSendHeaders(flush, end) {
+        if (response.headers[':status'] == null) {
+          if (response.status == null) {
             throw new Error('NO_STATUS');
           }
-          this.headers[':status'] = res.status;
+          response.headers[':status'] = response.status;
         }
-        stream.respond(this.headers);
+        if (!isWritable(stream)) return false;
+        stream.respond(response.headers, { endStream: end });
+        return true;
       },
-      onPushPath(path) {
-        const syncLock = new AsyncObject();
-        pendingPushSyncLocks.add(syncLock);
-        syncLock.prepare();
-        return new Promise((resolve, reject) => {
-          if (!stream.pushAllowed) {
-            reject(new Error('PUSH_NOT_ALLOWED'));
-            return;
-          }
-          const newHeaders = {
-            ':scheme': headers[':scheme'],
-            ':authority': headers[':authority'],
-            ':path': path,
-            ':method': 'GET',
-          };
-          [
-            'accept',
-            'accept-encoding',
-            'accept-language',
-            'user-agent',
-            'cache-control',
-          ].forEach((passedHeader) => {
-            if (passedHeader in headers) {
+    });
+
+    const transaction = new HttpTransaction({
+      httpVersion: '2.0',
+      request,
+      response,
+      socket: stream.session.socket,
+      canPing: true,
+      onPing: promisify(stream.session.ping),
+      canPushPath: () => stream.pushAllowed,
+      onPushPath: async (pushPath) => {
+        if (!stream.pushAllowed) {
+          throw new Error('PUSH_NOT_ALLOWED');
+        }
+
+        const newHeaders = {
+          ':scheme': headers[':scheme'],
+          ':authority': headers[':authority'],
+          ':path': pushPath,
+          ':method': 'GET',
+        };
+        for (const passedHeader of [
+          'accept',
+          'accept-encoding',
+          'accept-language',
+          'user-agent',
+          'cache-control',
+        ]) {
+          if (passedHeader in headers) {
             // @ts-ignore Coerce
-              newHeaders[passedHeader] = headers[passedHeader];
-            }
-          });
-          stream.pushStream(newHeaders, ((err, pushStream) => {
-            if (err) {
-              pendingPushSyncLocks.delete(syncLock);
-              syncLock.set(null);
-              reject(err);
-              return;
-            }
-            context.handleHttp2Stream(pushStream, newHeaders, { canPushPath: false })
-              .then(resolve).catch(reject).finally(() => {
-                pendingPushSyncLocks.delete(syncLock);
-                syncLock.set(null);
-              });
-          }));
-        });
+            newHeaders[passedHeader] = headers[passedHeader];
+          }
+        }
+
+        // Build promise function
+        const promiseFunction = async () => {
+          try {
+            const pushStream = await new Promise((resolve, reject) => {
+              stream.pushStream(newHeaders, ((error, newStream) => (error ? reject(error) : resolve(newStream))));
+            });
+            pushStream.addListener('error', (error) => {
+              if (error?.code === 'ECONNRESET') {
+                console.warn('HTTP/2 stream connection reset.', headers[':path']);
+              } else {
+                console.error('HTTP/2 stream error', headers, error);
+              }
+            });
+            await context.handleHttp2Stream(pushStream, newHeaders, { canPushPath: false });
+          } catch (error) {
+            console.error('onPushFailed', error, error.stack);
+            throw error;
+          }
+        };
+
+        // Schedule microtask
+        const promiseExecution = promiseFunction();
+
+        // Add as stream lock
+        pendingStreamLocks.push(promiseExecution);
+
+        // Wait for promise to complete before returning
+        await promiseExecution;
       },
-      ...responseOptions,
+      ...transactionOptions,
     });
 
-    // Workaround for https://github.com/nodejs/node/issues/31309
-    const STREAM_WAIT_MS = 0;
-    /** @type {NodeJS.Timeout} */
-    let pingTimeout = null;
-    /** @return {void} */
-    function sendPing() {
-      if (stream.session) stream.session.ping(noop);
+    await this.handleTransaction(transaction);
+
+    if (pendingStreamLocks.length) {
+      // Wait for all child push streams to terminate before we return.
+      await Promise.allSettled(pendingStreamLocks);
     }
-    const autoPingStream = new PassThrough({
-      read(...args) {
-        clearTimeout(pingTimeout);
-        pingTimeout = setTimeout(sendPing, STREAM_WAIT_MS);
-        // eslint-disable-next-line no-underscore-dangle
-        return PassThrough.prototype._read.call(this, ...args);
-      },
-    });
-    stream.pipe(autoPingStream);
-    req.replaceStream(autoPingStream);
 
-    stream.on('error', (err) => {
-      console.error(err);
-      console.error(headers[':path']);
-    });
-    return this.handleRequest({ req, res })
-      .then(() => Promise.all([...pendingPushSyncLocks.values()]
-        .map((syncLock) => syncLock.get().catch(noop))))
-      .then(() => {
-        res.stream.end();
-      })
-      .then(() => res);
+    if (isWritable(stream)) {
+      setTimeout(() => {
+        if (isWritable(stream)) {
+          console.warn('Respond stream end lagging more than 60s. Did you forget to call `.end()`?', request.url);
+        }
+      }, 60_000);
+    }
+
+    return transaction;
   }
 }