Quickstarters
Comment construire un Backend pour ExpressJS ?

52min
Introduction
Dans ce tutoriel, vous apprendrez à construire un backend complet pour une ExpressJS application en utilisant Back4app. 
Nous allons passer en revue l'intégration des fonctionnalités essentielles de Back4app—telles que la gestion de base de données, les fonctions Cloud Code, les API REST et GraphQL, l'authentification des utilisateurs, et les requêtes en temps réel (Live Queries)—pour créer un backend sécurisé, évolutif et robuste qui communique sans problème avec vos routes et middleware ExpressJS.
Vous verrez également comment la configuration rapide et l'environnement intuitif de Back4app peuvent réduire considérablement le temps et les efforts par rapport à la configuration manuelle des serveurs et des bases de données. 
En cours de route, vous acquerrez une expérience pratique avec des fonctionnalités clés, y compris des fonctionnalités de sécurité avancées, la planification de tâches avec Cloud Jobs, et la configuration de webhooks pour des intégrations externes.
À la fin de ce tutoriel, vous serez bien préparé à améliorer cette configuration de base en une application prête pour la production, ou à incorporer facilement une logique personnalisée et des API tierces selon vos besoins.
Conditions préalables
Pour compléter ce tutoriel, vous aurez besoin de :
Un compte Back4app et un nouveau projet Back4app
 Commencer avec Back4app.
Si vous n'avez pas de compte, vous pouvez en créer un gratuitement. Suivez le guide ci-dessus pour préparer votre projet.
Environnement de base Node.js / Express
 Vous pouvez le configurer en utilisant Express Generator ou un outil similaire. Assurez-vous d'avoir Node.js installé sur votre machine.
Node.js (version 14 ou supérieure) installé
Vous aurez besoin de Node.js pour installer des paquets npm et exécuter des serveurs de développement locaux. Installer Node.js﻿
Familiarité avec JavaScript et concepts de base d'ExpressJS
 Documentation officielle d'ExpressJS.
Si vous êtes nouveau sur Express, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir toutes ces conditions préalables en place avant de commencer. Avoir votre projet Back4app configuré et votre environnement local ExpressJS prêt vous aidera à suivre plus facilement.
Étape 1 – Configuration du projet Back4app
Créer un nouveau projet
La première étape pour construire votre backend ExpressJS sur Back4app consiste à créer un nouveau projet. Si vous n'en avez pas encore créé un, suivez ces étapes :
Connectez-vous à votre compte Back4app.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4app.
Donnez un nom à votre application (par exemple, “ExpressJS-Backend-Tutorial”).
﻿
Une fois le projet créé, vous le verrez listé dans votre tableau de bord Back4app. Ce projet sera la base de toutes les configurations backend discutées dans ce tutoriel.
Connectez le SDK Parse
Back4app s'appuie sur la plateforme Parse pour gérer vos données, fournir des fonctionnalités en temps réel, gérer l'authentification des utilisateurs, et plus encore. Connecter votre application ExpressJS à Back4app implique d'installer le package npm parse et de l'initialiser avec les identifiants de votre tableau de bord Back4app.
Récupérez vos clés Parse:
Dans votre tableau de bord Back4app, accédez à la section “Paramètres de l'application” ou “Sécurité & Clés” de votre application pour trouver votre ID d'application et Clé JavaScript. Vous trouverez également l'URL du serveur Parse (souvent au format https://parseapi.back4app.com).
﻿
Installez le SDK Parse dans votre projet ExpressJS :
Bash
npm install parse
npm install parse
﻿
Si vous utilisez Yarn, vous pouvez l'installer avec :
Bash
yarn add parse
yarn add parse
﻿
Initialisez Parse dans votre application ExpressJS :
Vous pouvez créer un fichier (par exemple, parseConfig.js) dans votre répertoire de projet :
src/parseConfig.js
// src/parseConfig.js
const Parse = require('parse/node');

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

module.exports = Parse;
// src/parseConfig.js
const Parse = require('parse/node');

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

