Express.txt

.........................................................................................................................................................................................................................................
							  Express.js - Web /Api Framework For node.js
.......................................................................................................................................................................................................................................
What is express?
   Express Fast, unopinionated, minimalist web framework for Node.js
express is built on top of http core module.

What apps can be built using express?

1.RESTFull WebServices
2.Dynamic content generation apps -  spring mvc, .netmvc.   with ui


Core features of Express:
1.Abstraction on core http module
2.lot of apis to send data like json api
3.routers : to create HTTP based web services and apps quickly.
4.middlewares : to extend core framework like - logging, database, security, templates...

Types of distributed Apps:

1.Monolithic App
2.Microservices

Can Express be used to build Microservices?
 No,
Express is just monolithic App framework
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
									Express Key concepts: in express every thing object
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
Objects in express

1.Application
  We call Container object which contain other objects
  entry and exit of an application
  application is created by calling function
2.Request
3.Response
4.Router


1.Application object roll:
	-Routing HTTP requests
	-Configuring middleware
	-Rendering HTML views
	-Registering a template engine


Express Project setup:
1.You can install express dependencies in existing plain node project
2.You can use express cli , to create project structures

Steps:

1.create project folder
2.create src folder
3.npm init
4.install express dependency
5.start writing code

mkdir express-app
cd express-app
npm init
...........................

Installing express framework:
.............................

npm i express --save
npm i nodemon --save-dev

  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "dev": "nodemon src/app.js"
  },
.....................................................................................
				Express- Coding
.....................................................................................

Express : HelloWorld

File Name : app.js - conventional name but you can save index.js as well.

//import express function
const express = require('express')
// console.log(express)

//creating application object
const app = express()

// console.log(app)

//api:
app.get('/hello', (req, res) => {
    //send response
    res.end('Hello Express')
})


//start the server

app.listen(3000, () => {
    console.log('Express Server is Ready!')
})
.................................................................................
			HTTP verbs and CURD
....................................................................................

HTTP Verbs         Operation Type

GET                Read

POST               Write

PUT                Update

DELETE          Remove

URL Pattern:
///////////
Every Http Verbs are mapped against url

/api/customers        -GET ,POST,PUT,DELETE
/api/products          --GET ,POST,PUT,DELETE
/api/reviews 		--GET ,POST,PUT,DELETE

 
const express = require('express')

const PORT = 3000
const app = express()

//expose apis
//get ===HTTP GET Verb
app.get('/', (req, res) => {
    res.end('Hello Express')
})

//Resource:USERs
app.get('/api/users', (req, res) => {
    res.end('USERS GET')
})
app.post('/api/users', (req, res) => {
    res.end('USERS POST')
})
app.put('/api/users', (req, res) => {
    res.end('USERS PUT')
})
app.delete('/api/users', (req, res) => {
    res.end('USERS DELETE')
})

//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
.........................................................................................................................................................................................................................................
									PORT, getting Server Info
.......................................................................................................................................................................................................................................

const express = require('express')

const PORT = 3000

const app = express()

//expose apis
//get ===HTTP GET Verb
app.get('/', (req, res) => {
    res.end('Hello Express')
})

//Resource:USERs
app.get('/api/users', (req, res) => {
    res.end('USERS GET')
})
app.post('/api/users', (req, res) => {
    res.end('USERS POST')
})
app.put('/api/users', (req, res) => {
    res.end('USERS PUT')
})
app.delete('/api/users', (req, res) => {
    res.end('USERS DELETE')
})

//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is Running at ${server.address().port}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										JSON - payload
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
const express = require('express')
const USERS = require('./mock-data/users')

const PORT = 3000

const app = express()

//expose apis
//get ===HTTP GET Verb
app.get('/', (req, res) => {
    res.end('Hello Express')
})

//Resource:USERs
app.get('/api/users', (req, res) => {
    res.json(USERS)
})
app.post('/api/users', (req, res) => {
    res.end('USERS POST')
})
app.put('/api/users', (req, res) => {
    res.end('USERS PUT')
})
app.delete('/api/users', (req, res) => {
    res.end('USERS DELETE')
})

//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is Running at ${server.address().port}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
									Service layer, controller, promise
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
const express = require('express')
const { findAll } = require('./services/user.service')

const PORT = 3000
const app = express()

//expose apis
//get ===HTTP GET Verb
app.get('/', (req, res) => {
    res.end('Hello Express')
})

//Resource:USERs
app.get('/api/users', async (req, res) => {
    try {
        const users = await findAll()
        res.json(users)
    }
    catch (err) {
        console.log(err)
    }
})
app.post('/api/users', (req, res) => {
    res.end('USERS POST')
})
app.put('/api/users', (req, res) => {
    res.end('USERS PUT')
})
app.delete('/api/users', (req, res) => {
    res.end('USERS DELETE')
})

//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is Running at ${server.address().port}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										Routers
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

src/routers/user.router.js
const express = require('express')
const { findAll } = require('../services/user.service')

const userRouter = express.Router()

userRouter.get('/', async (req, res) => {
    try {
        const users = await findAll()
        res.json(users)
    }
    catch (err) {
        console.log(err)
    }
})


module.exports = userRouter;


src/routers/post.router.js
const express = require('express')

const postRouter = express.Router()

postRouter.get('/', async (req, res) => {
    try {
        res.json({message:'Post Router'})
    }
    catch (err) {
        console.log(err)
    }
})


module.exports = postRouter;

src/routers/comments.router.js
const express = require('express')

const commentsRouter = express.Router()

commentsRouter.get('/', async (req, res) => {
    try {
        res.json({message:'Comments Router'})
    }
    catch (err) {
        console.log(err)
    }
})


module.exports = commentsRouter;

src/app.js
const express = require('express')
//const userRouter = require('./routers/user.router')
const PORT = 3000
const app = express()

