nitro5 1.0.0

package/src/cache.js

@@ -0,0 +1,53 @@
+import ms from "ms";
+
+export class MemoryCache {
+  constructor() {
+    this.store = new Map();
+  }
+  
+  set(key, value, ttl) {
+    const ttlMs = typeof ttl === "string" ? ms(ttl) : ttl;
+    const expiresAt = Date.now() + ttlMs;
+    
+    this.store.set(key, {
+      value,
+      expiresAt
+    });
+  }
+  
+  get(key) {
+    const item = this.store.get(key);
+    if (!item) return null;
+    
+    if (Date.now() > item.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    
+    return item.value;
+  }
+  
+  delete(key) {
+    this.store.delete(key);
+  }
+  
+  clear() {
+    this.store.clear();
+  }
+}
+
+export function matchesCacheRule(filePath, patterns = []) {
+  const lower = filePath.toLowerCase();
+  
+  return patterns.some((pattern) => {
+    const p = pattern.toLowerCase();
+    
+    if (p === "*.css") return lower.endsWith(".css");
+    if (p === "*.js") return lower.endsWith(".js");
+    if (p === "*.svg") return lower.endsWith(".svg");
+    if (p === "*.webp") return lower.endsWith(".webp");
+    if (p === "*.html") return lower.endsWith(".html");
+    
+    return false;
+  });
+}

package/src/dashboard.js

@@ -0,0 +1,215 @@
+import { getStats } from "./stats.js";
+import { getMetrics } from "./native.js";
+
+/* =========================
+   EVENT BUS (Redis-like)
+========================= */
+class EventBus {
+  constructor() {
+    this.channels = new Map();
+  }
+
+  subscribe(event, fn) {
+    if (!this.channels.has(event)) {
+      this.channels.set(event, new Set());
+    }
+
+    this.channels.get(event).add(fn);
+
+    return () => this.channels.get(event)?.delete(fn);
+  }
+
+  publish(event, data) {
+    const subs = this.channels.get(event);
+    if (!subs) return;
+
+    for (const fn of subs) {
+      try {
+        fn(data);
+      } catch (e) {
+        console.error("EventBus error:", e);
+      }
+    }
+  }
+}
+
+export const bus = new EventBus();
+
+/* =========================
+   SSE CLIENT STORE
+========================= */
+const clients = new Set();
+const PING_INTERVAL_MS = 15000;
+
+/* =========================
+   SAFE WRITE
+========================= */
+function safeWrite(res, data) {
+  if (!res || res.ended) return false;
+
+  try {
+    if (typeof data === "string" || Buffer.isBuffer(data)) {
+      res.write(data);
+    } else {
+      res.write(`data: ${JSON.stringify(data)}\n\n`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/* =========================
+   REMOVE CLIENT
+========================= */
+function removeClient(res) {
+  clients.delete(res);
+}
+
+/* =========================
+   EVENT BROADCAST
+========================= */
+export function sendEvent(data) {
+  bus.publish(data.type || "message", data);
+}
+
+/* =========================
+   ADAPTIVE INTERVAL ENGINE
+========================= */
+function getLoadScore() {
+  const cpu = process.cpuUsage();
+  const mem = process.memoryUsage().heapUsed;
+
+  return {
+    clients: clients.size,
+    cpu: cpu.user + cpu.system,
+    mem,
+  };
+}
+
+function calculateInterval() {
+  const load = getLoadScore();
+
+  let ms = 1000;
+
+  if (load.clients > 50) ms = 3000;
+  else if (load.clients > 20) ms = 2000;
+  else if (load.clients > 5) ms = 1000;
+
+  if (load.mem > 200 * 1024 * 1024) ms += 2000;
+
+  return ms;
+}
+
+/* =========================
+   SSE HANDLER
+========================= */
+export function handleSSE(req, res) {
+  if (!req || !res) return;
+
+  const socket = req.socket;
+
+  // header support fallback
+  if (typeof res.stream === "function") {
+    res.stream(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    });
+  } else {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    });
+  }
+
+  clients.add(res);
+
+  /* INIT MESSAGE */
+  safeWrite(res, "retry: 1000\n\n");
+
+  safeWrite(res, {
+    type: "stats",
+    stats: getStats(),
+    metrics: getMetrics(),
+    ts: Date.now(),
+  });
+
+  /* =========================
+     SUBSCRIBE CLIENT TO BUS
+  ========================= */
+  const unsubscribe = bus.subscribe("stats", (data) => {
+    safeWrite(res, data);
+  });
+
+  /* =========================
+     PING KEEP ALIVE
+  ========================= */
+  const pingTimer = setInterval(() => {
+    if (res.ended) {
+      cleanup();
+      return;
+    }
+
+    try {
+      res.write(": ping\n\n");
+    } catch {
+      cleanup();
+    }
+  }, PING_INTERVAL_MS);
+
+  pingTimer.unref?.();
+
+  /* =========================
+     CLEANUP
+  ========================= */
+  const cleanup = () => {
+    clearInterval(pingTimer);
+    unsubscribe?.();
+    removeClient(res);
+
+    try {
+      res.end?.();
+    } catch {}
+  };
+
+  /* SAFE SOCKET HOOK */
+  if (socket?.once) {
+    socket.once("close", cleanup);
+    socket.once("end", cleanup);
+    socket.once("error", cleanup);
+  } else {
+    req?.on?.("close", cleanup);
+  }
+}
+
+/* =========================
+   ADAPTIVE BROADCAST LOOP
+========================= */
+let lastPayload = null;
+let intervalMs = 1000;
+
+setInterval(() => {
+  intervalMs = calculateInterval();
+}, 5000);
+
+setInterval(() => {
+  if (clients.size === 0) return;
+
+  const payload = {
+    type: "stats",
+    stats: getStats(),
+    metrics: getMetrics(),
+    ts: Date.now(),
+  };
+
+  const serialized = JSON.stringify(payload);
+
+  if (serialized === lastPayload) return;
+  lastPayload = serialized;
+
+  sendEvent(payload);
+}, intervalMs).unref?.();

package/src/deps-cache.js

@@ -0,0 +1,37 @@
+const depGraph = new Map(); // file -> [deps]
+const reverseGraph = new Map(); // dep -> [files]
+
+const cache = new Map(); // file -> code
+
+export function setCache(file, code) {
+  cache.set(file, code);
+}
+
+export function getCache(file) {
+  return cache.get(file);
+}
+
+export function hasCache(file) {
+  return cache.has(file);
+}
+
+export function setDeps(file, deps = []) {
+  depGraph.set(file, deps);
+
+  for (const dep of deps) {
+    if (!reverseGraph.has(dep)) reverseGraph.set(dep, []);
+    reverseGraph.get(dep).push(file);
+  }
+}
+
+export function invalidate(file) {
+  cache.delete(file);
+
+  const dependents = reverseGraph.get(file) || [];
+
+  for (const dep of dependents) {
+    cache.delete(dep);
+  }
+
+  cache.delete(file);
+}

package/src/disk-cache.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const CACHE_DIR = "./.nitro-cache";
+
+if (!fs.existsSync(CACHE_DIR)) {
+  fs.mkdirSync(CACHE_DIR);
+}
+
+function safeName(file) {
+  return file.replace(/[\/\\:]/g, "_");
+}
+
+export function getDiskPath(file) {
+  return path.join(CACHE_DIR, safeName(file) + ".json");
+}
+
+export function readDiskCache(file) {
+  const p = getDiskPath(file);
+  if (!fs.existsSync(p)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function writeDiskCache(file, data) {
+  const p = getDiskPath(file);
+  fs.writeFileSync(p, JSON.stringify(data));
+}
+
+export function clearDiskCache(file) {
+  const p = getDiskPath(file);
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+}

package/src/file-worker.js

@@ -0,0 +1,19 @@
+import { parentPort } from "node:worker_threads";
+import { readFile } from "node:fs/promises";
+
+parentPort.on("message", async (message) => {
+  try {
+    const buffer = await readFile(message.filePath);
+    parentPort.postMessage({
+      id: message.id,
+      ok: true,
+      base64: buffer.toString("base64")
+    });
+  } catch (error) {
+    parentPort.postMessage({
+      id: message.id,
+      ok: false,
+      error: error?.message || "Failed to read file"
+    });
+  }
+});

package/src/hmr.js

@@ -0,0 +1,38 @@
+import { WebSocketServer } from "ws";
+
+export function createHMRServer({ port = 3001 } = {}) {
+  const clients = new Set();
+  const wss = new WebSocketServer({ port });
+
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+
+    ws.on("close", () => {
+      clients.delete(ws);
+    });
+  });
+
+  function broadcast(message) {
+    const data = JSON.stringify(message);
+
+    for (const client of clients) {
+      if (client.readyState === 1) {
+        client.send(data);
+      }
+    }
+  }
+
+  function close() {
+    for (const client of clients) {
+      client.close();
+    }
+    wss.close();
+  }
+
+  return {
+    port,
+    wss,
+    broadcast,
+    close
+  };
+}

package/src/logger.js

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { sendEvent } from "./dashboard.js";
+
+export function createLogger(config) {
+  const logDir = config.logging?.dir || "logs";
+
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  const accessLog = path.join(logDir, "access.log");
+  const errorLog = path.join(logDir, "error.log");
+
+  function write(file, message) {
+    fs.appendFile(file, message + "\n", () => {});
+  }
+
+  function formatAccess(req, res, timeMs) {
+    return `${new Date().toISOString()} | ${req.method} ${req.pathname} | ${res.statusCode} | ${timeMs}ms | ${req.headers["host"] || "-"}`
+  }
+
+  return {
+    access(req, res, timeMs) {
+  const line = formatAccess(req, res, timeMs);
+  console.log(line);
+  write(accessLog, line);
+
+  sendEvent({
+    type: "access",
+    method: req.method,
+    path: req.pathname,
+    status: res.statusCode,
+    time: timeMs,
+    ts: Date.now()
+  });
+}, 
+
+    error(err, req) {
+  const line = `${new Date().toISOString()} | ERROR | ${req?.method || "-"} ${req?.pathname || "-"} | ${err.stack || err}`;
+  console.error(line);
+  write(errorLog, line);
+
+  sendEvent({
+    type: "error",
+    message: err.stack || String(err),
+    ts: Date.now()
+  });
+}
+  };
+}

package/src/mime.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+
+export function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  
+  switch (ext) {
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".js":
+    case ".mjs":
+      return "application/javascript; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".ico":
+      return "image/x-icon";
+    case ".txt":
+      return "text/plain; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}

package/src/msg.js

@@ -0,0 +1,16 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const pkgPath = path.join(__dirname, "../package.json");
+
+const data= JSON.parse(readFileSync(pkgPath, "utf-8"));
+const msg = {
+  info: `Nitro 5 Web Server v${data.version}, Running on Node.js ${process.version}.\n\n`,
+  noConfigFound: `[NITRO 5 ERROR]: No config file are found in ${process.cwd()}.\n\nHint: you are no nitro5.config.js file, create the file and see https://nitro5.opendnf.cloud/config-file#example`
+}
+
+export default msg;

package/src/native.js

@@ -0,0 +1,75 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+let addon = null;
+
+try {
+  addon = require("../build/Release/nitro5.node");
+} catch {
+  addon = null;
+}
+
+function jsFallbackParse(raw) {
+  const headerEnd = raw.indexOf("\r\n\r\n");
+  const head = headerEnd >= 0 ? raw.slice(0, headerEnd) : raw;
+  const body = headerEnd >= 0 ? raw.slice(headerEnd + 4) : "";
+  
+  const lines = head.split("\r\n");
+  const [requestLine = "GET / HTTP/1.1"] = lines;
+  const [method = "GET", fullPath = "/", httpVersion = "HTTP/1.1"] = requestLine.split(" ");
+  
+  const [pathname = "/", query = ""] = fullPath.split("?");
+  const headers = {};
+  
+  for (const line of lines.slice(1)) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    
+    const key = line.slice(0, idx).trim().toLowerCase();
+    const value = line.slice(idx + 1).trim();
+    headers[key] = value;
+  }
+  
+  return {
+    method,
+    fullPath,
+    pathname,
+    query,
+    httpVersion,
+    headers,
+    body,
+    raw
+  };
+}
+
+export function parseHttpRequest(raw) {
+  if (addon && typeof addon.parseHttpRequest === "function") {
+    return addon.parseHttpRequest(raw);
+  }
+  return jsFallbackParse(raw);
+}
+
+export function getMetrics() {
+  try {
+    if (!nativeReady || !addon?.getMetrics) {
+      return {
+        memoryKB: process.memoryUsage().rss / 1024,
+        cpuUser: 0,
+        cpuSystem: 0,
+        fallback: true
+      };
+    }
+
+    return addon.getMetrics();
+  } catch (err) {
+    return {
+      memoryKB: process.memoryUsage().rss / 1024,
+      cpuUser: 0,
+      cpuSystem: 0,
+      error: true
+    };
+  }
+}
+
+export const nativeReady = Boolean(addon);

package/src/router.js

@@ -0,0 +1,85 @@
+export class Router {
+  constructor() {
+    this.routes = {
+      GET: new Map(),
+      POST: new Map(),
+      PUT: new Map(),
+      PATCH: new Map(),
+      DELETE: new Map()
+    };
+
+    this.middlewares = [];
+  }
+
+  // ---------------------------
+  // utils
+  // ---------------------------
+  normalize(path) {
+    if (!path) return "/";
+
+    let p = String(path);
+
+    // buang query + hash
+    p = p.split("?")[0].split("#")[0];
+
+    // normalize slash
+    p = p.replace(/\/+/g, "/");
+
+    // hapus trailing slash kecuali root
+    if (p.length > 1) p = p.replace(/\/+$/, "");
+
+    if (!p.startsWith("/")) p = "/" + p;
+
+    return p || "/";
+  }
+
+  // ---------------------------
+  // middleware
+  // ---------------------------
+  use(fn) {
+    this.middlewares.push(fn);
+  }
+
+  // ---------------------------
+  // register routes
+  // ---------------------------
+  get(path, handler) {
+    this.routes.GET.set(this.normalize(path), handler);
+  }
+
+  post(path, handler) {
+    this.routes.POST.set(this.normalize(path), handler);
+  }
+
+  put(path, handler) {
+    this.routes.PUT.set(this.normalize(path), handler);
+  }
+
+  patch(path, handler) {
+    this.routes.PATCH.set(this.normalize(path), handler);
+  }
+
+  delete(path, handler) {
+    this.routes.DELETE.set(this.normalize(path), handler);
+  }
+
+  // ---------------------------
+  // resolve route
+  // ---------------------------
+  resolve(method, pathname) {
+    const m = String(method || "GET").toUpperCase();
+    const p = this.normalize(pathname);
+
+    return this.routes[m]?.get(p) ?? null;
+  }
+
+  // ---------------------------
+  // debug helper (optional)
+  // ---------------------------
+  debug() {
+    console.log("=== ROUTES ===");
+    for (const method of Object.keys(this.routes)) {
+      console.log(method, [...this.routes[method].keys()]);
+    }
+  }
+}

package/src/stat.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;
+}