chat_server.js

const express = require('express');
const http = require('http');
const WebSocket = require('ws');

const port = 8989;
const server = http.createServer(express);
const wss = new WebSocket.Server({ server })

wss.on('connection', function connection(ws) {
  ws.on('message', function incoming(data) {
    wss.clients.forEach(function each(client) {
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        client.send(data);
      }
    })
  })
})

server.listen(port, function() {
  console.log(`Server is listening on ${port}!`)
})

index.html

<center><h1>WS Chat App</h1></center>
<pre id="messages" style="height: 400px; overflow: scroll"></pre>
<input type="text" id="messageBox" placeholder="Type your message here" style="display: block; width: 100%; margin-bottom: 10px; padding: 10px;" onkeyup="validateInput(event)"/>
<button id="send" title="Send Message!" style="width: 100%; height: 30px;">Send Message</button>

<script>
  (function() {
    const sendBtn = document.querySelector('#send');
    const messages = document.querySelector('#messages');
    const messageBox = document.querySelector('#messageBox');

    let ws;

    function showMessage(message) {
      if (message instanceof Blob) {
        reader = new FileReader();

        reader.onload = () => {
        //   console.log("Result: " + reader.result);
          messages.textContent += `\n\n${reader.result}`;
        };

        reader.readAsText(message);
      } else {
        console.log("Result: " + message);
        messages.textContent += `\n\n${message}`;
      }

      messages.scrollTop = messages.scrollHeight;
      messageBox.value = "";
    }

    function init() {
      if (ws) {
        ws.onerror = ws.onopen = ws.onclose = null;
        ws.close();
      }

      ws = new WebSocket('ws://localhost:8989');
      ws.onopen = () => {
        console.log('Connection opened!');
      }
      ws.onmessage = ({ data }) => showMessage(data);
      ws.onclose = function() {
        ws = null;
      }
    }

	
    sendBtn.onclick = function() {
      if (!ws) {
        showMessage("No WebSocket connection :(");
        return ;
      }

      ws.send(messageBox.value);
      showMessage(messageBox.value);
    }
	
	
	messageBox.onkeyup = function() {
		if(event.keyCode  == 13) {
			if (!ws) {
				showMessage("No WebSocket connection :(");
				return ;
			}

			ws.send(messageBox.value);
			showMessage(messageBox.value);
		}
    }

    init();
  })();
</script>

const mongoose = require("mongoose");
const conn_str = "mongodb://localhost:27017/tcet"
mongoose.connect(conn_str, { useNewUrlParser: true , useUnifiedTopology: true})
	.then( () => console.log("Connected successfully...") )
	.catch( (err) => console.log(err) );

const userSchema = new mongoose.Schema({
	name: String,
	age: Number,
	city: String,
	state: String
});

const user = new mongoose.model("user", userSchema);

/** Express Mongoose Integration **/

const express = require("express");
const app = express();

app.route("/user")
.get(async (req, res) => {
	let data = await user.find();
	res.send(data);
})
.post(async (req, res) => {
	req_data = req.query;
	let obj = new user(req.query)
	let result = await obj.save();
	res.send(result);
})
.put(async (req, res) => {
	req_data = req.query;
	let result = await user.updateOne({_id: req.query.id}, {$set : {city: req.query.city}})
	res.send(result);
})
.delete(async (req, res) => {
	let result = await user.deleteOne({_id: req.query.id})
	res.send(result);
})

app.listen(8080, () => {
	console.log("listening 8080...");
});

Connect to MongoDB Atlas Cluster

Whitelist your ip / or allow from all 0.0.0.0/0

Get Your Current IP Address from google > what is my ip

Atlas > Security > Network Access > ADD IP ADDRESS

First get the connection string or URI from Atlas

Atlas > Deployment > Databases > Connect > Connect your application > Driver Node.js > Version 2.2.12 or later

const port = 8080;
const mongoose = require("mongoose");
const uri ="get_uri_from_atlas"
mongoose.connect(uri, { useNewUrlParser: true , useUnifiedTopology: true})
	.then( () => console.log("Connected successfully...") )
	.catch( (err) => console.log(err) );

const userSchema = new mongoose.Schema({
	name: String,
	age: Number,
	city: String
});

const user = new mongoose.model("users", userSchema);

/** Express Mongoose Integration **/

const express = require("express");
const app = express();

