cpeak 2.2.4 → 2.3.0

package/README.md

@@ -8,11 +8,13 @@ This project is designed to be improved until it's ready for use in complex prod
 
 This is an educational project that was started as part of the [Understanding Node.js: Core Concepts](https://www.udemy.com/course/understanding-nodejs-core-concepts/?referralCode=0BC21AC4DD6958AE6A95) course. If you want to learn how to build a framework like this, and get to a point where you can build things like this yourself, check out this course!
 
+<em>This is the current demo, and the development of the project will begin starting from **September 2025.**</em>
+
 ## Why Cpeak?
 
 - **Minimalism**: No unnecessary bloat, with zero dependencies. Just the core essentials you need to build fast and reliable applications.
 - **Performance**: Engineered to be fast, **Cpeak** won’t sacrifice speed for excessive customizability.
-- **Educational**: Every new change made in the project will be explained in great detail in a YouTube playlist (playlist will be added soon). Follow this project and let's see what it takes to build an industry-leading product!
+- **Educational**: Every new change made in the project will be explained in great detail in this [YouTube playlist](https://www.youtube.com/playlist?list=PLCiGw8i6NhvqsA-ZZcChJ0kaHZ3hcIVdY). Follow this project and let's see what it takes to build an industry-leading product!
 - **Express.js Compatible**: You can easily refactor from Cpeak to Express.js and vice versa. Many npm packages that work with Express.js will also work with Cpeak.
 
 ## Table of Contents
@@ -24,13 +26,16 @@ This is an educational project that was started as part of the [Understanding No
   - [Initializing](#initializing)
   - [Middleware](#middleware)
   - [Route Handling](#route-handling)
+  - [Route Middleware](#route-middleware)
   - [URL Variables & Parameters](#url-variables--parameters)
   - [Sending Files](#sending-files)
+  - [Redirecting](#redirecting)
   - [Error Handling](#error-handling)
   - [Listening](#listening)
   - [Util Functions](#util-functions)
     - [serveStatic](#servestatic)
     - [parseJSON](#parsejson)
+    - [render](#render)
 - [Complete Example](#complete-example)
 - [Versioning Notice](#versioning-notice)
 
@@ -114,6 +119,40 @@ server.beforeEach((req, res, next) => {
 });
 ```
 
+### Route Middleware
+
+You can also add middleware functions for a particular route handler like this:
+
+```javascript
+const requireAuth = (req, res, next, handleErr) => {
+  // Check if user is logged in, if so then:
+  req.test = "this is a test value";
+  next();
+
+  // If user is not logged in:
+  return handleErr({ status: 401, message: "Unauthorized" });
+};
+
+server.route("get", "/profile", requireAuth, (req, res, handleErr) => {
+  console.log(req.test); // this is a test value
+});
+```
+
+You can add as many middleware functions as you want for a route:
+
+```javascript
+server.route(
+  "get",
+  "/profile",
+  requireAuth,
+  anotherFunction,
+  oneMore,
+  (req, res, handleErr) => {
+    // your logic
+  }
+);
+```
+
 ### Route Handling
 
 You can add new routes like this:
@@ -159,9 +198,17 @@ server.route("get", "/testing", (req, res) => {
 
 The file’s binary content will be in the HTTP response body content. Make sure you specify a correct path relative to your CWD (use the `path` module for better compatibility) and also the correct HTTP MIME type for that file.
 
+### Redirecting
+
+If you want to redirect to a new URL, you can simply do:
+
+```javascript
+res.redirect("https://whatever.com");
+```
+
 ### Error Handling
 
-If anywhere in your route functions you want to return an error, it's cleaner to pass it to the `handleErr` function like this:
+If anywhere in your route functions or route middleware functions you want to return an error, it's cleaner to pass it to the `handleErr` function like this:
 
 ```javascript
 server.route("get", "/api/document/:title", (req, res, handleErr) => {
@@ -210,6 +257,7 @@ The list of utility functions as of now:
 
 - serveStatic
 - parseJSON
+- render
 
 Including any one of them is done like this:
 
@@ -269,12 +317,50 @@ server.route("put", "/api/user", (req, res) => {
 });
 ```
 
+#### render
+
+With this function you can do server side rendering before sending a file to a client. This can be useful for dynamic customization and search engine optimization.
+
+First fire it up like this:
+
+```javascript
+server.beforeEach(render());
+```
+
+And then for rendering:
+
+```javascript
+server.route("get", "/", (req, res, next) => {
+  return res.render(
+    "./public/index.html",
+    {
+      title: "Page title",
+      name: "Allan",
+    },
+    "text/html"
+  );
+});
+```
+
+You can then inject the variables into your file in {{ variable_name }} like this:
+
+```HTML
+<html>
+    <head>
+        <title>{{ title }}</title>
+    </head>
+    <body>
+        <h1>{{ name }}</h1>
+    </body>
+</html>
+```
+
 ## Complete Example
 
 Here you can see all the features that Cpeak offers, in one small piece of code:
 
 ```javascript
-import cpeak, { serveStatic, parseJSON } from "cpeak";
+import cpeak, { serveStatic, parseJSON, render } from "cpeak";
 
 const server = new cpeak();
 
@@ -284,6 +370,8 @@ server.beforeEach(
   })
 );
 
+server.beforeEach(render());
+
 // For parsing JSON bodies
 server.beforeEach(parseJSON);
 
@@ -293,25 +381,56 @@ server.beforeEach((req, res, next) => {
   next();
 });
 
-// Adding route handlers
-server.route("get", "/api/document/:title", (req, res, handleErr) => {
-  // Reading URL variables
-  const title = req.vars.title;
+// A middleware function that can be specified to run before some particular routes
+const testRouteMiddleware = (req, res, next, handleErr) => {
+  req.whatever = "some calculated value maybe";
 
-  // Reading URL parameters (like /users?filter=active)
-  const filter = req.params.filter;
+  if (req.vars.test !== "something special") {
+    return handleErr({ status: 400, message: "an error message" });
+  }
 
-  // Reading JSON request body
-  const anything = req.body.anything;
+  next();
+};
 
-  // Handling errors
-  if (anything === "not-expected-thing")
-    return handleErr({ status: 400, message: "Invalid property." });
+// Adding route handlers
+server.route("get", "/", (req, res, next) => {
+  return res.render(
+    "<path-to-file-relative-to-cwd>",
+    {
+      test: "some testing value",
+      number: "2343242",
+    },
+    "<mime-type>"
+  );
+});
 
-  // Sending a JSON response
-  res.status(200).json({ message: "This is a test response" });
+server.route("get", "/old-url", testRouteMiddleware, (req, res, next) => {
+  return res.redirect("/new-url");
 });
 
+server.route(
+  "get",
+  "/api/document/:title",
+  testRouteMiddleware,
+  (req, res, handleErr) => {
+    // Reading URL variables
+    const title = req.vars.title;
+
+    // Reading URL parameters (like /users?filter=active)
+    const filter = req.params.filter;
+
+    // Reading JSON request body
+    const anything = req.body.anything;
+
+    // Handling errors
+    if (anything === "not-expected-thing")
+      return handleErr({ status: 400, message: "Invalid property." });
+
+    // Sending a JSON response
+    res.status(200).json({ message: "This is a test response" });
+  }
+);
+
 // Sending a file response
 server.route("get", "/file", (req, res) => {
   // Make sure to specify a correct path and MIME type...

package/lib/index.js

@@ -1,7 +1,7 @@
 import http from "node:http";
 import fs from "node:fs/promises";
 
-import { serveStatic, parseJSON } from "./utils/index.js";
+import { serveStatic, parseJSON, render } from "./utils/index.js";
 
 class Cpeak {
   constructor() {
@@ -27,6 +27,13 @@ class Cpeak {
         return res;
       };
 
+      // Redirects to a new URL
+      res.redirect = (location) => {
+        res.writeHead(302, { Location: location });
+        res.end();
+        return res;
+      };
+
       // Send a json data back to the client (for small json data, less than the highWaterMark)
       res.json = (data) => {
         // This is only good for bodies that their size is less than the highWaterMark value
@@ -42,9 +49,35 @@ class Cpeak {
       const params = new URLSearchParams(req.url.split("?")[1]);
       req.params = Object.fromEntries(params.entries());
 
-      // Run all the middleware functions before we run the corresponding route
+      // Run all the specific middleware functions for that router only and then run the handler
+      const runHandler = (req, res, middleware, cb, index) => {
+        // Our exit point...
+        if (index === middleware.length) {
+          // Call the route handler with the modified req and res objects
+          return cb(req, res, (error) => {
+            res.setHeader("Connection", "close");
+            this.handleErr(error, req, res);
+          });
+        } else {
+          middleware[index](
+            req,
+            res,
+            // The next function
+            () => {
+              runHandler(req, res, middleware, cb, index + 1);
+            },
+            // Error handler for a route middleware
+            (error) => {
+              res.setHeader("Connection", "close");
+              this.handleErr(error, req, res);
+            }
+          );
+        }
+      };
+
+      // Run all the middleware functions (beforeEach functions) before we run the corresponding route
       const runMiddleware = (req, res, middleware, index) => {
-        // Out exit point...
+        // Our exit point...
         if (index === middleware.length) {
           const routes = this.routes[req.method.toLowerCase()];
           if (routes && typeof routes[Symbol.iterator] === "function")
@@ -56,11 +89,7 @@ class Cpeak {
                 const vars = this.#extractVars(route.path, match);
                 req.vars = vars;
 
-                // Call the route handler with the modified req and res objects
-                return route.cb(req, res, (error) => {
-                  res.setHeader("Connection", "close");
-                  this.handleErr(error, req, res);
-                });
+                return runHandler(req, res, route.middleware, route.cb, 0);
               }
             }
 
@@ -79,11 +108,17 @@ class Cpeak {
     });
   }
 
-  route(method, path, cb) {
+  route(method, path, ...args) {
     if (!this.routes[method]) this.routes[method] = [];
 
+    // The last argument is always our handler
+    const cb = args.pop();
+
+    // Rest will be our middleware functions
+    const middleware = args.flat();
+
     const regex = this.#pathToRegex(path);
-    this.routes[method].push({ path, regex, cb });
+    this.routes[method].push({ path, regex, middleware, cb });
   }
 
   beforeEach(cb) {
@@ -132,6 +167,6 @@ class Cpeak {
   }
 }
 
-export { serveStatic, parseJSON };
+export { serveStatic, parseJSON, render };
 
 export default Cpeak;

package/lib/utils/index.js

@@ -1,4 +1,5 @@
 import { parseJSON } from "./parseJSON.js";
 import { serveStatic } from "./serveStatic.js";
+import { render } from "./render.js";
 
-export { serveStatic, parseJSON };
+export { serveStatic, parseJSON, render };

package/lib/utils/parseJSON.js

@@ -1,20 +1,28 @@
 // Parsing JSON
 const parseJSON = (req, res, next) => {
   // This is only good for bodies that their size is less than the highWaterMark value
-  if (req.headers["content-type"] === "application/json") {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString("utf-8");
-    });
 
-    req.on("end", () => {
-      body = JSON.parse(body);
-      req.body = body;
-      return next();
-    });
-  } else {
-    next();
+  function isJSON(contentType = "") {
+    // Remove any params like "; charset=UTF-8"
+    const [type] = contentType.split(";");
+    return (
+      type.trim().toLowerCase() === "application/json" ||
+      /\+json$/i.test(type.trim())
+    );
   }
+
+  if (!isJSON(req.headers["content-type"])) return next();
+
+  let body = "";
+  req.on("data", (chunk) => {
+    body += chunk.toString("utf-8");
+  });
+
+  req.on("end", () => {
+    body = JSON.parse(body);
+    req.body = body;
+    return next();
+  });
 };
 
 export { parseJSON };

package/lib/utils/render.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+
+function renderTemplate(templateStr, data) {
+  // Initialize variables
+  let result = [];
+
+  let currentIndex = 0;
+
+  while (currentIndex < templateStr.length) {
+    // Find the next opening placeholder
+    const startIdx = templateStr.indexOf("{{", currentIndex);
+    if (startIdx === -1) {
+      // No more placeholders, push the remaining string
+      result.push(templateStr.slice(currentIndex));
+      break;
+    }
+
+    // Push the part before the placeholder
+    result.push(templateStr.slice(currentIndex, startIdx));
+
+    // Find the closing placeholder
+    const endIdx = templateStr.indexOf("}}", startIdx);
+    if (endIdx === -1) {
+      // No closing brace found, treat the rest as plain text
+      result.push(templateStr.slice(startIdx));
+      break;
+    }
+
+    // Extract the variable name
+    const varName = templateStr.slice(startIdx + 2, endIdx).trim();
+
+    // Replace the variable with its value from the data, or use an empty string if not found
+    const replacement = data[varName] !== undefined ? data[varName] : "";
+
+    // Push the replacement to the result array
+    result.push(replacement);
+
+    // Move the index past the current closing placeholder
+    currentIndex = endIdx + 2;
+  }
+
+  // Join all parts into a final string
+  return result.join("");
+}
+
+// Errors to return: recommend to not render files larger than 100KB
+// To Explore: Doing the operation in C++ and return the data as stream back to the client
+// @TODO: remove the file from static map
+// @TODO: escape the string to prevent XSS
+// @TODO: add another {{{ }}} option to not escape the string
+const render = () => {
+  return function (req, res, next) {
+    res.render = async (path, data, mime) => {
+      let fileStr = await fs.readFile(path, "utf-8");
+      const finalStr = renderTemplate(fileStr, data);
+      res.setHeader("Content-Type", mime);
+      res.end(finalStr);
+    };
+
+    next();
+  };
+};
+
+export { render };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cpeak",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "description": "A minimal and fast Node.js HTTP framework.",
   "type": "module",
   "main": "./lib/index.js",
@@ -19,6 +19,8 @@
   "license": "MIT",
   "keywords": [
     "cpeak",
+    "backend",
+    "router",
     "nodejs",
     "http",
     "framework"

package/playground.js

@@ -0,0 +1,63 @@
+function renderTemplate(templateStr, data) {
+  // Initialize variables
+  let result = [];
+  let currentIndex = 0;
+
+  while (currentIndex < templateStr.length) {
+    // Find the next opening placeholder
+    const startIdx = templateStr.indexOf("{{", currentIndex);
+    if (startIdx === -1) {
+      // No more placeholders, push the remaining string
+      result.push(templateStr.slice(currentIndex));
+      break;
+    }
+
+    // Push the part before the placeholder
+    result.push(templateStr.slice(currentIndex, startIdx));
+
+    // Find the closing placeholder
+    const endIdx = templateStr.indexOf("}}", startIdx);
+    if (endIdx === -1) {
+      // No closing brace found, treat the rest as plain text
+      result.push(templateStr.slice(startIdx));
+      break;
+    }
+
+    // Extract the variable name
+    const varName = templateStr.slice(startIdx + 2, endIdx).trim();
+
+    // Replace the variable with its value from the data, or use an empty string if not found
+    const replacement = data[varName] !== undefined ? data[varName] : "";
+
+    // Push the replacement to the result array
+    result.push(replacement);
+
+    // Move the index past the current closing placeholder
+    currentIndex = endIdx + 2;
+  }
+
+  // Join all parts into a final string
+  return result.join("");
+}
+
+// Example usage:
+const templateStr = `
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Poster</title>
+
+    <link rel="stylesheet" href="/styles.css" />
+  </head>
+  <body style="color: #333">
+    <h1>{{ msg1 }} {{ msg2 }}</h1>
+
+    <!-- <strong>{{msgBar}}</strong> -->
+
+    <p>
+`;
+
+const data = { msg1: "Alice", msg2: 30 };
+
+const output = renderTemplate(templateStr, data);
+console.log(output); // Output: "Hello, Alice! You are 30 years old."