@velox0/cerver 0.4.2 → 0.5.0

package/lib/commands/run.js

@@ -3,12 +3,19 @@
 const { execFileSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
+const { findProjectRoot } = require("../config");
 
 /**
  * Run the compiled binary from dist/.
  */
 function run(opts) {
-  const projectDir = process.cwd();
+  const projectDir = findProjectRoot();
+  if (!projectDir) {
+    console.log("Not a cerver project");
+    process.exit(1);
+  }
+  process.chdir(projectDir);
+
   const binaryPath = path.join(projectDir, "dist", "server");
 
   if (!fs.existsSync(binaryPath)) {

package/lib/compiler/compile.js

@@ -45,12 +45,17 @@ function supportsFlag(cc, flag) {
  */
 function compile(distDir, runtimeDir, opts) {
   const cc = detectCompiler();
-  const serverC = path.join(distDir, "server.c");
   const outputBin = path.join(distDir, "server");
 
-  if (!fs.existsSync(serverC)) {
+  /* Collect all generated source files from distDir */
+  const generatedSources = fs
+    .readdirSync(distDir)
+    .filter((f) => f.endsWith(".c"))
+    .map((f) => path.join(distDir, f));
+
+  if (generatedSources.length === 0) {
     throw new Error(
-      `cerver: generated source not found at ${serverC}`
+      `cerver: no generated C source files found in ${distDir}`
     );
   }
 
@@ -68,7 +73,7 @@ function compile(distDir, runtimeDir, opts) {
     "-Wno-unused-parameter",
     "-o",
     outputBin,
-    serverC,
+    ...generatedSources,
     ...runtimeSources,
     `-I${runtimeDir}`,
     "-lpthread",

package/lib/config.js

@@ -53,4 +53,23 @@ function loadConfig(projectDir) {
   return config;
 }
 
-module.exports = { loadConfig, DEFAULTS };
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+
+  while (true) {
+    if (fs.existsSync(path.join(currentDir, "cerver.config.js"))) {
+      return currentDir;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  return null;
+}
+
+module.exports = { loadConfig, findProjectRoot, DEFAULTS };
+

package/lib/parser/discover.js

@@ -4,15 +4,15 @@ const fs = require("fs");
 const path = require("path");
 
 /**
- * Discover route files under app/routes/ and map them to URL paths.
+ * Discover route files under routes/ and map them to URL paths.
  *
  * File-based routing convention:
- *   app/routes/index.js      → /
- *   app/routes/page.js       → /page
- *   app/routes/group/item.js → /group/item
- *   app/routes/item/[id].js  → /item/:id
+ *   routes/index.js      → /
+ *   routes/page.js       → /page
+ *   routes/group/item.js → /group/item
+ *   routes/item/[id].js  → /item/:id
  *
- * @param {string} routesDir - Absolute path to app/routes/
+ * @param {string} routesDir - Absolute path to routes/
  * @returns {Array<{ filePath: string, urlPath: string }>}
  */
 function discoverRoutes(routesDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries",
   "main": "bin/cerver.js",
   "bin": {
@@ -30,4 +30,4 @@
     "chokidar": "^3.6.0",
     "commander": "^13.1.0"
   }
-}
+}

package/runtime/cerver.h

@@ -119,6 +119,9 @@ typedef struct {
 
   /* Keep-alive control: set to 1 to force close after response */
   int _force_close;
+
+  /* Internal file descriptor for sendfile serving */
+  int _file_fd;
 } cerver_response_t;
 
 /* Response helpers — called by generated handler code */
@@ -233,6 +236,9 @@ struct cerver_server {
   /* Worker pool */
   int              worker_count;
   cerver_worker_t* workers;
+
+  /* Route trie for radix/trie-based routing */
+  void* route_trie;
 };
 
 /* Server lifecycle */
@@ -262,6 +268,10 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive);
 
 int               cerver_route_match(const cerver_route_t* route, cerver_request_t* req);
 cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req);
+void*             cerver_trie_create(void);
+void              cerver_trie_insert(void* trie, const char* pattern, const char* method,
+                                     cerver_handler_fn handler);
+void              cerver_trie_free(void* trie);
 
 /* ------------------------------------------------------------------ */
 /*  MIME (internal)                                                   */

package/runtime/http_writer.c

@@ -12,6 +12,64 @@
 #include <string.h>
 #include <unistd.h>
 #include <sys/uio.h>
+#include <errno.h>
+
+#ifdef __linux__
+#include <sys/sendfile.h>
+static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
+  off_t off = offset;
+  return sendfile(out_fd, in_fd, &off, count);
+}
+#elif defined(__APPLE__)
+#include <sys/types.h>
+#include <sys/socket.h>
+static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
+  off_t len = (off_t)count;
+  int   res = sendfile(in_fd, out_fd, offset, &len, NULL, 0);
+  if (res == 0) {
+    return (ssize_t)len;
+  }
+  if (len > 0) {
+    return (ssize_t)len;
+  }
+  /* Fallback to read-write copy if not a socket or unsupported on this descriptor type */
+  char buf[8192];
+  if (lseek(in_fd, offset, SEEK_SET) == -1) return -1;
+  size_t  to_read = count > sizeof(buf) ? sizeof(buf) : count;
+  ssize_t n_read  = read(in_fd, buf, to_read);
+  if (n_read <= 0) return n_read;
+
+  size_t written = 0;
+  while (written < (size_t)n_read) {
+    ssize_t n_write = write(out_fd, buf + written, (size_t)n_read - written);
+    if (n_write < 0) {
+      if (errno == EINTR) continue;
+      return -1;
+    }
+    written += (size_t)n_write;
+  }
+  return (ssize_t)written;
+}
+#else
+static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
+  char buf[8192];
+  if (lseek(in_fd, offset, SEEK_SET) == -1) return -1;
+  size_t  to_read = count > sizeof(buf) ? sizeof(buf) : count;
+  ssize_t n_read  = read(in_fd, buf, to_read);
+  if (n_read <= 0) return n_read;
+
+  size_t written = 0;
+  while (written < (size_t)n_read) {
+    ssize_t n_write = write(out_fd, buf + written, (size_t)n_read - written);
+    if (n_write < 0) {
+      if (errno == EINTR) continue;
+      return -1;
+    }
+    written += (size_t)n_write;
+  }
+  return (ssize_t)written;
+}
+#endif
 
 /* ------------------------------------------------------------------ */
 /*  Status text lookup                                                */
@@ -93,40 +151,89 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
   hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "\r\n");
 
   /*
-   * Use writev() to send header + body in a single syscall.
-   * This avoids Nagle interaction and reduces context switches.
+   * Use writev() or sendfile() to send response, or copy to contiguous
+   * buffer if body is small to avoid writev round-trips.
    */
-  if (res->body && res->body_len > 0) {
-    struct iovec iov[2];
-    iov[0].iov_base = header;
-    iov[0].iov_len  = (size_t)hlen;
-    iov[1].iov_base = (void*)res->body;
-    iov[1].iov_len  = res->body_len;
-
-    size_t total   = iov[0].iov_len + iov[1].iov_len;
-    size_t written = 0;
+  if (res->_body_owned == 3) {
+    /* Send header first */
+    size_t header_total   = (size_t)hlen;
+    size_t header_written = 0;
+    while (header_written < header_total) {
+      ssize_t n = write(fd, header + header_written, header_total - header_written);
+      if (n < 0) {
+        if (errno == EINTR) continue;
+        return -1;
+      }
+      header_written += (size_t)n;
+    }
 
-    while (written < total) {
-      ssize_t n = writev(fd, iov, 2);
-      if (n < 0) return -1;
-      written += (size_t)n;
+    /* Zero-copy body sending via sendfile(2) */
+    size_t body_total = res->body_len;
+    size_t body_sent  = 0;
+    while (body_sent < body_total) {
+      ssize_t n = cerver_sendfile(fd, res->_file_fd, (off_t)body_sent, body_total - body_sent);
+      if (n < 0) {
+        if (errno == EINTR) continue;
+        return -1;
+      }
+      if (n == 0) break; /* EOF */
+      body_sent += (size_t)n;
+    }
+  } else if (res->body && res->body_len > 0) {
+    if ((size_t)hlen + res->body_len <= sizeof(header)) {
+      /* Small response optimization: copy body into header buffer and send in one syscall */
+      memcpy(header + hlen, res->body, res->body_len);
+      size_t total   = (size_t)hlen + res->body_len;
+      size_t written = 0;
+      while (written < total) {
+        ssize_t n = write(fd, header + written, total - written);
+        if (n < 0) {
+          if (errno == EINTR) continue;
+          return -1;
+        }
+        written += (size_t)n;
+      }
+    } else {
+      /* Large response: use writev to send header + body */
+      struct iovec iov[2];
+      iov[0].iov_base = header;
+      iov[0].iov_len  = (size_t)hlen;
+      iov[1].iov_base = (void*)res->body;
+      iov[1].iov_len  = res->body_len;
+
+      size_t total   = iov[0].iov_len + iov[1].iov_len;
+      size_t written = 0;
 
-      /* Adjust iov for partial writes */
-      if (written < iov[0].iov_len) {
-        iov[0].iov_base = header + written;
-        iov[0].iov_len -= (size_t)n;
-      } else {
-        /* Header fully sent, adjust body iov */
-        size_t body_sent = written - (size_t)hlen;
-        iov[0].iov_len   = 0;
-        iov[1].iov_base  = (void*)(res->body + body_sent);
-        iov[1].iov_len   = res->body_len - body_sent;
+      while (written < total) {
+        ssize_t n = writev(fd, iov, 2);
+        if (n < 0) return -1;
+        written += (size_t)n;
+
+        /* Adjust iov for partial writes */
+        size_t to_consume = (size_t)n;
+        if (to_consume < iov[0].iov_len) {
+          iov[0].iov_base = (char*)iov[0].iov_base + to_consume;
+          iov[0].iov_len -= to_consume;
+        } else {
+          to_consume -= iov[0].iov_len;
+          iov[0].iov_len  = 0;
+          iov[1].iov_base = (char*)iov[1].iov_base + to_consume;
+          iov[1].iov_len -= to_consume;
+        }
       }
     }
   } else {
     /* No body — just send header */
-    ssize_t written = write(fd, header, (size_t)hlen);
-    if (written < 0) return -1;
+    size_t total   = (size_t)hlen;
+    size_t written = 0;
+    while (written < total) {
+      ssize_t n = write(fd, header + written, total - written);
+      if (n < 0) {
+        if (errno == EINTR) continue;
+        return -1;
+      }
+      written += (size_t)n;
+    }
   }
 
   return 0;

package/runtime/router.c

@@ -19,8 +19,15 @@
 
 const char* cerver_req_param(const cerver_request_t* req, const char* key) {
   for (int i = 0; i < req->params_count; i++) {
-    if (strcmp(req->params[i].key, key) == 0) {
-      return req->params[i].value;
+    const char* pkey = req->params[i].key;
+    if (pkey && pkey[0] == key[0]) {
+      int j = 0;
+      while (key[j] && pkey[j] == key[j]) {
+        j++;
+      }
+      if (key[j] == '\0' && (pkey[j] == '\0' || pkey[j] == '/')) {
+        return req->params[i].value;
+      }
     }
   }
   return "";
@@ -101,7 +108,9 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
   const char* pp = pattern; /* pattern pointer */
   const char* rp = path;    /* request path pointer */
 
-  int saved_params = req->params_count;
+  int   saved_params = req->params_count;
+  char* param_slashes[CERVER_MAX_PARAMS];
+  int   param_slash_count = 0;
 
   /* Skip leading '/' */
   if (*pp == '/') pp++;
@@ -122,10 +131,12 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
       /* Dynamic segment — extract parameter */
       if (req->params_count < CERVER_MAX_PARAMS) {
         req->params[req->params_count].key = pp_seg + 1;
-        /* Temporarily NUL-terminate the key at the slash */
-        /* The key points into the route pattern (static/const) */
+        /* The key points into the route pattern (static/const, not NUL-terminated) */
         req->params[req->params_count].value = rp_seg;
         req->params_count++;
+        if (*rp == '/') {
+          param_slashes[param_slash_count++] = (char*)rp;
+        }
       }
     } else {
       /* Static segment — must match exactly */
@@ -146,6 +157,11 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
     return 0;
   }
 
+  /* Match succeeded, NUL-terminate extracted values in-place inside req->path */
+  for (int i = 0; i < param_slash_count; i++) {
+    *param_slashes[i] = '\0';
+  }
+
   return 1;
 }
 
@@ -153,6 +169,168 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
 /*  Dispatch: find and return the handler for a request               */
 /* ------------------------------------------------------------------ */
 
+/* ------------------------------------------------------------------ */
+/*  Trie/Radix Route Router                                           */
+/* ------------------------------------------------------------------ */
+
+static char* trie_strndup(const char* s, size_t n) {
+  char* p = malloc(n + 1);
+  if (p) {
+    memcpy(p, s, n);
+    p[n] = '\0';
+  }
+  return p;
+}
+
+typedef struct trie_node trie_node_t;
+
+struct trie_node {
+  char* segment;
+  int   is_param;
+  char* param_name;
+
+  struct {
+    const char*       method;
+    cerver_handler_fn handler;
+  } handlers[16];
+  int handler_count;
+
+  trie_node_t** children;
+  int           children_count;
+  int           children_cap;
+};
+
+void* cerver_trie_create(void) {
+  trie_node_t* node = calloc(1, sizeof(trie_node_t));
+  return node;
+}
+
+static trie_node_t* trie_create_node(const char* segment, size_t len) {
+  trie_node_t* node = calloc(1, sizeof(trie_node_t));
+  if (node && segment) {
+    node->segment = trie_strndup(segment, len);
+    if (node->segment[0] == ':') {
+      node->is_param   = 1;
+      node->param_name = trie_strndup(node->segment + 1, len - 1);
+    }
+  }
+  return node;
+}
+
+void cerver_trie_insert(void* trie, const char* pattern, const char* method,
+                        cerver_handler_fn handler) {
+  if (!trie) return;
+  trie_node_t* curr = (trie_node_t*)trie;
+  const char*  p    = pattern;
+  while (*p == '/') p++;
+
+  while (*p) {
+    const char* seg_start = p;
+    while (*p && *p != '/') p++;
+    size_t len = (size_t)(p - seg_start);
+    if (len == 0) {
+      while (*p == '/') p++;
+      continue;
+    }
+
+    // Find if child exists
+    trie_node_t* child = NULL;
+    for (int i = 0; i < curr->children_count; i++) {
+      trie_node_t* c = curr->children[i];
+      if (strlen(c->segment) == len && memcmp(c->segment, seg_start, len) == 0) {
+        child = c;
+        break;
+      }
+    }
+
+    if (!child) {
+      child = trie_create_node(seg_start, len);
+      if (curr->children_count >= curr->children_cap) {
+        curr->children_cap = curr->children_cap == 0 ? 4 : curr->children_cap * 2;
+        curr->children     = realloc(curr->children, curr->children_cap * sizeof(trie_node_t*));
+      }
+      curr->children[curr->children_count++] = child;
+    }
+
+    curr = child;
+    while (*p == '/') p++;
+  }
+
+  // Add handler to leaf
+  if (curr->handler_count < 16) {
+    curr->handlers[curr->handler_count].method  = method;
+    curr->handlers[curr->handler_count].handler = handler;
+    curr->handler_count++;
+  }
+}
+
+void cerver_trie_free(void* trie) {
+  if (!trie) return;
+  trie_node_t* node = (trie_node_t*)trie;
+  for (int i = 0; i < node->children_count; i++) {
+    cerver_trie_free(node->children[i]);
+  }
+  free(node->children);
+  free(node->segment);
+  free(node->param_name);
+  free(node);
+}
+
+static int trie_match_recursive(trie_node_t* node, const char* path, cerver_request_t* req,
+                                cerver_handler_fn* out_handler, int param_start_idx) {
+  // Skip leading slashes
+  while (*path == '/') path++;
+
+  if (*path == '\0') {
+    // Check if node has a handler for req->method
+    for (int i = 0; i < node->handler_count; i++) {
+      if (strcmp(node->handlers[i].method, req->method) == 0) {
+        *out_handler      = node->handlers[i].handler;
+        req->params_count = param_start_idx;
+        return 1;
+      }
+    }
+    return 0;
+  }
+
+  // Extract next segment from path
+  const char* seg_start = path;
+  while (*path && *path != '/') path++;
+  size_t seg_len = (size_t)(path - seg_start);
+
+  // Try static children first
+  for (int i = 0; i < node->children_count; i++) {
+    trie_node_t* child = node->children[i];
+    if (!child->is_param) {
+      if (strlen(child->segment) == seg_len && memcmp(child->segment, seg_start, seg_len) == 0) {
+        if (trie_match_recursive(child, path, req, out_handler, param_start_idx)) {
+          return 1;
+        }
+      }
+    }
+  }
+
+  // Try parameter/dynamic children next
+  for (int i = 0; i < node->children_count; i++) {
+    trie_node_t* child = node->children[i];
+    if (child->is_param) {
+      if (param_start_idx < CERVER_MAX_PARAMS) {
+        req->params[param_start_idx].key   = child->param_name;
+        req->params[param_start_idx].value = seg_start;
+      }
+      if (trie_match_recursive(child, path, req, out_handler, param_start_idx + 1)) {
+        return 1;
+      }
+    }
+  }
+
+  return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Dispatch: find and return the handler for a request               */
+/* ------------------------------------------------------------------ */
+
 cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
   /* Try the generated compile-time dispatch first */
   if (srv->dispatch_override) {
@@ -160,13 +338,19 @@ cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
     if (h) return h;
   }
 
-  /* Fall back to generic route table scan */
-  if (!srv->routes) return NULL;
+  /* Fall back to generic route table scan via Trie */
+  if (!srv->route_trie) return NULL;
 
-  for (int i = 0; i < srv->route_count; i++) {
-    if (cerver_route_match(&srv->routes[i], req)) {
-      return srv->routes[i].handler;
+  cerver_handler_fn handler = NULL;
+  req->params_count         = 0;
+  if (trie_match_recursive((trie_node_t*)srv->route_trie, req->path, req, &handler, 0)) {
+    // NUL-terminate extracted values in-place inside req->path
+    for (int i = 0; i < req->params_count; i++) {
+      char* val = (char*)req->params[i].value;
+      while (*val && *val != '/') val++;
+      if (*val == '/') *val = '\0';
     }
+    return handler;
   }
 
   return NULL;

package/runtime/server.c

@@ -278,6 +278,8 @@ static void handle_connection(cerver_server_t* srv, int client_fd) {
       free((void*)res.body);
     else if (res._body_owned == 2 && res.body)
       munmap((void*)res.body, res.body_len);
+    else if (res._body_owned == 3 && res._file_fd >= 0)
+      close(res._file_fd);
 
     free(buf);
     if (write_err < 0) break;
@@ -348,7 +350,7 @@ static int create_listener(int port, int reuseport) {
   int opt = 1;
   setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
   if (reuseport) setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
 #else
   (void)reuseport;
@@ -621,6 +623,13 @@ int cerver_init(cerver_server_t* srv, int port, int threads) {
 int cerver_add_routes(cerver_server_t* srv, cerver_route_t* routes, int count) {
   srv->routes      = routes;
   srv->route_count = count;
+
+  srv->route_trie = cerver_trie_create();
+  if (srv->route_trie) {
+    for (int i = 0; i < count; i++) {
+      cerver_trie_insert(srv->route_trie, routes[i].pattern, routes[i].method, routes[i].handler);
+    }
+  }
   return 0;
 }
 
@@ -702,7 +711,7 @@ int cerver_listen(cerver_server_t* srv) {
     return -1;
   }
 
-  srv->sock_fd = create_listener(srv->port, 0);
+  srv->sock_fd = create_listener(srv->port, 1);
   if (srv->sock_fd < 0) {
     srv->running = 0;
     for (int i = 0; i < pool_size; i++) pthread_join(pool_threads[i], NULL);
@@ -730,9 +739,13 @@ int cerver_listen(cerver_server_t* srv) {
     w->id              = i;
     w->srv             = srv;
     w->event_fd        = -1;
-#ifdef __linux__
-    w->listen_fd = create_listener(srv->port, 1);
-    if (w->listen_fd < 0) w->listen_fd = srv->sock_fd;
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+    if (i == 0) {
+      w->listen_fd = srv->sock_fd;
+    } else {
+      w->listen_fd = create_listener(srv->port, 1);
+      if (w->listen_fd < 0) w->listen_fd = srv->sock_fd;
+    }
 #else
     w->listen_fd = srv->sock_fd;
 #endif
@@ -758,6 +771,22 @@ int cerver_listen(cerver_server_t* srv) {
   printf("cerver: %d acceptor(s), %d connection workers, keep-alive max %d req/conn\n",
          acceptor_count, pool_size, CERVER_KEEPALIVE_MAX);
 
+  for (int i = 0; i < srv->route_count; i++) {
+    const char* method = srv->routes[i].method;
+    const char* color  = "\x1B[35m";
+    if (strcmp(method, "GET") == 0) {
+      color = "\x1B[32m";
+    } else if (strcmp(method, "POST") == 0) {
+      color = "\x1B[33m";
+    } else if (strcmp(method, "PUT") == 0) {
+      color = "\x1B[36m";
+    } else if (strcmp(method, "DELETE") == 0) {
+      color = "\x1B[31m";
+    }
+    printf("  → Mapped {%s, %s%s\x1B[0m} route\n", srv->routes[i].pattern, color, method);
+  }
+  fflush(stdout);
+
   release_acceptors();
 
   pthread_attr_destroy(&attr);
@@ -791,7 +820,7 @@ void cerver_shutdown(cerver_server_t* srv) {
 
   if (srv->workers) {
     for (int i = 0; i < srv->worker_count; i++) {
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
       if (srv->workers[i].listen_fd != srv->sock_fd && srv->workers[i].listen_fd >= 0)
         close(srv->workers[i].listen_fd);
 #endif
@@ -801,6 +830,11 @@ void cerver_shutdown(cerver_server_t* srv) {
     srv->workers = NULL;
   }
 
+  if (srv->route_trie) {
+    cerver_trie_free(srv->route_trie);
+    srv->route_trie = NULL;
+  }
+
   if (srv->sock_fd >= 0) {
     close(srv->sock_fd);
     srv->sock_fd = -1;