module.exports = Parse;
﻿
Ce fichier garantit que chaque fois que vous importez Parse ailleurs dans votre application Express (par exemple, dans vos routes ou contrôleurs), il est préconfiguré pour se connecter à votre instance Back4app spécifique.
En complétant cette étape, vous avez établi une connexion sécurisée entre votre serveur ExpressJS et le backend Back4app. Toutes les requêtes et transactions de données sont acheminées de manière sécurisée via ce SDK, réduisant la complexité des appels REST ou GraphQL manuels (bien que vous puissiez toujours les utiliser si nécessaire).
Étape 2 – Configuration de la base de données
Sauvegarde et requête de données
Avec votre projet Back4app configuré et le SDK Parse intégré dans votre application Express, vous pouvez maintenant commencer à sauvegarder et récupérer des données. La manière la plus simple de créer un enregistrement est d'utiliser la classe Parse.Object . Dans l'un de vos gestionnaires de route, par exemple :
JS
// routes/todo.js
const express = require('express');
const router = express.Router();
const Parse = require('../parseConfig');

// Example: Create a Todo item
router.post('/create', async (req, res) => {
  try {
    const { title, isCompleted } = req.body;
    const Todo = Parse.Object.extend('Todo');
    const todo = new Todo();
    todo.set('title', title);
    todo.set('isCompleted', isCompleted);

    const savedTodo = await todo.save();
    res.status(200).json({ message: 'Todo saved successfully', savedTodo });
  } catch (error) {
    res.status(500).json({ error: 'Error saving Todo', details: error.message });
  }
});

// Example: Query all Todo items
router.get('/', async (req, res) => {
  try {
    const Todo = Parse.Object.extend('Todo');
    const query = new Parse.Query(Todo);
    const results = await query.find();
    res.status(200).json(results);
  } catch (error) {
    res.status(500).json({ error: 'Error fetching Todos', details: error.message });
  }
});

module.exports = router;
// routes/todo.js
const express = require('express');
const router = express.Router();
const Parse = require('../parseConfig');

// Example: Create a Todo item
router.post('/create', async (req, res) => {
  try {
    const { title, isCompleted } = req.body;
    const Todo = Parse.Object.extend('Todo');
    const todo = new Todo();
    todo.set('title', title);
    todo.set('isCompleted', isCompleted);

    const savedTodo = await todo.save();
    res.status(200).json({ message: 'Todo saved successfully', savedTodo });
  } catch (error) {
    res.status(500).json({ error: 'Error saving Todo', details: error.message });
  }
});

// Example: Query all Todo items
router.get('/', async (req, res) => {
  try {
    const Todo = Parse.Object.extend('Todo');
    const query = new Parse.Query(Todo);
    const results = await query.find();
    res.status(200).json(results);
  } catch (error) {
    res.status(500).json({ error: 'Error fetching Todos', details: error.message });
  }
});

module.exports = router;
﻿
Alternativement, vous pouvez utiliser les points de terminaison de l'API REST de Back4app :
Curl
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Back4app fournit également une interface GraphQL :
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Ces options diverses vous permettent d'intégrer les opérations de données de la manière qui convient le mieux à votre processus de développement, que ce soit via le SDK Parse, REST ou GraphQL.
Conception de schéma et types de données
Par défaut, Parse permet la création de schéma à la volée, mais vous pouvez également définir vos classes et types de données dans le tableau de bord Back4app pour plus de contrôle.
Accédez à la section “Base de données” dans votre tableau de bord Back4app.
Créez une nouvelle classe (par exemple, “Todo”) et ajoutez des colonnes pertinentes, telles que titre (String) et isCompleted (Boolean). 
Créer une nouvelle classe
﻿
Back4app prend également en charge divers types de données : String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, et Polygon. Vous pouvez choisir le type approprié pour chaque champ. Si vous le souhaitez, vous pouvez également laisser Parse créer automatiquement ces colonnes lorsque vous enregistrez pour la première fois un objet depuis votre application Express.
Créer une colonne
﻿
Back4app propose un agent IA qui peut vous aider à concevoir votre modèle de données :
Ouvrez l'Agent IA depuis votre tableau de bord d'application ou dans le menu.
Décrivez votre modèle de données dans un langage simple (par exemple, “Veuillez créer une nouvelle application ToDo sur back4app avec un schéma de classe complet.”).
Laissez l'Agent IA créer le schéma pour vous. 
﻿
Utiliser l'Agent IA peut vous faire gagner du temps lors de la configuration de votre architecture de données et garantir la cohérence de votre application.
Données relationnelles
Si vous avez des données relationnelles—par exemple, un objet Catégorie qui pointe vers plusieurs éléments Todo—vous pouvez utiliser des Pointeurs ou des Relations dans Parse. Par exemple, ajouter un pointeur à une Catégorie:
JS
// Linking a Task to a Category with a pointer
const Parse = require('./parseConfig');

