@velox0/cerver 0.5.2 → 0.5.3

package/Makefile

@@ -7,7 +7,8 @@ RUNTIME_SRCS = \
 	runtime/router.c \
 	runtime/static.c \
 	runtime/mime.c \
-	runtime/server.c
+	runtime/server.c \
+	runtime/fetch.c
 
 TEST_SRCS = runtime/tests/runtime_tests.c \
 	runtime/tests/minunit.c
@@ -20,7 +21,7 @@ test-runtime: $(TEST_BIN)
 
 $(TEST_BIN): $(RUNTIME_SRCS) $(TEST_SRCS) runtime/cerver.h
 	mkdir -p build
-	$(CC) $(CFLAGS) -Iruntime -o $(TEST_BIN) $(RUNTIME_SRCS) $(TEST_SRCS) -pthread
+	$(CC) $(CFLAGS) -Iruntime -o $(TEST_BIN) $(RUNTIME_SRCS) $(TEST_SRCS) -pthread -lcurl
 
 clean:
 	rm -rf build

package/lib/codegen/emit.js

@@ -143,6 +143,31 @@ function emitExpression(expr) {
       return '""';
     }
 
+    case "Fetch": {
+      /*
+       * Fetch is a special expression — it returns a call to cerver_fetch().
+       * The generated code will be: cerver_fetch(url, method, body, headers)
+       * where headers is either NULL or a stack-allocated array.
+       *
+       * Because the actual headers array setup requires multiple statements,
+       * simple inline expressions won't work for headers. We handle headers
+       * at the statement level in emitStatement instead.
+       * For inline expression contexts (like variable init), we emit without
+       * custom headers when headers are present — the statement emitter
+       * will handle the full form.
+       */
+      const urlCode = emitExpression(expr.url);
+      const methodCode = expr.method ? emitExpression(expr.method) : "NULL";
+      const bodyCode = expr.body ? emitExpression(expr.body) : "NULL";
+
+      if (expr.headers && expr.headers.length > 0) {
+        /* Flag that this needs statement-level emission */
+        return `__fetch_with_headers__`;
+      }
+
+      return `cerver_fetch(${urlCode}, ${methodCode}, ${bodyCode}, NULL)`;
+    }
+
     default:
       return '""';
   }
