Construire une API simple avec Deno

Deno est un runtime JavaScript construit sur V8, le même moteur JavaScript qui alimente Google Chrome. Le créateur original de Node.js a créé Deno pour résoudre certaines des lacunes et des problèmes de sécurité de Node.js.

Bien qu'il soit relativement nouveau, Deno a gagné en popularité en tant qu'environnement d'exécution JavaScript sécurisé et moderne. L'accent mis sur la sécurité, la prise en charge des fonctionnalités de langage moderne et les outils conviviaux pour les développeurs en font un choix attrayant. Vous pouvez l'utiliser pour créer des applications côté serveur, des outils de ligne de commande et d'autres projets JavaScript/TypeScript, comme une simple API.

Installation de Deno

Avant de pouvoir utiliser Deno, vous devez le télécharger et l'installer. L'installation de Deno varie en fonction de votre système d'exploitation.

Sur macOS et Linux, vous pouvez installer Deno en exécutant cette commande :

curl -fsSL https://deno.land/x/install/install.sh | sh

Sous Windows, vous pouvez installer Deno avec Powershell, en utilisant cette commande :

irm https://deno.land/install.ps1 | iex

Vous pouvez confirmer que votre installation a réussi en exécutant la commande ci-dessous :

deno --version

La commande ci-dessus doit imprimer la version Deno sur la console.

Si vous utilisez VS Code comme IDE, vous pouvez télécharger Extension VS Code de Deno pour ajouter IntelliSense, améliorant votre productivité et votre expérience de développement lorsque vous travaillez avec des projets Deno.

Après avoir installé l'extension avec succès, créez un .vscode dossier dans le répertoire racine de votre projet et créez un paramètres.json fichier dedans.

Ensuite, ajoutez le bloc de code ci-dessous au paramètres.json fichier pour activer IntelliSense :

{
"deno.enable": true,
"deno.unstable": true,
}

Connexion à une base de données

Pour ce didacticiel, vous utiliserez MongoDB comme base de données pour conserver les données de votre API.

Pour connecter votre application Deno à une base de données MongoDB, créez un db.js fichier dans le répertoire racine de votre projet et ajoutez-y le bloc de code ci-dessous :

// db.js
import { MongoClient } from"https://deno.land/x/[email protected]/mod.ts";
const client = new MongoClient();
try {
await client.connect("mongodb://localhost: 27017/todo");
console.log("Connected to database");
} catch (err) {
console.log("Error connecting to database", err);
}
const db = client.database("todo");
exportdefault db;

Contrairement à Node.js, qui dépend de gestionnaires de paquets comme le Node Package Manager (npm) ou le fil, Deno dispose d'un système de gestion de packages intégré pour importer et gérer les dépendances directement à partir des URL.

Par exemple, le bloc de code ci-dessus importe MongoClient à partir de l'url https://deno.land/x/[email protected]/mod.ts, ce qui conduit au package.

Ensuite, en utilisant le pilote Deno MongoDB importé (MongoClient), Deno établit une connexion entre votre application et une base de données MongoDB locale.

Dans les scénarios réels, il est plus sûr de stocker vos informations d'identification de base de données dans un .env fichier au lieu de les stocker en texte brut, comme fait ci-dessus.

Création d'un modèle de base de données

Alors qu'il est possible de interagir avec une base de données MongoDB sans modèle de base de données, cela peut conduire à un code non structuré et moins maintenable.

Pour éviter cela, créez un TodoModel.ts dans le répertoire racine de votre projet et structurez vos données en ajoutant le bloc de code ci-dessous au fichier :

import db from"./db.ts";
interface Todo {
 title: string;
 description: string;
 completed?: boolean;
}
const Todo = db.collection("todos");
exportdefault Todo;

Le bloc de code ci-dessus définit une interface Faire qui représente la structure d'un seul élément de tâche. Ensuite, à l'aide de l'interface Todo, il crée une collection Todo en appelant la méthode de collection exposée par votre instance MongoDB précédemment créée.

Créer un serveur avec Oak

Oak est un middleware pour le serveur HTTP natif de Deno. Il a été inspiré par Koa, qui est un alternative à Express.js.

Pour créer un serveur avec Oak, créez un main.ts fichier dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous à votre fichier.

// main.ts
import { Application } from"https://deno.land/x/oak/mod.ts";
import router from"./router.ts";
const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());
await app.listen({ port: 8000 });
console.log("Server running on port 8000");

Le bloc de code ci-dessus importe Application à partir de l'URL Oak et crée une instance d'application (application) qui écoute le trafic entrant sur le port 8000.

Le app.use (routeur.routes()) line enregistre les routes du routeur en tant que middleware dans l'application Oak. Cela signifie que l'application fera correspondre les itinéraires enregistrés avec les demandes entrantes, et les gestionnaires correspondants s'exécuteront s'il existe une correspondance.

Le app.use (routeur.allowedMethods()) La ligne gère les méthodes HTTP qui ne sont pas explicitement définies dans le routeur. Par exemple, s'il reçoit une demande avec une méthode non prise en charge, par exemple, une demande PUT non enregistrée, le méthodesautorisées() middleware enverra automatiquement une réponse appropriée (par exemple, Méthode 405 non autorisée).

