solid-server 5.8.7 → 5.8.8-22f4cfec

package/lib/requests/delete-account-confirm-request.mjs

@@ -0,0 +1,85 @@
+import AuthRequest from './auth-request.mjs'
+import debugModule from '../debug.mjs'
+import fs from 'fs-extra'
+
+const debug = debugModule.accounts
+
+export default class DeleteAccountConfirmRequest extends AuthRequest {
+  constructor (options) {
+    super(options)
+    this.token = options.token
+    this.validToken = false
+  }
+
+  static fromParams (req, res) {
+    const locals = req.app.locals
+    const accountManager = locals.accountManager
+    const userStore = locals.oidc.users
+    const token = this.parseParameter(req, 'token')
+    const options = { accountManager, userStore, token, response: res }
+    return new DeleteAccountConfirmRequest(options)
+  }
+
+  static async get (req, res) {
+    const request = DeleteAccountConfirmRequest.fromParams(req, res)
+    try {
+      await request.validateToken()
+      return request.renderForm()
+    } catch (error) {
+      return request.error(error)
+    }
+  }
+
+  static post (req, res) {
+    const request = DeleteAccountConfirmRequest.fromParams(req, res)
+    return DeleteAccountConfirmRequest.handlePost(request)
+  }
+
+  static async handlePost (request) {
+    try {
+      const tokenContents = await request.validateToken()
+      await request.deleteAccount(tokenContents)
+      return request.renderSuccess()
+    } catch (error) {
+      return request.error(error)
+    }
+  }
+
+  async validateToken () {
+    try {
+      if (!this.token) {
+        return false
+      }
+      const validToken = await this.accountManager.validateDeleteToken(this.token)
+      if (validToken) {
+        this.validToken = true
+      }
+      return validToken
+    } catch (error) {
+      this.token = null
+      throw error
+    }
+  }
+
+  async deleteAccount (tokenContents) {
+    const user = this.accountManager.userAccountFrom(tokenContents)
+    const accountDir = this.accountManager.accountDirFor(user.username)
+    debug('Preparing removal of account for user:', user)
+    await this.userStore.deleteUser(user)
+    await fs.remove(accountDir)
+    debug('Removed user' + user.username)
+  }
+
+  renderForm (error) {
+    const params = { validToken: this.validToken, token: this.token }
+    if (error) {
+      params.error = error.message
+      this.response.status(error.statusCode)
+    }
+    this.response.render('account/delete-confirm', params)
+  }
+
+  renderSuccess () {
+    this.response.render('account/account-deleted')
+  }
+}

package/lib/requests/{delete-account-request.js → delete-account-request.mjs}