//bind Routers with application object, so that application can redirect to routers
// app.use('/api/users',userRouter)
app.use('/api/users', require('./routers/user.router'))
app.use('/api/posts', require('./routers/post.router'))
app.use('/api/comments', require('./routers/comments.router'))

//expose apis
//get ===HTTP GET Verb
app.get('/', (req, res) => {
    res.end('Hello Express')
})

//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is Running at ${server.address().port}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
				&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
											Router Parameters and Query Strings
const express = require('express')
const app = express()
// console.log(app)

//expose apis 
app.get('/', (req, res) => {
    res.end('Home')
})
//users 
app.get('/api/users', (req, res) => {
    res.end('GET-Users')
})
//users by city - /api/users/address?city='xxx'&state='xxx'
app.get('/api/users/address', (req, res) => {
    const queryparams = req.query
    console.log(queryparams.city)
    res.json({ message: queryparams })
})
//users by id-route parameters
app.get('/api/users/:id', (req, res) => {
    const params = req.params
    res.json({ message: params.id })
})

app.post('/api/users', (req, res) => {
    res.end('POST-Users')
})
app.put('/api/users', (req, res) => {
    res.end('PUT-Users')
})
app.delete('/api/users', (req, res) => {
    res.end('DELETE-Users')
})

app.listen(3000, () => {
    console.log('Server running on port 3000')
})

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										Payload

const express = require('express')
const app = express()
// console.log(app)

app.post('/api/users', (req, res) => {
    let data = ''
    req.on('data', (chunk) => {
        data += chunk
    })
    req.on('end', () => {
        console.log(data)
        //save
        console.log(JSON.parse(data))
        res.end('Data is Posted')
    })
})
app.listen(3000, () => {
    console.log('Server running on port 3000')
})

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										  Express middlewares
.......................................................................................................................................................................................................................................
What is Middleware?
       Middleware is JavaScript function that have access request object and response and next function in the application request response              cycle.
 The difference between normal function which handles req and response with express , middleware takes third arg

normal function
 app.get('url',(req,res)=>{})

Middleware function
  app.get('url',(req,res,next)=>{
       //pre and post processing
  })
 req and res are objects
 next is a function

The "next" function is a function in the express router which, when invoked, executes the middleware succeeding the current middleware.


Tasks are middleware is doing:

1.Execute any code
2.Make changes to request and response object before handling real req and res cycle.
3.Middlwares can be attached on application object and also router object

Middleware Flow:
 Request-------->[Middlware 1]--------[Middleware 2]---------[Middleware N]----routerHandler ---Response

use Method
  use method is used to registry middleware.

app.use
router.use

app.use('/api/users', require('./routers/users/user.router'))
 In this code we have registered already middleware which is called as "routerMidleware" - Router itself is middleware.

How to write our own middleware? - Custom Middleware.
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Use case: Simple Middleware
const express = require('express')
const PORT = 3000
const app = express()

//middlewares
app.use(function (req, res, next) {
    console.log('Middleware')
    //chain the middleware: move to next
    next()
})


app.get('/', (req, res) => {
    res.end('Hello Express')
})


//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Use case :Multiple Middlewares
const express = require('express')
const PORT = 3000
const app = express()

//middlewares
app.use(function (req, res, next) {
    console.log('M1')
    //chain the middleware: move to next
    next()
})
app.use(function (req, res, next) {
    console.log('M2')
    //chain the middleware: move to next
    next()
})
app.use(function (req, res, next) {
    console.log('M3')
    //chain the middleware: move to next
    next()
})


app.get('/', (req, res) => {
    res.end('Hello Express')
})


//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Use case : Add some custom Header
const express = require('express')
const PORT = 3000
const app = express()

//middlewares
app.use(function (req, res, next) {
    //custom header
    res.set("message", "Hello")
    //chain the middleware: move to next
    next()
})
app.use(function (req, res, next) {
    res.set("name", "Subramanian")

    console.log('M2')
    //chain the middleware: move to next
    next()
})
app.use(function (req, res, next) {
    res.set("company", "IBM")

    console.log('M3')
    //chain the middleware: move to next
    next()
})


app.get('/', (req, res) => {
    res.end('Hello Express')
})


//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
*********************************************************************************************************************************************************
											Middleware for specific URL
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
const express = require('express')
const PORT = 3000
const app = express()

//url specific middleware
app.use('/api/hello', (req, res, next) => {
    res.set('hello', 'helloapi')
    next()
})

app.get('/', (req, res) => {
    res.end('Hello Express')
})

app.get('/api/hello', (req, res) => {
    res.end('Hello-GET')
})
app.post('/api/hello', (req, res) => {
    res.end('Hello-POST')
})
app.put('/api/hello', (req, res) => {
    res.end('Hello-Put')
})
app.delete('/api/hello', (req, res) => {
    res.end('Hello-Delete')
})

app.get('/api/hai', (req, res) => {
    res.end('hai-GET')
})
//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
							        URL and specific method
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
const express = require('express')
const PORT = 3000
const app = express()

//url specific middleware
app.get('/api/hello', (req, res, next) => {
    res.set('hello', 'this is get method')
    next()
})

app.get('/', (req, res) => {
    res.end('Hello Express')
})

app.get('/api/hello', (req, res) => {
    res.end('Hello-GET')
})
app.post('/api/hello', (req, res) => {
    res.end('Hello-POST')
})
app.put('/api/hello', (req, res) => {
    res.end('Hello-Put')
})
app.delete('/api/hello', (req, res) => {
    res.end('Hello-Delete')
})

app.get('/api/hai', (req, res) => {
    res.end('hai-GET')
})
//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
								   Routers and middlewares
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
const express = require('express')
const PORT = 3000
const app = express()
//router
const userRouter = express.Router()
app.use('/api/users', userRouter)