Implémentation de la fonctionnalité CRUD

Ce didacticiel présentera une simple API todo avec la fonctionnalité CRUD.

Créer un routeur.ts dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous à votre fichier :

import { Router } from"https://deno.land/x/oak/mod.ts";
import Todo from"./todoModel.ts";
import { ObjectId } from"https://deno.land/x/[email protected]/mod.ts";
const router = new Router(); // Create Router

Le bloc de code ci-dessus importe et crée une instance du routeur Oak. À l'aide de cette instance, vous pouvez créer des gestionnaires de route pour diverses méthodes HTTP en appelant les noms de méthode respectifs (obtenir, poste, mettre, supprimer).

Par exemple, le bloc de code ci-dessous est un exemple de la façon dont vous pouvez créer un gestionnaire de route GET qui renvoie tous les documents de votre collection Todo.

router
 .get("/api/todos", (ctx: RouterContextapi/todos">) => {
 ctx.response.body = Todo.find();
 })

Pour envoyer un objet de réponse à l'aide de Deno, vous devez attribuer le réponse.corps objet sur le RouterContex à l'objet de réponse. Il en va de même pour les codes d'état.

Pour ajouter d'autres gestionnaires de routage, vous pouvez les enchaîner au gestionnaire de routage précédent.

Ainsi:

.get("/api/todo/:id", async (ctx: RouterContext<"/api/todo/:id">) => {
try {
const todo = await Todo.findOne({ _id: new ObjectId(ctx.params.id) });
if (!todo) {
 ctx.response.status = 404;
 ctx.response.body = {
 msg: "Todo not found",
 };
return;
 }
 ctx.response.body = todo;
 } catch (error) {
 ctx.response.status = 500;
 ctx.response.body = {
 msg: "Error getting todo",
 error,
 };
 }
 })

Le bloc de code ci-dessus définit un gestionnaire de route GET qui renvoie un seul élément Todo correspondant à l'ID dans les paramètres d'URL.

Ensuite, définissez un gestionnaire de route CREATE qui ajoute de nouveaux documents à votre collection :

.post("/api/todo/new", async (ctx: RouterContext<"/api/todo/new">) => {
const body = ctx.request.body();
const todo = await body.value;
if (!todo) {
 ctx.response.status = 400;
 ctx.response.body = { msg: "Invalid data. Please provide a valid todo." };
return;
 }
const { title, description } = todo;
if (!(title && description)) {
 ctx.response.status = 400;
 ctx.response.body = {
 msg: "Title or description missing. Please provide a valid todo.",
 };
return;
 }
try {
await Todo.insertOne({
 title: todo.title,
 description: todo.description,
 completed: false,
 });
 ctx.response.status = 201;
 ctx.response.body = {
 msg: "Todo added successfully",
 };
 } catch (error) {
 ctx.response.status = 500;
 ctx.response.body = {
 msg: "Error adding todo",
 error,
 };
 }
 })

Ensuite, ajoutez un gestionnaire de route PUT qui met à jour une tâche en fonction de la identifiant paramètre, avec les données envoyées dans le corps de la requête.

.put("/api/todo/:id", async (ctx: RouterContext<"/api/todo/:id">) => {
try {
const body = ctx.request.body();
const todo = await body.value;
await Todo.updateOne(
 { _id: new ObjectId(ctx.params.id) },
 { $set: { title: todo.title, description: todo.description } }
 );
 ctx.response.status = 200;
 ctx.response.body = {
 msg: "Todo updated successfully",
 };
 } catch (error) {
console.log(error);
 ctx.response.status = 500;
 ctx.response.body = {
 msg: "Error updating todo",
 error: error.message,
 };
 }
 })

Enfin, créez un gestionnaire de route DELETE qui supprime un Todo de votre collection MongoDB :

.delete("/api/todo/:id", async (ctx: RouterContext<"/api/todo/:id">) => {
await Todo.deleteOne({ _id: new ObjectId(ctx.params.id) });
 ctx.response.status = 200;
 ctx.response.body = {
 msg: "Todo deleted successfully",
 };
 });

Vous pouvez démarrer votre application Deno avec cette commande :

deno run --allow-net --allow-read --allow-env --watch main.ts

Par défaut, un script Deno ne peut accéder à rien en dehors de sa portée, comme le réseau ou le système de fichiers. Donc, pour démarrer votre application, vous devez inclure divers indicateurs pour accorder à Deno les autorisations requises.

--allow-net permet à Deno de faire des requêtes réseau. --allow-read permet à Deno d'accéder au système de fichiers et de lire des fichiers. --allow-env permet à Deno d'accéder aux variables environnementales. Le --montre flag démarre votre application Deno en mode montre.

Migration de Node.js vers Deno

La migration de Node.js vers Deno pour la création d'API REST peut apporter des avantages significatifs en matière de sécurité, de productivité des développeurs et de gestion des dépendances. En utilisant le runtime sécurisé de Deno, la prise en charge native de TypeScript et la gestion simplifiée des dépendances, vous pouvez facilement créer des API REST robustes et efficaces.

Cependant, l'écosystème immature de Deno peut vous amener à reconsidérer. Si vous choisissez de migrer, pesez soigneusement le pour et le contre.