equipped 5.3.0-alpha.0 → 5.3.0

package/dist/types/{chunk-32DMHN3G.js → chunk-YTY3EFNB.js}

@@ -46,6 +46,7 @@ var RequestError = class extends EquippedError {
 };
 
 // src/server/adapters/base.ts
+import "http";
 import "@fastify/cors";
 import "cors";
 import { Server as SocketServer } from "socket.io";
@@ -935,6 +936,22 @@ var serverConfigPipe = () => v3.object({
   ),
   socketsAuthMethods: v3.defaults(v3.array(v3.instanceOf(BaseRequestAuthMethod)), [])
 });
+var rawResponseHandledSymbol = /* @__PURE__ */ Symbol("rawResponseHandled");
+var rawResponseHandled = Object.freeze({ [rawResponseHandledSymbol]: true });
+var rawResponseNotStartedMessage = "Raw not-found handler did not start or complete a response";
+function isRawResponseHandled(input) {
+  return Boolean(input && typeof input === "object" && rawResponseHandledSymbol in input);
+}
+function hasRawResponseStarted(response) {
+  return response.headersSent || response.writableEnded;
+}
+function writeRawHandlerError(response, error) {
+  if (hasRawResponseStarted(response)) return;
+  response.statusCode = StatusCodes.BadRequest;
+  response.setHeader("Content-Type", "application/json");
+  const message = error instanceof Error ? error.message : `${error}`;
+  response.end(JSON.stringify([{ message }]));
+}
 var errorsSchemas = Object.entries(StatusCodes).filter(([, value]) => value > 399).map(([key, value]) => ({
   status: value,
   contentType: "application/json",
@@ -951,6 +968,8 @@ var Server = class {
   #serverConfig;
   #queue = [];
   #routesByKey = /* @__PURE__ */ new Set();
+  #started = false;
+  #notFoundHandler = null;
   setup(httpServer, config) {
     this.#httpServer = httpServer;
     this.#serverConfig = config;
@@ -1000,10 +1019,16 @@ var Server = class {
       });
     });
   }
+  setNotFoundHandler(handler) {
+    if (this.#started) throw new EquippedError("Cannot set not-found handler after server has started", {});
+    this.#notFoundHandler = handler;
+    return this;
+  }
   test() {
     return supertest(this.#httpServer);
   }
   async start() {
+    this.#started = true;
     const config = this.#serverConfig;
     const instance = Instance.get();
     const { app } = instance.settings;
@@ -1017,10 +1042,7 @@ var Server = class {
         })
       });
     await Promise.all(this.#queue.map((cb) => cb()));
-    this.registerNotFoundHandler(async (req) => {
-      const request = await this.parseRequest(req);
-      throw new NotFoundError(`Route ${request.path} not found`);
-    });
+    this.registerNotFoundHandler(async (req, res) => await this.#handleNotFound(req, res));
     this.registerErrorHandler(async (error, _, res) => {
       if (!(error instanceof EquippedError)) Instance.get().log.error({ error }, "Uncaught error in route handler");
       const response = error instanceof RequestError ? new Response({
@@ -1039,6 +1061,31 @@ var Server = class {
     if (started) Instance.get().log.info(`${instance.id}(${app.name}) service listening on port ${config.port}`);
     return started;
   }
+  createNodeRawResponder(input) {
+    return async (handler) => {
+      input.beforeHandle?.();
+      try {
+        await handler(input.request, input.response);
+      } catch (error) {
+        if (!hasRawResponseStarted(input.response)) {
+          writeRawHandlerError(input.response, error);
+          return rawResponseHandled;
+        }
+        throw error;
+      }
+      if (!hasRawResponseStarted(input.response))
+        writeRawHandlerError(input.response, new EquippedError(rawResponseNotStartedMessage, {}));
+      return rawResponseHandled;
+    };
+  }
+  async #handleNotFound(req, res) {
+    const request = await this.parseRequest(req);
+    if (!this.#notFoundHandler) throw new NotFoundError(`Route ${request.path} not found`);
+    const result = await this.#notFoundHandler({ request, respondWithRaw: this.createRawResponder(req, res) });
+    if (isRawResponseHandled(result)) return;
+    if (result instanceof Response) return await this.handleResponse(res, result);
+    throw new EquippedError("Not-found handler must return a Response or respondWithRaw(...)", {});
+  }
   #resolveSchema(method, schema) {
     const defaultStatusCode = schema?.defaultStatusCode ?? StatusCodes.Ok;
     const defaultContentType = schema?.defaultContentType ?? "application/json";
@@ -1129,6 +1176,170 @@ var Server = class {
     };
   }
 };
+if (void 0) {
+  let ensureTestInstance = function() {
+    const instance = Instance.maybeGet() ?? Instance.create({ app: { name: "equipped-test" }, log: { level: "silent" } });
+    if (!testInstanceState.__equippedTestInstanceAliased) {
+      instance.alias("equipped-test");
+      testInstanceState.__equippedTestInstanceAliased = true;
+    }
+  }, createRawResponse = function() {
+    const chunks = [];
+    return {
+      statusCode: 200,
+      headersSent: false,
+      writableEnded: false,
+      headers: {},
+      setHeader(key, value) {
+        this.headers[key] = value;
+      },
+      end(chunk) {
+        if (chunk !== void 0) chunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+        this.headersSent = true;
+        this.writableEnded = true;
+      },
+      body() {
+        return chunks.join("");
+      }
+    };
+  };
+  ensureTestInstance2 = ensureTestInstance, createRawResponse2 = createRawResponse;
+  const { describe, expect, test } = void 0;
+  const testInstanceState = globalThis;
+  class TestServer extends Server {
+    handledResponse = null;
+    notFoundHandler = null;
+    constructor() {
+      super();
+      this.setup(http.createServer(), {
+        port: 0,
+        cors: void 0,
+        eventBus: void 0,
+        publicPath: void 0,
+        healthPath: void 0,
+        openapi: { docsVersion: "1.0.0", docsBaseUrl: ["/"], docsPath: "/__docs" },
+        requests: {
+          log: false,
+          rateLimit: { enabled: false, periodInMs: 1, limit: 1 },
+          slowdown: { enabled: false, periodInMs: 1, delayAfter: 1, delayInMs: 1 }
+        },
+        socketsAuthMethods: []
+      });
+    }
+    async parseRequest(req) {
+      return new Request2({
+        ip: "127.0.0.1",
+        body: {},
+        cookies: {},
+        params: {},
+        query: {},
+        method: Methods.get,
+        path: req.path,
+        headers: {},
+        files: {}
+      });
+    }
+    async handleResponse(_, response) {
+      this.handledResponse = response;
+    }
+    createRawResponder(req, res) {
+      return this.createNodeRawResponder({ request: req.rawRequest, response: res.rawResponse });
+    }
+    registerRoute() {
+    }
+    registerErrorHandler() {
+    }
+    registerNotFoundHandler(cb) {
+      this.notFoundHandler = cb;
+    }
+    async startServer() {
+      return true;
+    }
+    async dispatchNotFound(path) {
+      if (!this.notFoundHandler) throw new Error("not-found handler was not registered");
+      this.handledResponse = null;
+      const rawResponse = createRawResponse();
+      await this.notFoundHandler({ path, rawRequest: {} }, { rawResponse });
+      return { handledResponse: this.handledResponse, rawResponse };
+    }
+  }
+  describe("Server not-found handler", () => {
+    test("throws the default Equipped not-found error when no custom handler is set", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      await expect(server.dispatchNotFound("/missing")).rejects.toBeInstanceOf(NotFoundError);
+    });
+    test("allows a custom not-found handler to return an Equipped response", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler(
+        ({ request }) => new Response({
+          body: [{ message: `No route for ${request.path}` }],
+          status: StatusCodes.NotFound,
+          headers: {},
+          cookies: {},
+          contentType: "application/json"
+        })
+      );
+      await server.start();
+      const result = await server.dispatchNotFound("/custom");
+      expect(result.handledResponse?.status).toBe(StatusCodes.NotFound);
+      expect(result.handledResponse?.body).toEqual([{ message: "No route for /custom" }]);
+    });
+    test("allows a custom not-found handler to complete the response through a raw Node listener", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler(
+        ({ respondWithRaw }) => respondWithRaw((_, response) => {
+          response.statusCode = 203;
+          response.end("raw fallback");
+        })
+      );
+      await server.start();
+      const result = await server.dispatchNotFound("/page");
+      expect(result.handledResponse).toBeNull();
+      expect(result.rawResponse.statusCode).toBe(203);
+      expect(result.rawResponse.body()).toBe("raw fallback");
+    });
+    test("writes a clear raw error when a raw not-found handler does not start a response", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler(({ respondWithRaw }) => respondWithRaw(() => {
+      }));
+      await server.start();
+      const result = await server.dispatchNotFound("/page");
+      expect(result.handledResponse).toBeNull();
+      expect(result.rawResponse.statusCode).toBe(StatusCodes.BadRequest);
+      expect(result.rawResponse.body()).toContain(rawResponseNotStartedMessage);
+    });
+    test("rejects a custom not-found handler result that is neither an Equipped response nor raw completion", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler((() => void 0));
+      await server.start();
+      await expect(server.dispatchNotFound("/bad")).rejects.toThrow("Not-found handler must return a Response or respondWithRaw(...)");
+    });
+    test("rejects setting the custom not-found handler after server startup", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      expect(
+        () => server.setNotFoundHandler(
+          () => new Response({
+            body: null,
+            status: StatusCodes.NotFound,
+            headers: {},
+            cookies: {},
+            contentType: "application/json"
+          })
+        )
+      ).toThrow("Cannot set not-found handler after server has started");
+    });
+  });
+}
+var ensureTestInstance2;
+var createRawResponse2;
 
 // src/server/middlewares/requireAuthUser.ts
 var requireAuthUser = (methods) => makeMiddleware(

package/dist/types/dbs/adapters/mongodb/index.js

@@ -2,13 +2,13 @@ import {
   Db,
   QueryKeys,
   dbChangeConfigPipe
-} from "../../../chunk-JZ2JTENY.js";
-import "../../../chunk-IAHTILKJ.js";
+} from "../../../chunk-3M4PBZAQ.js";
+import "../../../chunk-XGGGAEET.js";
 import {
   EquippedError,
   Instance,
   retry
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 

package/dist/types/dbs/index.js

@@ -6,9 +6,9 @@ import {
   queryParamsPipe,
   queryResultsPipe,
   wrapQueryParams
-} from "../chunk-JZ2JTENY.js";
-import "../chunk-IAHTILKJ.js";
-import "../chunk-32DMHN3G.js";
+} from "../chunk-3M4PBZAQ.js";
+import "../chunk-XGGGAEET.js";
+import "../chunk-YTY3EFNB.js";
 import "../chunk-KZKFYO4V.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/types/errors/index.js