//userRouter
// userRouter.use(function (req, res, next) {
//     console.log('User Router')
//     res.set('user', 'this is user Router')
//     next()
// })
// userRouter.use('/', function (req, res, next) {
//     console.log('User Router')
//     res.set('user', 'this is user Router')
//     next()
// })
userRouter.get('/api/users', function (req, res, next) {
    console.log('User Router')
    res.set('user', 'this is user Router')
    next()
})
userRouter.get('/', (req, res) => {
    res.send('User router')
})
userRouter.get('/:id', (req, res) => {
    res.send('User router details')
})


//start server
app.listen(PORT, () => {
    console.log(`Express server is Running at ${PORT}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

Use case:
I want to log every request into a file- building logger using middleware

const express = require('express')
const fs = require('node:fs')
const path = require('node:path')

const PORT = 3000

//middleware function 
function fileLoggerMiddleware(type = 'console') {
    return function (req, res, next) {
        const logFormat = `[${new Date().toISOString()}] - ${req.method} - ${req.url}\n`
        if (type === 'file') {
            fs.appendFileSync(path.join(__dirname, 'access.log'), logFormat)
            next()
        } else {
            console.log(logFormat)
            next()
        }
    }
}

const app = express()
app.use(fileLoggerMiddleware('file'))

app.get('/api/greet', (req, res) => {
    res.json({ message: 'Greet' })
})

app.get('/api/hello', (req, res) => {
    res.json({ message: 'Hello' })
})

app.listen(PORT, () => {
    console.log(`Express server is running @ ${PORT}`)
})&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
									Types of Middlewares
...........................................................................................................................................................................................................................................
1.Application middleware
2.Router level middleware
3.Error handling middleware
4.Third party middleware

1.Application middleware:
  Middleware is attached on application object

2.Router level middleware
->writing router:
 In express except ,request and response , all features including router is middleware.
 Router is in built middleware.


								Error Handling Middleware

const express = require('express')
const app = express()

const PORT = 3000

app.get('/api/user/:name', (req, res) => {
    const name = req.params.name
    if (name === 'admin') {
        res.send({ message: 'Welcome to Admin' })
    } else {
        throw new Error('User Is not valid')
    }
})

//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is ready! at ${server.address().port}`)
})
//server properties

In the above code, the exception is thrown when user is not valid, we have to convert into meaningful  response

Error Handling middleware

What is Error Handling Middleware in Express?

In Express.js, an error-handling middleware is a special middleware function that handles errors across your app.

const express = require('express')
const app = express()

const PORT = 3000


app.get('/api/user/:name', (req, res) => {
    const name = req.params.name
    if (name === 'admin') {
        res.send({ message: 'Welcome to Admin' })
    } else {
        throw new Error('User Is not valid')
    }
})

//404 Route not found error handler
//this must be placed before Global error handler
//it wont take next arg, because it terminates the request and response
app.use((req, res) => {
    res.status(404).json({
        success: false,
        message: `The route ${req.originalUrl} not Found`,
    });
});
//Error Handling middleware
app.use((err, req, res, next) => {
    console.error(err.message);
    res.status(500).json({
        success: false,
        message: err.message
    });
})
//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is ready! at ${server.address().port}`)
})

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
									Chaining middleware
app.post('/users',authenticate,validateUser,(req,res)=>{
     //code 
})
const middlewareStack = [authenticate,validateUser]

app.post('/users',middewareStack,(req,res)=>{
     //code 
})
const express = require('express')
const app = express()


app.get('/', (req, res) => {
    res.end('Home')
})

//way - 1 chaining
// app.get('/api/greet', function (req, res, next) {
//     console.log('chain-1')
//     next()
// }, function (req, res, next) {
//     console.log('chain-2')
//     next()
// }, (req, res) => {
//     res.end('Home')
// })

//way 2: writting middleware separatly 
// const chain1 = function (req, res, next) {
//     console.log('chain-1')
//     next()
// }
// const chain2 = function (req, res, next) {
//     console.log('chain-2')
//     next()
// }
// app.get('/api/greet', chain1, chain2, (req, res) => {
//     res.end('Home')
// })

const chain1 = function (req, res, next) {
    console.log('chain-1')
    next()
}
const chain2 = function (req, res, next) {
    console.log('chain-2')
    next()
}
const chains = [chain1, chain2]
app.get('/api/greet', chains, (req, res) => {
    res.end('Home')
})

app.listen(3000, () => {
    console.log('Server running on port 3000')
})

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										 Third party Middlewares

Built in middleware or third party middlewares
Middlewares are supplied as part of the express team, open source community.

Common Middlewares From Express Team:

body-parser		Parse HTTP request body.
compression		Compress HTTP responses.
connect-rid		Generate unique request ID.
cookie-parser		Parse cookie header and populate req.cookies. See also cookies.
cookie-session	Establish cookie-based sessions.
cors				Enable cross-origin resource sharing (CORS) with various options.
errorhandler		Development error-handling/debugging.
method-override	Override HTTP methods using header.
morgan			HTTP request logger.
multer			Handle multi-part form data.
response-time		Record HTTP response time.
serve-favicon		Serve a favicon.
serve-index		Serve directory listing for a given path.
serve-static		Serve static files.
session			Establish server-based sessions (development only).
timeout			Set a timeout perioHTTP request processing.
vhost			Create virtual domains.

Every middleware is available as npm dependency.

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										bodyParser Middleware
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

bodyParser middleware parses incoming payload(json/formdata), converts into "JavaScript Object"

bodyParser can parse different types of incoming data

JSON body parser - into js object
Raw body parser - into js object
Text body parser - into js object
URL-encoded form body parser - into js object

Steps:

1.install middleware
npm install body-parser

2.configuration as part of application object
const bodyParser = require('body-parser')
app.use(bodyParser.urlencoded())
// parse application/json
app.use(bodyParser.json())

Use case:You have create products api 
findAllproducts
saveProducts
findbyid
updateProduct
removeProduct
filterProductByCategory

Use array as data store
Have error Handler too...

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										CORS - Cross Origin Resource sharing
.........................................................................................................................................................................................................................................