@@ -167,6 +192,45 @@ function isStringExpr(expr) {
  * Emit a statement into C code lines.
  * Returns an array of C source lines.
  */
+
+/* Counter for unique fetch variable names */
+let fetchVarCounter = 0;
+
+/**
+ * Emit the headers array and cerver_fetch call for a Fetch expression.
+ * Returns { lines: string[], varName: string } where varName holds the result.
+ */
+function emitFetchBlock(fetchExpr, pad, varName) {
+  const lines = [];
+  const urlCode = emitExpression(fetchExpr.url);
+  const methodCode = fetchExpr.method ? emitExpression(fetchExpr.method) : "NULL";
+  const bodyCode = fetchExpr.body ? emitExpression(fetchExpr.body) : "NULL";
+
+  if (fetchExpr.headers && fetchExpr.headers.length > 0) {
+    const count = fetchExpr.headers.length;
+    /* Build the headers array on the stack */
+    for (let i = 0; i < count; i++) {
+      const hKey = emitExpression(fetchExpr.headers[i].key);
+      const hVal = emitExpression(fetchExpr.headers[i].value);
+      /* Format: "Key: Value" */
+      lines.push(`${pad}char ${varName}_h${i}[512];`);
+      lines.push(`${pad}snprintf(${varName}_h${i}, sizeof(${varName}_h${i}), "%s: %s", ${hKey}, ${hVal});`);
+    }
+    /* NULL-terminated array */
+    lines.push(`${pad}const char *${varName}_hdrs[] = {`);
+    for (let i = 0; i < count; i++) {
+      lines.push(`${pad}    ${varName}_h${i},`);
+    }
+    lines.push(`${pad}    NULL`);
+    lines.push(`${pad}};`);
+    lines.push(`${pad}char *${varName} = cerver_fetch(${urlCode}, ${methodCode}, ${bodyCode}, ${varName}_hdrs);`);
+  } else {
+    lines.push(`${pad}char *${varName} = cerver_fetch(${urlCode}, ${methodCode}, ${bodyCode}, NULL);`);
+  }
+
+  return { lines, varName };
+}
+
 function emitStatement(stmt, level) {
   if (!stmt) return [];
   const pad = indent(level);
@@ -175,9 +239,20 @@ function emitStatement(stmt, level) {
   switch (stmt.type) {
     case "Return": {
       const fnName = `cerver_res_${stmt.responseType}`;
-      const valueCode = emitExpression(stmt.value);
-      lines.push(`${pad}${fnName}(res, ${stmt.status}, ${valueCode});`);
-      lines.push(`${pad}return;`);
+
+      /* Check if the return value involves a fetch() call */
+      if (stmt.value && stmt.value.type === "Fetch") {
+        const tempName = `_fetch_res_${fetchVarCounter++}`;
+        const fetchBlock = emitFetchBlock(stmt.value, pad, tempName);
+        lines.push(...fetchBlock.lines);
+        lines.push(`${pad}${fnName}(res, ${stmt.status}, ${tempName});`);
+        lines.push(`${pad}free(${tempName});`);
+        lines.push(`${pad}return;`);
+      } else {
+        const valueCode = emitExpression(stmt.value);
+        lines.push(`${pad}${fnName}(res, ${stmt.status}, ${valueCode});`);
+        lines.push(`${pad}return;`);
+      }
       break;
     }
 
@@ -217,11 +292,17 @@ function emitStatement(stmt, level) {
     }
 
     case "Variable": {
-      const val = emitExpression(stmt.initExpr);
-      if (stmt.valueType === "number") {
-        lines.push(`${pad}int ${stmt.name} = ${val};`);
+      /* Check if the variable is initialized with a fetch() call */
+      if (stmt.initExpr && stmt.initExpr.type === "Fetch") {
+        const fetchBlock = emitFetchBlock(stmt.initExpr, pad, stmt.name);
+        lines.push(...fetchBlock.lines);
       } else {
-        lines.push(`${pad}const char *${stmt.name} = ${val};`);
+        const val = emitExpression(stmt.initExpr);
+        if (stmt.valueType === "number") {
+          lines.push(`${pad}int ${stmt.name} = ${val};`);
+        } else {
+          lines.push(`${pad}const char *${stmt.name} = ${val};`);
+        }
       }
       break;
     }

package/lib/codegen/generator.js

@@ -98,6 +98,7 @@ function generateRoutesC(routes) {
   lines.push('#include "cerver.h"');
   lines.push("#include <string.h>");
   lines.push("#include <stdlib.h>");
+  lines.push("#include <stdio.h>");
   lines.push("");
 
   /* ---- Route table (forward decls + table) ---- */

package/lib/commands/build.js

@@ -13,6 +13,23 @@ const { discoverAssets } = require("../assets/discover");
 const { generateEmbeddedAssets } = require("../assets/embed");
 const { compile: compileC } = require("../compiler/compile");
 
+/**
+ * Recursively check if an IR node tree contains any Fetch expressions.
+ */
+function irUsesFetch(node) {
+  if (!node || typeof node !== "object") return false;
+  if (node.type === "Fetch") return true;
+  for (const key of Object.keys(node)) {
+    const val = node[key];
+    if (Array.isArray(val)) {
+      if (val.some((item) => irUsesFetch(item))) return true;
+    } else if (val && typeof val === "object" && val.type) {
+      if (irUsesFetch(val)) return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Full build pipeline: parse → validate → IR → codegen → compile
  */
@@ -136,7 +153,17 @@ async function build(opts) {
 
   /* ---- 7. Compile ---- */
   console.log("  → compiling...");
-  const binaryPath = compileC(distDir, runtimeDir, { static: opts.static });
+
+  /* Detect if any route uses fetch() — only link libcurl when needed */
+  const usesFetch = allRoutes.some((route) => irUsesFetch(route.handler));
+  if (usesFetch) {
+    console.log("    fetch() detected — linking libcurl");
+  }
+
+  const binaryPath = compileC(distDir, runtimeDir, {
+    static: opts.static,
+    usesFetch,
+  });
 
   /* ---- Done ---- */
   const elapsed = Date.now() - startTime;

package/lib/compiler/compile.js

@@ -63,6 +63,8 @@ function compile(distDir, runtimeDir, opts) {
   const runtimeSources = fs
     .readdirSync(runtimeDir)
     .filter((f) => f.endsWith(".c"))
+    /* Exclude fetch.c when not used — avoids libcurl dependency */
+    .filter((f) => f !== "fetch.c" || (opts && opts.usesFetch))
     .map((f) => path.join(runtimeDir, f));
 
   /* Build the compiler command with aggressive optimization */
@@ -79,6 +81,11 @@ function compile(distDir, runtimeDir, opts) {
     "-lpthread",
   ];
 
+  /* Link libcurl only when fetch() is used */
+  if (opts && opts.usesFetch) {
+    args.push("-lcurl");
+  }
+
   /* Add LTO if supported */
   if (supportsFlag(cc, "-flto")) {
     args.splice(1, 0, "-flto");

package/lib/ir/transform.js

@@ -295,6 +295,44 @@ function transformCallExpr(node, ctx) {
     return IR.IRCall("res", method, args);
   }
 
+  /* fetch(url) or fetch(url, { method, body, headers }) */
+  if (
+    node.callee.type === "Identifier" &&
+    node.callee.name === "fetch"
+  ) {
+    const urlExpr = node.arguments[0]
+      ? transformExpression(node.arguments[0], ctx)
+      : IR.IRStringLiteral("");
+
+    let methodExpr = null;
+    let bodyExpr = null;
+    let headersArr = null;
+
+    /* Parse options object if present: fetch(url, { method, body, headers }) */
+    if (node.arguments[1] && node.arguments[1].type === "ObjectExpression") {
+      const opts = node.arguments[1];
+      for (const prop of opts.properties) {
+        const key = prop.key.name || prop.key.value;
+        if (key === "method") {
+          methodExpr = transformExpression(prop.value, ctx);
+        } else if (key === "body") {
+          bodyExpr = transformExpression(prop.value, ctx);
+        } else if (key === "headers" && prop.value.type === "ObjectExpression") {
+          headersArr = [];
+          for (const hProp of prop.value.properties) {
+            const hKey = hProp.key.name || hProp.key.value;
+            headersArr.push({
+              key: IR.IRStringLiteral(hKey),
+              value: transformExpression(hProp.value, ctx),
+            });
+          }
+        }
+      }
+    }
+
+    return IR.IRFetch(urlExpr, methodExpr, bodyExpr, headersArr);
+  }
+
   /* String methods like str.toLowerCase(), includes() etc. — return as-is */
   if (node.callee.type === "MemberExpression") {
     const obj = transformExpression(node.callee.object, ctx);

package/lib/ir/types.js

@@ -184,6 +184,19 @@ function IRCall(object, method, args) {
   };
 }
 
+/**
+ * An outbound HTTP fetch call.
+ */
+function IRFetch(url, method, body, headers) {
+  return {
+    type: "Fetch",
+    url,        /* IRExpression — the URL */
+    method,     /* IRExpression | null — "GET", "POST", etc. */
+    body,       /* IRExpression | null — request body */
+    headers,    /* Array<{key: IRExpression, value: IRExpression}> | null */
+  };
+}
+
 module.exports = {
   IRRoute,
   IRHandler,
@@ -201,4 +214,5 @@ module.exports = {
   IRIdentifier,
   IRConcat,
   IRCall,
+  IRFetch,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries",
   "main": "bin/cerver.js",
   "bin": {

package/runtime/cerver.h

@@ -273,6 +273,26 @@ void              cerver_trie_insert(void* trie, const char* pattern, const char
                                      cerver_handler_fn handler);
 void              cerver_trie_free(void* trie);
 
+/* ------------------------------------------------------------------ */
+/*  Fetch — outbound HTTP client (libcurl)                            */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Perform a synchronous HTTP request.
+ *
+ * @param url     Request URL (required).
+ * @param method  HTTP method: "GET", "POST", "PUT", "DELETE", "PATCH"
+ *                (NULL defaults to "GET").
+ * @param body    Request body string (NULL for none).
+ * @param headers NULL-terminated array of "Key: Value" header strings,
+ *                or NULL for no custom headers.
+ *
+ * @return Heap-allocated response body (caller must free()), or
+ *         empty heap-allocated string on error.
+ */
+char* cerver_fetch(const char* url, const char* method,
+                   const char* body, const char** headers);
+
 /* ------------------------------------------------------------------ */
 /*  MIME (internal)                                                   */
 /* ------------------------------------------------------------------ */

package/runtime/fetch.c

@@ -0,0 +1,163 @@
+/*
+ * fetch.c — HTTP client for outbound API calls using libcurl.
+ *
+ * Provides cerver_fetch() which performs synchronous HTTP requests
+ * from within generated handler code. Supports GET/POST/PUT/DELETE,
+ * custom headers, and request bodies.
+ *
+ * The returned string is heap-allocated and must be freed by the caller.
+ */
+
+#include "cerver.h"
+
+#include <curl/curl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* ------------------------------------------------------------------ */
+/*  Internal write callback for curl                                  */
+/* ------------------------------------------------------------------ */
+
+typedef struct {
+  char*  data;
+  size_t len;
+  size_t cap;
+} cerver_fetch_buf_t;
+
+static size_t fetch_write_cb(void* contents, size_t size, size_t nmemb,
+                             void* userp) {
+  size_t realsize       = size * nmemb;
+  cerver_fetch_buf_t* buf = (cerver_fetch_buf_t*)userp;
+
+  /* Grow buffer if needed */
+  while (buf->len + realsize + 1 > buf->cap) {
+    size_t newcap = buf->cap * 2;
+    if (newcap < 4096) newcap = 4096;
+    char* tmp = realloc(buf->data, newcap);
+    if (!tmp) return 0; /* signal error to curl */
+    buf->data = tmp;
+    buf->cap  = newcap;
+  }
+
+  memcpy(buf->data + buf->len, contents, realsize);
+  buf->len += realsize;
+  buf->data[buf->len] = '\0';
+
+  return realsize;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Global curl init (thread-safe, called once)                       */
+/* ------------------------------------------------------------------ */
+
+static pthread_once_t curl_init_once = PTHREAD_ONCE_INIT;
+
+static void curl_global_init_once(void) {
+  curl_global_init(CURL_GLOBAL_DEFAULT);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Public API                                                        */
+/* ------------------------------------------------------------------ */
+
+/**
+ * cerver_fetch — Perform a synchronous HTTP request.
+ *
+ * @param url     The URL to request (required).
+ * @param method  HTTP method: "GET", "POST", "PUT", "DELETE" (NULL = "GET").
+ * @param body    Request body for POST/PUT (NULL for none).
+ * @param headers Array of "Key: Value" header strings (NULL-terminated, or NULL for none).
+ *
+ * @return Heap-allocated response body string (caller must free), or
+ *         empty string "" (heap-allocated) on error.
+ */
+char* cerver_fetch(const char* url, const char* method,
+                   const char* body, const char** headers) {
+  if (!url) {
+    char* empty = malloc(1);
+    if (empty) empty[0] = '\0';
+    return empty;
+  }
+
+  /* Ensure global curl init */
+  pthread_once(&curl_init_once, curl_global_init_once);
+
+  CURL* curl = curl_easy_init();
+  if (!curl) {
+    char* empty = malloc(1);
+    if (empty) empty[0] = '\0';
+    return empty;
+  }
+
+  /* Response buffer */
+  cerver_fetch_buf_t buf;
+  buf.data = malloc(4096);
+  buf.len  = 0;
+  buf.cap  = 4096;
+  if (!buf.data) {
+    curl_easy_cleanup(curl);
+    char* empty = malloc(1);
+    if (empty) empty[0] = '\0';
+    return empty;
+  }
+  buf.data[0] = '\0';
+
+  /* Configure request */
+  curl_easy_setopt(curl, CURLOPT_URL, url);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fetch_write_cb);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&buf);
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
+  curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
+  curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L); /* thread-safe */
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, "cerver/1.0");
+
+  /* Set HTTP method */
+  if (method) {
+    if (strcmp(method, "POST") == 0) {
+      curl_easy_setopt(curl, CURLOPT_POST, 1L);
+    } else if (strcmp(method, "PUT") == 0) {
+      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+    } else if (strcmp(method, "DELETE") == 0) {
+      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
+    } else if (strcmp(method, "PATCH") == 0) {
+      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PATCH");
+    }
+    /* GET is the default — no action needed */
+  }
+
+  /* Set request body */
+  if (body) {
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body);
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen(body));
+  }
+
+  /* Set custom headers */
+  struct curl_slist* header_list = NULL;
+  if (headers) {
+    for (int i = 0; headers[i] != NULL; i++) {
+      header_list = curl_slist_append(header_list, headers[i]);
+    }
+    if (header_list) {
+      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);
+    }
+  }
+
+  /* Perform the request */
+  CURLcode res = curl_easy_perform(curl);
+
+  if (res != CURLE_OK) {
+    fprintf(stderr, "cerver: fetch error: %s (url: %s)\n",
+            curl_easy_strerror(res), url);
+    /* Return empty string on error */
+    buf.data[0] = '\0';
+    buf.len     = 0;
+  }
+
+  /* Cleanup */
+  if (header_list) curl_slist_free_all(header_list);
+  curl_easy_cleanup(curl);
+
+  return buf.data;
+}