@@ -1,144 +1,83 @@
-'use strict'
-
-const AuthRequest = require('./auth-request')
-const debug = require('./../debug').accounts
-
-// class DeleteAccountRequest  {
-class DeleteAccountRequest extends AuthRequest {
-  constructor (options) {
-    super(options)
-
-    this.username = options.username
+import AuthRequest from './auth-request.mjs'
+import debugModule from '../debug.mjs'
+
+const debug = debugModule.accounts
+
+export default class DeleteAccountRequest extends AuthRequest {
+  constructor (options) {
+    super(options)
+    this.username = options.username
   }
-
-  /**
-   * Calls the appropriate form to display to the user.
-   * Serves as an error handler for this request workflow.
-   *
-   * @param error {Error}
-   */
-  error (error) {
-    error.statusCode = error.statusCode || 400
-
-    this.renderForm(error)
+
+  error (error) {
+    error.statusCode = error.statusCode || 400
+    this.renderForm(error)
   }
-
-  /**
-   * Returns a user account instance for the submitted username.
-   *
-   * @throws {Error} Rejects if user account does not exist for the username
-   *
-   * @returns {Promise<UserAccount>}
-   */
-  async loadUser () {
-    const username = this.username
-
-    return this.accountManager.accountExists(username)
-      .then(exists => {
-        if (!exists) {
-          throw new Error('Account not found for that username')
-        }
-
-        const userData = { username }
-
-        return this.accountManager.userAccountFrom(userData)
-      })
+
+  async loadUser () {
+    const username = this.username
+    return this.accountManager.accountExists(username)
+      .then(exists => {
+        if (!exists) {
+          throw new Error('Account not found for that username')
+        }
+        const userData = { username }
+        return this.accountManager.userAccountFrom(userData)
+      })
   }
-
-  /**
-   * Renders the Delete form
-   */
-  renderForm (error) {
-    this.response.render('account/delete', {
-      error,
-      multiuser: this.accountManager.multiuser
-    })
+
+  renderForm (error) {
+    this.response.render('account/delete', {
+      error,
+      multiuser: this.accountManager.multiuser
+    })
   }
-
-  /**
-   * Displays the 'your reset link has been sent' success message view
-   */
-  renderSuccess () {
-    this.response.render('account/delete-link-sent')
+
+  renderSuccess () {
+    this.response.render('account/delete-link-sent')
   }
-
-  /**
-   * Loads the account recovery email for a given user and sends out a
-   * password request email.
-   *
-   * @param userAccount {UserAccount}
-   *
-   * @return {Promise}
-   */
-  async sendDeleteLink (userAccount) {
-    const accountManager = this.accountManager
-
-    const recoveryEmail = await accountManager.loadAccountRecoveryEmail(userAccount)
-    userAccount.email = recoveryEmail
-
-    debug('Preparing delete account email to:', recoveryEmail)
-
-    return accountManager.sendDeleteAccountEmail(userAccount)
+
+  async sendDeleteLink (userAccount) {
+    const accountManager = this.accountManager
+    const recoveryEmail = await accountManager.loadAccountRecoveryEmail(userAccount)
+    userAccount.email = recoveryEmail
+    debug('Preparing delete account email to:', recoveryEmail)
+    return accountManager.sendDeleteAccountEmail(userAccount)
   }
-
-  /**
-   * Validates the request parameters, and throws an error if any
-   * validation fails.
-   *
-   * @throws {Error}
-   */
-  validate () {
-    if (this.accountManager.multiuser && !this.username) {
-      throw new Error('Username required')
-    }
+
+  validate () {
+    if (this.accountManager.multiuser && !this.username) {
+      throw new Error('Username required')
+    }
   }
-
-  static async post (req, res) {
-    const request = DeleteAccountRequest.fromParams(req, res)
-
-    debug(`User '${request.username}' requested to be sent a delete account email`)
-
-    return DeleteAccountRequest.handlePost(request)
+
+  static async post (req, res) {
+    const request = DeleteAccountRequest.fromParams(req, res)
+    debug(`User '${request.username}' requested to be sent a delete account email`)
+    return DeleteAccountRequest.handlePost(request)
   }
-
-  /**
-   * Performs a 'send me a password reset email' request operation, after the
-   * user has entered an email into the reset form.
-   *
-   * @param request {DeleteAccountRequest}
-   *
-   * @return {Promise}
-   */
-  static async handlePost (request) {
-    try {
-      request.validate()
-      const userAccount = await request.loadUser()
-      await request.sendDeleteLink(userAccount)
-      return request.renderSuccess()
-    } catch (error) {
-      return request.error(error)
-    }
+
+  static async handlePost (request) {
+    try {
+      request.validate()
+      const userAccount = await request.loadUser()
+      await request.sendDeleteLink(userAccount)
+      return request.renderSuccess()
+    } catch (error) {
+      return request.error(error)
+    }
   }
-
-  static get (req, res) {
-    const request = DeleteAccountRequest.fromParams(req, res)
-
-    request.renderForm()
+
+  static get (req, res) {
+    const request = DeleteAccountRequest.fromParams(req, res)
+    request.renderForm()
   }
-
-  static fromParams (req, res) {
-    const locals = req.app.locals
-    const accountManager = locals.accountManager
-    const username = this.parseParameter(req, 'username')
-
-    const options = {
-      accountManager,
-      response: res,
-      username
-    }
-
-    return new DeleteAccountRequest(options)
-  }
-}
-
-module.exports = DeleteAccountRequest
+
+  static fromParams (req, res) {
+    const locals = req.app.locals
+    const accountManager = locals.accountManager
+    const username = this.parseParameter(req, 'username')
+    const options = { accountManager, response: res, username }
+    return new DeleteAccountRequest(options)
+  }
+}

package/lib/requests/login-request.mjs

@@ -0,0 +1,89 @@
+import debugModule from '../debug.mjs'
+import AuthRequest from './auth-request.mjs'
+import { PasswordAuthenticator, TlsAuthenticator } from '../models/authenticator.mjs'
+
+const debug = debugModule.authentication
+
+export const PASSWORD_AUTH = 'password'
+export const TLS_AUTH = 'tls'
+
+export class LoginRequest extends AuthRequest {
+  constructor (options) {
+    super(options)
+    this.authenticator = options.authenticator
+    this.authMethod = options.authMethod
+  }
+
+  static fromParams (req, res, authMethod) {
+    const options = AuthRequest.requestOptions(req, res)
+    options.authMethod = authMethod
+    switch (authMethod) {
+      case PASSWORD_AUTH:
+        options.authenticator = PasswordAuthenticator.fromParams(req, options)
+        break
+      case TLS_AUTH:
+        options.authenticator = TlsAuthenticator.fromParams(req, options)
+        break
+      default:
+        options.authenticator = null
+        break
+    }
+    return new LoginRequest(options)
+  }
+
+  static get (req, res) {
+    const request = LoginRequest.fromParams(req, res)
+    request.renderForm(null, req)
+  }
+
+  static loginPassword (req, res) {
+    debug('Logging in via username + password')
+    const request = LoginRequest.fromParams(req, res, PASSWORD_AUTH)
+    return LoginRequest.login(request)
+  }
+
+  static loginTls (req, res) {
+    debug('Logging in via WebID-TLS certificate')
+    const request = LoginRequest.fromParams(req, res, TLS_AUTH)
+    return LoginRequest.login(request)
+  }
+
+  static login (request) {
+    return request.authenticator.findValidUser()
+      .then(validUser => {
+        request.initUserSession(validUser)
+        request.redirectPostLogin(validUser)
+      })
+      .catch(error => request.error(error))
+  }
+
+  postLoginUrl (validUser) {
+    if (/token|code/.test(this.authQueryParams.response_type)) {
+      return this.sharingUrl()
+    } else if (validUser) {
+      return this.authQueryParams.redirect_uri || validUser.accountUri
+    }
+  }
+
+  redirectPostLogin (validUser) {
+    const uri = this.postLoginUrl(validUser)
+    debug('Login successful, redirecting to ', uri)
+    this.response.redirect(uri)
+  }
+
+  renderForm (error, req) {
+    const queryString = (req && req.url && req.url.replace(/[^?]+\?/, '')) || ''
+    const params = Object.assign({}, this.authQueryParams, {
+      registerUrl: this.registerUrl(),
+      returnToUrl: this.returnToUrl,
+      enablePassword: this.localAuth.password,
+      enableTls: this.localAuth.tls,
+      tlsUrl: `/login/tls?${encodeURIComponent(queryString)}`
+    })
+    if (error) {
+      params.error = error.message
+      this.response.status(error.statusCode)
+    }
+    this.response.render('auth/login', params)
+  }
+}