What is CORS?
 Internet browsers usually block access to undefined websites from your services and apis.
 Implementing this module enable your server to share its resources solely with clients who reside in the same domain as yours.

 CORS an HTTP header based mechanism implemented by browsers, enables a server or api to specific any origins

Implementation:
Step 1:
npm install cors

Step 2:
activate cors in app.js via middleware

const cors = require('cors')

app.use(cors()) - enabled for all routes

Enabled for particular route:

app.get('/products/:id', cors(), function (req, res, next) {
  res.json({msg: 'This is CORS-enabled for a Single Route'})
})

Note:
 HTTP methods,get,post,delete,update syntax
 
  app.get('url',requestlistener)

  app.get('url',middleware,requestlistener)

Default CORS Configuration values:
{
  "origin": "*",
  "methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
  "preflightContinue": false,
  "optionsSuccessStatus": 204
}

eg
const express = require('express')
const cors = require('cors')

const app = express()
const PORT = 3000

//this means any body from outside can access our resources
// app.use(cors())

// const corsOptions = {
//     origin: 'http://www.abc.com'
// }
//allow only from this url.
// const corsOptions = {
//     origin: 'http://127.0.0.1:5500'
// }
// app.use(cors(corsOptions))

//white list - many origins
const whiteList = [
    'http://127.0.0.1:5500',
    'http://localhost:8080',
    'http://example.com',
    'http://jsbin.com'
]
app.use(cors({
    // methods: ['GET'],
    origin: (origin, callback) => {
        //allow requests with no origin(mobile,apps,curl,postman)
        if (!origin) return callback(null, true);
        if (whiteList.includes(origin)) {
            callback(null, true) // allowed
        } else {
            callback(new Error('CorsBlocked: ${origin} not allowed'))
        }
    },
}))


app.get('/api/customers/:id', (req, res, next) => {
    res.json({ msg: 'cors enabled for only this particular' })
})

app.post('/api/customers', (req, res) => {
    res.status(201).json({ message: 'post' })
})


const server = app.listen(PORT, () => {
    console.log(server.address())
    console.log(`Server running on port ${server.address().port} `)
})


Testing:
create index.html
  run this file in vs code with "live server"

How to install live server?
  live server is extensions that should be installed first.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        async function getCustomer() {
            const res = await fetch('http://localhost:3000/api/customers/1')
            const result = await res.json()
            console.log(result)
        }
        getCustomer()
        async function postData(url, data) {
            try {
                const response = await fetch(url, {
                    method: 'POST', // Specify the method
                    headers: {
                        'Content-Type': 'application/json' // Inform the server about the data format
                    },
                    body: JSON.stringify(data) // Convert the JavaScript object to a JSON string
                });

                // Check if the request was successful (status in the 200-299 range)
                if (!response.ok) {
                    throw new Error(`HTTP error! status: ${response.status}`);
                }

                const responseData = await response.json(); // Parse the response body as JSON
                console.log('Success:', responseData);
                return responseData;

            } catch (error) {
                console.error('Error:', error); // Handle network errors or HTTP errors
            }
        }
        postData('http://localhost:3000/api/customers', { message: 'submitted' })
    </script>
</body>

</html>right click on this file and try to run , from there you can send request.


In the browser console.
content_script_bundle.js:1 Attempting initialization Mon Jul 15 2024 20:48:41 GMT+0530 (India Standard Time)
index.html:1 Access to fetch at 'http://localhost:3001/api/customers/1' from origin 'http://127.0.0.1:5500' has been blocked by CORS policy: The 'Access-Control-Allow-Origin' header has a value 'http://www.abce.com' that is not equal to the supplied origin. Have the server send the header with a valid value, or, if an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.Understand this error
index.html:13 
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										 Logger
.................................................................................................................................................................................................................................

In Express, we have many logger implementation ...

Morgan:
   HTTP request logger middleware for node.js

How to use Morgan

Steps:

npm install morgan

const express = require('express')
const app = express()
const fs = require('node:fs')
const path = require('node:path')
const morgan = require('morgan')

//console log information
// app.use(morgan('dev'))
const accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), { flags: 'a' })

app.use(morgan('combined', { stream: accessLogStream }))

app.get('/api/greet',(req,res)=>{
    res.send('Hello')
})

//start server
const server = app.listen(3000, () => {
    console.log(server.address())
    console.log(`Express is running @ ${server.address().port}`)
})
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
									express.static middleware
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

To serve static files such as HTML,CSS,js,images and fonts can be served using the built-in middleware called express.static

you dont need to install any dependency.

project structure 

express-app
   src
	public
		index.html
     app.js
const express = require('express')
const fs = require('node:fs')
const morgan = require('morgan')
const path = require('node:path')

const app = express()
//register to serve static pages : it looks index.html automatically.
app.use(express.static(path.join(__dirname, "public")))

const accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), { flags: 'a' })

app.use(morgan('combined', { stream: accessLogStream }))


const PORT = 3000

//expose apis 
app.get('/', (req, res) => {
    res.send('index.html')
})

app.get('/api/greet',(req,res)=>{
    res.send('Hello')
})


const server = app.listen(PORT, () => {
    console.log(server.address())
    console.log(`Server running on port ${server.address().port} `)
})

Error handling Middleware:

📌 It must have 4 parameters:

(err, req, res, next)

Express knows it's for handling errors because of the 4 parameters.

Rules:
1.It must have 4 parameters - err,req,res,next
2.It must be placed after all routers -
	General middlewares are placed at top of the  routers
	Exception Middlewares are place at bottom of the routers

const express = require('express')
const app = express()
const PORT = 3000

app.get('/api/user/:name', (req, res) => {
    const name = req.params.name
    if (name === 'admin') {
        res.send({ message: 'Welcome to Admin' })
    } else {
        throw new Error('User Is not valid')
    }
})
//Error Handling middleware

