nitro5 1.0.0

package/src/static.js

@@ -0,0 +1,201 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { getMimeType } from "./mime.js";
+import { matchesCacheRule } from "./cache.js";
+import { bundleTS } from "./tsc.js";
+
+/**
+ * Safe path resolver (anti directory traversal)
+ */
+function safeResolve(root, requestPath) {
+  const clean = requestPath.startsWith("/")
+    ? requestPath
+    : `/${requestPath}`;
+
+  const normalized = path.normalize(clean).replace(/^(\.\.[/\\])+/, "");
+  const abs = path.resolve(root, `.${normalized}`);
+  const rootAbs = path.resolve(root);
+
+  if (!abs.startsWith(rootAbs)) return null;
+  return abs;
+}
+
+function getMTimeKey(absPath) {
+  const stat = fs.statSync(absPath);
+  return `${absPath}:${stat.mtimeMs}`;
+}
+
+function injectHMRClient(html, hmrPort = 3001) {
+  const client = `
+<script>
+(() => {
+  try {
+    const ws = new WebSocket("ws://" + location.hostname + ":" + ${hmrPort});
+
+    ws.onmessage = async (event) => {
+      let msg;
+      try {
+        msg = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+
+      if (msg.type === "hmr:update" && typeof msg.code === "string") {
+        const blob = new Blob([msg.code], { type: "text/javascript" });
+        const url = URL.createObjectURL(blob) + "?t=" + Date.now();
+
+        try {
+          await import(url);
+        } catch (err) {
+          console.error("HMR import failed:", err);
+          location.reload();
+        }
+      }
+    };
+
+    ws.onclose = () => {
+      console.warn("HMR socket closed");
+    };
+  } catch (err) {
+    console.error("HMR client error:", err);
+  }
+})();
+</script>
+`;
+
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${client}</body>`);
+  }
+
+  return html + client;
+}
+
+/**
+ * Static server factory
+ */
+export function createStaticServer({
+  publicDir,
+  cache,
+  cacheConfig,
+  filePool,
+  vite,
+  hmrPort = 3001
+}) {
+  return async function serveStatic(req, res) {
+    let requestPath = req.pathname || "/";
+    requestPath = requestPath.split("?")[0];
+
+    if (requestPath === "/") {
+      requestPath = "/index.html";
+    }
+
+    const absPath = safeResolve(publicDir, requestPath);
+    if (!absPath) return false;
+
+    if (!fs.existsSync(absPath)) return false;
+    if (!fs.statSync(absPath).isFile()) return false;
+
+    const ext = path.extname(absPath).toLowerCase();
+    const cacheable =
+      cacheConfig?.enabled &&
+      matchesCacheRule(absPath, cacheConfig.files);
+
+    const cacheKey = cacheable ? getMTimeKey(absPath) : null;
+
+    /**
+     * =========================
+     * CACHE HIT
+     * =========================
+     */
+    if (cacheable && cacheKey) {
+      const cached = cache.get(cacheKey);
+      if (cached) {
+        res.binary(cached.buffer, 200, cached.contentType);
+        return true;
+      }
+    }
+
+    /**
+     * =========================
+     * HTML (VITE STYLE TRANSFORM)
+     * =========================
+     */
+    if (ext === ".html") {
+      const html = await fsp.readFile(absPath, "utf8");
+
+      let transformed = html;
+
+      if (vite?.transformIndexHtml) {
+        transformed = await vite.transformIndexHtml(
+          req.fullPath || req.pathname || "/",
+          html
+        );
+      }
+
+      transformed = injectHMRClient(transformed, hmrPort);
+
+      const buffer = Buffer.from(transformed);
+      const contentType = "text/html; charset=utf-8";
+
+      if (cacheable && cacheKey) {
+        cache.set(cacheKey, { buffer, contentType }, cacheConfig.ttl);
+      }
+
+      res.binary(buffer, 200, contentType);
+      return true;
+    }
+
+    /**
+     * =========================
+     * TYPESCRIPT SUPPORT
+     * =========================
+     */
+    if (ext === ".ts" || ext === ".tsx") {
+      try {
+        const code = await bundleTS(absPath);
+
+        if (!code) {
+          throw new Error("TS bundle returned empty output");
+        }
+
+        const buffer = Buffer.from(code);
+        const contentType = "application/javascript; charset=utf-8";
+
+        if (cacheable && cacheKey) {
+          cache.set(cacheKey, { buffer, contentType }, cacheConfig.ttl);
+        }
+
+        res.binary(buffer, 200, contentType);
+        return true;
+      } catch (err) {
+        console.error("TS BUNDLE ERROR:", err);
+
+        res.send(
+          `console.error("TS build failed: ${err.message}")`,
+          500,
+          "application/javascript"
+        );
+        return true;
+      }
+    }
+
+    /**
+     * =========================
+     * NORMAL FILES
+     * =========================
+     */
+    const contentType = getMimeType(absPath);
+
+    const buffer = filePool
+      ? await filePool.run(absPath)
+      : await fsp.readFile(absPath);
+
+    if (cacheable && cacheKey) {
+      cache.set(cacheKey, { buffer, contentType }, cacheConfig.ttl);
+    }
+
+    res.binary(buffer, 200, contentType);
+    return true;
+  };
+}

package/src/stats.js

@@ -0,0 +1,25 @@
+const stats = {
+  totalRequests: 0,
+  totalErrors: 0,
+  activeConnections: 0
+};
+
+export function incRequest() {
+  stats.totalRequests++;
+}
+
+export function incError() {
+  stats.totalErrors++;
+}
+
+export function incConn() {
+  stats.activeConnections++;
+}
+
+export function decConn() {
+  stats.activeConnections--;
+}
+
+export function getStats() {
+  return stats;
+}

package/src/supervisor.js

@@ -0,0 +1,249 @@
+import cluster from "node:cluster";
+import os from "node:os";
+import path from "node:path";
+import chalk from "chalk";
+import { createApp } from "./app.js";
+import { watchProjectFiles } from "./watcher.js";
+
+function resolveWorkers(value) {
+  if (value === "auto") return os.cpus().length;
+
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    if (Number.isFinite(n) && n > 0) return Math.floor(n);
+  }
+
+  return 1;
+}
+
+function serializeConfig(config) {
+  try {
+    return JSON.stringify(config ?? {});
+  } catch {
+    return "{}";
+  }
+}
+
+function readConfigFromEnv() {
+  try {
+    const raw = process.env.NITRO5_CONFIG;
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function formatChangedFile(changedFile) {
+  if (!changedFile || changedFile === "manual-restart") return "manual-restart";
+  try {
+    return path.relative(process.cwd(), changedFile) || changedFile;
+  } catch {
+    return String(changedFile);
+  }
+}
+
+async function startWorker(inputConfig = {}) {
+  const config =
+    inputConfig && Object.keys(inputConfig).length > 0
+      ? inputConfig
+      : readConfigFromEnv();
+
+  const app = await createApp(config);
+  const port = Number(config.server?.port) || 3000;
+
+  let server;
+  try {
+    server = await app.listen(port, () => {
+      console.log(
+        chalk.green(`[worker ${process.pid}] Nitro5 listening on ${port}`)
+      );
+    });
+  } catch (error) {
+    console.error(
+      chalk.red(`[worker ${process.pid}] failed to listen on ${port}:`),
+      error
+    );
+    process.exit(1);
+    return;
+  }
+
+  let shuttingDown = false;
+
+  const shutdown = (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    console.log(
+      chalk.yellow(`[worker ${process.pid}] received ${signal}, shutting down...`)
+    );
+
+    const exitNow = () => process.exit(0);
+
+    try {
+      if (server && typeof server.close === "function") {
+        server.close(exitNow);
+      } else {
+        exitNow();
+      }
+    } catch {
+      exitNow();
+    }
+
+    setTimeout(() => process.exit(0), 5000).unref?.();
+  };
+
+  process.once("SIGTERM", () => shutdown("SIGTERM"));
+  process.once("SIGINT", () => shutdown("SIGINT"));
+
+  process.on("uncaughtException", (error) => {
+    console.error(chalk.red(`[worker ${process.pid}] uncaughtException:`), error);
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", (error) => {
+    console.error(
+      chalk.red(`[worker ${process.pid}] unhandledRejection:`),
+      error
+    );
+    process.exit(1);
+  });
+
+  return server;
+}
+
+export async function startSupervisor(config = {}) {
+  const isPrimary = cluster.isPrimary ?? cluster.isMaster;
+
+  if (!isPrimary) {
+    await startWorker(config);
+    return;
+  }
+
+  const workerCount = resolveWorkers(config.server?.workers ?? 1);
+
+  console.log(
+    chalk.cyan(`Nitro5 supervisor started with ${workerCount} worker(s)`)
+  );
+
+  const workers = new Set();
+  const baseEnv = {
+    ...process.env,
+    NITRO5_CONFIG: serializeConfig(config),
+  };
+
+  let restarting = false;
+  let restartQueued = false;
+
+  const spawnWorker = () => {
+    const worker = cluster.fork(baseEnv);
+    workers.add(worker);
+
+    worker.on("online", () => {
+      console.log(chalk.gray(`[supervisor] worker ${worker.process.pid} online`));
+    });
+
+    worker.on("message", (msg) => {
+      if (msg?.type === "restart") {
+        void restartAll("manual-restart");
+      }
+    });
+
+    worker.on("exit", (code, signal) => {
+      workers.delete(worker);
+
+      console.log(
+        chalk.gray(
+          `[supervisor] worker ${worker.process.pid} exited (code=${code}, signal=${signal ?? "none"})`
+        )
+      );
+
+      if (!restarting && config.server?.autoStart) {
+        setTimeout(() => {
+          if (!restarting) spawnWorker();
+        }, 300);
+      }
+    });
+
+    return worker;
+  };
+
+  const spawnWorkerBatch = () => {
+    for (let i = 0; i < workerCount; i++) {
+      spawnWorker();
+    }
+  };
+
+  const restartAll = async (changedFile = "manual-restart") => {
+    if (restarting) {
+      restartQueued = true;
+      return;
+    }
+
+    restarting = true;
+
+    console.log(
+      chalk.magenta(
+        `[hot reload] ${formatChangedFile(changedFile)} changed`
+      )
+    );
+
+    const currentWorkers = Array.from(workers);
+
+    for (const worker of currentWorkers) {
+      try {
+        worker.kill("SIGTERM");
+      } catch {}
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    workers.clear();
+    spawnWorkerBatch();
+
+    restarting = false;
+
+    if (restartQueued) {
+      restartQueued = false;
+      void restartAll("queued-restart");
+    }
+  };
+
+  const shutdownPrimary = () => {
+    if (restarting) return;
+    restarting = true;
+
+    console.log(chalk.yellow("[supervisor] shutting down workers..."));
+
+    for (const worker of workers) {
+      try {
+        worker.kill("SIGTERM");
+      } catch {}
+    }
+
+    setTimeout(() => process.exit(0), 5000).unref?.();
+  };
+
+  process.once("SIGTERM", shutdownPrimary);
+  process.once("SIGINT", shutdownPrimary);
+
+  spawnWorkerBatch();
+
+  if (config.dev?.hotReload) {
+    watchProjectFiles({
+      roots: [
+        path.join(process.cwd(), "src"),
+        path.join(process.cwd(), "public"),
+        path.join(process.cwd(), "native"),
+        process.cwd(),
+      ],
+      onChange: (changedFile) => {
+        void restartAll(changedFile);
+      },
+    });
+  }
+}

package/src/thread-pool.js

@@ -0,0 +1,107 @@
+import os from "node:os";
+import { Worker } from "node:worker_threads";
+
+class PoolWorker {
+  constructor(worker) {
+    this.worker = worker;
+    this.busy = false;
+    this.currentJob = null;
+  }
+}
+
+export class ThreadPool {
+  constructor(size = 1) {
+    this.size = Math.max(1, size);
+    this.workers = [];
+    this.queue = [];
+    this.jobId = 0;
+    
+    for (let i = 0; i < this.size; i++) {
+      this.workers.push(this.createWorker());
+    }
+  }
+  
+  createWorker() {
+    const worker = new Worker(new URL("./file-worker.js", import.meta.url), {
+      type: "module"
+    });
+    
+    const wrapped = new PoolWorker(worker);
+    
+    worker.on("message", (msg) => {
+      const job = wrapped.currentJob;
+      if (!job) return;
+      
+      wrapped.currentJob = null;
+      wrapped.busy = false;
+      
+      if (msg.ok) {
+        job.resolve(Buffer.from(msg.base64, "base64"));
+      } else {
+        job.reject(new Error(msg.error || "Worker thread failed"));
+      }
+      
+      this.dispatch();
+    });
+    
+    worker.on("error", (error) => {
+      const job = wrapped.currentJob;
+      wrapped.currentJob = null;
+      wrapped.busy = false;
+      
+      if (job) job.reject(error);
+    });
+    
+    worker.on("exit", (code) => {
+      if (code !== 0) {
+        const job = wrapped.currentJob;
+        wrapped.currentJob = null;
+        wrapped.busy = false;
+        
+        if (job) {
+          job.reject(new Error(`Worker exited with code ${code}`));
+        }
+        
+        const index = this.workers.indexOf(wrapped);
+        if (index >= 0) {
+          this.workers[index] = this.createWorker();
+        }
+      }
+    });
+    
+    return wrapped;
+  }
+  
+  run(filePath) {
+    return new Promise((resolve, reject) => {
+      const job = {
+        id: ++this.jobId,
+        filePath,
+        resolve,
+        reject
+      };
+      
+      this.queue.push(job);
+      this.dispatch();
+    });
+  }
+  
+  dispatch() {
+    for (const wrapped of this.workers) {
+      if (wrapped.busy) continue;
+      const job = this.queue.shift();
+      if (!job) return;
+      
+      wrapped.busy = true;
+      wrapped.currentJob = job;
+      wrapped.worker.postMessage({
+        id: job.id,
+        filePath: job.filePath
+      });
+    }
+  }
+  
+  async close() {
+    await Promise.allSettled(this.workers.map((w) => w.worker.terminate()));
+  }
+}