async function createTaskForCategory(categoryObjectId, title) {
  const todo = new Parse.Object('Todo');

  // Construct a pointer to the category
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  // Set fields
  todo.set('title', title);
  todo.set('category', categoryPointer);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}
// Linking a Task to a Category with a pointer
const Parse = require('./parseConfig');

async function createTaskForCategory(categoryObjectId, title) {
  const todo = new Parse.Object('Todo');

  // Construct a pointer to the category
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  // Set fields
  todo.set('title', title);
  todo.set('category', categoryPointer);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}
﻿
Lorsque vous interrogez, vous pouvez également inclure des données de pointeur :
JS
const Parse = require('./parseConfig');

const query = new Parse.Query('Todo');
query.include('category');
query.find().then((todosWithCategory) => {
  console.log('Todos with category details:', todosWithCategory);
});
const Parse = require('./parseConfig');

const query = new Parse.Query('Todo');
query.include('category');
query.find().then((todosWithCategory) => {
  console.log('Todos with category details:', todosWithCategory);
});
﻿
Cet appel include('category') récupère les détails de la catégorie avec chaque Todo, rendant vos données relationnelles facilement accessibles.
Requêtes en direct
Pour des mises à jour en temps réel, Back4app fournit des Requêtes en direct. Dans votre application ExpressJS, vous pouvez vous abonner aux changements dans une classe spécifique. Bien que généralement associé aux abonnements front-end (comme dans React ou Angular), vous pouvez toujours gérer des connexions en temps réel dans un environnement Node ou transmettre des mises à jour aux clients connectés via des websockets.
Activer les requêtes en direct dans votre tableau de bord Back4app sous les Paramètres du serveur. Assurez-vous que les “Requêtes en direct” sont activées.
Initialiser une souscription aux requêtes en direct dans votre code :
src/parseConfig.js
// src/parseConfig.js
const Parse = require('parse/node');

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

// Live Query's subdomain:
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

module.exports = Parse;
// src/parseConfig.js
const Parse = require('parse/node');

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

// Live Query's subdomain:
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

module.exports = Parse;
﻿
JS
// A Node script to subscribe to Live Queries
const Parse = require('./parseConfig');

async function subscribeToTodos(callback) {
  const query = new Parse.Query('Todo');
  const subscription = await query.subscribe();

  subscription.on('create', (newTodo) => {
    console.log('New Todo created:', newTodo);
    callback('create', newTodo);
  });

  subscription.on('update', (updatedTodo) => {
    console.log('Todo updated:', updatedTodo);
    callback('update', updatedTodo);
  });

  subscription.on('delete', (deletedTodo) => {
    console.log('Todo deleted:', deletedTodo);
    callback('delete', deletedTodo);
  });

  return subscription;
}
// A Node script to subscribe to Live Queries
const Parse = require('./parseConfig');