app.use((err, req, res, next) => {
    console.error(err.message);
    res.status(500).json({
        success: false,
        message: err.message
    });

})

//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is ready! at ${server.address().port}`)
})
//server properties

Handling 404 - Route not  found:
.......................................................

app.use((req, res) => {
  res.status(404).json({
    success: false,
    message: "Route not found",
  });
});
Put this before the global error middleware.

Full Code:
const express = require('express')
const app = express()

const PORT = 3000



app.get('/api/user/:name', (req, res) => {
    const name = req.params.name
    if (name === 'admin') {
        res.send({ message: 'Welcome to Admin' })
    } else {
        throw new Error('User Is not valid')
    }
})

//404 Route not found error handler
//this must be placed before Global error handler
//it wont take next arg, because it terminates the request and response
app.use((req, res) => {
    res.status(404).json({
        success: false,
        message: `The route ${req.originalUrl} not Found`,
    });
});
//Error Handling middleware
app.use((err, req, res, next) => {
    console.error(err.message);

    res.status(500).json({
        success: false,
        message: err.message
    });
})


//start server
const server = app.listen(PORT, () => {
    console.log(`Express server is ready! at ${server.address().port}`)
})
//server properties

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
			 Data base Integration
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
 
Now a days data storage is basically classified into two category.

1.SQL Based
2.No SQL Based
  1.Key-value pair
  2.Document based 
  3.column based
  4.graph based

Products 
1.SQL
  Oracle
  Microsoft SQL server
  MySQL
  DB2
  Postgress 
  MariaDB
 etc...

2.NoSQL
 1.Key-value pair
    Redis
 2.Document oriented
   Mongodb
 3.Column based
   Aws dynamo 
 4.Graph based
     neo4j

Note:
 From node.js(express) , we can connect and work with all databases, if there is drivers and apis for those databases

In order to connect with databases, application frameworks offers the frameworks which makes code more simple and abstract database operations

Mongodb frameworks: 

 ODM - Object Document Modeling framework 

Basic Requirements:

1.You need mongodb installed in your local machine

Note: Nobody is installing mongodb /any database locally.

Ways of using mongo(any database)

1.Via docker / Pod Man
2.You can use free cloud account for testing


Code:

.env
PORT=3000
DATABASE_URL=mongodb+srv://subugee:subugee222@cluster0.shfpbhv.mongodb.net/myDatabase?retryWrites=true&w=majority&appName=Cluster0

src/models/Post.model.js
const mongoose = require('mongoose')

//delclare schema and later create model
const postSchema = mongoose.Schema({
    title: String,
    content: String
})
//create model and export 
module.exports = mongoose.model("Post", postSchema)

src/services/post.service.js
const Post = require("../models/post.model")

class PostService {

    async save({ title, content }) {
        const newPost = new Post({ title, content })
        //call method of mongoose
        await newPost.save()
        return newPost
    }
    async findAll() {
        return Post.find({})
    }
    async findById(id) {
        const post = await Post.findOne({ _id: id })
        return post
    }
    //update
    async update(id, { title, content }) {
        const post = await Post.findOne({ _id: id })
        if (!post) {
            throw Error()
        }
        if (title) {
            //update title
            post.title = title
        }
        if (content) {
            post.content = content
        }
        //update operations
        await post.save()
        return post
    }
    async remove(id) {
        const post = await Post.findOne({ _id: id })
        if (post) {
            await Post.deleteOne({ _id: id })
        }
        else {
            throw Error("No record is found")
        }
    }
}

module.exports = new PostService()

src/router/post.router.js
const express = require('express')
const { findAll, save, findById, update, remove } = require('../services/post.service')

const postRouter = express.Router()


postRouter.get('/', async (req, res) => {
    try {
        const posts = await findAll()
        res.json(posts)
    }
    catch (err) {
        res.status(404).json({ err })
    }
})
postRouter.post('/', async (req, res) => {
    const post = req.body
    try {
        const savedPost = await save(post)
        res.status(201).json(savedPost)
    }
    catch (err) {
        res.status(400).json({ err })
    }
})
postRouter.get('/:id', async (req, res) => {
    const id = req.params.id
    try {
        const post = await findById(id)
        if (post) {
            res.json(post)
        } else {
            res.json({ message: 'No Post Available' })
        }
    }
    catch (err) {
        res.status(400).json({ err })

    }
})
postRouter.put('/:id', async (req, res) => {
    const id = req.params.id
    const postInput = req.body
    try {
        const post = await update(id, postInput)
        res.json(post)
    }
    catch (err) {
        res.status(404).json({ err })
    }
})
postRouter.delete('/:id', async (req, res) => {
    const id = req.params.id
    try {
        await remove(id)
        res.status(204).send()
    }
    catch (err) {
        res.status(400).json({ err: err.message })
    }
})



module.exports = postRouter

src/app.js
require('dotenv').config()
const express = require('express')
const bodyParser = require('body-parser')
const mongoose = require('mongoose')

const app = express()
const PORT = process.env.PORT || 3000
app.use(bodyParser.json())

async function connectDb() {
    try {
        await mongoose.connect(process.env.DATABASE_URL)
        console.log('Database has been connected')
        // const server = app.listen(PORT, () => {
        //     console.log(server.address())
        //     console.log(`Express is running @ ${server.address().port}`)
        // })
    }
    catch (err) {
        console.log(err)
    }
}
connectDb()

app.use('/api/posts', require('./routers/post.router'))


const server = app.listen(PORT, () => {
    console.log(server.address())
    console.log(`Express is running @ ${server.address().port}`)
})


&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
										 Data base Integration
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
 
Now a days data storage is basically classified into two category.

1.SQL Based
2.No SQL Based
  1.Key-value pair
  2.Document based 
  3.column based
  4.graph based

Products 
1.SQL
  Oracle
  Microsoft SQL server
  MySQL
  DB2
  Postgress 
  MariaDB
 etc...

