refactor!: fully migrate to fetch api using srvx

docs/1.guide/2.app.md

@@ -37,7 +37,6 @@ When initializing an h3 app, you can register global hooks:
 - `onError`
 - `onRequest`
 - `onBeforeResponse`
-- `onAfterResponse`
 
 These hooks are called for every request and can be used to add global logic to your app such as logging, error handling, etc.
 

package.json

@@ -42,6 +42,7 @@
   "dependencies": {
     "cookie-es": "^2.0.0",
     "rou3": "^0.5.1",
+    "srvx": "^0.2.5",
     "uncrypto": "^0.1.3"
   },
   "resolutions": {

src/_deprecated.ts

@@ -10,11 +10,7 @@ import type {
   RequestHeaders,
 } from "./types";
 import { iterable, noContent, redirect } from "./utils/response";
-import {
-  defineNodeHandler,
-  fromNodeHandler,
-  toNodeHandler,
-} from "./adapters/node";
+import { defineNodeHandler, fromNodeHandler, toNodeHandler } from "./adapters";
 import { defineEventHandler, defineLazyEventHandler } from "./handler";
 import { proxy } from "./utils/proxy";
 import { createH3 } from "./h3";

src/adapters.ts

@@ -0,0 +1,94 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { NodeHandler, NodeMiddleware } from "./types/node";
+import type {
+  H3,
+  EventHandler,
+  H3EventContext,
+  EventHandlerResponse,
+} from "./types";
+import { toNodeHandler as _toNodeHandler } from "srvx/node";
+import { createError } from "./error";
+
+export function toWebHandler(
+  app: H3,
+): (request: Request, context?: H3EventContext) => Promise<Response> {
+  return (request, context) => {
+    return Promise.resolve(app.fetch(request, { h3: context }));
+  };
+}
+
+export function fromWebHandler(
+  handler: (request: Request, context?: H3EventContext) => Promise<Response>,
+): EventHandler {
+  return (event) => handler(event.request, event.context);
+}
+
+/**
+ * Convert a Node.js handler function (req, res, next?) to an EventHandler.
+ *
+ * **Note:** The returned event handler requires to be executed with h3 Node.js handler.
+ */
+export function fromNodeHandler(handler: NodeMiddleware): EventHandler;
+export function fromNodeHandler(handler: NodeHandler): EventHandler;
+export function fromNodeHandler(
+  handler: NodeHandler | NodeMiddleware,
+): EventHandler {
+  if (typeof handler !== "function") {
+    throw new TypeError(`Invalid handler. It should be a function: ${handler}`);
+  }
+  return (event) => {
+    if (!event.node) {
+      throw new Error(
+        "[h3] Executing Node.js middleware is not supported in this server!",
+      );
+    }
+    return callNodeHandler(
+      handler,
+      event.node.req,
+      event.node.res,
+    ) as EventHandlerResponse;
+  };
+}
+
+export function defineNodeHandler(handler: NodeHandler) {
+  return handler;
+}
+
+export function defineNodeMiddleware(handler: NodeMiddleware) {
+  return handler;
+}
+
+/**
+ * Convert H3 app instance to a NodeHandler with (IncomingMessage, ServerResponse) => void signature.
+ */
+export function toNodeHandler(app: H3): NodeHandler {
+  return _toNodeHandler(app.fetch);
+}
+
+function callNodeHandler(
+  handler: NodeHandler | NodeMiddleware,
+  req: IncomingMessage,
+  res: ServerResponse,
+) {
+  const isMiddleware = handler.length > 2;
+  return new Promise((resolve, reject) => {
+    const next = (err?: Error) => {
+      if (isMiddleware) {
+        res.off("close", next);
+        res.off("error", next);
+      }
+      return err ? reject(createError(err)) : resolve(undefined);
+    };
+    try {
+      const returned = handler(req, res, next);
+      if (isMiddleware && returned === undefined) {
+        res.once("close", next);
+        res.once("error", next);
+      } else {
+        resolve(returned);
+      }
+    } catch (error) {
+      next(error as Error);
+    }
+  });
+}