Node.js: Connectez-Auth VS. EveryAuth

Je suis l'auteur de everyauth.

J'ai écrit everyauth parce que j'ai trouvé à l'aide de connect-auth manque en termes de:

1. Facile et puissant de configuration

   Pour obtenir particulier, une zone où il a été manqué de configuration a été mise en facebook du "champ d'application" paramètres de sécurité de façon dynamique.

2. Bonne prise en charge du débogage

   J'ai trouvé connect-auth n'est pas si facile à déboguer en termes d'isoler la partie de l'auth processus a été un échec. Cela est principalement dû à la façon dont connectez-auth met en place son imbriqués les rappels.

Avec everyauth, j'ai essayé de créer un système qui a résolu les problèmes que j'ai rencontré avec connectez-auth.

• Sur la configuration - chaque everyauth module d'authentification est définie comme une série d'étapes et de paramètres configurables. Comme un résultat, vous avez une intervention chirurgicale comme la précision sur les paramètres (par exemple, nom d'hôte, l'url de callback, etc.) ou étapes (p. ex., getAccessToken, addToSession) vous souhaitez modifié. Avec connect-auth, si vous voulez changer une chose en plus rares construits dans les paramètres configurables chaque auth stratégie de l'offre, vous devez ré-écrire l'ensemble de la this.authenticate fonction qui définit la logique de tous de cette stratégie. En d'autres termes, il a moins de précision de la configurabilité de everyauth. Dans d'autres cas, vous ne pouvez pas utiliser connect-auth, comme est, par exemple, la réalisation de la dynamique de facebook "champ d'application" de la configurabilité - c'est à dire, de demander à des utilisateurs pour plus de facebook autorisations au fur et à mesure qu'ils arrivent à des parties de votre application qui nécessitent plus d'autorisations.

  En plus configurable étapes et les paramètres, vous pouvez également profiter de everyauths'module auth héritage. Tous les modules hériter fait de la everymodule module auth. Tous les OAuth2 à base de modules d'hériter de la oauth2 module. Disons que vous voulez tous les oauth2 modules à se comporter différemment. Tout ce que vous devez faire est de modifier le module d'authentification oauth2, et tous les oauth2 à base de modules héritera que de nouveaux comportements d'elle.

• Sur le débogage - everyauth, à mon avis, a une meilleure mise en visibilité en raison du fait même qu'elle les segments de chaque module explicitement dans les étapes qui la composent. Par la mise en

  everyauth.debug = true;

  vous obtenez un résultat de ce que les étapes dans le processus d'authentification est terminée et celles qui ont échoué. Vous avez également un contrôle granulaire sur la durée de chaque étape, dans chaque auth stratégie avant qu'il expire.

• Sur l'extensibilité - j'ai conçu everyauth pour maximiser le code de la réutilisation. Comme mentionné précédemment, tous les modules hériter fait de la everymodule module auth. Cela signifie que vous pouvez obtenir de très modulaire des systèmes, tout en ayant en même temps contrôle de précision, en termes de plus-de l'équitation une étape spécifique à partir d'un ancêtre module. Pour voir comment il est facile d'étendre everyauth avec votre propre module d'authentification, il suffit de prendre un coup d'oeil à aucune des modules auth dans everyauth de la source.