2.NoSQL
 1.Key-value pair
    Redis
 2.Document oriented
   Mongodb
 3.Column based
   Aws dynamo 
 4.Graph based
     neo4j

Note:
 From node.js(express) , we can connect and work with all databases, if there is drivers and apis for those databases

In order to connect with databases, application frameworks offers the frameworks which makes code more simple and abstract database operations

Mongodb frameworks: 

 ODM - Object Document Modeling framework 

Basic Requirements:

1.You need mongodb installed in your local machine

Note: Nobody is installing mongodb /any database locally.

Ways of using mongo(any database)

1.Via docker / Pod Man
2.You can use free cloud account for testing


Code:

.env
PORT=3000
DATABASE_URL=mongodb+srv://subugee:subugee222@cluster0.shfpbhv.mongodb.net/myDatabase?retryWrites=true&w=majority&appName=Cluster0

src/models/Post.model.js
const mongoose = require('mongoose')

//delclare schema and later create model
const postSchema = mongoose.Schema({
    title: String,
    content: String
})
//create model and export 
module.exports = mongoose.model("Post", postSchema)

src/services/post.service.js
const Post = require("../models/post.model")

class PostService {

    async save({ title, content }) {
        const newPost = new Post({ title, content })
        //call method of mongoose
        await newPost.save()
        return newPost
    }
    async findAll() {
        return Post.find({})
    }
    async findById(id) {
        const post = await Post.findOne({ _id: id })
        return post
    }
    //update
    async update(id, { title, content }) {
        const post = await Post.findOne({ _id: id })
        if (!post) {
            throw Error()
        }
        if (title) {
            //update title
            post.title = title
        }
        if (content) {
            post.content = content
        }
        //update operations
        await post.save()
        return post
    }
    async remove(id) {
        const post = await Post.findOne({ _id: id })
        if (post) {
            await Post.deleteOne({ _id: id })
        }
        else {
            throw Error("No record is found")
        }
    }
}

module.exports = new PostService()

src/router/post.router.js
const express = require('express')
const { findAll, save, findById, update, remove } = require('../services/post.service')

const postRouter = express.Router()


postRouter.get('/', async (req, res) => {
    try {
        const posts = await findAll()
        res.json(posts)
    }
    catch (err) {
        res.status(404).json({ err })
    }
})
postRouter.post('/', async (req, res) => {
    const post = req.body
    try {
        const savedPost = await save(post)
        res.status(201).json(savedPost)
    }
    catch (err) {
        res.status(400).json({ err })
    }
})
postRouter.get('/:id', async (req, res) => {
    const id = req.params.id
    try {
        const post = await findById(id)
        if (post) {
            res.json(post)
        } else {
            res.json({ message: 'No Post Available' })
        }
    }
    catch (err) {
        res.status(400).json({ err })

    }
})
postRouter.put('/:id', async (req, res) => {
    const id = req.params.id
    const postInput = req.body
    try {
        const post = await update(id, postInput)
        res.json(post)
    }
    catch (err) {
        res.status(404).json({ err })
    }
})
postRouter.delete('/:id', async (req, res) => {
    const id = req.params.id
    try {
        await remove(id)
        res.status(204).send()
    }
    catch (err) {
        res.status(400).json({ err: err.message })
    }
})



module.exports = postRouter

src/app.js
require('dotenv').config()
const express = require('express')
const bodyParser = require('body-parser')
const mongoose = require('mongoose')

const app = express()
const PORT = process.env.PORT || 3000
app.use(bodyParser.json())

async function connectDb() {
    try {
        await mongoose.connect(process.env.DATABASE_URL)
        console.log('Database has been connected')
        // const server = app.listen(PORT, () => {
        //     console.log(server.address())
        //     console.log(`Express is running @ ${server.address().port}`)
        // })
    }
    catch (err) {
        console.log(err)
    }
}
connectDb()

app.use('/api/posts', require('./routers/post.router'))


const server = app.listen(PORT, () => {
    console.log(server.address())
    console.log(`Express is running @ ${server.address().port}`)
})
											 Express ,Prisma-7 ,SQL - Typescript version
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
Set up Prisma framework:
............................................

Relational databases

Prerequisites
1.an existing Node.js project with a package.json

2.Node.js installed on your machine

3.A database server running and a database with at least one table
  (we are going sqlite db)

create project with all dependency:

 Note: we are going to use in-memory database called SQLite.

1. Create a new project
Create a project directory and navigate into it:

mkdir expressPrisma
cd expressPrisma

Initialize a TypeScript project:
npm init -y
npm install typescript tsx @types/node --save-dev
npx tsc --init

2. Install required dependencies
Install the packages needed for this quickstart:

npm install prisma @types/node @types/better-sqlite3 -D
npm install @prisma/client @prisma/adapter-better-sqlite3 dotenv

Here's what each package does:

prisma - The Prisma CLI for running commands like prisma init, prisma migrate, and prisma generate
@prisma/client - The Prisma Client library for querying your database
@prisma/adapter-better-sqlite3 - The SQLite driver adapter that connects Prisma Client to your database
@types/better-sqlite3 - TypeScript type definitions for better-sqlite3
dotenv - Loads environment variables from your .env file

3. Configure ESM support
Update tsconfig.json for ESM compatibility:

tsconfig.json
{
  "compilerOptions": {
    "module": "ESNext",
    "moduleResolution": "bundler",
    "target": "ES2023",
    "strict": true,
    "esModuleInterop": true,
    "ignoreDeprecations": "6.0"
  }
}
Update package.json to enable ESM:

{
  "type": "module"
}
4. Initialize Prisma ORM
You can now invoke the Prisma CLI by prefixing it with npx:

Next, set up your Prisma ORM project by creating your Prisma Schema file with the following command:

>npx prisma init --datasource-provider sqlite --output ../generated/prisma

This command does a few things:

Creates a prisma/ directory with a schema.prisma file containing your database connection and schema models
Creates a .env file in the root directory for environment variables
Creates a prisma.config.ts file for Prisma configuration