async function subscribeToTodos(callback) {
  const query = new Parse.Query('Todo');
  const subscription = await query.subscribe();

  subscription.on('create', (newTodo) => {
    console.log('New Todo created:', newTodo);
    callback('create', newTodo);
  });

  subscription.on('update', (updatedTodo) => {
    console.log('Todo updated:', updatedTodo);
    callback('update', updatedTodo);
  });

  subscription.on('delete', (deletedTodo) => {
    console.log('Todo deleted:', deletedTodo);
    callback('delete', deletedTodo);
  });

  return subscription;
}
﻿
En vous abonnant, vous recevez des notifications en temps réel chaque fois qu'une nouvelle Todo est créée, mise à jour ou supprimée. Cette fonctionnalité est particulièrement précieuse pour les applications collaboratives ou dynamiques où plusieurs utilisateurs doivent voir les dernières données sans sondage supplémentaire.
Étape 3 – Appliquer la sécurité avec les ACL et les CLP
Mécanisme de sécurité Back4app
Back4app prend la sécurité au sérieux en fournissant Des Listes de Contrôle d'Accès (ACL) et Des Permissions au Niveau de la Classe (CLP). Ces fonctionnalités vous permettent de restreindre qui peut lire ou écrire des données sur une base par objet ou par classe, garantissant que seuls les utilisateurs autorisés peuvent modifier vos données.
﻿
Des Listes de Contrôle d'Accès (ACL)
Une ACL est appliquée à des objets individuels pour déterminer quels utilisateurs, rôles ou le public peuvent effectuer des opérations de lecture/écriture. Par exemple:
JS
const Parse = require('./parseConfig');

async function createPrivateTodo(title, ownerUser) {
  const Todo = Parse.Object.extend('Todo');
  const todo = new Todo();
  todo.set('title', title);

  // Create an ACL granting read/write access only to the owner
  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);

  todo.setACL(acl);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error saving private todo:', err);
  }
}
const Parse = require('./parseConfig');