@@ -7,7 +7,7 @@ import {
   RequestError,
   TokenExpired,
   ValidationError
-} from "../chunk-32DMHN3G.js";
+} from "../chunk-YTY3EFNB.js";
 import "../chunk-KZKFYO4V.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/types/events/adapters/kafka/index.js

@@ -1,8 +1,8 @@
 import {
   KafkaEventBus,
   kafkaConfigPipe
-} from "../../../chunk-IAHTILKJ.js";
-import "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-XGGGAEET.js";
+import "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 export {

package/dist/types/events/adapters/rabbitmq/index.js

@@ -3,7 +3,7 @@ import {
   configurable,
   parseJSONValue,
   random_exports
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import {
   EventBus
 } from "../../../chunk-KZKFYO4V.js";

package/dist/types/index.js

@@ -1,6 +1,6 @@
 import {
   Instance
-} from "./chunk-32DMHN3G.js";
+} from "./chunk-YTY3EFNB.js";
 import "./chunk-KZKFYO4V.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/types/instance/index.js

@@ -1,6 +1,6 @@
 import {
   Instance
-} from "../chunk-32DMHN3G.js";
+} from "../chunk-YTY3EFNB.js";
 import "../chunk-KZKFYO4V.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/types/{introspection-ZQCAW254.js → introspection-VOIU3XE6.js}

