Une API CRUD gère les données via quatre opérations de base de données de base: créer, lire, mettre à jour et supprimer. Vous pouvez créer une API CRUD simple avec juste Express et une base de données PostgreSQL.
Commencez par créer un serveur Express auquel vous connecterez PostgreSQL. Ensuite, créez les fonctions CRUD et connectez-les aux points de terminaison de l'API. Une fois cela fait, vous pourrez connecter Node à PostgreSQL et effectuer des requêtes de base de données sur chaque route.
Prérequis pour la construction de l'API
Pour suivre ce tutoriel, vous devez :
- Installez Node sur votre ordinateur.
- Installez le serveur PostgreSQL sur votre machine.
- Avoir une connaissance de base de Express.js.
Créer un serveur express
À créer un serveur Express, commencez par créer un nouveau répertoire et saisissez-le :
notes mkdir
CD Remarques
Ensuite, initialisez npm :
npm init -y
Cette commande générera un package.json fichier dans le dossier des notes. Enfin, installez Express.
npm installer Express
Créez un nouveau fichier appelé index.js et ajoutez le code suivant.
constante exprimer = exiger("Express");
constante app = express();application.utilisation(Express.urlencodé({
étendu: vrai
}));
application.utilisation(Express.json())
app.listen (3000, () => console.log("Ecoute sur le port 3000"));
Cela créera un nouveau serveur écoutant sur le port 3000.
Créer une base de données PostgreSQL
Exécutez la commande suivante dans l'invite de commande psql pour créer une base de données PostgreSQL appelée noteb.
postgres=# CREATE DATABASE notéb ;
Exécutez cette commande pour lister toutes les bases de données Postgres et vérifiez que vous avez créé la base de données notéeb :
postgres=# \lConnectez-vous à la base de données
Tout d'abord, connectez votre application Node au serveur PostgreSQL. Vous pouvez utiliser le module node-Postgres.
Exécutez ce qui suit pour l'installer via npm :
npm installer page
Comme bonne pratique, connectez-vous à la base de données dans un fichier séparé.
Créez un nouveau fichier appelé db.js et ajoutez ce qui suit.
constante {Client} = exiger("page");
constante { utilisateur, hôte, base de données, mot de passe, port } = exiger(""./dbConfig");constante client = Nouveau Client({
utilisateur,
héberger,
base de données,
le mot de passe,
Port,
});
client.relier();
module.exportations = client ;
Ici, vous exportez la chaîne de connexion que vous utiliserez pour communiquer avec la base de données. Notez que vous lisez les paramètres de connexion à la base de données à partir d'un fichier de configuration appelé dbConfig.js. Par conséquent, créez dbConfig.js et ajoutez-y les données suivantes.
module.exportations = {
utilisateur: "{dbUser}",
héberger: "{dbHost}",
base de données: "notéb",
le mot de passe: "{dbPassword}",
port: 5432,
};
N'oubliez pas de remplacer les détails de la base de données par vos propres valeurs locales.
Créer une table PostgreSQL
Dans l'invite de commande psql, créez une table appelée notes. Pour commencer, connectez-vous à la base de données notéeb à l'aide de la commande \c.
postgres=# \c notéb
Ensuite, créez une table dans la base de données connectée à l'aide de la commande CREATE TABLE.
notéb=# CRÉER des notes de TABLE (
ID SÉRIE CLÉ PRIMAIRE,
notez VARCHAR(255)
);
Ce tableau est assez simple. Il n'a qu'un ID qui est une clé primaire générée automatiquement et un champ de texte appelé note.
Créer une note
Au lieu d'effectuer les opérations CRUD dans les routes, créez des fonctions qui interagiront avec la base de données dans un fichier séparé.
Créez un fichier d'aide appelé helper.js et importez l'objet de connexion à partir de db.js.
constante client = exiger(""./db");
Utilisez le code suivant pour créer la fonction createNote().
constante createNote = (req, res) => {
essayer {
constante { note } = req.body ;si (!note) {
jeterErreur("Envoyer une note dans corps de la requête" );
}
client.requête(
"INSÉRERDANS remarques (note) VALEURS ($1)",
[Remarque],
(erreur, données) => {
res.statut(201).json({
Erreur: nul,
message: "Nouvelle note créée",
});
}
);
} attraper (Erreur) {
res.statut(500).json({
Erreur: Erreur.message,
message: "Échec de créerNouveau Remarque",
});
}
};
Cette fonction vérifie d'abord si le corps de la requête inclut une note. Si la note est absente, il génère une erreur.
Pour créer une note, la fonction utilise la clause INSERT. Il renvoie un objet JSON contenant un message d'erreur nul et un message de réussite en cas de succès.
Obtenir toutes les notes
Pour obtenir toutes les notes de la table, utilisez la clause SELECT *.
constante getNotes = (req, res) => {
essayer {
client.query("SÉLECTIONNER * À PARTIR des notes", (erreur, données) => {
si (se tromper) jeter se tromper;
res.statut(200).json({
se tromper: nul,
Remarques: Les données.Lignes,
});
});
} attraper (Erreur) {
res.statut(500).json({
se tromper: Erreur.message,
Remarques: nul,
});
}
};
getNotes() envoie le tableau de notes dans l'objet de réponse si la requête aboutit.
Obtenir une note par ID
L'API aura également un point de terminaison qui renvoie une note par ID. Dans helper.js, ajoutez une fonction getNoteById().
constante getNoteById = (req, res) => {
essayer {
constante { id } = req.params ;
client.query("SELECT * FROM notes WHERE id=$1", [id], (err, données) => {
si (se tromper) jeter se tromper;
res.statut(200).json({
se tromper: nul,
Remarque: Les données.Lignes[0],
});
});
} attraper (Erreur) {
res.statut(500).json({
se tromper: se tromper.message,
Remarque: nul,
});
}
};
Cette fonction renverra un objet JSON contenant la note et un objet d'erreur.
Note de mise à jour par ID
Pour mettre à jour une note, vous avez besoin d'une note et de l'ID de cette note. Vous obtiendrez la note du corps de la requête et l'ID de l'URL.
La fonction updateNoteById() utilise la clause UPDATE pour mettre à jour une note existante avec une nouvelle note.
constante updateNoteById = (req, res) => {
essayer {
constante { id } = req.params ;
constante { note } = req.body ;
client.requête(
"METTRE À JOUR Remarques POSITIONNER remarque = $1OÙidentifiant = $2",
[note, identifiant],
(erreur, données) => {
si (se tromper) jeter se tromper;
res.statut(201).json({
se tromper: nul,
message: "Remarque mise à jour",
});
}
);
} attraper (Erreur) {
res.statut(500).json({
se tromper: Erreur.message,
message: "Échec de la mise à jour de la note",
});
}
};
Cette fonction renvoie un message de réussite si la table est mise à jour et un message d'erreur si ce n'est pas le cas.
Supprimer la note par ID
Pour supprimer une note par ID du tableau, utilisez le code suivant.
constante deleteNote = (req, res) => {
essayer {
constante { id } = req.params ;
client.query("DELETE FROM notes WHERE id=$1", [id], (err, données) => {
si (se tromper) jeter se tromper;
res.statut(200).json({
Erreur: nul,
message: "Remarque supprimée",
});
});
} attraper (Erreur) {
res.statut(500).json({
Erreur: Erreur.message,
message: "Échec de la suppression de la note",
});
}
};
Maintenant que vous avez créé toutes les fonctions CRUD, exportez-les.
Dans helper.js, ajoutez ce qui suit.
module.exportations = { createNote, getNotes, getNoteById, updateNoteById, deleteNote } ;
Vous les importerez dans index.js lors de la création des points de terminaison de l'API.
Créer des itinéraires d'API
La dernière étape consiste à créer des points de terminaison d'API dans index.js pour chacune des opérations CRUD.
Commencez par importer le fichier helper.js.
constante db = exiger("./assistant")
Ensuite, créez chaque point de terminaison.
app.get("/notes", db.getNotes);
app.get("/note/:id", db.getNoteById);
app.put("/note/:id", db.updateNoteById);
app.post("/note", db.createNote);
app.delete("/note/:id", db.deleteNote);
Une API REST pour mettre à jour votre base de données
Une fois que vous avez terminé, vous pouvez vérifier que votre API fonctionne en utilisant un client REST comme Postman, ou en écrivant des tests unitaires. Vous devriez être en mesure de vous assurer que les cinq points de terminaison fonctionnent tous comme prévu.
Vous pouvez également inspecter et gérer les données que vous avez ajoutées à la base de données à l'aide de l'outil pgAdmin. Il s'agit d'une application graphique qui facilite l'administration de la base de données et l'interaction avec les serveurs PostgreSQL.