app.route("/user")
.get(async (req, res) => {
	let data = await user.find();
	res.send(data);
})
.post(async (req, res) => {
	req_data = req.query;
	let obj = new user(req.query)
	let result = await obj.save();
	res.send(result);
})
.put(async (req, res) => {
	req_data = req.query;
	let result = await user.updateOne({_id: req.query.id}, {$set : {city: req.query.city}})
	res.send(result);
})
.delete(async (req, res) => {
	let result = await user.deleteOne({_id: req.query.id})
	res.send(result);
})

app.listen(process.env.PORT || port, () => {
	console.log("listening 8080...");
});

Insert

console.log("mongo db connection");

const mongoose = require("mongoose");

const conn_str = "mongodb://localhost:27017/tcet";
mongoose.connect(conn_str, { useNewUrlParser: true, useUnifiedTopology: true })
	.then( () => console.log("Connected Successfully..."))
	.catch( (error) => console.log(error));
	
//schema defining for collection
const teacherSchema = new mongoose.Schema({
	name: {
		type: String,
		required: true
	},
	age: Number,
	city: String
})

// create collection
const Teacher = new mongoose.model("Teacher", teacherSchema);
console.log(Teacher);
	
/*insertOne
const t1 = new Teacher({name: "Shailesh", age: 32, city: "Nagpur"});
console.log(t1.save());


//insertOne
const insertOne = async () => {
	try {
		const t2 = new Teacher({name: "Amy", age: 32, city: "Nagpur"});
		const result = await t2.save();
		console.log(result);
	} catch(e) {
		console.log(e);
	}
};

insertOne();


//insertMany
const insertMany = async () => {
	try {
		const t1 = new Teacher({name: "Amy1", age: 32, city: "Nagpur"});
		const t2 = new Teacher({name: "Amy2", age: 32, city: "Nagpur"});
		const t3 = new Teacher({name: "Amy3", age: 32, city: "Nagpur"});
		const result = await Teacher.insertMany([t1,t2,t3]);
		console.log(result);
	} catch(e) {
		console.log(e);
	}
};

insertMany();
*/

Connection Module

const mongoose = require("mongoose");

const conn_str = "mongodb://localhost:27017/tcet";
mongoose.connect(conn_str, { useNewUrlParser: true, useUnifiedTopology: true })
	.then( () => console.log("Connected Successfully..."))
	.catch( (error) => console.log(error));
	
//schema defining for collection
const teacherSchema = new mongoose.Schema({
	name: {
		type: String,
		required: true
	},
	age: Number,
	city: String
})

// create collection
const Teacher = new mongoose.model("Teacher", teacherSchema);

exports.Teacher = Teacher;

Read

var teacher = require("./teacher");
const Teacher = teacher.Teacher;

/*
const t1 = new Teacher({name: "Penny", age: 25, city: "Nagpur"});
console.log(t1.save());
*/

const getData = async () => {
const data = await Teacher.find({name: /l/i}).select({_id: 0, __v: 0}).limit(2).sort({name: -1});
	console.log(data);
}

getData();

Update

var teacher = require("./teacher");
const Teacher = teacher.Teacher;

/*
const updateOne = async (oname, nname) => {
	try {
		var res = await Teacher.updateOne({name: oname}, {
			$set : { name : nname }
		});
		console.log(res);
	} catch (e) {
		console.log(e);
	}
}

updateOne("Howa", "Kuwa.....");

const updateMany = async (city) => {
	try {
		var res = await Teacher.updateMany({age: {$lt: 30}}, {
			$set : { city : city }
		});
		console.log(res);
	} catch (e) {
		console.log(e);
	}
}

updateMany("Mumbai");

*/

Delete

var teacher = require("./teacher");
const Teacher = teacher.Teacher;

/*
const deleteMany = async (where) => {
	try {
		var res = await Teacher.deleteMany(where);
		console.log(res);
	} catch(error) {
		console.log(error);
	}
}

deleteMany({age : {$in: [25, 37]}});
*/

NODE CUSTOM MODULE

index.js

var mymath = require("./mymodule")

console.log(mymath.add(5,6));
console.log(mymath.sub(5,6));
console.log(mymath.mul(5,6));
console.log(mymath.div(5,6));
console.log(mymath.mod(5,6));

cobj = new mymath.MyCircle(5);
cobj.area();

mymodule.js

exports.add = (x, y) => x + y;
exports.sub = (x, y) => x – y;
exports.mul = (x, y) => x * y;
exports.div = (x, y) => x / y;
exports.mod = (x, y) => x % y;

exports.MyCircle = class {

constructor(r) {
    this.radius = r;
    console.log("Hello I am My Circle Constructor...");
}

area() {
    let area = Math.PI * this.radius * this.radius;
    console.log(`Area: ${area.toFixed(2)}`);
}
}

NODE http MODULE

