Liaison de comptes utilisateur : implémentation côté serveur

Décrit comment lier des comptes utilisateur dans une application Web classique à l’aide de code côté serveur, selon un exemple concret.

Auth0 prend en charge la liaison de comptes utilisateur provenant de divers fournisseurs d’identité. Vous pouvez utiliser du code côté serveur pour lier des comptes dans une application Web classique, en impliquant l’utilisateur et en lui demandant son autorisation avant de continuer. Votre code authentifiera les utilisateurs, puis les recherchera et les identifiera à l’aide de leur adresse courriel. Votre application invitera ensuite l’utilisateur à lier ses comptes en s’authentifiant avec les identifiants du compte cible, puis procédera à la liaison des comptes.

Vous trouverez le code source complet de cet exemple d’application sur GitHub.

1. Connectez l’utilisateur à votre application.
   

   L’utilisateur s’authentifie auprès de votre application à l’aide de Universal Login. Pour en savoir plus, consultez le guide de démarrage rapide pour les applications Web traditionnelles et demandez un jeton pour l’audience de l’Auth0 Management API (audience=https://{yourDomain}/api/v2/).

2. Rechercher des utilisateurs ayant la même adresse courriel.
   

   Vous pouvez récupérer le profil de l’utilisateur et la liste des utilisateurs ayant le même courriel vérifié.

   router.get("/", async (req, res) => {
     const { sub, email_verified } = req.openid.user;
     //récupérer le profil de l'utilisateur contenant les propriétés user_metadata et app_metadata
     try {
       let getUsersWithSameVerifiedEmail = [];
       const getUserProfile = auth0Client.getUser(sub);
       if (email_verified)
         // la liaison de compte n'est proposée qu'avec un courriel vérifié
         getUsersWithSameVerifiedEmail = auth0Client.getUsersWithSameVerifiedEmail(
           req.openid.user
         );
   
       const [user, suggestedUsers] = await Promise.all([
         getUserProfile,
         getUsersWithSameVerifiedEmail,
       ]);
   
       const flashError = clear(req);
       res.render("user", {
         user,
         suggestedUsers,
         wrongAccountError: flashError && flashError === Errors.WrongAccount,
       });
     } catch (err) {
       debug("GET /user[s] failed: %o", err);
       res.render("error", err);
     }
   });
   

   Pour obtenir la liste de tous les enregistrements utilisateur ayant la même adresse de courriel, votre application appelle le point de terminaison Get Users By Email de la Management API d’Auth0 à l’aide d’un jeton d’accès de la Management API avec le scope read:users.

   const request = require('request');
   class Auth0Client {
   ...
   async getUsersWithSameVerifiedEmail({ sub, email }) {
     return await this.request({
       url: `${process.env.ISSUER_BASE_URL}/api/v2/users-by-email?email=${email}`,
     });
   }
   

3. Demandez à l’utilisateur de lier des comptes.

   1. Si Auth0 renvoie un ou plusieurs enregistrements ayant des adresses de courriel correspondantes, l’utilisateur verra la liste accompagnée du message suivant lui demandant de lier les comptes.

   2. Si l’utilisateur veut lier un compte en particulier, il peut cliquer sur Lier à côté du compte approprié.

      

4. Lorsque l’utilisateur clique sur Lier, votre application lui demandera de s’authentifier auprès du compte cible, puis procédera à la liaison des comptes.

   Pour conserver et fusionner le user_metadata du compte secondaire, vous devez le récupérer et l’intégrer aux métadonnées du compte principal avant d’appeler le point de terminaison de l’API. Une fois les comptes liés, les métadonnées du compte secondaire sont supprimées.

   Lorsque vous lancez la liaison des comptes, vous pouvez choisir quelle identité sera utilisée comme compte principal et laquelle sera utilisée comme compte secondaire. Ce choix dépendra de l’ensemble des attributs que vous souhaitez conserver dans le profil principal.

   L’extrait de code suivant montre comment vérifier et fusionner les métadonnées :

   async function accountLink(req, res, next) {
   const {
     linking: { targetUserId },
   } = req.appSession;
   const { sub: authenticatedTargetUserId } = req.openidTokens.claims();
   if (authenticatedTargetUserId !== targetUserId) {
     debug(
       "Skipping account linking as the authenticated user(%s)  is different than target linking user (%s)",
       authenticatedTargetUserId,
       targetUserId
     );
     set(req, Errors.WrongAccount);
     return next();
   }
   
   debug(
     "User %s succesfully authenticated. Account linking with %s... ",
     authenticatedTargetUserId,
     targetUserId
   );
   const { id_token: targetIdToken } = req.openidTokens;
   const { sub: primaryUserId } = req.appSession.claims;
   
   try {
     await mergeMetadata(primaryUserId, authenticatedTargetUserId);
     await auth0Client.linkAccounts(primaryUserId, targetIdToken);
     debug("Accounts linked.");
   } catch (err) {
     debug("Linking failed %o", err);
   } finally {
     next();
   }
   }
   

5. Votre application appelle le point de terminaison Lier un compte utilisateur de la Management API d’Auth0 à l’aide d’un jeton d’accès à la Management API doté du scope update:users.

​

Exemple de fusion des métadonnées

L’exemple suivant montre explicitement comment les user_metadata et app_metadata du compte secondaire sont fusionnés au compte principal à l’aide du SDK Node.js d’Auth0 pour l’API v2.

/*
 * Fusionne récursivement user_metadata et app_metadata du compte secondaire dans le compte principal.
 * Les données de l'utilisateur principal ont la prépondérance.
 * Les champs de type tableau sont concaténés.
 */
async function mergeMetadata(primaryUserId, secondaryUserId) {
  // charger les deux utilisateurs avec leurs métadonnées.
  const [primaryUser, secondaryUser] = await Promise.all(
    [primaryUserId, secondaryUserId].map((uid) => auth0Client.getUser(uid))
  );

  const customizerCallback = function (objectValue, sourceValue) {
    if (_.isArray(objectValue)) {
      return sourceValue.concat(objectValue);
    }
  };
  const mergedUserMetadata = _.merge(
    {},
    secondaryUser.user_metadata,
    primaryUser.user_metadata,
    customizerCallback
  );
  const mergedAppMetadata = _.merge(
    {},
    secondaryUser.app_metadata,
    primaryUser.app_metadata,
    customizerCallback
  );
  await auth0Client.updateUser(primaryUserId, {
    user_metadata: mergedUserMetadata,
    app_metadata: mergedAppMetadata,
  });
}

​

En savoir plus

• Vérifier les appels API
• Résoudre les erreurs de jeton invalide