async function createPrivateTodo(title, ownerUser) {
  const Todo = Parse.Object.extend('Todo');
  const todo = new Todo();
  todo.set('title', title);

  // Create an ACL granting read/write access only to the owner
  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);

  todo.setACL(acl);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error saving private todo:', err);
  }
}
﻿
Lorsque vous enregistrez l'objet, il a un ACL qui empêche quiconque, sauf l'utilisateur spécifié, de le lire ou de le modifier.
Modifier l'ACL
﻿
Permissions au niveau de la classe (CLP)
Les CLP régissent les permissions par défaut d'une classe entière, telles que si la classe est lisible ou modifiable publiquement, ou si seuls certains rôles peuvent y accéder.
Allez sur votre tableau de bord Back4app, sélectionnez votre application et ouvrez la base de données section.
Sélectionnez une classe (par exemple, “Todo”).
Ouvrez l'onglet des permissions au niveau de la classe. 
Configurez vos paramètres par défaut, tels que “Nécessite une authentification” pour la lecture ou l'écriture, ou “Aucun accès” pour le public.
﻿
Ces permissions établissent la base, tandis que les ACL affinent les permissions pour des objets individuels. Un modèle de sécurité robuste combine généralement à la fois les CLP (restrictions larges) et les ACL (restrictions fines par objet). Pour plus d'informations, allez à Directives de sécurité de l'application.﻿
Étape 4 – Écriture et déploiement des fonctions cloud
Le code cloud est une fonctionnalité de l'environnement Parse Server qui vous permet d'exécuter du code JavaScript personnalisé côté serveur—sans avoir besoin de gérer vos serveurs ou votre infrastructure. En écrivant du code cloud, vous pouvez étendre votre backend Back4app avec une logique métier supplémentaire, des validations, des déclencheurs et des intégrations qui s'exécutent de manière sécurisée et efficace sur le serveur Parse.
Comment ça fonctionne
Lorsque vous écrivez du code cloud, vous placez généralement vos fonctions JavaScript, déclencheurs et tous les modules NPM requis dans un fichier main.js (ou app.js) . Ce fichier est ensuite déployé sur votre projet Back4app, qui est exécuté dans l'environnement Parse Server. Étant donné que ces fonctions et déclencheurs s'exécutent sur le serveur, vous pouvez leur faire confiance pour gérer une logique confidentielle, traiter des données sensibles ou effectuer des appels API réservés au backend—des processus que vous ne voudriez peut-être pas exposer directement au client.
Tout le code Cloud pour votre application Back4app s'exécute à l'intérieur du serveur Parse géré par Back4app, donc vous n'avez pas à vous soucier de la maintenance du serveur, de la mise à l'échelle ou de l'approvisionnement. Chaque fois que vous mettez à jour et déployez votre fichier main.js, le serveur Parse en cours d'exécution est mis à jour avec votre dernier code.
Structure du fichier main.js
Un main.js typique pourrait contenir :
Instructions require pour tous les modules nécessaires (packages NPM, modules Node intégrés ou autres fichiers de code cloud).
Définitions de fonctions Cloud utilisant Parse.Cloud.define().
Déclencheurs tels que Parse.Cloud.beforeSave(), Parse.Cloud.afterSave(), etc.
Modules NPM que vous avez installés (si nécessaire). Par exemple, vous pourriez installer un package comme axios pour effectuer des requêtes HTTP. Vous pouvez ensuite le require (ou l'importer) en haut de votre fichier.
JS
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Avec la possibilité d'installer et d'utiliser des modules NPM, le code Cloud devient incroyablement flexible, vous permettant de vous intégrer à des API externes, d'effectuer des transformations de données ou d'exécuter une logique complexe côté serveur.
Cas d'utilisation typiques
Logique métier: Par exemple, vous pouvez calculer le score d'un utilisateur dans un jeu en agrégeant plusieurs propriétés d'objet, puis stocker ces données automatiquement.
Validations de données: Assurez-vous que certains champs sont présents ou qu'un utilisateur a les bonnes autorisations avant de sauvegarder ou de supprimer un enregistrement.
Déclencheurs: Effectuez des actions lorsque les données changent (par exemple, envoyez une notification lorsqu'un utilisateur met à jour son profil).
Intégrations: Connectez-vous à des API ou services tiers. Par exemple, vous pourriez vous intégrer à des passerelles de paiement, des notifications Slack ou des plateformes de marketing par e-mail directement depuis Cloud Code.
Application de la sécurité: Ajoutez une couche de sécurité supplémentaire en validant et en nettoyant les paramètres d'entrée dans vos fonctions Cloud Code.
Déployez votre fonction
Voici une fonction Cloud Code simple qui calcule la longueur d'une chaîne de texte envoyée par le client :
main.js
// main.js

Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js

Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Déployer via le Back4app CLI:
1 - Installer le CLI :
Pour Linux/MacOS :
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Pour Windows :
Téléchargez le b4a.exe fichier depuis la page des versions.
2 - Configurer votre clé de compte :﻿
Bash
b4a configure accountkey
b4a configure accountkey
﻿
3 - Déployez votre code cloud :
Bash
b4a deploy
b4a deploy
﻿
Déployer via le tableau de bord:
Dans le tableau de bord de votre application, allez à Cloud Code > Fonctions.
Copiez/collez la fonction dans l'éditeur main.js.
Cliquez sur Déployer.
﻿
Appel de votre fonction
Depuis votre application ExpressJS, vous pouvez appeler la fonction Cloud Code en utilisant le SDK Parse :
JS
const Parse = require('./parseConfig');

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
const Parse = require('./parseConfig');

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
﻿
Vous pouvez également l'appeler via REST :
Curl
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
﻿
Ou via GraphQL :
GraphQL
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
﻿
Cette flexibilité vous permet d'intégrer votre logique personnalisée dans votre backend ExpressJS ou tout autre client qui prend en charge REST ou GraphQL.
Étape 5 – Configuration de l'authentification des utilisateurs
Authentification des utilisateurs dans Back4app
Back4app utilise la Parse User classe comme base pour l'authentification. Par défaut, Parse gère le hachage des mots de passe, les jetons de session et le stockage sécurisé. Cela signifie que vous n'avez pas à configurer manuellement des flux de sécurité complexes.
Configuration de l'authentification des utilisateurs
Dans une application Express, vous pourriez créer des routes pour l'inscription et la connexion des utilisateurs :
JS
// routes/user.js
const express = require('express');
const router = express.Router();
const Parse = require('../parseConfig');

// Sign up route
router.post('/signup', async (req, res) => {
  try {
    const { username, password, email } = req.body;
    const user = new Parse.User();
    user.set('username', username);
    user.set('password', password);
    user.set('email', email);

    await user.signUp();
    res.status(201).json({ message: 'User signed up successfully!' });
  } catch (error) {
    res.status(500).json({ error: 'Error signing up user', details: error.message });
  }
});

// Log in route
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    const user = await Parse.User.logIn(username, password);
    res.status(200).json({ message: 'User logged in', user });
  } catch (error) {
    res.status(401).json({ error: 'Invalid credentials', details: error.message });
  }
});

