feat: modular auth + queue tasks

server/authentication/azure.js

@@ -0,0 +1,33 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// Azure AD Account
+// ------------------------------------
+
+const AzureAdOAuth2Strategy = require('passport-azure-ad-oauth2').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.azure && wiki.config.auth.azure.enabled) {
+    const jwt = require('jsonwebtoken')
+    passport.use('azure_ad_oauth2',
+      new AzureAdOAuth2Strategy({
+        clientID: wiki.config.auth.azure.clientId,
+        clientSecret: wiki.config.auth.azure.clientSecret,
+        callbackURL: wiki.config.host + '/login/azure/callback',
+        resource: wiki.config.auth.azure.resource,
+        tenant: wiki.config.auth.azure.tenant
+      }, (accessToken, refreshToken, params, profile, cb) => {
+        let waadProfile = jwt.decode(params.id_token)
+        waadProfile.id = waadProfile.oid
+        waadProfile.provider = 'azure'
+        wiki.db.User.processProfile(waadProfile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}

server/authentication/facebook.js

@@ -0,0 +1,28 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// Facebook Account
+// ------------------------------------
+
+const FacebookStrategy = require('passport-facebook').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.facebook && wiki.config.auth.facebook.enabled) {
+    passport.use('facebook',
+      new FacebookStrategy({
+        clientID: wiki.config.auth.facebook.clientId,
+        clientSecret: wiki.config.auth.facebook.clientSecret,
+        callbackURL: wiki.config.host + '/login/facebook/callback',
+        profileFields: ['id', 'displayName', 'email']
+      }, function (accessToken, refreshToken, profile, cb) {
+        wiki.db.User.processProfile(profile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}

server/authentication/github.js

@@ -0,0 +1,28 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// GitHub Account
+// ------------------------------------
+
+const GitHubStrategy = require('passport-github2').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.github && wiki.config.auth.github.enabled) {
+    passport.use('github',
+      new GitHubStrategy({
+        clientID: wiki.config.auth.github.clientId,
+        clientSecret: wiki.config.auth.github.clientSecret,
+        callbackURL: wiki.config.host + '/login/github/callback',
+        scope: ['user:email']
+      }, (accessToken, refreshToken, profile, cb) => {
+        wiki.db.User.processProfile(profile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}

server/authentication/google.js

@@ -0,0 +1,27 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// Google ID Account
+// ------------------------------------
+
+const GoogleStrategy = require('passport-google-oauth20').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.google && wiki.config.auth.google.enabled) {
+    passport.use('google',
+      new GoogleStrategy({
+        clientID: wiki.config.auth.google.clientId,
+        clientSecret: wiki.config.auth.google.clientSecret,
+        callbackURL: wiki.config.host + '/login/google/callback'
+      }, (accessToken, refreshToken, profile, cb) => {
+        wiki.db.User.processProfile(profile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}

server/authentication/ldap.js

@@ -0,0 +1,41 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// LDAP Account
+// ------------------------------------
+
+const LdapStrategy = require('passport-ldapauth').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.ldap && wiki.config.auth.ldap.enabled) {
+    passport.use('ldapauth',
+      new LdapStrategy({
+        server: {
+          url: wiki.config.auth.ldap.url,
+          bindDn: wiki.config.auth.ldap.bindDn,
+          bindCredentials: wiki.config.auth.ldap.bindCredentials,
+          searchBase: wiki.config.auth.ldap.searchBase,
+          searchFilter: wiki.config.auth.ldap.searchFilter,
+          searchAttributes: ['displayName', 'name', 'cn', 'mail'],
+          tlsOptions: (wiki.config.auth.ldap.tlsEnabled) ? {
+            ca: [
+              fs.readFileSync(wiki.config.auth.ldap.tlsCertPath)
+            ]
+          } : {}
+        },
+        usernameField: 'email',
+        passReqToCallback: false
+      }, (profile, cb) => {
+        profile.provider = 'ldap'
+        profile.id = profile.dn
+        wiki.db.User.processProfile(profile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}

server/authentication/local.js

@@ -0,0 +1,34 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// Local Account
+// ------------------------------------
+
+const LocalStrategy = require('passport-local').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.local && wiki.config.auth.local.enabled) {
+    passport.use('local',
+      new LocalStrategy({
+        usernameField: 'email',
+        passwordField: 'password'
+      }, (uEmail, uPassword, done) => {
+        wiki.db.User.findOne({ email: uEmail, provider: 'local' }).then((user) => {
+          if (user) {
+            return user.validatePassword(uPassword).then(() => {
+              return done(null, user) || true
+            }).catch((err) => {
+              return done(err, null)
+            })
+          } else {
+            return done(new Error('INVALID_LOGIN'), null)
+          }
+        }).catch((err) => {
+          done(err, null)
+        })
+      }
+      ))
+  }
+}

server/authentication/microsoft.js

@@ -0,0 +1,27 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// Microsoft Account
+// ------------------------------------
+
+const WindowsLiveStrategy = require('passport-windowslive').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.microsoft && wiki.config.auth.microsoft.enabled) {
+    passport.use('windowslive',
+      new WindowsLiveStrategy({
+        clientID: wiki.config.auth.microsoft.clientId,
+        clientSecret: wiki.config.auth.microsoft.clientSecret,
+        callbackURL: wiki.config.host + '/login/ms/callback'
+      }, function (accessToken, refreshToken, profile, cb) {
+        wiki.db.User.processProfile(profile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}

server/authentication/slack.js

@@ -0,0 +1,27 @@
+'use strict'
+
+/* global wiki */
+
+// ------------------------------------
+// Slack Account
+// ------------------------------------
+
+const SlackStrategy = require('passport-slack').Strategy
+
+module.exports = (passport) => {
+  if (wiki.config.auth.slack && wiki.config.auth.slack.enabled) {
+    passport.use('slack',
+      new SlackStrategy({
+        clientID: wiki.config.auth.slack.clientId,
+        clientSecret: wiki.config.auth.slack.clientSecret,
+        callbackURL: wiki.config.host + '/login/slack/callback'
+      }, (accessToken, refreshToken, profile, cb) => {
+        wiki.db.User.processProfile(profile).then((user) => {
+          return cb(null, user) || true
+        }).catch((err) => {
+          return cb(err, null) || true
+        })
+      }
+      ))
+  }
+}