npm - cpeak - Versions diffs - 2.2.5 → 2.3.0 - Mend

cpeak 2.2.5 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -8,6 +8,8 @@ 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.
@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "cpeak",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "A minimal and fast Node.js HTTP framework.",
   "type": "module",
   "main": "./lib/index.js",

package/playground.js ADDED Viewed

@@ -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."