module.exports = router;
// routes/user.js
const express = require('express');
const router = express.Router();
const Parse = require('../parseConfig');

// Sign up route
router.post('/signup', async (req, res) => {
  try {
    const { username, password, email } = req.body;
    const user = new Parse.User();
    user.set('username', username);
    user.set('password', password);
    user.set('email', email);

    await user.signUp();
    res.status(201).json({ message: 'User signed up successfully!' });
  } catch (error) {
    res.status(500).json({ error: 'Error signing up user', details: error.message });
  }
});

// Log in route
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    const user = await Parse.User.logIn(username, password);
    res.status(200).json({ message: 'User logged in', user });
  } catch (error) {
    res.status(401).json({ error: 'Invalid credentials', details: error.message });
  }
});

module.exports = router;
﻿
Via REST, une connexion pourrait ressembler à :
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Gestion des sessions
Après une connexion réussie, Parse crée un jeton de session qui est stocké dans l'objet utilisateur. Dans votre application Express, vous pourriez stocker ce jeton dans une session ou le renvoyer au client :
JS
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Currently logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Currently logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
﻿
Parse gère automatiquement les sessions basées sur des jetons en arrière-plan, mais vous pouvez également les gérer ou les révoquer manuellement. Cela est utile lorsque vous devez vous déconnecter :
JS
await Parse.User.logOut();
await Parse.User.logOut();
﻿
Intégration de la connexion sociale
Back4app et Parse peuvent s'intégrer avec des fournisseurs OAuth populaires, tels que Google ou Facebook, en installant des packages supplémentaires ou en utilisant des adaptateurs existants. Par exemple, vous pouvez configurer une connexion Facebook en configurant votre Facebook App ID et en utilisant Parse.FacebookUtils.logIn(). Les instructions détaillées varient, alors référez-vous aux Docs de connexion sociale.﻿
JS
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
﻿
Vérification par e-mail et réinitialisation du mot de passe
Pour activer la vérification par e-mail et la réinitialisation du mot de passe :
Accédez aux paramètres d'e-mail dans votre tableau de bord Back4app.
Activez la vérification par e-mail pour garantir que les nouveaux utilisateurs vérifient la propriété de leurs adresses e-mail.
Configurez l'adresse de l'expéditeur, les modèles d'e-mail et votre domaine personnalisé si désiré.
Ces fonctionnalités améliorent la sécurité des comptes et l'expérience utilisateur en validant la propriété des e-mails par les utilisateurs et en fournissant une méthode de récupération de mot de passe sécurisée.
Étape 6 – Gestion du stockage de fichiers
Téléchargement et récupération de fichiers
Parse inclut la classe Parse.File pour gérer les téléchargements de fichiers, que Back4app stocke de manière sécurisée. Dans une route Express, vous pourriez faire :
JS
const express = require('express');
const router = express.Router();
const multer = require('multer'); // For handling file uploads
const upload = multer({ dest: 'uploads/' });
const Parse = require('../parseConfig');

router.post('/upload', upload.single('file'), async (req, res) => {
  try {
    const { file } = req;
    if (!file) {
      return res.status(400).json({ error: 'No file uploaded' });
    }

    const parseFile = new Parse.File(file.originalname, file);
    const savedFile = await parseFile.save();
    res.status(200).json({ url: savedFile.url() });
  } catch (err) {
    res.status(500).json({ error: 'Error uploading file', details: err.message });
  }
});

module.exports = router;
const express = require('express');
const router = express.Router();
const multer = require('multer'); // For handling file uploads
const upload = multer({ dest: 'uploads/' });
const Parse = require('../parseConfig');