• Sur la lisibilité - je trouver everyauth source plus facile à lire en termes de ce qui se passe. Avec connect-auth, j'ai trouvé moi-même en sautant autour de la plusieurs fichiers à comprendre dans quels contextes (c'est à dire, pendant ce qui suit, dans everyauth langage) chaque imbriquée rappel configuré par une stratégie est en cours d'exécution. Avec everyauth, vous savez exactement quelle pièce de la logique est associé à quel contexte (aka étape). Pour exemple, voici le code décrivant ce qui se passe quand un oauth2 fournisseur renvoie à votre service:

  .get('callbackPath',                                                                                                                                               
       'the callback path that the 3rd party OAuth provider redirects to after an OAuth authorization result - e.g., "/auth/facebook/callback"')                     
    .step('getCode')
      .description('retrieves a verifier code from the url query')                                                                                                   
      .accepts('req res')  
      .promises('code')                                                       
      .canBreakTo('authCallbackErrorSteps')
    .step('getAccessToken')
      .accepts('code')
      .promises('accessToken extra')                                                                                                                                 
    .step('fetchOAuthUser')
      .accepts('accessToken')                                                                                                                                        
      .promises('oauthUser')
    .step('getSession')
      .accepts('req')
      .promises('session')
    .step('findOrCreateUser')                                                                                                                                        
      .accepts('session accessToken extra oauthUser')                                                                                                                
      .promises('user')
    .step('compile')
      .accepts('accessToken extra oauthUser user')
      .promises('auth')
    .step('addToSession')
      .accepts('session auth')                                                                                                                                       
      .promises(null)
    .step('sendResponse')
      .accepts('res')
      .promises(null)

  Sans avoir besoin de vous expliquer comment cela fonctionne, c'est assez simple de voir ce qu'est un oauth2 stratégie n'. Voulez savoir ce que getCode n'? La source est encore très simple:

  .getCode( function (req, res) {
    var parsedUrl = url.parse(req.url, true);
    if (this._authCallbackDidErr(req)) {
      return this.breakTo('authCallbackErrorSteps', req, res);
    }
    return parsedUrl.query && parsedUrl.query.code;
  })

  Comparer tout cela à connect-auth's facebook code, qui, pour moi, au moins, a pris plus de temps que j'ai pensé qu'il devrait avoir à comprendre ce qui est arriver a exécuté lorsqu'. C'est surtout à cause de la façon dont le code est répandue à travers les fichiers et en raison de l'utilisation d'un seul authenticate méthode et imbriqués les rappels à définir la logique d'authentification (everyauth utilise promet de briser la logique dans digeste étapes):

  that.authenticate= function(request, response, callback) {
    //todo: makw the call timeout ....
    var parsedUrl= url.parse(request.url, true);
    var self= this;
    if( parsedUrl.query && parsedUrl.query.code  ) {
      my._oAuth.getOAuthAccessToken(parsedUrl.query && parsedUrl.query.code ,
         {redirect_uri: my._redirectUri}, function( error, access_token, refresh_token ){
           if( error ) callback(error)
           else {
             request.session["access_token"]= access_token;
             if( refresh_token ) request.session["refresh_token"]= refresh_token;
               my._oAuth.getProtectedResource("https://graph.facebook.com/me", request.session["access_token"], function (error, data, response) {
                 if( error ) {
                   self.fail(callback);
                 }else {
                   self.success(JSON.parse(data), callback)
                 }
               })
           }
      });
    }
    else {
       request.session['facebook_redirect_url']= request.url;
       var redirectUrl= my._oAuth.getAuthorizeUrl({redirect_uri : my._redirectUri, scope: my.scope })
       self.redirect(response, redirectUrl, callback);
     }
  }

Quelques autres différences:

• everyauth prend en charge traditionnel authentification par mot de passe. connect-auth, de cette écriture, ne fonctionne pas.
• Foursquare et google en connectez-auth est basée sur l'ancien OAuth1.un spec. everyauth's foursquare et google les modules sont basés sur leurs implémentations de la plus récente OAuth2 spec.
• OpenId soutien dans everyauth.
• everyauth la documentation est beaucoup plus complet que connectez-auth est.

Enfin, des observations sur la réponse de Nathan qui n'était pas certain de everyauth prise en charge de plusieurs fournisseurs en même temps, everyauth prend en charge de multiples, simultanées fournisseurs. Le fichier lisez-moi sur everyauth's github page fournit des instructions sur la façon d'utiliser everyauth pour atteindre cet objectif.

Pour conclure, je pense que le choix de bibliothèques dépend du développeur. J', et d'autres, trouver everyauth plus puissant à partir de leur point de vue. Que de Nathan réponse illustre, d'autres encore trouver connect-auth plus à l'écoute de leurs préférences. Quel que soit votre choix, j'espère que cette écriture-up sur pourquoi j'ai écrit everyauth vous aide dans votre décision.

J'ai passé une matinée à jouer avec everyauth mangouste-auth pour trouver les exemples ont été cassé et qu'ils étaient morts projets. Voici la validation d'histoire:

https://github.com/jaredhanson/passport/commits/master - 5 juin (c'est le 18 juin)
https://github.com/ciaranj/connect-auth/commits/master - le 18 avril (il y a 2 mois)
https://github.com/bnoguchi/mongoose-auth/commits/master - Février 2012

Voici un google Tendances de everyauth, connectez-auth, et passportjs
http://www.google.com/trends/explore?q=passportjs%2C+connect-auth%2C+everyauth#q=passportjs%2C%20connect-auth%2C%20everyauth&cmpt=q