Initialized Prisma in your project

  prisma/
    schema.prisma
  prisma.config.ts
  .env
  .gitignore

Next, set up your database:
  1. Configure your DATABASE_URL in prisma.config.ts
  2. Run prisma db pull to introspect your database.

Then, define your models in prisma/schema.prisma and run prisma migrate dev to apply your schema.

Learn more: https://pris.ly/getting-started

The generated prisma.config.ts file looks like this:

import "dotenv/config";
import { defineConfig, env } from "prisma/config";

export default defineConfig({
  schema: "prisma/schema.prisma",
  migrations: {
    path: "prisma/migrations",
  },
  datasource: {
    url: env("DATABASE_URL"),
  },
});

A .env file should be created with the following value:

.env

DATABASE_URL="file:./dev.db"

5. Define your data model
Open prisma/schema.prisma and add the following models:

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

datasource db {
  provider = "sqlite"
}
model User { 
  id    Int     @id @default(autoincrement()) 
  email String  @unique
  name  String?
} 

6. Create and apply your first migration
Create your first migration to set up the database tables:

>npx prisma migrate dev --name init
Loaded Prisma config from prisma.config.ts.

Prisma schema loaded from prisma\schema.prisma.
Datasource "db": SQLite database "dev.db" at "file:./dev.db"

SQLite database dev.db created at file:./dev.db

Applying migration `20260223063102_init`

The following migration(s) have been created and applied from new schema changes:

prisma\migrations/
  └─ 20260223063102_init/
    └─ migration.sql

Your database is now in sync with your schema.

This command creates the database tables based on your schema.

Now run the following command to generate the Prisma Client:

npx prisma generate

>npx prisma generate
Loaded Prisma config from prisma.config.ts.

Prisma schema loaded from prisma\schema.prisma.

✔ Generated Prisma Client (7.4.1) to .\generated\prisma in 32ms

7. Instantiate Prisma Client
Now that you have all the dependencies installed, you can instantiate Prisma Client. You need to pass an instance of the Prisma ORM driver adapter adapter to the PrismaClient constructor:

lib/prisma.ts
import "dotenv/config";
import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
import { PrismaClient } from "../generated/prisma/client";

const connectionString = `${process.env.DATABASE_URL}`;

const adapter = new PrismaBetterSqlite3({ url: connectionString });
const prisma = new PrismaClient({ adapter });

export { prisma };

8.Testing:
import { prisma } from "../lib/prisma";


async function main() {
    try {
        //primsa.
        const users = await prisma.user.findMany();
        console.log(users)
    }
    catch (err) {
        console.log(err)
    }
}
main()
 >npx tsx src/app.ts
[]

if you get empty array, your prisma setup is working fine.

Express with Typescript Setup:
{
  "name": "expressprisma",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "dev": "nodemon --watch 'src/**/*.ts' --exec \"npx tsx\" src/app.ts"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "module",
  "devDependencies": {
    "@types/better-sqlite3": "^7.6.13",
    "@types/body-parser": "^1.19.6",
    "@types/express": "^5.0.6",
    "@types/node": "^25.3.0",
    "nodemon": "^3.1.14",
    "prisma": "^7.4.1",
    "ts-node": "^10.9.2",
    "tsx": "^4.21.0",
    "typescript": "^5.9.3"
  },
  "dependencies": {
    "@prisma/adapter-better-sqlite3": "^7.4.1",
    "@prisma/client": "^7.4.1",
    "body-parser": "^2.2.2",
    "dotenv": "^17.3.1",
    "express": "^5.2.1"
  }
}

src/app.ts

import express from 'express'
import { userRouter } from './routers/user.router.ts'

const app = express()

app.use(express.json())

app.use('/api/users', userRouter)

app.get('/', (req, res) => {
    res.json({ message: 'Home' })
})

app.listen(3000, () => {
    console.log("Server is Running")
})
routers/user.router.js
import express from 'express'
import { prisma } from '../../lib/prisma.ts'

const userRouter = express.Router()

userRouter.get('/', async (req, res) => {
    try {
        const users = await prisma.user.findMany();

        res.json(users)
    }
    catch (err) {
        res.status(500).json({ err: err })
    }
})

userRouter.post('/', async (req, res) => {
    try {
        const newUser = req.body
        console.log('newUser', newUser)
        if (newUser) {
            const user = await prisma.user.create({
                data: {
                    email: newUser.email,
                    name: newUser.name
                }
            })
            res.status(201).location("/api/users/save").json(user)
        }
    }
    catch (err) {
        res.status(400).json({ message: err })

    }
})

userRouter.get('/:id', async (req, res) => {
    const id = Number(req.params.id)
    try {
        const user = await prisma.user.findUnique({
            where: {
                //id: id
                id
            },
        })
        if (user == null) {
            res.status(401).json({ message: `User not found for ID ${id}` })
        }
        res.status(200).json(user)
    }
    catch (err) {
        res.status(400).json({ message: err })
    }
})
userRouter.put('/:id', async (req, res) => {
    try {
        const id = Number(req.params.id)
        const user = req.body
        //update 
        const updateUser = await prisma.user.update({
            where: {
                id: id
            },
            data: {
                name: user.name,
                email: user.email
            }
        })
        if (updateUser) {
            res.status(200).json(updateUser)
        } else {
            res.status(401).json({ message: `Update failed for ${id}` })
        }
    }
    catch (err) {
        res.status(400).json({ message: err })
    }
})
userRouter.delete('/:id', async (req, res) => {
    const id = Number(req.params.id)
    try {
        const user = await prisma.user.findUnique({
            where: {
                //id: id
                id
            },
        })
        if (user == null) {
            res.status(401).json({ message: `User not found for ID ${id}` })
        } else {
            await prisma.user.delete({
                where: {
                    id
                },
            })
            res.status(204).end()
        }


    }
    catch (err) {
        res.status(400).json({ message: err.message })
    }
})
export { userRouter }

