equipped 5.3.0 → 5.3.2

package/dist/cjs/server/index.cjs

@@ -1017,19 +1017,6 @@ var openapi = (config) => {
   };
 };
 
-// src/utilities/json.ts
-var parseJSONValue = (data) => {
-  try {
-    if (data?.constructor?.name !== "String") return data;
-    return JSON.parse(data);
-  } catch {
-    return data;
-  }
-};
-function parseJSONObject(data) {
-  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, parseJSONValue(value)]));
-}
-
 // src/server/requests.ts
 var Request = class {
   ip;
@@ -1058,8 +1045,10 @@ var Request = class {
     this.params = params;
     this.cookies = cookies;
     this.headers = headers;
-    this.query = parseJSONObject(query);
-    this.body = Object.assign(parseJSONObject(body), files);
+    const hasFiles = Object.keys(files).length > 0;
+    const bodyFields = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+    this.query = query;
+    this.body = hasFiles ? Object.assign({}, bodyFields, files) : body;
   }
   pipe(stream, opts = {}) {
     return new Response({ ...opts, piped: true, body: stream });
@@ -1105,6 +1094,83 @@ var Response = class {
     });
   }
 };
+if (void 0) {
+  const { describe, expect, test } = void 0;
+  describe("Request", () => {
+    test("preserves adapter-provided query and body values without JSON normalization", () => {
+      const query = {
+        count: "10",
+        active: "true",
+        filter: '{"name":"test"}',
+        quoted: '"value"'
+      };
+      const body = {
+        count: "10",
+        active: "false",
+        payload: '{"nested":true}',
+        quoted: '"value"'
+      };
+      const request = new Request({
+        ip: void 0,
+        body,
+        cookies: {},
+        params: {},
+        query,
+        method: "post",
+        path: "/items",
+        headers: {},
+        files: {}
+      });
+      expect(request.query).toEqual(query);
+      expect(request.body).toEqual(body);
+    });
+    test("continues merging uploaded files into body fields without parsing string fields", () => {
+      const file = {
+        name: "avatar.png",
+        type: "image/png",
+        size: 4,
+        isTruncated: false,
+        data: Buffer.from("file"),
+        duration: 0
+      };
+      const body = { metadata: '{"alt":"avatar"}' };
+      const request = new Request({
+        ip: void 0,
+        body,
+        cookies: {},
+        params: {},
+        query: {},
+        method: "post",
+        path: "/upload",
+        headers: {},
+        files: { avatar: [file] }
+      });
+      expect(request.body).toEqual({ metadata: '{"alt":"avatar"}', avatar: [file] });
+    });
+    test("does not spread non-object body values when uploaded files are present", () => {
+      const file = {
+        name: "avatar.png",
+        type: "image/png",
+        size: 4,
+        isTruncated: false,
+        data: Buffer.from("file"),
+        duration: 0
+      };
+      const request = new Request({
+        ip: void 0,
+        body: "raw text body",
+        cookies: {},
+        params: {},
+        query: {},
+        method: "post",
+        path: "/upload",
+        headers: {},
+        files: { avatar: [file] }
+      });
+      expect(request.body).toEqual({ avatar: [file] });
+    });
+  });
+}
 
 // src/server/requests-auth-methods/base.ts
 var import_node_http2 = require("http2");
@@ -1402,6 +1468,7 @@ var Server = class {
   #queue = [];
   #routesByKey = /* @__PURE__ */ new Set();
   #started = false;
+  #beforeListenHandlers = [];
   #notFoundHandler = null;
   setup(httpServer, config) {
     this.#httpServer = httpServer;
@@ -1457,6 +1524,11 @@ var Server = class {
     this.#notFoundHandler = handler;
     return this;
   }
+  onBeforeListen(handler) {
+    if (this.#started) throw new EquippedError("Cannot add before-listen handler after server has started", {});
+    this.#beforeListenHandlers.push(handler);
+    return this;
+  }
   test() {
     return (0, import_supertest.default)(this.#httpServer);
   }
@@ -1490,6 +1562,7 @@ var Server = class {
       });
       return await this.handleResponse(res, response);
     });
+    for (const handler of this.#beforeListenHandlers) await handler({ httpServer: this.#httpServer, port: config.port });
     const started = await this.startServer(config.port);
     if (started) Instance.get().log.info(`${instance.id}(${app.name}) service listening on port ${config.port}`);
     return started;
@@ -1641,6 +1714,7 @@ if (void 0) {
   const testInstanceState = globalThis;
   class TestServer extends Server {
     handledResponse = null;
+    startedPorts = [];
     notFoundHandler = null;
     constructor() {
       super();
@@ -1685,7 +1759,8 @@ if (void 0) {
     registerNotFoundHandler(cb) {
       this.notFoundHandler = cb;
     }
-    async startServer() {
+    async startServer(port) {
+      this.startedPorts.push(port);
       return true;
     }
     async dispatchNotFound(path) {
@@ -1696,6 +1771,43 @@ if (void 0) {
       return { handledResponse: this.handledResponse, rawResponse };
     }
   }
+  describe("Server before-listen handlers", () => {
+    test("runs before-listen handlers before adapter listen in registration order", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      const calls = [];
+      let receivedServer = null;
+      server.onBeforeListen(({ httpServer, port }) => {
+        calls.push(`first:${port}`);
+        receivedServer = httpServer;
+        expect(server.startedPorts).toEqual([]);
+      }).onBeforeListen(({ httpServer, port }) => {
+        calls.push(`second:${port}`);
+        expect(httpServer).toBe(receivedServer);
+        expect(server.startedPorts).toEqual([]);
+      });
+      await server.start();
+      expect(calls).toEqual(["first:0", "second:0"]);
+      expect(receivedServer).toBeInstanceOf(http.Server);
+      expect(server.startedPorts).toEqual([0]);
+    });
+    test("rejects startup when a before-listen handler fails before adapter listen", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.onBeforeListen(async () => {
+        throw new Error("before-listen failed");
+      });
+      await expect(server.start()).rejects.toThrow("before-listen failed");
+      expect(server.startedPorts).toEqual([]);
+    });
+    test("rejects adding before-listen handlers after server startup", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      expect(() => server.onBeforeListen(() => {
+      })).toThrow("Cannot add before-listen handler after server has started");
+    });
+  });
   describe("Server not-found handler", () => {
     test("throws the default Equipped not-found error when no custom handler is set", async () => {
       ensureTestInstance();