@@ -1,7 +1,7 @@
 import {
   OrmIntrospectionError
-} from "./chunk-XOU2A2Y6.js";
-import "./chunk-32DMHN3G.js";
+} from "./chunk-OHFTQGQG.js";
+import "./chunk-YTY3EFNB.js";
 import "./chunk-KZKFYO4V.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/types/jobs/adapters/redis/index.js

@@ -1,8 +1,8 @@
 import {
   RedisCache,
   redisConfigPipe
-} from "../../../chunk-4LRJJSGG.js";
-import "../../../chunk-LWUMIHL4.js";
+} from "../../../chunk-65EHKCDZ.js";
+import "../../../chunk-3TKJGSCZ.js";
 import {
   Job
 } from "../../../chunk-LN3A6R4Y.js";
@@ -10,7 +10,7 @@ import {
   Instance,
   configurable,
   random_exports
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 

package/dist/types/orm/adapters/in-memory/index.js

@@ -1,8 +1,8 @@
 import {
   InMemoryAdapter
-} from "../../../chunk-H6JBLKX5.js";
-import "../../../chunk-A2MRYMCA.js";
-import "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-NJ2FHI3U.js";
+import "../../../chunk-JQ2FWX4W.js";
+import "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 export {

package/dist/types/orm/adapters/json/index.js

@@ -1,12 +1,12 @@
 import {
   InMemoryAdapter
-} from "../../../chunk-H6JBLKX5.js";
+} from "../../../chunk-NJ2FHI3U.js";
 import {
   OrmAdapter
-} from "../../../chunk-A2MRYMCA.js";
+} from "../../../chunk-JQ2FWX4W.js";
 import {
   configurable
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 

package/dist/types/orm/adapters/mongodb/index.js

@@ -11,11 +11,11 @@ import {
   PushOp,
   UnsetOp,
   flattenOps
-} from "../../../chunk-A2MRYMCA.js";
+} from "../../../chunk-JQ2FWX4W.js";
 import {
   EquippedError,
   configurable
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 

package/dist/types/orm/adapters/postgresql/index.js

@@ -12,11 +12,11 @@ import {
   PushOp,
   UnsetOp,
   flattenOps
-} from "../../../chunk-A2MRYMCA.js";
+} from "../../../chunk-JQ2FWX4W.js";
 import {
   EquippedError,
   configurable
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 
@@ -1109,7 +1109,7 @@ var PostgresAdapter = class extends configurable(postgresqlConnectionPipe, OrmAd
     await this.#getClient().query(`ALTER TABLE "${change.table}" DROP CONSTRAINT "${change.name}"`);
   }
   async introspect() {
-    const { OrmIntrospectionError } = await import("../../../introspection-ZQCAW254.js");
+    const { OrmIntrospectionError } = await import("../../../introspection-VOIU3XE6.js");
     const client = this.#getClient();
     const tablesResult = await client.query(`
 			SELECT table_name FROM information_schema.tables

package/dist/types/orm/index.js

@@ -1,6 +1,6 @@
 import {
   OrmIntrospectionError
-} from "../chunk-XOU2A2Y6.js";
+} from "../chunk-OHFTQGQG.js";
 import {
   ComputedField,
   Field,
@@ -33,11 +33,11 @@ import {
   set,
   toFieldName,
   unset
-} from "../chunk-A2MRYMCA.js";
+} from "../chunk-JQ2FWX4W.js";
 import {
   EquippedError,
   Instance
-} from "../chunk-32DMHN3G.js";
+} from "../chunk-YTY3EFNB.js";
 import "../chunk-KZKFYO4V.js";
 import "../chunk-MLKGABMK.js";
 

package/dist/types/server/adapters/express/index.d.ts

@@ -1,7 +1,8 @@
-import { B as BaseRequestAuthMethod, S as Server } from '../../../base-3PpBAx1K.js';
+import { B as BaseRequestAuthMethod, S as Server, R as RawResponder } from '../../../base-DVr0fHil.js';
 import { A as AuthUser } from '../../../overrides-6Hxg764S.js';
 import { R as Request, a as Response, M as MethodsEnum } from '../../../requestError-DdaL8hc3.js';
 import { EventBus } from '../../../events/index.js';
+import express from 'express';
 import 'node:http';
 import '@fastify/cors';
 import 'cors';
@@ -185,6 +186,7 @@ declare class ExpressServer extends ExpressServer_base {
     protected constructor(config: typeof ExpressServer.Config);
     protected parseRequest(req: any): Promise<Request<any>>;
     protected handleResponse(res: any, response: Response<any>): Promise<void>;
+    protected createRawResponder(req: express.Request, res: express.Response): RawResponder;
     protected registerRoute(method: MethodsEnum, path: string, cb: (req: any, res: any) => Promise<void>): void;
     protected registerErrorHandler(cb: (error: Error, req: any, res: any) => Promise<void>): void;
     protected registerNotFoundHandler(cb: (req: any, res: any) => Promise<void>): void;

package/dist/types/server/adapters/express/index.js

@@ -6,7 +6,7 @@ import {
   configurable,
   getMediaDuration,
   serverConfigPipe
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 
@@ -100,6 +100,9 @@ var ExpressServer = class extends configurable(serverConfigPipe, Server) {
       response.body.pipe(res);
     }
   }
+  createRawResponder(req, res) {
+    return this.createNodeRawResponder({ request: req, response: res });
+  }
   registerRoute(method, path, cb) {
     this.#app[method]?.(path, async (req, res) => cb(req, res));
   }
@@ -120,6 +123,54 @@ var ExpressServer = class extends configurable(serverConfigPipe, Server) {
     });
   }
 };
+if (void 0) {
+  let ensureTestInstance = function() {
+    const instance = Instance.maybeGet() ?? Instance.create({ app: { name: "equipped-test" }, log: { level: "silent" } });
+    if (!testInstanceState.__equippedTestInstanceAliased) {
+      instance.alias("equipped-test");
+      testInstanceState.__equippedTestInstanceAliased = true;
+    }
+  }, createExpressResponse = function() {
+    return {
+      statusCode: 200,
+      headersSent: false,
+      writableEnded: false,
+      setHeader: vi.fn(),
+      end(chunk) {
+        void chunk;
+        this.headersSent = true;
+        this.writableEnded = true;
+      }
+    };
+  };
+  ensureTestInstance2 = ensureTestInstance, createExpressResponse2 = createExpressResponse;
+  const { describe, expect, test, vi } = void 0;
+  const testInstanceState = globalThis;
+  class TestExpressServer extends ExpressServer {
+    exposeRawResponder(req, res) {
+      return this.createRawResponder(req, res);
+    }
+  }
+  describe("ExpressServer raw responder", () => {
+    test("passes the Express request and response to the raw Node handler", async () => {
+      ensureTestInstance();
+      const server = TestExpressServer.create({ port: 0, requests: { log: false } });
+      const req = { marker: "request" };
+      const res = createExpressResponse();
+      let received = null;
+      await server.exposeRawResponder(
+        req,
+        res
+      )(async (request, response) => {
+        received = { request, response };
+        response.end("ok");
+      });
+      expect(received).toEqual({ request: req, response: res });
+    });
+  });
+}
+var ensureTestInstance2;
+var createExpressResponse2;
 export {
   ExpressServer
 };

package/dist/types/server/adapters/fastify/index.d.ts

@@ -1,7 +1,8 @@
-import { B as BaseRequestAuthMethod, S as Server } from '../../../base-3PpBAx1K.js';
+import { B as BaseRequestAuthMethod, S as Server, R as RawResponder } from '../../../base-DVr0fHil.js';
 import { A as AuthUser } from '../../../overrides-6Hxg764S.js';
 import { R as Request, a as Response, M as MethodsEnum } from '../../../requestError-DdaL8hc3.js';
 import { EventBus } from '../../../events/index.js';
+import { FastifyRequest, FastifyReply } from 'fastify';
 import 'node:http';
 import '@fastify/cors';
 import 'cors';
@@ -210,6 +211,7 @@ declare class FastifyServer extends FastifyServer_base {
         contentType: string;
     }>>;
     protected handleResponse(res: any, response: Response<any>): Promise<void>;
+    protected createRawResponder(req: FastifyRequest, res: FastifyReply): RawResponder;
     protected registerRoute(method: MethodsEnum, path: string, cb: (req: any, res: any) => Promise<void>): void;
     protected registerErrorHandler(cb: (error: Error, req: any, res: any) => Promise<void>): void;
     protected registerNotFoundHandler(cb: (req: any, res: any) => Promise<void>): void;

package/dist/types/server/adapters/fastify/index.js

@@ -7,7 +7,7 @@ import {
   configurable,
   getMediaDuration,
   serverConfigPipe
-} from "../../../chunk-32DMHN3G.js";
+} from "../../../chunk-YTY3EFNB.js";
 import "../../../chunk-KZKFYO4V.js";
 import "../../../chunk-MLKGABMK.js";
 
@@ -96,6 +96,9 @@ var FastifyServer = class extends configurable(serverConfigPipe, Server) {
     for (const [key, { value, ...opts }] of Object.entries(response.cookies)) res = res.setCookie(key, value, opts);
     await res.status(response.status).headers(response.headers).send(response.body);
   }
+  createRawResponder(req, res) {
+    return this.createNodeRawResponder({ request: req.raw, response: res.raw, beforeHandle: () => res.hijack() });
+  }
   registerRoute(method, path, cb) {
     this.#app.register(async (inst) => {
       inst.route({ url: path, method, handler: cb });
@@ -125,6 +128,57 @@ function excludeBufferKeys(body) {
     files: Object.fromEntries(fileEntries)
   };
 }
+if (void 0) {
+  let ensureTestInstance = function() {
+    const instance = Instance.maybeGet() ?? Instance.create({ app: { name: "equipped-test" }, log: { level: "silent" } });
+    if (!testInstanceState.__equippedTestInstanceAliased) {
+      instance.alias("equipped-test");
+      testInstanceState.__equippedTestInstanceAliased = true;
+    }
+  }, createRawResponse = function() {
+    return {
+      statusCode: 200,
+      headersSent: false,
+      writableEnded: false,
+      setHeader: vi.fn(),
+      end(chunk) {
+        void chunk;
+        this.headersSent = true;
+        this.writableEnded = true;
+      }
+    };
+  };
+  ensureTestInstance2 = ensureTestInstance, createRawResponse2 = createRawResponse;
+  const { describe, expect, test, vi } = void 0;
+  const testInstanceState = globalThis;
+  class TestFastifyServer extends FastifyServer {
+    exposeRawResponder(req, res) {
+      return this.createRawResponder(req, res);
+    }
+  }
+  describe("FastifyServer raw responder", () => {
+    test("hijacks the Fastify reply before passing Node raw request and response to the handler", async () => {
+      ensureTestInstance();
+      const server = TestFastifyServer.create({ port: 0, requests: { log: false } });
+      const rawRequest = { marker: "request" };
+      const rawResponse = createRawResponse();
+      const reply = { raw: rawResponse, hijack: vi.fn() };
+      const request = { raw: rawRequest };
+      let received = null;
+      await server.exposeRawResponder(
+        request,
+        reply
+      )(async (req, res) => {
+        received = { request: req, response: res };
+        res.end("ok");
+      });
+      expect(reply.hijack).toHaveBeenCalledOnce();
+      expect(received).toEqual({ request: rawRequest, response: rawResponse });
+    });
+  });
+}
+var ensureTestInstance2;
+var createRawResponse2;
 export {
   FastifyServer
 };

package/dist/types/server/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BaseRequestAuthMethod } from '../base-3PpBAx1K.js';
-export { O as OnJoinFn, R as Router, S as Server, a as ServerConfig, b as SocketCallbacks, c as SocketEmitter, s as serverConfigPipe } from '../base-3PpBAx1K.js';
+import { B as BaseRequestAuthMethod } from '../base-DVr0fHil.js';
+export { O as OnJoinFn, R as RawResponder, b as RawResponseHandled, c as RawResponseHandler, f as Router, S as Server, a as ServerConfig, d as ServerNotFoundContext, e as ServerNotFoundHandler, g as SocketCallbacks, h as SocketEmitter, s as serverConfigPipe } from '../base-DVr0fHil.js';
 import { A as AuthUser } from '../overrides-6Hxg764S.js';
 import { R as Request, c as RouteDefToReqRes, d as RouteDef, e as Route } from '../requestError-DdaL8hc3.js';
 export { C as CookieVal, h as DefaultCookies, D as DefaultHeaders, I as IncomingFile, k as MergeRouteDefs, f as Methods, M as MethodsEnum, a as Response, i as RouteConfig, l as RouteDefHandler, j as RouterConfig, S as StatusCodes, g as StatusCodesEnum, o as makeErrorMiddleware, m as makeMiddleware, n as makeResponseMiddleware } from '../requestError-DdaL8hc3.js';