dinou 7.0.0 → 7.2.0

package/dinou/index.d.ts

@@ -120,8 +120,29 @@ export interface RequestContextStore {
 // DINOU CONFIGURATION & PLUGIN INTERFACES
 // ====================================================================
 
+export type NodeMiddleware = (
+  req: import("node:http").IncomingMessage,
+  res: import("node:http").ServerResponse,
+  next: () => void
+) => void | Promise<void>;
+
+export interface ServerHookContext {
+  /** The underlying Node.js http.Server instance */
+  server: import("node:http").Server;
+  /** Whether the server is running in development mode */
+  isDev: boolean;
+  /** Register a raw Node.js middleware (req, res, next) executed before Dinou routes */
+  use(middleware: NodeMiddleware): void;
+}
+
 export interface DinouPlugin {
   name?: string;
+  /**
+   * Hook invoked when the Node.js HTTP server is instantiated,
+   * allowing plugins to attach WebSockets (Socket.IO, ws), listeners, or raw Node middlewares.
+   */
+  configureServer?(context: ServerHookContext): Promise<void> | void;
+
   /**
    * Universal Web Standards middleware and webhook handler.
    * Runs on every incoming HTTP request before React rendering.

package/dinou/node/build.mjs

@@ -119,12 +119,32 @@ export async function fetch(req) {
 
 const PORT = Number(process.env.PORT || 3000);
 
-export function startServer(port = PORT, host = "0.0.0.0") {
+const nodeMiddlewares = [];
+
+export async function startServer(port = PORT, host = "0.0.0.0") {
   const server = http.createServer(async (req, res) => {
     try {
+      if (res.writableEnded || res.headersSent) {
+        return;
+      }
+
+      if (nodeMiddlewares.length > 0) {
+        for (const mw of nodeMiddlewares) {
+          let continued = false;
+          await mw(req, res, () => {
+            continued = true;
+          });
+          if (!continued || res.writableEnded || res.headersSent) {
+            return;
+          }
+        }
+      }
+
       const webReq = nodeToWebRequest(req);
       const webRes = await fetch(webReq);
-      await sendWebResponseToNode(webRes, res);
+      if (!res.writableEnded && !res.headersSent) {
+        await sendWebResponseToNode(webRes, res);
+      }
     } catch (err) {
       console.error("[Dinou Node Server] Request error:", err);
       if (!res.headersSent) {
@@ -135,6 +155,29 @@ export function startServer(port = PORT, host = "0.0.0.0") {
     }
   });
 
+  try {
+    const { getDinouConfig } = await import("${dinouDirSlash}/core/load-dinou-config.js");
+    const cfg = await getDinouConfig();
+    if (cfg.plugins && Array.isArray(cfg.plugins)) {
+      const serverContext = {
+        server,
+        isDev: false,
+        use(middleware) {
+          if (typeof middleware === "function") {
+            nodeMiddlewares.push(middleware);
+          }
+        },
+      };
+      for (const plugin of cfg.plugins) {
+        if (typeof plugin.configureServer === "function") {
+          await plugin.configureServer(serverContext);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("❌ [Dinou Node Server] Error running configureServer plugins:", err);
+  }
+
   return new Promise((resolve, reject) => {
     server.on("error", reject);
     server.listen(port, () => {

package/dinou/node/dev.mjs

@@ -2302,9 +2302,52 @@ async function startClientBundler(tool) {
   throw new Error(`Unsupported DINOU_BUILD_TOOL: ${tool}`);
 }
 
+// Node.js Middlewares registered by plugins via configureServer
+const nodeMiddlewares = [];
+
+async function applyServerPlugins(serverInstance) {
+  try {
+    const { getDinouConfig } = require(path.join(dinouDir, "core/load-dinou-config.js"));
+    const config = await getDinouConfig();
+    if (config.plugins && Array.isArray(config.plugins)) {
+      const serverContext = {
+        server: serverInstance,
+        isDev: true,
+        use(middleware) {
+          if (typeof middleware === "function") {
+            nodeMiddlewares.push(middleware);
+          }
+        },
+      };
+      for (const plugin of config.plugins) {
+        if (typeof plugin.configureServer === "function") {
+          await plugin.configureServer(serverContext);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("❌ [Dinou Dev] Error applying plugin configureServer hooks:", err);
+  }
+}
+
 // HTTP Server
 const server = http.createServer(async (req, res) => {
   try {
+    if (res.writableEnded || res.headersSent) {
+      return;
+    }
+
+    if (nodeMiddlewares.length > 0) {
+      for (const mw of nodeMiddlewares) {
+        let continued = false;
+        await mw(req, res, () => {
+          continued = true;
+        });
+        if (!continued || res.writableEnded || res.headersSent) {
+          return;
+        }
+      }
+    }
     if (clientBundlerPromise) {
       await clientBundlerPromise;
     }
@@ -2493,7 +2536,9 @@ const server = http.createServer(async (req, res) => {
       console.log(`[DEV 404] ${req.method} ${pathname}`);
     }
 
-    await sendWebResponseToNode(webRes, res);
+    if (!res.writableEnded && !res.headersSent) {
+      await sendWebResponseToNode(webRes, res);
+    }
   } catch (err) {
     console.error("[Dinou Dev Server] Request error:", err);
     if (!res.headersSent) {
@@ -2515,6 +2560,8 @@ server.on("error", (err) => {
   process.exit(1);
 });
 
+await applyServerPlugins(server);
+
 server.listen(PORT, async () => {
   const buildTool = isWebpackBuild ? "webpack" : (process.env.DINOU_BUILD_TOOL || "esbuild");
 

package/dinou/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinou-ejected",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "main": "index.js",
   "private": true,
   "exports": {