router.post('/upload', upload.single('file'), async (req, res) => {
  try {
    const { file } = req;
    if (!file) {
      return res.status(400).json({ error: 'No file uploaded' });
    }

    const parseFile = new Parse.File(file.originalname, file);
    const savedFile = await parseFile.save();
    res.status(200).json({ url: savedFile.url() });
  } catch (err) {
    res.status(500).json({ error: 'Error uploading file', details: err.message });
  }
});

module.exports = router;
﻿
Pour attacher le fichier à un objet dans la base de données, vous pouvez faire :
JS
const Photo = Parse.Object.extend('Photo');
const photo = new Photo();
photo.set('imageFile', parseFile);
await photo.save();
const Photo = Parse.Object.extend('Photo');
const photo = new Photo();
photo.set('imageFile', parseFile);
await photo.save();
﻿
Et récupérer l'URL du fichier est simple :
JS
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
﻿
Vous pouvez ensuite servir ou répondre avec imageUrl dans vos routes Express.
Sécurité des fichiers
Parse Server fournit des configurations flexibles pour gérer la sécurité des téléchargements de fichiers. L'exemple suivant montre comment vous pouvez définir des autorisations pour contrôler qui peut télécharger des fichiers sur le serveur :
{
"fileUpload": {
"enableForPublic": true,
"enableForAnonymousUser": true,
"enableForAuthenticatedUser": true
}
}
enableForPublic: Lorsqu'il est défini sur vrai, permet à quiconque, quel que soit son statut d'authentification, de télécharger des fichiers.
enableForAnonymousUser: Contrôle si les utilisateurs anonymes (non inscrits) peuvent télécharger des fichiers.
enableForAuthenticatedUser: Spécifie si seuls les utilisateurs authentifiés peuvent télécharger des fichiers.
Étape 7 – Planification des tâches avec les Cloud Jobs
Cloud Jobs
Emplois Cloud dans Back4app vous permet de planifier et d'exécuter des tâches de routine sur votre backend, comme nettoyer les anciennes données ou envoyer un e-mail de résumé quotidien. Un emploi Cloud typique pourrait ressembler à ceci :
JS
// main.js

