Convert and store JSON data:

const fs = require("fs");

const data = {
  author: "Emily",
  title: "Ego is the Enemy",
};

fs.writeFileSync("1-json.json", JSON.stringify(data));

Read and convert JSON data:

const fs = require("fs");

const dataBuffer = fs.readFileSync("1-json.json");
const dataJSON = dataBuffer.toString();
const data = JSON.parse(dataJSON);

console.log(data);
console.log(data.title);

utils1.js

const username = "Username";


module.exports = username;

utils2.js

const add = function(a,b) {
	return a + b;
}
module.exports = add

module.exports = { 
	getNotes: getNotes, 
	addNote: addNote 
};
//or
module.exports = { getNotes, addNote, removeNote };

const notes = require("./notes.js");

notes.getNotes();
notes.addNote(title,body);

Chalk

NPM package used to stylise console message.

const chalk = require("chalk");

const error = chalk.bgRed;
const success = chalk.bold.green; // or chalk.green.bold
const warning = chalk.hex("#FFA500"); // Orange color

console.log(success("Success!"));
console.log(warning("Warning!"));
console.log(error("Error!"));

Nodemon

NPM package used to hot reload on save.

nodemon app.js

"scripts": {
    "start": "",
    "dev": "nodemon src/index.js"
  },

npm run dev

Yargs

Package used to parse command line arguments

Yargs Setup

const yargs = require("yargs");

// Customize yargs version
yargs.version("1.1.0");

// Setup commands
yargs.command({
  command: "add",
  describe: "Add a new note",
  handler: function () {
    console.log("Adding a new note!");
  },
});
yargs.command({
  command: "remove",
  describe: "Remove a note",
  handler() {
    console.log("Removing the note!");
  },
});

console.log(yargs.argv);

node app.js add #will print Adding a new note

node app.js —version will print current version of yargs setup

node app.js —help will print all commands setup

Yargs Builder

yargs.command({
  command: "add",
  describe: "Add a new note",
  builder: {
    title: {
      describe: "Note title",
      demandOption: true,
      type: "string",
    },
  },
  handler(argv) {
    console.log("Title: " + argv.title);
  },
});

node app.js add will now show title as required and of type string.

Bcrypt

A library to help you hash passwords.

const bcrypt = require("bcrypt");

const hashFunction = async () => {
  const password = "Red12345!";
  const hashedPassword = await bcrypt.hash(password, 8);

  const isMatch = await bcrypt.compare("Red12345!", hashedPassword);
  console.log(isMatch);
};
hashFunction();

Jsonwebtoken

npm i jsonwebtoken

Multer

Multi-part upload handler. Used for file uploads.

npm i multer

Sharp

Convert large images in common formats to smaller, web-friendly JPEG, PNG, WebP, GIF and AVIF images of varying dimensions.

npm i sharp

Edge

Goto URL edge://inspect

Chrome

Goto URL chrome://inspect

MongoDB

Mongoose

JWT (JSON Web Token)

const jwt = require("jsonwebtoken");

const tokenFunction = async () => {
  const token = jwt.sign({ _id: "abc123" }, "thisismynewcourse", {
    expiresIn: "7 days",
  });
  console.log(token);

  const data = jwt.verify(token, "thisismynewcourse");
  console.log(data);
};

Generate JWT For A User

// JWT Token generate
userSchema.methods.generateAuthToken = async function () {
  const user = this;

  const token = jwt.sign({ _id: user._id.toString() }, "thisismynewcourse");
  user.tokens = user.tokens.concat({ token });
  await user.save();

  return token;
};

Login Request

Unauthorised request

router.post("/users/login", async (req, res) => {
  try {
    const user = await User.findByCredentials(
      req.body.email,
      req.body.password
    );
    const token = await user.generateAuthToken();
    res.send({ user, token });
  } catch (error) {
    res.status(400).send(error);
  }
});

Create User Request

Unauthorised request

router.post("/users", async (req, res) => {
  const user = new User(req.body);
  try {
    await user.save();
    const token = await user.generateAuthToken();
    res.status(201).send({ user, token });
  } catch (e) {
    res.status(400).send(e);
  }
});

Logout

router.post("/users/logout", auth, async (req, res) => {
  try {
    req.user.token = req.user.tokens.filter(
      (token) => token.token !== req.token
    );
    await req.user.save();
    res.send();
  } catch (error) {
    res.status(500).send(error);
  }
});

Logout All

Logout from all active sessions (devices).

router.post("/users/logoutAll", auth, async (req, res) => {
  try {
    req.user.tokens = [];
    await req.user.save();
    res.send();
  } catch (error) {
    res.status(500).send(error);
  }
});

router.get("/tasks", auth, async (req, res) => {
  const match = {};
  if (req.query.completed) {
    match.completed = req.query.completed === "true";
  }
  try {
    await req.user.populate({
      path: "tasks",
      match,
    });
    res.send(req.user.tasks);
  } catch (error) {
    res.status(500).send(error.message);
  }
});

If request url is in the form: {{host}}/tasks?completed=false then, match object will contain completed as false and only those tasks will be returned.

Pagination

// GET /tasks?limit=10&skip=0
router.get("/tasks", auth, async (req, res) => {
  const options = {};

  if (req.query.limit) {
    options.limit = parseInt(req.query.limit);
  }

  if (req.query.skip) {
    options.skip = parseInt(req.query.skip);
  }

  try {
    await req.user.populate({
      path: "tasks",
      match,
      options,
    });
    res.send(req.user.tasks);
  } catch (error) {
    res.status(500).send(error.message);
  }
});

Sorting

// GET /tasks?sortBy=createdAt:desc
router.get("/tasks", auth, async (req, res) => {
  const options = {};
  if (req.query.sortBy) {
    const parts = req.query.sortBy.split(":");
    options.sort = {};
    options.sort[parts[0]] = parts[1] === "desc" ? -1 : 1;
  }

  try {
    await req.user.populate({
      path: "tasks",
      match,
      options,
    });
    res.send(req.user.tasks);
  } catch (error) {
    res.status(500).send(error.message);
  }
});

import { WebSocketServer } from "ws";
import ws from "../src/config/ws.js";

const websocketport = process.env.WEBSOCKET_PORT || 443;

const wss = new WebSocketServer({
	port: websocketport,
	perMessageDeflate: false,
});
console.log(`WebSocket is running on port ${websocketport}`);

wss.on("connection", (ws) => {
	console.log("Client connected");
	clients.add(ws);

	// Handle messages from the client
	ws.on("message", (message) => {
		console.log(`Received: ${message}`);
		// Echo the message back to the client
		ws.send(`Server received: ${message}`);
	});

	ws.on("error", (error) => {
		console.error("WebSocket error:", error);
	});

	ws.on("close", () => {
		console.log("Client disconnected");
		clients.delete(ws);
	});
});

const clients = new Set();

const broadcast = (message) => {
	clients.forEach((client) => {
		if (client.readyState === WebSocket.OPEN) {
			client.send(message);
		}
	});
};

export default { clients, broadcast };