cpeak 2.2.1 → 2.2.2

package/lib/index.js

@@ -1,7 +1,7 @@
 import http from "node:http";
 import fs from "node:fs/promises";
 
-import { serveStatic, parseJSON } from "./util.js";
+import { serveStatic, parseJSON } from "./utils/index.js";
 
 class Cpeak {
   constructor() {

package/lib/utils/index.js

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

package/lib/utils/parseJSON.js

@@ -0,0 +1,20 @@
+// 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();
+  }
+};
+
+export { parseJSON };

package/lib/{util.js → utils/serveStatic.js}

@@ -74,23 +74,4 @@ const serveStatic = (folderPath, newMimeTypes) => {
   };
 };
 
-// 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();
-  }
-};
-
-export { serveStatic, parseJSON };
+export { serveStatic };

package/package.json

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

package/private.txt

@@ -0,0 +1,351 @@
+NPM publish
+
+after making a regular comment:
+1- update package.json version number
+2- git commit -am '2.2.0'
+3- git tag v2.2.0
+4- npm publish
+5- git push
+6- git push --tags
+
+
+https://www.freecodecamp.org/news/how-to-create-and-publish-your-first-npm-package/
+
+https://cloudfour.com/thinks/how-to-publish-an-updated-version-of-an-npm-package/
+
+git push --tags
+
+
+
+
+
+
+
+A minimal and fast Node.js framework aiming to become one of the best. Every step of the development is explained and documented for educational purposes.
+
+
+For documentation refer to here: [cododev.ca/cpeak]
+
+
+
+
+
+
+rm -rf nodemodules && npm i
+
+
+README Backup:
+# Cpeak
+
+Cpeak is a minimal and fast Node.js framework inspired by Express.js.
+
+This project is meant to be improved to be ready for use in complex production applications, and be more performant and minimal than Express.js. This frameworks is for HTTP applications that just deal with with JSON and file-based message bodies.
+
+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, and if you want to learn how to build a framework like this, and also get to a point to be bale to build things like these yourself, checkout out this course!
+
+## 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 that is made in the project, will be explained in great detail in this YouTube Playlist (playlist will be added soon). Follow this project, and let's see what it takes to build an industry leading product!
+- **Expess.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.
+
+## Getting Starter
+
+Ready to dive in? Install **Cpeak** via npm:
+
+```bash
+npm install cpeak
+```
+
+#### Hello World App:
+
+```javascript
+import cpeak from "cpeak";
+
+const server = new cpeak();
+
+server.route("get", "/", (req, res) => {
+  res.json({ message: "Hi there!" });
+});
+
+server.listen(3000, () => {
+  console.log("Server has started on port 3000");
+});
+```
+
+## Documentation
+
+#### Including
+
+Include the framework like this:
+
+```
+import cpeak from "cpeak";
+```
+
+Because of the minimalistic philosophy, you will not add in unnecessary objects to your memory as soon as you include the framework. If at any point you want to use a particular utility function (like pareJSON and serveStatic), include that like the line below, and only at that point in will be moved to your memory:
+
+```
+import cpeak, { serveStatic, parseJSON } from "cpeak";
+```
+
+#### Initializing
+
+Initialize the Cpeak server like this:
+
+```
+const server = new cpeak();
+```
+
+Now you can use this server object to start listening, add route logic, add middleware functions, and also handle errors.
+
+#### Middleware
+
+If you add a middleware function, that function will run before your route logic kicks in. Here you can customize the request object, return an error, or do anything else that you want to do prior to your route logics like authentication.
+
+After calling next, the next middleware functions is going to run if there's any, otherwise the route logic is going to run.
+
+```javascript
+server.beforeEach((req, res, next) => {
+  if (req.headers.authentication) {
+    // Your authentication logic...
+    req.userId = "<something>";
+    req.custom = "This is some string";
+    next();
+  } else {
+    // Return an error and close the request...
+    return res.status(401).json({ error: "Unauthorized" });
+  }
+});
+
+server.beforeEach((req, res, next) => {
+  console.log(
+    "The custom was added from the previous middleware: ",
+    req.custom
+  );
+  next();
+});
+```
+
+#### Route Handling
+
+You can add in new routes like this:
+
+```javascript
+server.route("patch", "/the-path-you-want", (req, res) => {
+  // your route logic
+});
+```
+
+The req and res object types are the same with the Node.js HTTP module (http.IncomingMessage and http.ServerResponse). You can read more about them in the [official Node.js documentation](https://nodejs.org/docs/latest/api/http.html).
+
+#### URL Variables & Parameters
+
+Because in HTTP these are called URL parameters: `/path?key1=value1&key2=value2&foo=900`, here in Cpeak we also call them params short for HTTP URL parameters.
+We can also do custom path management, and we call them vars short for URL variables.
+
+Here's how we can read both:
+
+```javascript
+// Imaging request URL is example.com/test/my-title/more-text?filter=newest
+server.route("patch", "/test/:title/more-text", (req, res) => {
+  const title = req.vars.title;
+  const filter = req.params.get("filter");
+
+  console.log(title); // my-title
+  console.log(filter); // newest
+});
+```
+
+#### Sending Files
+
+You can send a file as a Node.js Stream anywhere in your route or middleware logic like this:
+
+```javascript
+server.route("get", "/testing", (req, res) => {
+  return res.status(200).sendFile("<file-path>", "<mime-type>");
+
+  // Example:
+  // return res.status(200).sendFile("./images/sun.jpeg", "image/jpeg");
+});
+```
+
+The file 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.
+
+#### Error Handling
+
+If anywhere in you route functions, you want to return an error, it's better to pass to the handleErr function like this:
+
+```javascript
+server.route("get", "/api/document/:title", (req, res, handleErr) => {
+  const title = req.vars.title;
+
+  // Handling errors
+  if (title.length > 500)
+    return handleErr({ status: 400, message: "Title too long." });
+
+  // The rest of your logic...
+});
+```
+
+And then handle all the errors like here in the handleErr callback:
+
+```javascript
+server.handleErr((error, req, res) => {
+  if (error && error.status) {
+    res.status(error.status).json({ error: error.message });
+  } else {
+    // Log the unexpected errors somewhere so you can keep track of them...
+    console.error(error);
+    res.status(500).json({
+      error: "Sorry, something unexpected happened from our side.",
+    });
+  }
+});
+```
+
+The error object is the object that you passed to the handleErr function before in your routes.
+
+#### Listening
+
+Start listening on a specific port like this:
+
+```javascript
+server.listen(3000, () => {
+  console.log("Server has started on port 3000");
+});
+```
+
+### Util Functions
+
+There are utility functions that you can include and use as middleware functions. These are meant to make it easier for you to make HTTP applications. In the future, many more will be added, and you only move them to your memory once you include them. No need to have many NPM dependencies for simple applications!
+
+The list of utility functions as of now:
+
+- serveStatic
+- parseJSON
+
+Including any one of them is like this:
+
+```javascript
+import cpeak, { utilName } from "cpeak";
+```
+
+#### serveStatic
+
+With this middleware function, you can automatically set a folder in your project to be served by Cpeak. Here's how to set it up:
+
+```javascript
+server.beforeEach(
+  serveStatic("./public", {
+    mp3: "audio/mpeg",
+  })
+);
+```
+
+If you have file types in your public folder that are not one of the followings, make sure to add the MIME types manually as the second argument in the function as an object where each property key is the file extension, and each value is the correct MIME type for that. You can see all the available MIME types from [iana website](https://www.iana.org/assignments/media-types/media-types.xhtml) .
+
+```
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  svg: "image/svg+xml",
+  txt: "text/plain",
+  eot: "application/vnd.ms-fontobject",
+  otf: "font/otf",
+  ttf: "font/ttf",
+  woff: "font/woff",
+  woff2: "font/woff2"
+```
+
+#### parseJSON
+
+With this middleware function, you can easily read and send JSON in HTTP message bodies in route and middleware functions. Fire it up like this:
+
+```javascript
+server.beforeEach(parseJSON);
+```
+
+Read and send JSON from HTTP messages like this:
+
+```javascript
+server.route("put", "/api/user", (req, res) => {
+  // Reading JSON from the HTTP request:
+  const email = req.body.email;
+
+  // rest of your logic...
+
+  // Sending JSON in the HTTP response:
+  res.status(201).json({ message: "Something was created..." });
+});
+```
+
+## Complete Example
+
+Here you can see all the features the Cpeak offers, in one small piece of code:
+
+```javascript
+import cpeak, { serveStatic, parseJSON } from "cpeak";
+
+const server = new cpeak();
+
+server.beforeEach(
+  serveStatic("./public", {
+    mp3: "audio/mpeg",
+  })
+);
+
+// For parsing JSON body
+server.beforeEach(parseJSON);
+
+// Adding custom middleware functions
+server.beforeEach((req, res, next) => {
+  req.custom = "This is some string";
+  next();
+});
+
+// Adding route handlers
+server.route("get", "/api/document/:title", (req, res, handleErr) => {
+  // Reading URL variables
+  const title = req.vars.title;
+
+  // Reading URL parameters (like /users?filter=active)
+  const filter = req.params.get("filter");
+
+  // Reading JSON request body
+  const anything = req.body.anything;
+
+  // Handling errors
+  if (anything === "not-expected-thing")
+    return handleErr({ status: 401, 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...
+  res.status(200).sendFile("<path-to-file-relative-to-cwd>", "<mime-type>");
+});
+
+// Handle all the errors that could happen in the routes
+server.handleErr((error, req, res) => {
+  if (error && error.status) {
+    res.status(error.status).json({ error: error.message });
+  } else {
+    console.error(error);
+    res.status(500).json({
+      error: "Sorry, something unexpected happened from our side.",
+    });
+  }
+});
+
+server.listen(3000, () => {
+  console.log("Server has started on port 3000");
+});
+```

package/test/errors.test.js

@@ -1,40 +0,0 @@
-import assert from "node:assert";
-import supertest from "supertest";
-import cpeak from "../lib/index.js";
-
-const PORT = 7543;
-const request = supertest(`http://localhost:${PORT}`);
-
-describe("Error handling with handleErr", function () {
-  let server;
-
-  before(function (done) {
-    server = new cpeak();
-
-    server.route("patch", "/foo/:bar", (req, res, handleErr) => {
-      const bar = req.vars.bar;
-
-      if (bar === "random") {
-        return handleErr({ status: 403, message: "an error msg" });
-      }
-
-      return res.status(200).json({ bar });
-    });
-
-    server.handleErr((error, req, res) => {
-      return res.status(error.status).json({ error: error.message });
-    });
-
-    server.listen(PORT, done);
-  });
-
-  after(function (done) {
-    server.close(done);
-  });
-
-  it("should get an error using the handleErr function from a router", async function () {
-    const res = await request.patch("/foo/random");
-    assert.strictEqual(res.status, 403);
-    assert.deepStrictEqual(res.body, { error: "an error msg" });
-  });
-});

package/test/files/styles.css

@@ -1,9 +0,0 @@
-/* some styles for testing... */
-.my-class {
-  color: red;
-}
-
-.my-class-2 {
-  color: blue;
-}
-

package/test/files/test.txt

@@ -1 +0,0 @@
-This is a test file.

package/test/files.test.js

@@ -1,35 +0,0 @@
-import assert from "node:assert";
-import supertest from "supertest";
-import fs from "node:fs/promises";
-import cpeak from "../lib/index.js";
-
-const PORT = 7543;
-const request = supertest(`http://localhost:${PORT}`);
-
-describe("Returning files with sendFile", function () {
-  let server;
-
-  before(function (done) {
-    server = new cpeak();
-
-    server.route("get", "/file", (req, res) => {
-      res.status(200).sendFile("./test/files/test.txt", "text/plain");
-    });
-
-    server.listen(PORT, done);
-  });
-
-  after(function (done) {
-    server.close(done);
-  });
-
-  it("should get a file as the response with the correct MIME type", async function () {
-    const res = await request.get("/file");
-
-    const fileContent = await fs.readFile("./test/files/test.txt", "utf-8");
-
-    assert.strictEqual(res.status, 200);
-    assert.strictEqual(res.headers["content-type"], "text/plain");
-    assert.strictEqual(res.text, fileContent);
-  });
-});

package/test/middleware.test.js

@@ -1,68 +0,0 @@
-import assert from "node:assert";
-import supertest from "supertest";
-import cpeak from "../lib/index.js";
-
-const PORT = 7543;
-const request = supertest(`http://localhost:${PORT}`);
-
-describe("Middleware functions", function () {
-  let server;
-
-  before(function (done) {
-    server = new cpeak();
-
-    server.beforeEach((req, res, next) => {
-      const value = req.params.value;
-
-      if (value === "random")
-        return res.status(400).json({ error: "an error msg" });
-
-      next();
-    });
-
-    server.beforeEach((req, res, next) => {
-      req.foo = "text";
-      next();
-    });
-
-    server.beforeEach((req, res, next) => {
-      res.unauthorized = () => {
-        res.statusCode = 401;
-        return res;
-      };
-      next();
-    });
-
-    server.route("get", "/bar", (req, res) => {
-      res.status(200).json({ message: req.foo });
-    });
-
-    server.route("get", "/bar-more", (req, res) => {
-      res.unauthorized().json({});
-    });
-
-    server.listen(PORT, done);
-  });
-
-  after(function (done) {
-    server.close(done);
-  });
-
-  it("should modify the req object with a new property", async function () {
-    const res = await request.get("/bar");
-    assert.strictEqual(res.status, 200);
-    assert.strictEqual(res.body.message, "text");
-  });
-
-  it("should modify the res object with a new method", async function () {
-    const res = await request.get("/bar-more");
-    assert.strictEqual(res.status, 401);
-  });
-
-  it("should exit the middleware and route chain if a middleware wants to", async function () {
-    const res = await request.get("/bar?value=random");
-    assert.strictEqual(res.status, 400);
-    assert.strictEqual(res.body.message, undefined);
-    assert.deepStrictEqual(res.body, { error: "an error msg" });
-  });
-});

package/test/parseJSON.test.js

@@ -1,43 +0,0 @@
-import assert from "node:assert";
-import supertest from "supertest";
-import cpeak, { parseJSON } from "../lib/index.js";
-
-const PORT = 7543;
-const request = supertest(`http://localhost:${PORT}`);
-
-describe("Parsing request bodies with parseJSON", function () {
-  let server;
-
-  before(function (done) {
-    server = new cpeak();
-
-    server.beforeEach(parseJSON);
-
-    server.route("post", "/do-something", (req, res) => {
-      res.status(205).json({ receivedData: req.body });
-    });
-
-    server.listen(PORT, done);
-  });
-
-  after(function (done) {
-    server.close(done);
-  });
-
-  it("should return the same data that was sent in request body as JSON", async function () {
-    const obj = {
-      key1: "value1",
-      key2: 42,
-      key3: {
-        nestedKey1: "nestedValue1",
-        nestedKey2: ["arrayValue1", "arrayValue2", 1000],
-      },
-      key4: true,
-    };
-
-    const res = await request.post("/do-something").send(obj);
-
-    assert.strictEqual(res.status, 205);
-    assert.deepStrictEqual(res.body.receivedData, obj);
-  });
-});

package/test/router.test.js

@@ -1,85 +0,0 @@
-import assert from "node:assert";
-import supertest from "supertest";
-import cpeak from "../lib/index.js";
-
-const PORT = 7543;
-const request = supertest(`http://localhost:${PORT}`);
-
-describe("General route logic & URL variables and parameters", function () {
-  let server;
-
-  before(function (done) {
-    server = new cpeak();
-
-    server.route("get", "/hello", (req, res) => {
-      res.status(200).json({ message: "Hello, World!" });
-    });
-
-    server.route("get", "/document/:title/more/:another/final", (req, res) => {
-      const title = req.vars.title;
-      const another = req.vars.another;
-      const params = req.params;
-
-      res.status(200).json({ title, another, params });
-    });
-
-    server.listen(PORT, done);
-  });
-
-  after(function (done) {
-    server.close(done);
-  });
-
-  it("should return a simple response with no variables and parameters", async function () {
-    const res = await request.get("/hello");
-    assert.strictEqual(res.status, 200);
-    assert.deepStrictEqual(res.body, { message: "Hello, World!" });
-  });
-
-  it("should return a 404 for unknown routes", async function () {
-    const res = await request.get("/unknown");
-    assert.strictEqual(res.status, 404);
-    assert.deepStrictEqual(res.body, {
-      error: "Cannot GET /unknown",
-    });
-  });
-
-  it("should return a 404 for not handled methods", async function () {
-    const res = await request.patch("/random");
-    assert.strictEqual(res.status, 404);
-    assert.deepStrictEqual(res.body, {
-      error: "Cannot PATCH /random",
-    });
-  });
-
-  it("should return the correct URL variables and parameters", async function () {
-    const expectedResponseBody = {
-      title: "some-title",
-      another: "thisISsome__more-text",
-      params: {
-        filter: "comments-date",
-        page: "2",
-        sortBy: "date-desc",
-        tags: JSON.stringify(["nodejs", "express", "url-params"]),
-        author: JSON.stringify({ name: "John Doe", id: 123 }),
-        isPublished: "true",
-        metadata: JSON.stringify({ version: "1.0.0", language: "en" }),
-      },
-    };
-
-    const res = await request
-      .get("/document/some-title/more/thisISsome__more-text/final")
-      .query({
-        filter: "comments-date",
-        page: 2,
-        sortBy: "date-desc",
-        tags: JSON.stringify(["nodejs", "express", "url-params"]),
-        author: JSON.stringify({ name: "John Doe", id: 123 }),
-        isPublished: true,
-        metadata: JSON.stringify({ version: "1.0.0", language: "en" }),
-      });
-
-    assert.strictEqual(res.status, 200);
-    assert.deepStrictEqual(res.body, expectedResponseBody);
-  });
-});

package/test/serveStatic.test.js

@@ -1,53 +0,0 @@
-import assert from "node:assert";
-import supertest from "supertest";
-import fs from "node:fs/promises";
-import cpeak, { serveStatic } from "../lib/index.js";
-
-const PORT = 7543;
-const request = supertest(`http://localhost:${PORT}`);
-
-describe("Serving static files with serveStatic", function () {
-  let server;
-
-  before(function (done) {
-    server = new cpeak();
-
-    server.beforeEach(serveStatic("./test/files", { m4a: "audio/mp4" }));
-
-    server.listen(PORT, done);
-  });
-
-  after(function (done) {
-    server.close(done);
-  });
-
-  it("should return the correct file with the correct MIME type", async function () {
-    const textRes = await request.get("/test.txt");
-    const cssRes = await request.get("/styles.css");
-
-    const fileTextContent = await fs.readFile("./test/files/test.txt", "utf-8");
-    const fileCssContent = await fs.readFile(
-      "./test/files/styles.css",
-      "utf-8"
-    );
-
-    assert.strictEqual(textRes.status, 200);
-    assert.strictEqual(textRes.headers["content-type"], "text/plain");
-    assert.strictEqual(textRes.text, fileTextContent);
-
-    assert.strictEqual(cssRes.status, 200);
-    assert.strictEqual(cssRes.headers["content-type"], "text/css");
-    assert.strictEqual(cssRes.text, fileCssContent);
-  });
-
-  it("should return the correct file with the specified MIME type by the developer", async function () {
-    const res = await request.get("/audio.m4a");
-
-    // read the file as binary
-    const fileBuffer = await fs.readFile("./test/files/audio.m4a");
-
-    assert.strictEqual(res.status, 200);
-    assert.strictEqual(res.headers["content-type"], "audio/mp4");
-    assert.deepStrictEqual(res.body, fileBuffer);
-  });
-});