feat(loader): access to the whole intercepted srvx instance

Author: pi0

src/adapters/bun.ts

@@ -40,11 +40,11 @@ class BunServer implements Server<BunFetchHandler> {
 
     // Detect running in srvx loader
     const loader = (globalThis as any).__srvxLoader__ as
-      | ((handler: ServerHandler) => void)
+      | ((obj: { server: Server }) => void)
       | undefined;
     if (loader) {
       this.fetch = fetchHandler;
-      loader(fetchHandler);
+      loader({ server: this });
       return;
     }
 

src/adapters/deno.ts

@@ -45,11 +45,11 @@ class DenoServer implements Server<DenoFetchHandler> {
 
     // Detect running in srvx loader
     const loader = (globalThis as any).__srvxLoader__ as
-      | ((handler: ServerHandler) => void)
+      | ((obj: { server: Server }) => void)
       | undefined;
     if (loader) {
       this.fetch = fetchHandler;
-      loader(fetchHandler);
+      loader({ server: this });
       return;
     }
 

src/adapters/node.ts

@@ -63,12 +63,23 @@ class NodeServer implements Server {
 
     const fetchHandler = (this.fetch = wrapFetch(this));
 
+    const handler = (nodeReq: NodeServerRequest, nodeRes: NodeServerResponse) => {
+      const request = new NodeRequest({ req: nodeReq, res: nodeRes });
+      request.waitUntil = this.#wait?.waitUntil;
+      const res = fetchHandler(request);
+      return res instanceof Promise
+        ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes))
+        : sendNodeResponse(nodeRes, res);
+    };
+
+    this.node = { handler, server: undefined };
+
     // Detect running in srvx loader
     const loader = (globalThis as any).__srvxLoader__ as
-      | ((handler: ServerHandler) => void)
+      | ((obj: { server: Server }) => void)
       | undefined;
     if (loader) {
-      loader(fetchHandler);
+      loader({ server: this });
       return;
     }
 
@@ -77,15 +88,6 @@ class NodeServer implements Server {
     this.#wait = createWaitUntil();
     this.waitUntil = this.#wait.waitUntil;
 
-    const handler = (nodeReq: NodeServerRequest, nodeRes: NodeServerResponse) => {
-      const request = new NodeRequest({ req: nodeReq, res: nodeRes });
-      request.waitUntil = this.#wait?.waitUntil;
-      const res = fetchHandler(request);
-      return res instanceof Promise
-        ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes))
-        : sendNodeResponse(nodeRes, res);
-    };
-
     const tls = resolveTLSOptions(this.options);
     const { port, hostname: host } = resolvePortAndHost(this.options);
     this.serveOptions = {
@@ -115,7 +117,7 @@ class NodeServer implements Server {
       server = nodeHTTP.createServer(this.serveOptions as NodeHttp.ServerOptions, handler);
     }
 
-    this.node = { server, handler };
+    this.node.server = server;
 
     if (!options.manual) {
       this.serve();

src/loader.ts

@@ -82,6 +82,11 @@ export type LoadedServerEntry = {
    * When `true`, no valid entry point could be located.
    */
   notFound?: boolean;
+
+  /**
+   * The original srvx server instance if the module used the loader API to export a server directly.
+   */
+  srvxServer?: Server;
 };
 
 export async function loadServerEntry(opts: LoadOptions): Promise<LoadedServerEntry> {
@@ -114,13 +119,13 @@ export async function loadServerEntry(opts: LoadOptions): Promise<LoadedServerEn
   // Import the user file
   let mod: any;
   let interceptedNodeHandler: NodeHttpHandler | undefined;
-  let interceptedFetchHandler: ServerHandler | undefined;
+  let interceptedServer: Server | undefined;
   try {
     if (opts.interceptHttpListen !== false) {
       const loaded = await interceptListen(() => import(url));
       mod = loaded.res;
       interceptedNodeHandler = loaded.listenHandler;
-      interceptedFetchHandler = loaded.fetchHandler;
+      interceptedServer = loaded.server;
     } else {
       mod = await import(url);
     }
@@ -145,7 +150,7 @@ export async function loadServerEntry(opts: LoadOptions): Promise<LoadedServerEn
   mod = (await opts?.onLoad?.(mod)) || mod;
 
   let fetchHandler =
-    mod?.fetch || mod?.default?.fetch || mod?.default?.default?.fetch || interceptedFetchHandler;
+    mod?.fetch || mod?.default?.fetch || mod?.default?.default?.fetch || interceptedServer?.fetch;
   if (!fetchHandler && typeof mod?.default === "function" && mod.default.length < 2) {
     fetchHandler = mod.default;
   }
@@ -167,6 +172,7 @@ export async function loadServerEntry(opts: LoadOptions): Promise<LoadedServerEn
     nodeCompat,
     url,
     fetch: fetchHandler,
+    srvxServer: interceptedServer,
   };
 }
 
@@ -175,16 +181,20 @@ let _interceptQueue: Promise<unknown> = Promise.resolve();
 
 async function interceptListen<T = unknown>(
   cb: () => T | Promise<T>,
-): Promise<{ res?: T; listenHandler?: NodeHttpHandler; fetchHandler?: ServerHandler }> {
+): Promise<{
+  res?: T;
+  listenHandler?: NodeHttpHandler;
+  server?: Server;
+}> {
   // Chain onto the queue to ensure sequential execution
   const result = _interceptQueue.then(async () => {
     const originalListen = nodeHTTP.Server.prototype.listen;
     let res: T;
     let listenHandler: NodeHttpHandler | undefined;
-    let fetchHandler: ServerHandler | undefined;
+    let server: Server | undefined;
 
-    (globalThis as any).__srvxLoader__ = (handler: ServerHandler) => {
-      fetchHandler = handler;
+    (globalThis as any).__srvxLoader__ = (obj: { server?: Server }) => {
+      server = obj.server;
     };
 
     try {
@@ -226,7 +236,7 @@ async function interceptListen<T = unknown>(
       nodeHTTP.Server.prototype.listen = originalListen;
       delete (globalThis as any).__srvxLoader__;
     }
-    return { res, listenHandler, fetchHandler };
+    return { res, listenHandler, server };
   });
 
   // Update queue to point to this operation (swallow errors for queue chaining)