Node Js

etape node js mangodb api

1. faire un npm init

2. installer les dependences
3. mettre un script dans le package .json ex: "server": "nodemon ./backend/server.js"
4. creer un dossier backend , creer un fichier server.js.
5. declarer ds server.js express via const express = require("express");
6. appeller ds server.js express via const app = express();
7. on va lancer le serveur sur port declaré

const port = 5000 // declaration du port

commande qui renvoie un console .log si le serveur est demarré

app.listen(port,()=> console.log("Le serveur a démarré " + port))

exemple de route avec la méthode get renvoyant un json.

app.get("/post",(req,res)=> {
res.json ({message: "Voici les données"});
})

=>on peut tester la route dans postman

8. dans le dossier backend , on va creer un dossier routes , dans celui-ci on creera un fichier post.routes.js (pour les routes avec l'url /post.

8.1 declaration de express et de router de express.

const express = require ('express');

const router = express.Router();

8.2 on va mettre ici (post.routes.js)

route méthode get

router.get("/",(req,res)=> {
res.json ({message: "Voici les données"});
})

route méthode post

router.post("/",(req,res)=> {
res.json ({message: req.body.message}); => req.body pour recuperer le body
})

route méthode put

router.put('/:id',(req,res)=> {
res.json ({messageId: req.params.id});
})

route méthode delete

router.delete('/:id',(req,res)=> {
res.json ({message: "post supprimmé id : " + req.params.id });
})

route méthode patch

 router.patch('/like-post/:id',(req,res)=> {
res.json ({message: "post liké : id : " + req.params.id });
})
router.patch('/dislike-post/:id',(req,res)=> {
res.json ({message: "post disliké : id : " + req.params.id });
})

8.3 exporter router

module.exports = router;

9 - dans server.js

app.use("/post",require("./routes/post.routes")); // appel de la route

// ajouter les middleware pour la comprehension des requêtes

app.use(express.json());
app.use (express.urlencoded({extended:false}));

Mongodb
après avoir creer son cluster en ligne

dans le dossier backend on va creer un dossier config (on y mettra nos config) pour la connexion à bdd on creer un fichier db.js

on y importe mongoose

const mongoose = require ('mongoose')

try catch de connection BDD

async function connectDB() {

try{
mongoose.set('strictQuery',false);
mongoose.connect(process.env.MONGO_URI)
console.log('mongo connecté');
} catch (error){
console.log(error);
process.exit();
}
};

dans le server.js importer fichier config db

const connectDB = require("./config/db");

//importer dotenv

const dotenv = require("dotenv").config();

//connexion à la db

connectDB();

creation d'un .env on y mettra Mongo_URI (lien de connexion mongodb fourni par le site mongo atlas)

attention => le mot de passe ne doit pas contenir de caractère speciaux

creation d'un .gitignore => node_modules .env

Les Modeles

on cree un fichier post.model.js (dans le cadre de l'exemple) dans un dossier models

Dans ce model , nous creons un schema

ex:

const mongoose = require ("mongoose"); // import de mangoose

const postSchema = mongoose.Schema(

{
message :{
type: String,
require: true,
},
author :{
type:String,
require:true,
},
likers:{
type:String,
require:true,
},
timestamps:true,
}
);

et on l'exporte => module.exports = mongoose.model("post",postSchema);

Les Controllers

on cree un fichier post.controller.js (dans le cadre de l'exemple) dans un dossier controller

on importer notre model

//simple verif

module.exports.setPosts = async (req,res) => {

res.json ({message: "Ca fonctionne"});
}

--

pour la méthode post

//une verif avec une condition

module.exports.setPosts = async (req,res) => {

if (!req.body.message){
res.status(400).json({message:"Merci d'ajouter un message "});
}

const post = await PostModel.create(

{
message:req.body.message,
author :req.body.author,
}
);
res.status(200).json(post);
};

pour la méthode get

module.exports.getPosts = async(req,res) => {

const posts = await PostModel.find();
res.status(200).json(posts);
}
pour la méthode put

module.exports.editPost = async (req, res) => {

const post = await PostModel.findById(req.params.id);

if (!post) {
res.status(400).json({ message: "Ce post n'existe pas" });
}

const updatePost = await PostModel.findByIdAndUpdate(post, req.body, {

new: true,
});

res.status(200).json(updatePost);
};

pour la méthode delete

module.exports.deletePost = async (req, res) => {

const post = await PostModel.findById(req.params.id);

if (!post) {
res.status(400).json({ message: "Ce post n'existe pas" });
}

await post.deleteOne({id: req.params.id})

res.status(200).json("Message supprimé " + req.params.id);

};

Fonctionnnement

modèle qui travaille avec notre mongoose lié à la bdd au niveau des route , on va importer notre controller (routes/post.routes.js)

const { setPosts } = require('../controllers/post.controller ');

et modifier notre route ecrite en dur => celle ci fera appel a notre controller (qui lui connait notre model)

methode post => router.post("/",setPosts);

methode get => router.get("/",getPosts);
methode put => route.put("/:id",putPosts);
methode delete => route.delete ('/:id',deletePost);