@velox0/cerver 0.1.0

package/lib/codegen/generator.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const { handlerName, emitStatement } = require("./emit");
+const { generateRouteTable } = require("./route_table");
+
+/**
+ * Generate the complete C server source file from IR routes.
+ *
+ * @param {IRRoute[]} routes - All IR routes
+ * @param {object} config - Build config (port, embed, etc.)
+ * @param {string|null} assetsCode - Generated embedded assets C code, or null
+ * @returns {string} - Complete C source file
+ */
+function generateServer(routes, config, assetsCode) {
+  const lines = [];
+
+  /* ---- Header ---- */
+  lines.push("/*");
+  lines.push(" * Auto-generated by cerver — do not edit.");
+  lines.push(" */");
+  lines.push("");
+  lines.push('#include "cerver.h"');
+  lines.push("");
+  lines.push("#include <stdio.h>");
+  lines.push("#include <stdlib.h>");
+  lines.push("#include <string.h>");
+  lines.push("");
+
+  /* ---- Embedded assets (if any) ---- */
+  if (assetsCode) {
+    lines.push("/* ---- Embedded Assets ---- */");
+    lines.push("");
+    lines.push(assetsCode);
+    lines.push("");
+  } else {
+    lines.push("/* No embedded assets */");
+    lines.push("static cerver_asset_t *cerver_embedded_assets = NULL;");
+    lines.push("static const int cerver_embedded_asset_count = 0;");
+    lines.push("");
+  }
+
+  /* ---- Route table (forward decls + table) ---- */
+  lines.push("/* ---- Routes ---- */");
+  lines.push("");
+  lines.push(generateRouteTable(routes));
+
+  /* ---- Handler implementations ---- */
+  lines.push("/* ---- Handler Implementations ---- */");
+  lines.push("");
+
+  for (const route of routes) {
+    const name = handlerName(route.method, route.urlPath);
+    lines.push(
+      `static void ${name}(cerver_request_t *req, cerver_response_t *res) {`
+    );
+
+    /* Emit local variables */
+    for (const v of route.handler.variables) {
+      const varLines = emitStatement(v, 1);
+      lines.push(...varLines);
+    }
+
+    /* Emit body statements */
+    for (const stmt of route.handler.body) {
+      const stmtLines = emitStatement(stmt, 1);
+      lines.push(...stmtLines);
+    }
+
+    lines.push("}");
+    lines.push("");
+  }
+
+  /* ---- Main function ---- */
+  lines.push("/* ---- Entry Point ---- */");
+  lines.push("");
+  lines.push("int main(int argc, char *argv[]) {");
+  lines.push("    (void)argc;");
+  lines.push("    (void)argv;");
+  lines.push("");
+  lines.push(`    int port = ${config.port};`);
+  lines.push("");
+  lines.push("    /* Allow PORT env override */");
+  lines.push('    const char *env_port = getenv("CERVER_PORT");');
+  lines.push("    if (!env_port) env_port = getenv(\"PORT\");");
+  lines.push("    if (env_port) port = atoi(env_port);");
+  lines.push("");
+  lines.push("    cerver_server_t srv;");
+  lines.push("    cerver_init(&srv, port);");
+  lines.push("");
+  lines.push(
+    "    cerver_add_routes(&srv, cerver_routes, cerver_route_count);"
+  );
+  lines.push("");
+
+  if (assetsCode) {
+    lines.push(
+      "    cerver_set_assets(&srv, cerver_embedded_assets, cerver_embedded_asset_count);"
+    );
+  } else {
+    lines.push('    cerver_set_public_dir(&srv, "./public");');
+  }
+
+  lines.push("");
+  lines.push("    return cerver_listen(&srv);");
+  lines.push("}");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+module.exports = { generateServer };

package/lib/codegen/route_table.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { cString, handlerName } = require("./emit");
+
+/**
+ * Generate the static route dispatch table as C source.
+ *
+ * @param {IRRoute[]} routes - All routes to include
+ * @returns {string} - C source for the route table
+ */
+function generateRouteTable(routes) {
+  const lines = [];
+
+  lines.push("/* Auto-generated route table — do not edit */");
+  lines.push("");
+
+  /* Forward declarations */
+  for (const route of routes) {
+    const name = handlerName(route.method, route.urlPath);
+    lines.push(
+      `static void ${name}(cerver_request_t *req, cerver_response_t *res);`
+    );
+  }
+
+  lines.push("");
+
+  /* Route table array */
+  lines.push("static cerver_route_t cerver_routes[] = {");
+  for (const route of routes) {
+    const name = handlerName(route.method, route.urlPath);
+    lines.push(
+      `    { ${cString(route.method)}, ${cString(route.urlPath)}, ${name} },`
+    );
+  }
+  lines.push("};");
+  lines.push(
+    `static const int cerver_route_count = ${routes.length};`
+  );
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+module.exports = { generateRouteTable };

package/lib/commands/build.js

@@ -0,0 +1,122 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const { loadConfig } = require("../config");
+const { discoverRoutes } = require("../parser/discover");
+const { parseFile } = require("../parser/parse");
+const { validate } = require("../validator/validate");
+const { transformFile } = require("../ir/transform");
+const { generateServer } = require("../codegen/generator");
+const { discoverAssets } = require("../assets/discover");
+const { generateEmbeddedAssets } = require("../assets/embed");
+const { compile: compileC } = require("../compiler/compile");
+
+/**
+ * Full build pipeline: parse → validate → IR → codegen → compile
+ */
+async function build(opts) {
+  const projectDir = process.cwd();
+  const startTime = Date.now();
+
+  console.log("\n  cerver build\n");
+
+  /* ---- 1. Load config ---- */
+  console.log("  → loading config...");
+  const config = loadConfig(projectDir);
+
+  /* CLI overrides */
+  if (opts.embed !== undefined) config.embed = opts.embed;
+  if (opts.minify === false) config.minify = false;
+
+  console.log(
+    `    port: ${config.port}, embed: ${config.embed}, minify: ${config.minify}`
+  );
+
+  /* ---- 2. Discover routes ---- */
+  const routesDir = path.join(projectDir, "app", "routes");
+  console.log("  → discovering routes...");
+  const routeFiles = discoverRoutes(routesDir);
+
+  if (routeFiles.length === 0) {
+    console.warn("  ⚠ no route files found in app/routes/");
+  } else {
+    for (const r of routeFiles) {
+      console.log(`    ${r.urlPath} ← ${path.relative(projectDir, r.filePath)}`);
+    }
+  }
+
+  /* ---- 3. Parse & validate ---- */
+  console.log("  → parsing and validating...");
+  const allRoutes = [];
+
+  for (const routeFile of routeFiles) {
+    const { ast, source } = parseFile(routeFile.filePath);
+    validate(ast, routeFile.filePath, source);
+
+    const irRoutes = transformFile(ast, routeFile.urlPath);
+    allRoutes.push(...irRoutes);
+  }
+
+  console.log(`    ${allRoutes.length} handler(s) compiled`);
+
+  /* ---- 4. Asset pipeline ---- */
+  let assetsCode = null;
+
+  if (config.embed) {
+    const publicDir = path.join(projectDir, "public");
+    console.log("  → embedding assets...");
+    const assets = discoverAssets(publicDir);
+
+    if (assets.length > 0) {
+      let totalSize = 0;
+      for (const a of assets) {
+        totalSize += a.size;
+        console.log(
+          `    ${a.servePath} (${(a.size / 1024).toFixed(1)} KB)`
+        );
+      }
+
+      assetsCode = await generateEmbeddedAssets(assets, config.minify);
+      console.log(
+        `    ${assets.length} asset(s), ${(totalSize / 1024).toFixed(1)} KB total`
+      );
+    } else {
+      console.log("    no assets found in public/");
+    }
+  }
+
+  /* ---- 5. Generate C source ---- */
+  console.log("  → generating C source...");
+  const cSource = generateServer(allRoutes, config, assetsCode);
+
+  /* Write to dist/ */
+  const distDir = path.join(projectDir, "dist");
+  fs.mkdirSync(distDir, { recursive: true });
+
+  const serverCPath = path.join(distDir, "server.c");
+  fs.writeFileSync(serverCPath, cSource);
+  console.log(`    wrote ${(cSource.length / 1024).toFixed(1)} KB → dist/server.c`);
+
+  /* ---- 6. Copy runtime headers ---- */
+  const runtimeDir = path.join(__dirname, "..", "..", "runtime");
+
+  /* Copy cerver.h to dist/ so the generated server.c can include it */
+  fs.copyFileSync(
+    path.join(runtimeDir, "cerver.h"),
+    path.join(distDir, "cerver.h")
+  );
+
+  /* ---- 7. Compile ---- */
+  console.log("  → compiling...");
+  const binaryPath = compileC(distDir, runtimeDir, { static: opts.static });
+
+  /* ---- Done ---- */
+  const elapsed = Date.now() - startTime;
+  console.log(`\n  ✓ build complete in ${elapsed}ms`);
+  console.log(`    binary: ${path.relative(projectDir, binaryPath)}`);
+  console.log(`    run with: cerver run\n`);
+}
+
+module.exports = { build };

package/lib/commands/new.js

@@ -0,0 +1,96 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Scaffold a new cerver project.
+ */
+function newProject(name) {
+  const projectDir = path.resolve(process.cwd(), name);
+
+  if (fs.existsSync(projectDir)) {
+    console.error(`cerver: directory "${name}" already exists`);
+    process.exit(1);
+  }
+
+  console.log(`\n  Creating cerver project: ${name}\n`);
+
+  // Create directory structure
+  const dirs = [
+    "",
+    "app",
+    "app/routes",
+    "public",
+    "dist",
+  ];
+
+  for (const dir of dirs) {
+    fs.mkdirSync(path.join(projectDir, dir), { recursive: true });
+  }
+
+  // Copy templates
+  const templatesDir = path.join(__dirname, "..", "..", "templates");
+
+  // cerver.config.js
+  fs.copyFileSync(
+    path.join(templatesDir, "cerver.config.js"),
+    path.join(projectDir, "cerver.config.js")
+  );
+
+  // Default route
+  fs.copyFileSync(
+    path.join(templatesDir, "index.route.js"),
+    path.join(projectDir, "app", "routes", "index.js")
+  );
+
+  // Default public/index.html
+  fs.writeFileSync(
+    path.join(projectDir, "public", "index.html"),
+    `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${name}</title>
+</head>
+<body>
+  <h1>${name}</h1>
+  <p>Served by cerver.</p>
+</body>
+</html>
+`
+  );
+
+  // package.json
+  fs.writeFileSync(
+    path.join(projectDir, "package.json"),
+    JSON.stringify(
+      {
+        name: name,
+        version: "0.1.0",
+        private: true,
+        scripts: {
+          build: "cerver build",
+          start: "cerver run",
+        },
+      },
+      null,
+      2
+    ) + "\n"
+  );
+
+  console.log("  Created:");
+  console.log("    app/routes/index.js");
+  console.log("    public/index.html");
+  console.log("    cerver.config.js");
+  console.log("    package.json");
+  console.log("");
+  console.log("  Next steps:");
+  console.log(`    cd ${name}`);
+  console.log("    cerver build");
+  console.log("    cerver run");
+  console.log("");
+}
+
+module.exports = { newProject };

package/lib/commands/run.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const { execFileSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+/**
+ * Run the compiled binary from dist/.
+ */
+function run(opts) {
+  const projectDir = process.cwd();
+  const binaryPath = path.join(projectDir, "dist", "server");
+
+  if (!fs.existsSync(binaryPath)) {
+    console.error("cerver: no compiled binary found. Run `cerver build` first.");
+    process.exit(1);
+  }
+
+  // Make sure it's executable
+  try {
+    fs.chmodSync(binaryPath, 0o755);
+  } catch (_) {
+    // Ignore — may already be executable
+  }
+
+  const env = { ...process.env };
+  if (opts.port) {
+    env.CERVER_PORT = opts.port;
+  }
+
+  console.log(`cerver: starting server from ${binaryPath}`);
+
+  try {
+    execFileSync(binaryPath, [], {
+      stdio: "inherit",
+      env,
+      cwd: projectDir,
+    });
+  } catch (err) {
+    if (err.status !== null) {
+      process.exit(err.status);
+    }
+    throw err;
+  }
+}
+
+module.exports = { run };

package/lib/compiler/compile.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const { execFileSync, execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Detect available C compiler.
+ */
+function detectCompiler() {
+  const candidates = ["cc", "gcc", "clang"];
+  for (const cc of candidates) {
+    try {
+      execSync(`which ${cc}`, { stdio: "ignore" });
+      return cc;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    "cerver: no C compiler found. Install gcc or clang."
+  );
+}
+
+/**
+ * Compile the generated C source into a binary.
+ *
+ * @param {string} distDir - Output directory (dist/)
+ * @param {string} runtimeDir - Path to runtime/ C sources
+ * @param {object} opts - { static: bool }
+ */
+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)) {
+    throw new Error(
+      `cerver: generated source not found at ${serverC}`
+    );
+  }
+
+  /* Collect all runtime .c files */
+  const runtimeSources = fs
+    .readdirSync(runtimeDir)
+    .filter((f) => f.endsWith(".c"))
+    .map((f) => path.join(runtimeDir, f));
+
+  /* Build the compiler command */
+  const args = [
+    "-O2",
+    "-Wall",
+    "-Wextra",
+    "-Wno-unused-parameter",
+    "-o",
+    outputBin,
+    serverC,
+    ...runtimeSources,
+    `-I${runtimeDir}`,
+  ];
+
+  if (opts && opts.static) {
+    args.push("-static");
+  }
+
+  console.log(`  compiling with ${cc}...`);
+  console.log(`  ${cc} ${args.join(" ")}`);
+
+  const start = Date.now();
+
+  try {
+    execFileSync(cc, args, {
+      stdio: "inherit",
+      cwd: distDir,
+    });
+  } catch (err) {
+    throw new Error(
+      `cerver: compilation failed (exit code ${err.status})`
+    );
+  }
+
+  const elapsed = Date.now() - start;
+  const stat = fs.statSync(outputBin);
+  const sizeKB = (stat.size / 1024).toFixed(1);
+
+  console.log(`  compiled in ${elapsed}ms — ${sizeKB} KB`);
+
+  return outputBin;
+}
+
+module.exports = { compile, detectCompiler };

package/lib/config.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULTS = {
+  port: 8080,
+  embed: true,
+  minify: true,
+  compression: "none",
+};
+
+/**
+ * Load cerver.config.js from the project root.
+ * Falls back to defaults for any missing fields.
+ */
+function loadConfig(projectDir) {
+  const configPath = path.join(projectDir, "cerver.config.js");
+  let userConfig = {};
+
+  if (fs.existsSync(configPath)) {
+    // Read the config file and evaluate it
+    const raw = fs.readFileSync(configPath, "utf8");
+
+    // Support both `module.exports = { ... }` and `export default { ... }`
+    // We transpile the export default form to module.exports for eval
+    const normalized = raw.replace(
+      /export\s+default\s+/,
+      "module.exports = "
+    );
+
+    // Create a mini-module context to evaluate the config
+    const mod = { exports: {} };
+    const fn = new Function("module", "exports", normalized);
+    fn(mod, mod.exports);
+    userConfig = mod.exports;
+  }
+
+  const config = { ...DEFAULTS, ...userConfig };
+
+  // Validate
+  if (typeof config.port !== "number" || config.port < 1 || config.port > 65535) {
+    throw new Error(`cerver: invalid port ${config.port}`);
+  }
+  if (!["none", "gzip", "brotli"].includes(config.compression)) {
+    throw new Error(`cerver: unsupported compression "${config.compression}"`);
+  }
+
+  return config;
+}
+
+module.exports = { loadConfig, DEFAULTS };