lib/prisma.ts
import "dotenv/config";
import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
import { PrismaClient } from "../generated/prisma/client";

const connectionString = `${process.env.DATABASE_URL}`;

const adapter = new PrismaBetterSqlite3({ url: connectionString });
const prisma = new PrismaClient({ adapter });

export { prisma };

How to run

>npx tsx src/app.ts
or
>npm run dev

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
				&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
				 Authentication and Authorization 

JWT based authentication:
1.user registration
2.login
3.token creation
4.token validation
5.Protected route

Project setup:
>mkdir express-jwt-auth
>npm init --yes
>npm i express
>npm i body-parser
>npm install nodemon --save-dev
>npm i jsonwebtoken
>npm i bcryptjs


Step 1: registration:
const express = require('express')
const bodyParser = require('body-parser')
const jwt = require('jsonwebtoken')
const bcrypt = require('bcryptjs') //password hashing

const app = express()
const PORT = 3000
app.use(bodyParser.json())

//Registration; how to initalize the users without actual database.
const users = [];

//user registration route
app.post('/register', async (req, res) => {
    const { username, password } = req.body
    //hash the password before storing into db
    const hashedPassword = await bcrypt.hash(password, 10)
    users.push({ username, password: hashedPassword })
    console.log(users)
    res.status(201).json({ message: 'User Registered!' })
})

app.listen(PORT, (req, res) => {
    console.log(`Express Server is ready`)
})

Step 2:

User login and Token Generation:

const express = require('express')
const bodyParser = require('body-parser')
const jwt = require('jsonwebtoken')
const bcrypt = require('bcryptjs') //password hashing

const app = express()
const PORT = 3000
app.use(bodyParser.json())

//Registration; how to initalize the users without actual database.
const users = [];

//user registration route
app.post('/register', async (req, res) => {
    const { username, password } = req.body
    //hash the password before storing into db
    const hashedPassword = await bcrypt.hash(password, 10)
    users.push({ username, password: hashedPassword })
    console.log(users)
    res.status(201).json({ message: 'User Registered!' })
})

app.post('/login', async (req, res) => {
    const { username, password } = req.body
    //find user is available in the db or not
    const user = users.find(u => u.username === username)
    if (!user || !(await bcrypt.compare(password, user.password))) {
        return res.status(401).json({ message: 'Invalid Credentials' })
    }
    //if valid user, generate token and send that token to user
    const privateKey = 'your-secret-key'
    const token = jwt.sign({ username: user.username }, privateKey, { 'expiresIn': '1hr' })
    res.json({ token })
})

app.listen(PORT, (req, res) => {
    console.log(`Express Server is ready`)
})

Step 3:
 I am going to create a particular route, i want to protect , that means without login, i should not access that route.

const express = require('express')
const bodyParser = require('body-parser')
const jwt = require('jsonwebtoken')
const bcrypt = require('bcryptjs') //password hashing

const app = express()
const PORT = 3000
app.use(bodyParser.json())

const privateKey = 'your-secret-key'

//Registration; how to initalize the users without actual database.
const users = [];

//user registration route
app.post('/register', async (req, res) => {
    const { username, password } = req.body
    //hash the password before storing into db
    const hashedPassword = await bcrypt.hash(password, 10)
    users.push({ username, password: hashedPassword })
    console.log(users)
    res.status(201).json({ message: 'User Registered!' })
})

app.post('/login', async (req, res) => {
    const { username, password } = req.body
    //find user is available in the db or not
    const user = users.find(u => u.username === username)
    if (!user || !(await bcrypt.compare(password, user.password))) {
        return res.status(401).json({ message: 'Invalid Credentials' })
    }
    //if valid user, generate token and send that token to user

    const token = jwt.sign({ username: user.username }, privateKey, { 'expiresIn': '1hr' })
    res.json({ token })
})

//middleware to intercept before access dashboard
function authicateToken(req, res, next) {
    const authHeader = req.headers['authorization']
    const token = authHeader && authHeader.split(' ')[1]
    if (!token) {
        return res.status(401).json({ message: 'Access Denied. No Token Provided' })
    }
    jwt.verify(token, privateKey, (err, user) => {
        if (err) {
            return res.status(403).json({ message: 'Invalid or Expired Token' })
        }
        req.user = user
        next()
    })
}


//route to be protected
app.get('/dashboard', authicateToken, (req, res) => {
    res.json({ message: `Welcome ${req.user.username}` })
})
app.listen(PORT, (req, res) => {
    console.log(`Express Server is ready`)
})

Testing:

Register:

POST  localhost:3000/register

Login

POST /localhost:3000/login 
{
    "username":"subu",
    "password": "subu"
}
response would be:
{
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InN1YnUiLCJpYXQiOjE3NjIxNTUzNDQsImV4cCI6MTc2MjE1ODk0NH0.1Or5uJRJrzZmHUW1MfOrCWQ2IKM8th3GEX9_w8clP7U"
}

GET localhost:3000/dashboard

Go to Authroization section in POST Man,Find Authorization , BearToken, past the token generated in the login step
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InN1YnUiLCJpYXQiOjE3NjIxNTUzNDQsImV4cCI6MTc2MjE1ODk0NH0.1Or5uJRJrzZmHUW1MfOrCWQ2IKM8th3GEX9_w8clP7U"

Click send button

Response:
{
    "message": "Welcome subu"
}

if token not supplied
{
    "message": "Access Denied. No Token Provided"
}
if wrong token
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InN1YnUiLCJpYXQiOjE3NjIxNTUzNDQsImV4cCI6MTc2MjE1ODk0NH0.1Or5uJRJrzZmHUW1MfOrCWQ2IKM8th3GEX9_w8cflP7U

Response wourld be
{
    "message": "Invalid or Expired Token"
}

Task : 
  You have to register users into db - Prisma -SQLite