index.js

var http = require(“http”)

http.createServer((req, res) => {
// res.writeHead(‘Content-Type’, ‘text/plain’);
// res.writeHead(‘Content-Type’, ‘application/json’);
res.writeHead(200, {‘Content-Type’ : ‘text/html’});
res.write("this is line 1….");

console.log(req.url);

if(req.url == "/") {
    res.write("Home req hit</br>")
} else 

if(req.url == "/teacher") {
    res.write("Teacher req hit</br>")
} else 

if(req.url == "/student") {
    res.write("Student req hit</br>")
} else 

{
    res.end("Page Not Found....");
}

res.end("hello world....");
}).listen(8989, () => {
console.log("listening at port 8989…")
});

EXPRESS ROUTING

index.js

var express = require("express");
var app = express();

app.get("/", (req, res) => {
  res.send("Home Page");
});

app.get("/student", (req, res) => {
  data = { result: "Student GET Request" };
  res.send(data);
});

app.post("/student", (req, res) => {
  data = { result: "Student post Request" };
  res.send(data);
});

app.put("/student", (req, res) => {
  data = { result: "Student put Request" };
  res.send(data);
});

app.delete("/student", (req, res) => {
  data = { result: "Student delete Request" };
  res.send(data);
});

app
  .route("/teacher")
  .get((req, res) => {
    data = { result: "Teacher get Request" };
    res.send(data);
  })
  .post((req, res) => {
    data = { result: "Teacher post Request" };
    res.send(data);
  })
  .put((req, res) => {
    data = { result: "Teacher put Request" };
    res.send(data);
  })
  .delete((req, res) => {
    data = { result: "Teacher delete Request" };
    res.send(data);
  });


app.listen(8989, () => {
  console.log("Listening at port 8989");
});

RUN COMMAND

#if file is index.js then you can simply run using . instead of filename
node .
node app.js

#install nodemon
npm i nodemon
OR
npm i -g nodemon

nodemon .
nodemon app.js

OR
 
./node_modules/nodemon/bin/nodemon.js .
./node_modules/nodemon/bin/nodemon.js app.js

EXPRESS MODULAR ROUTING

index.js

var express = require("express");
var app = express();
var home = require("./home");
var student = require("./student");
var teacher = require("./teacher");

app.use("/", home);
app.use("/student", student);
app.use("/teacher", teacher);

app.use(function (req, res, next) {
  res.status(404);
  res.send("404: File Not Found");
});

app.listen(8989, () => {
  console.log("Listening at port 8989");
});

student.js

const express = require("express");
const router = express.Router();

router
  .route("/")
  .get((req, res) => {
    res.send("student listing");
  })

  .post((req, res) => {
    res.send("student post");
  })

  .put((req, res) => {
    res.send("student put");
  })

  .delete((req, res) => {
    res.send("student delete");
  });

module.exports = router;

teacher.js

const express = require("express");
const router = express.Router();
router
  .route("/")
  .get((req, res) => {
    res.send("teachers listing");
  })
  .post((req, res) => {
    res.send("teachers post");
  })
  .put((req, res) => {
    res.send("teachers put");
  })
  .delete((req, res) => {
    res.send("teachers delete");
  });

module.exports = router;

EXPRESS READ DATA

index.js

const express = require("express");
const app = express();
app.use(express.json());

app
  .route("/")
  .get((req, res) => {
    data = req.query;
    res.send(data);
  })
  .post((req, res) => {
    data = req.body;
    res.send(data);
  })
  .put((req, res) => {
    data = req.body;
    res.send(data);
  });


app.listen(8989, () => {
  console.log("Listening at port 8989");
});

Assignment: WA Web Service to read number from user and return square and cube of that number. Return data in JSON format.

Fetch Api

<table border=1>
	<thead>
		<th>Id</th>
		<th>Name</th>
		<th>Email</th>
		<th>Aavatar</th>
	</thead>
	<tbody id="records">
		<tr>
			<td>sample </td>
			<td>sample</td>
			<td>sample</td>
			<td>sample</td>
		</tr>
	</tbody>

</table>
<img id="image" />
<script>
	url = "https://reqres.in/api/users?page=1";

	fetch(url)
	.then(res => res.json())
	.then(result => {
		console.table(result.data);
		console.log(result.data[0]['avatar'])
		document.getElementById("image").src = result.data[0]['avatar'];
		records = result.data;
		output = '';
		for(i = 0;i<records.length; i++){
			output += `<tr>`
			output += `<td>${records[i]['id']} </td>`
			output += `<td>${records[i]['first_name']} ${records[i]['last_name']}</td>`
			output += `<td>${records[i]['email']}</td>`
			output += `<td><img id="image" src="${records[i]['avatar']}" /></td>`
			output += `</tr>`
			console.log(records[i]['id'])
		}
	document.getElementById("records").innerHTML = output;
	
	})
	