Parse.Cloud.job('cleanupOldTodos', async (request) => {
  // This runs in the background, not triggered by a direct user request
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  // For example, remove todos older than 30 days
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
// main.js

Parse.Cloud.job('cleanupOldTodos', async (request) => {
  // This runs in the background, not triggered by a direct user request
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  // For example, remove todos older than 30 days
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Déployez votre code Cloud avec le nouvel emploi (via CLI ou le tableau de bord).
Allez sur le tableau de bord Back4app > Paramètres de l'application > Paramètres du serveur > Tâches d'arrière-plan. 
Planifiez l'emploi pour s'exécuter quotidiennement ou à tout autre intervalle qui convient à vos besoins.
Planification d'un emploi Cloud
﻿
Les emplois Cloud vous permettent d'automatiser la maintenance en arrière-plan ou d'autres processus périodiques, sans nécessiter d'intervention manuelle.
Étape 8 – Intégration des Webhooks
Webhooks permettent à votre application Back4app d'envoyer des requêtes HTTP à un service externe chaque fois que certains événements se produisent. C'est puissant pour s'intégrer à des systèmes tiers comme des passerelles de paiement (par exemple, Stripe), des outils de marketing par e-mail ou des plateformes d'analyse.
Accédez à la configuration des Webhooks dans votre tableau de bord Back4app > Plus > WebHooks, puis cliquez sur Ajouter un Webhook.
Configurez un point de terminaison (par exemple, https://your-external-service.com/webhook-endpoint).
Configurez des déclencheurs pour spécifier quels événements dans vos classes Back4app ou fonctions Cloud Code déclencheront le webhook.
Ajout d'un Webhook
﻿
Par exemple, si vous souhaitez notifier un canal Slack chaque fois qu'un nouveau Todo est créé :
Créez une application Slack qui accepte les webhooks entrants.
Copiez l'URL du webhook Slack.
Dans votre tableau de bord Back4app, définissez le point de terminaison sur cette URL Slack pour l'événement « Nouvel enregistrement dans la classe Todo. »
Vous pouvez également ajouter des en-têtes HTTP ou des charges utiles personnalisées si nécessaire.
Vous pouvez également définir des Webhooks dans Cloud Code en effectuant des requêtes HTTP personnalisées dans des déclencheurs comme beforeSave, afterSave :
WebHook BeforeSave
﻿
Étape 9 – Exploration du panneau d'administration Back4app
L’ Application Admin Back4app est une interface de gestion basée sur le web conçue pour les utilisateurs non techniques afin d'effectuer des opérations CRUD et de gérer des tâches de données courantes sans écrire de code. Elle fournit une interface centrée sur le modèle, conviviale qui rationalise l'administration de la base de données, la gestion des données personnalisées et les opérations de niveau entreprise.
Activation de l'application Admin
Activez cela en allant dans Tableau de bord de l'application > Plus > Application Admin et en cliquant sur le bouton “Activer l'application Admin”. 
Activer l'application Admin
﻿
Créez un premier utilisateur Admin (nom d'utilisateur/mot de passe), ce qui génère automatiquement un nouveau rôle (B4aAdminUser) et des classes (B4aSetting, B4aMenuItem et B4aCustomField) dans le schéma de votre application.
﻿
Choisissez un sous-domaine pour accéder à l'interface d'administration et complétez la configuration.
﻿
Connectez-vous en utilisant les identifiants administratifs que vous avez créés pour accéder à votre nouveau tableau de bord de l'application Admin.
﻿
Une fois activée, l'application Admin Back4app facilite la visualisation, l'édition ou la suppression d'enregistrements de votre base de données—sans nécessiter l'utilisation directe du tableau de bord Parse ou du code backend. Avec des contrôles d'accès configurables, vous pouvez partager en toute sécurité cette interface avec des membres de l'équipe ou des clients qui ont besoin d'une manière claire et simple de gérer les données.
Conclusion
En suivant ce tutoriel complet, vous avez :
Créé un backend sécurisé pour une application ExpressJS sur Back4app.
Configuré une base de données avec des schémas de classe, des types de données et des relations.
Intégré des requêtes en temps réel (Requêtes en direct) pour des mises à jour de données immédiates.
Appliqué des mesures de sécurité en utilisant des ACL et des CLP pour protéger et gérer l'accès aux données.
Implémenté des fonctions Cloud Code pour exécuter une logique métier personnalisée côté serveur.
Mis en place l'authentification des utilisateurs avec prise en charge de la vérification par e-mail et des réinitialisations de mot de passe.
Géré les téléchargements de fichiers et la récupération, avec des contrôles de sécurité des fichiers en option.
Planifié des tâches Cloud pour des tâches d'arrière-plan automatisées.
Utilisé des Webhooks pour s'intégrer à des services externes.
Exploré le panneau d'administration Back4app pour la gestion des données.
Avec un serveur ExpressJS solide et un backend Back4app robuste, vous êtes maintenant bien équipé pour développer des applications riches en fonctionnalités, évolutives et sécurisées. Continuez à explorer des fonctionnalités plus avancées, intégrez votre logique métier et exploitez la puissance de Back4app pour vous faire gagner d'innombrables heures dans l'administration des serveurs et des bases de données. Bon codage!
Prochaines étapes
Construire une application ExpressJS prête pour la production en étendant ce backend pour gérer des modèles de données plus complexes, des stratégies de mise en cache et des optimisations de performance.
Intégrer des fonctionnalités avancées telles que des flux d'authentification spécialisés, un contrôle d'accès basé sur les rôles ou des API externes (comme des passerelles de paiement).
Consultez la documentation officielle de Back4app pour des plongées plus profondes dans la sécurité avancée, le réglage des performances et l'analyse des journaux.
Explorez d'autres tutoriels sur les applications de chat en temps réel, les tableaux de bord IoT ou les services basés sur la localisation. Vous pouvez combiner les techniques apprises ici avec des API tierces pour créer des applications complexes et réelles.
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour TypeScript ?
Comment construire un backend pour MeteorJS ?