</script>

Express File Upload

//get directory name
console.log(`Project Path: ${__dirname}`);

const express = require("express");
const fileUpload = require("express-fileupload");
const app = express();

//options / middleware
app.use(fileUpload());

app.post("/file_upload", (req, res) => {
	
	console.log(req.body);
	console.log(req.files);
	
	let file_to_upload = req.files.file_to_upload;
	
	//file_to_upload.mv(path,callbackfun);
	const upload_path = __dirname + '/uploads/' + file_to_upload.name;
	//file_to_upload.mv(upload_path);
	
	file_to_upload.mv(upload_path, (err) => {
		if(err) {
			res.status(500)
			res.send(err);
		}
		
		res.status(200)
		res.send("File Upload successfully...")
	})
	
});

app.listen(8989, () => {
	console.log("Listening at port 8989");
})

json webtoken

const express = require("express");
const jwt = require("jsonwebtoken");
const cors = require("cors");

const app = express();
app.use(express.json());
app.use(cors());

// Secret key (keep in env var in production)
const SECRET_KEY = "shhhhh";

// Dummy credentials
const USERNAME = "admin";
const PASSWORD = "@dmin";

// ---------------------------
// 🔐 JWT Auth Middleware
// ---------------------------
function verifyToken(req, res, next) {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith("Bearer ")) {
    return res.status(401).json({ message: "No token provided" });
  }

  const token = authHeader.split(" ")[1];

  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) {
      return res.status(403).json({ message: "Invalid or expired token" });
    }

    req.user = decoded; // attach decoded data to request
    next();
  });
}

// ---------------------------
// 🧩 Routes
// ---------------------------

// Login route - issues token
app.post("/login", (req, res) => {
  const { username, password } = req.body;

  if (username !== USERNAME || password !== PASSWORD) {
    return res.status(401).json({ message: "Invalid credentials" });
  }

  const token = jwt.sign({ username, role: "manager" }, SECRET_KEY, {
    expiresIn: "1h",
  });

  res.json({ token });
});

// Protected routes
app.get("/dashboard", verifyToken, (req, res) => {
  res.json({ message: `Welcome ${req.user.username} to the dashboard` });
});

app.get("/employees", verifyToken, (req, res) => {
  res.json({ message: "Employee page data", user: req.user });
});

// ---------------------------
// 🏃 Start Server
// ---------------------------
app.listen(8080, () => {
  console.log("✅ Server listening at http://localhost:8080");
});

atlas.js

const conn_str = "mongodb+srv://<username>:<password>@clusterurl_obtained_from_mongodbatlas/<databasename>?retryWrites=true&w=majority";
//please replace username password and database name 
const mongoose = require("mongoose");

mongoose.connect(conn_str)
.then(() => console.log("Connected successfully..."))
.catch( (error) => console.log(error) );


const express = require("express");
const app = express();
app.use(express.json());

const empSchema = new mongoose.Schema({});
const emp = new mongoose.model("emps", empSchema);


var cors = require('cors')
app.use(cors())


app.get("/employees", async (req, res) => {
    // var data = [{name: "hari", salary: 25000}, {name: "sameer", salary: 23000}]
    let data = await emp.find();
    res.send(data)
})

app.listen(8989, () => {
	console.log("listening 8989...");
});

index.js

<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-C6RzsynM9kWDrMNeT87bh95OGNyZPhcTNXj1NW7RuBCsyN/o0jlpcV8Qyq46cDfL" crossorigin="anonymous"></script>

<table class="table table-striped">
    <thead>
        <tr>
            <th>Name</th>
            <th>City</th>
            <th>Phone No.</th>
            <th>Salary</th>
            <th>Action</th>
        </tr>
    </thead>
    <tbody id="records"></tbody>
</table>


<script>

url = "http://localhost:8989/employees"

fetch(url)
.then(res => res.json())
.then(res => {
    console.log(res)
    console.table(res)

    output = ''

    for(let i = 0; i < res.length; i++) {

        output += `<tr>
            <td>${res[i]['name']}</td>
            <td>${res[i]['address']}</td>
            <td>${res[i]['contact_number']}</td>
            <td>${res[i]['salary']}</td>
            <td><button class="btn btn-danger">Delete</button></td>
            </tr>`
    }

    document.getElementById("records").innerHTML = output
})

</script>