solid-server 5.8.7 → 5.8.8-22f4cfec

package/lib/requests/password-reset-request.mjs

@@ -0,0 +1,47 @@
+export default class PasswordResetRequest {
+  constructor (options) {
+    this.accountManager = options.accountManager
+    this.email = options.email
+    this.response = options.response
+  }
+
+  static handle (req, res, accountManager) {
+    let request
+    try {
+      request = PasswordResetRequest.fromParams(req, res, accountManager)
+    } catch (error) {
+      return Promise.reject(error)
+    }
+    return PasswordResetRequest.resetPassword(request)
+  }
+
+  static fromParams (req, res, accountManager) {
+    const email = req.body.email
+    if (!email) {
+      const error = new Error('Email is required for password reset')
+      error.status = 400
+      throw error
+    }
+    const options = { accountManager, email, response: res }
+    return new PasswordResetRequest(options)
+  }
+
+  static resetPassword (request) {
+    const { accountManager, email } = request
+    return accountManager.resetPassword(email)
+      .catch(err => {
+        err.status = 400
+        err.message = 'Error resetting password: ' + err.message
+        throw err
+      })
+      .then(() => {
+        request.sendResponse()
+      })
+  }
+
+  sendResponse () {
+    const { response } = this
+    response.status(200)
+    response.send({ message: 'Password reset email sent' })
+  }
+}

package/lib/requests/register-request.mjs

@@ -0,0 +1,48 @@
+export default class RegisterRequest {
+  constructor (options) {
+    this.accountManager = options.accountManager
+    this.userAccount = options.userAccount
+    this.response = options.response
+  }
+
+  static handle (req, res, accountManager) {
+    let request
+    try {
+      request = RegisterRequest.fromParams(req, res, accountManager)
+    } catch (error) {
+      return Promise.reject(error)
+    }
+    return RegisterRequest.register(request)
+  }
+
+  static fromParams (req, res, accountManager) {
+    const userAccount = accountManager.userAccountFrom(req.body)
+    if (!userAccount) {
+      const error = new Error('User account information is required')
+      error.status = 400
+      throw error
+    }
+    const options = { accountManager, userAccount, response: res }
+    return new RegisterRequest(options)
+  }
+
+  static register (request) {
+    const { accountManager, userAccount } = request
+    return accountManager.register(userAccount)
+      .catch(err => {
+        err.status = 400
+        err.message = 'Error registering user: ' + err.message
+        throw err
+      })
+      .then(() => {
+        request.sendResponse()
+      })
+  }
+
+  sendResponse () {
+    const { response, userAccount } = this
+    response.set('User', userAccount.webId)
+    response.status(201)
+    response.send({ message: 'User registered successfully' })
+  }
+}

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

@@ -1,261 +1,174 @@
-'use strict'
-/* eslint-disable no-mixed-operators, no-async-promise-executor */
-
-const debug = require('./../debug').authentication
-
-const AuthRequest = require('./auth-request')
-
-const url = require('url')
-const intoStream = require('into-stream')
-
-const $rdf = require('rdflib')
-const ACL = $rdf.Namespace('http://www.w3.org/ns/auth/acl#')
-
-/**
- * Models a local Login request
- */
-class SharingRequest extends AuthRequest {
-  /**
-   * @constructor
-   * @param options {Object}
-   *
-   * @param [options.response] {ServerResponse} middleware `res` object
-   * @param [options.session] {Session} req.session
-   * @param [options.userStore] {UserStore}
-   * @param [options.accountManager] {AccountManager}
-   * @param [options.returnToUrl] {string}
-   * @param [options.authQueryParams] {Object} Key/value hashmap of parsed query
-   *   parameters that will be passed through to the /authorize endpoint.
-   * @param [options.authenticator] {Authenticator} Auth strategy by which to
-   *   log in
-   */
-  constructor (options) {
-    super(options)
-
-    this.authenticator = options.authenticator
-    this.authMethod = options.authMethod
-  }
-
-  /**
-   * Factory method, returns an initialized instance of LoginRequest
-   * from an incoming http request.
-   *
-   * @param req {IncomingRequest}
-   * @param res {ServerResponse}
-   * @param authMethod {string}
-   *
-   * @return {LoginRequest}
-   */
-  static fromParams (req, res) {
-    const options = AuthRequest.requestOptions(req, res)
-
-    return new SharingRequest(options)
-  }
-
-  /**
-   * Handles a Login GET request on behalf of a middleware handler, displays
-   * the Login page.
-   * Usage:
-   *
-   *   ```
-   *   app.get('/login', LoginRequest.get)
-   *   ```
-   *
-   * @param req {IncomingRequest}
-   * @param res {ServerResponse}
-   */
-  static async get (req, res, next) {
-    const request = SharingRequest.fromParams(req, res)
-
-    const appUrl = request.getAppUrl()
-    if (!appUrl) return next()
-    const appOrigin = appUrl.origin
-    const serverUrl = new url.URL(req.app.locals.ldp.serverUri)
-
-    // Check if is already registered or is data browser or the webId is not on this machine
-    if (request.isUserLoggedIn()) {
-      if (
-        !request.isSubdomain(serverUrl.host, new url.URL(request.session.subject._id).host) ||
-        (appUrl && request.isSubdomain(serverUrl.host, appUrl.host) && appUrl.protocol === serverUrl.protocol) ||
-        await request.isAppRegistered(req.app.locals.ldp, appOrigin, request.session.subject._id)
-      ) {
-        request.setUserShared(appOrigin)
-        request.redirectPostSharing()
-      } else {
-        request.renderForm(null, req, appOrigin)
-      }
-    } else {
-      request.redirectPostSharing()
-    }
-  }
-
-  /**
-   * Performs the login operation -- loads and validates the
-   * appropriate user, inits the session with credentials, and redirects the
-   * user to continue their auth flow.
-   *
-   * @param request {LoginRequest}
-   *
-   * @return {Promise}
-   */
-  static async share (req, res) {
-    let accessModes = []
-    let consented = false
-    if (req.body) {
-      accessModes = req.body.access_mode || []
-      if (!Array.isArray(accessModes)) {
-        accessModes = [accessModes]
-      }
-      consented = req.body.consent
-    }
-
-    const request = SharingRequest.fromParams(req, res)
-
-    if (request.isUserLoggedIn()) {
-      const appUrl = request.getAppUrl()
-      const appOrigin = `${appUrl.protocol}//${appUrl.host}`
-      debug('Sharing App')
-
-      if (consented) {
-        await request.registerApp(req.app.locals.ldp, appOrigin, accessModes, request.session.subject._id)
-        request.setUserShared(appOrigin)
-      }
-
-      // Redirect once that's all done
-      request.redirectPostSharing()
-    } else {
-      request.redirectPostSharing()
-    }
-  }
-
-  isSubdomain (domain, subdomain) {
-    const domainArr = domain.split('.')
-    const subdomainArr = subdomain.split('.')
-    for (let i = 1; i <= domainArr.length; i++) {
-      if (subdomainArr[subdomainArr.length - i] !== domainArr[domainArr.length - i]) {
-        return false
-      }
-    }
-    return true
-  }
-
-  setUserShared (appOrigin) {
-    if (!this.session.consentedOrigins) {
-      this.session.consentedOrigins = []
-    }
-    if (!this.session.consentedOrigins.includes(appOrigin)) {
-      this.session.consentedOrigins.push(appOrigin)
-    }
-  }
-
-  isUserLoggedIn () {
-    // Ensure the user arrived here by logging in
-    return !!(this.session.subject && this.session.subject._id)
-  }
-
-  getAppUrl () {
-    if (!this.authQueryParams.redirect_uri) return
-    return new url.URL(this.authQueryParams.redirect_uri)
-  }
-
-  async getProfileGraph (ldp, webId) {
-    return await new Promise(async (resolve, reject) => {
-      const store = $rdf.graph()
-      const profileText = await ldp.readResource(webId)
-      $rdf.parse(profileText.toString(), store, this.getWebIdFile(webId), 'text/turtle', (error, kb) => {
-        if (error) {
-          reject(error)
-        } else {
-          resolve(kb)
-        }
-      })
-    })
-  }
-
-  async saveProfileGraph (ldp, store, webId) {
-    const text = $rdf.serialize(undefined, store, this.getWebIdFile(webId), 'text/turtle')
-    await ldp.put(webId, intoStream(text), 'text/turtle')
-  }
-
-  getWebIdFile (webId) {
-    const webIdurl = new url.URL(webId)
-    return `${webIdurl.origin}${webIdurl.pathname}`
-  }
-
-  async isAppRegistered (ldp, appOrigin, webId) {
-    const store = await this.getProfileGraph(ldp, webId)
-    return store.each($rdf.sym(webId), ACL('trustedApp')).find((app) => {
-      return store.each(app, ACL('origin')).find(rdfAppOrigin => rdfAppOrigin.value === appOrigin)
-    })
-  }
-
-  async registerApp (ldp, appOrigin, accessModes, webId) {
-    debug(`Registering app (${appOrigin}) with accessModes ${accessModes} for webId ${webId}`)
-    const store = await this.getProfileGraph(ldp, webId)
-    const origin = $rdf.sym(appOrigin)
-    // remove existing statements on same origin - if it exists
-    store.statementsMatching(null, ACL('origin'), origin).forEach(st => {
-      store.removeStatements([...store.statementsMatching(null, ACL('trustedApp'), st.subject)])
-      store.removeStatements([...store.statementsMatching(st.subject)])
-    })
-
-    // add new triples
-    const application = new $rdf.BlankNode()
-    store.add($rdf.sym(webId), ACL('trustedApp'), application, new $rdf.NamedNode(webId))
-    store.add(application, ACL('origin'), origin, new $rdf.NamedNode(webId))
-
-    accessModes.forEach(mode => {
-      store.add(application, ACL('mode'), ACL(mode))
-    })
-    await this.saveProfileGraph(ldp, store, webId)
-  }
-
-  /**
-   * Returns a URL to redirect the user to after login.
-   * Either uses the provided `redirect_uri` auth query param, or simply
-   * returns the user profile URI if none was provided.
-   *
-   * @param validUser {UserAccount}
-   *
-   * @return {string}
-   */
-  postSharingUrl () {
-    return this.authorizeUrl()
-  }
-
-  /**
-   * Redirects the Login request to continue on the OIDC auth workflow.
-   */
-  redirectPostSharing () {
-    const uri = this.postSharingUrl()
-    debug('Login successful, redirecting to ', uri)
-    this.response.redirect(uri)
-  }
-
-  /**
-   * Renders the login form
-   */
-  renderForm (error, req, appOrigin) {
-    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)}`,
-        app_origin: appOrigin
-      })
-
-    if (error) {
-      params.error = error.message
-      this.response.status(error.statusCode)
-    }
-
-    this.response.render('auth/sharing', params)
-  }
-}
-
-module.exports = {
-  SharingRequest
-}
+import debugModule from '../debug.mjs'
+import AuthRequest from './auth-request.mjs'
+import url from 'url'
+import intoStream from 'into-stream'
+import * as $rdf from 'rdflib'
+
+const debug = debugModule.authentication
+const ACL = $rdf.Namespace('http://www.w3.org/ns/auth/acl#')
+
+export class SharingRequest extends AuthRequest {
+  constructor (options) {
+    super(options)
+    this.authenticator = options.authenticator
+    this.authMethod = options.authMethod
+  }
+
+  static fromParams (req, res) {
+    const options = AuthRequest.requestOptions(req, res)
+    return new SharingRequest(options)
+  }
+
+  static async get (req, res, next) {
+    const request = SharingRequest.fromParams(req, res)
+    const appUrl = request.getAppUrl()
+    if (!appUrl) return next()
+    const appOrigin = appUrl.origin
+    const serverUrl = new url.URL(req.app.locals.ldp.serverUri)
+    if (request.isUserLoggedIn()) {
+      if (
+        !request.isSubdomain(serverUrl.host, new url.URL(request.session.subject._id).host) ||
+        (appUrl && request.isSubdomain(serverUrl.host, appUrl.host) && appUrl.protocol === serverUrl.protocol) ||
+        await request.isAppRegistered(req.app.locals.ldp, appOrigin, request.session.subject._id)
+      ) {
+        request.setUserShared(appOrigin)
+        request.redirectPostSharing()
+      } else {
+        request.renderForm(null, req, appOrigin)
+      }
+    } else {
+      request.redirectPostSharing()
+    }
+  }
+
+  static async share (req, res) {
+    let accessModes = []
+    let consented = false
+    if (req.body) {
+      accessModes = req.body.access_mode || []
+      if (!Array.isArray(accessModes)) {
+        accessModes = [accessModes]
+      }
+      consented = req.body.consent
+    }
+    const request = SharingRequest.fromParams(req, res)
+    if (request.isUserLoggedIn()) {
+      const appUrl = request.getAppUrl()
+      const appOrigin = `${appUrl.protocol}//${appUrl.host}`
+      debug('Sharing App')
+      if (consented) {
+        await request.registerApp(req.app.locals.ldp, appOrigin, accessModes, request.session.subject._id)
+        request.setUserShared(appOrigin)
+      }
+      request.redirectPostSharing()
+    } else {
+      request.redirectPostSharing()
+    }
+  }
+
+  isSubdomain (domain, subdomain) {
+    const domainArr = domain.split('.')
+    const subdomainArr = subdomain.split('.')
+    for (let i = 1; i <= domainArr.length; i++) {
+      if (subdomainArr[subdomainArr.length - i] !== domainArr[domainArr.length - i]) {
+        return false
+      }
+    }
+    return true
+  }
+
+  setUserShared (appOrigin) {
+    if (!this.session.consentedOrigins) {
+      this.session.consentedOrigins = []
+    }
+    if (!this.session.consentedOrigins.includes(appOrigin)) {
+      this.session.consentedOrigins.push(appOrigin)
+    }
+  }
+
+  isUserLoggedIn () {
+    return !!(this.session.subject && this.session.subject._id)
+  }
+
+  getAppUrl () {
+    if (!this.authQueryParams.redirect_uri) return
+    return new url.URL(this.authQueryParams.redirect_uri)
+  }
+
+  async getProfileGraph (ldp, webId) {
+    const store = $rdf.graph()
+    const profileText = await ldp.readResource(webId)
+    return new Promise((resolve, reject) => {
+      $rdf.parse(profileText.toString(), store, this.getWebIdFile(webId), 'text/turtle', (error, kb) => {
+        if (error) {
+          reject(error)
+        } else {
+          resolve(kb)
+        }
+      })
+    })
+  }
+
+  async saveProfileGraph (ldp, store, webId) {
+    const text = $rdf.serialize(undefined, store, this.getWebIdFile(webId), 'text/turtle')
+    await ldp.put(webId, intoStream(text), 'text/turtle')
+  }
+
+  getWebIdFile (webId) {
+    const webIdurl = new url.URL(webId)
+    return `${webIdurl.origin}${webIdurl.pathname}`
+  }
+
+  async isAppRegistered (ldp, appOrigin, webId) {
+    const store = await this.getProfileGraph(ldp, webId)
+    return store.each($rdf.sym(webId), ACL('trustedApp')).find((app) => {
+      return store.each(app, ACL('origin')).find(rdfAppOrigin => rdfAppOrigin.value === appOrigin)
+    })
+  }
+
+  async registerApp (ldp, appOrigin, accessModes, webId) {
+    debug(`Registering app (${appOrigin}) with accessModes ${accessModes} for webId ${webId}`)
+    const store = await this.getProfileGraph(ldp, webId)
+    const origin = $rdf.sym(appOrigin)
+    store.statementsMatching(null, ACL('origin'), origin).forEach(st => {
+      store.removeStatements([...store.statementsMatching(null, ACL('trustedApp'), st.subject)])
+      store.removeStatements([...store.statementsMatching(st.subject)])
+    })
+    const application = new $rdf.BlankNode()
+    store.add($rdf.sym(webId), ACL('trustedApp'), application, new $rdf.NamedNode(webId))
+    store.add(application, ACL('origin'), origin, new $rdf.NamedNode(webId))
+    accessModes.forEach(mode => {
+      store.add(application, ACL('mode'), ACL(mode))
+    })
+    await this.saveProfileGraph(ldp, store, webId)
+  }
+
+  postSharingUrl () {
+    return this.authorizeUrl()
+  }
+
+  redirectPostSharing () {
+    const uri = this.postSharingUrl()
+    debug('Login successful, redirecting to ', uri)
+    this.response.redirect(uri)
+  }
+
+  renderForm (error, req, appOrigin) {
+    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)}`,
+      app_origin: appOrigin
+    })
+    if (error) {
+      params.error = error.message
+      this.response.status(error.statusCode)
+    }
+    this.response.render('auth/sharing', params)
+  }
+}
+
+export default SharingRequest

package/lib/{resource-mapper.js → resource-mapper.mjs}

@@ -1,11 +1,12 @@
 /* eslint-disable node/no-deprecated-api, no-mixed-operators */
 
-const fs = require('fs')
-const URL = require('url')
-const { promisify } = require('util')
-const { types, extensions } = require('mime-types')
+import fs from 'fs'
+import URL from 'url'
+import { promisify } from 'util'
+import mime from 'mime-types'
+import HTTPError from './http-error.mjs'
+const { types, extensions } = mime
 const readdir = promisify(fs.readdir)
-const HTTPError = require('./http-error')
 
 /*
  * A ResourceMapper maintains the mapping between HTTP URLs and server filenames,
@@ -223,4 +224,4 @@ class ResourceMapper {
   }
 }
 
-module.exports = ResourceMapper
+export default ResourceMapper

package/lib/{server-config.js → server-config.mjs}

@@ -1,15 +1,19 @@
-'use strict'
-
 /**
  * Server config initialization utilities
  */
 
-const fs = require('fs-extra')
-const path = require('path')
-const templateUtils = require('./common/template-utils')
-const fsUtils = require('./common/fs-utils')
+import fs from 'fs-extra'
+import path from 'path'
+import { processHandlebarFile } from './common/template-utils.mjs'
+import { copyTemplateDir } from './common/fs-utils.mjs'
+import { fileURLToPath } from 'url'
+
+import debug from './debug.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
-const debug = require('./debug')
+export { ensureDirCopyExists, ensureWelcomePage, initConfigDir, initDefaultViews, initTemplateDirs, printDebugInfo }
 
 function printDebugInfo (options) {
   debug.settings('Server URI: ' + options.serverUri)
@@ -61,12 +65,12 @@ async function ensureWelcomePage (argv) {
   const { resourceMapper, templates, server, host } = argv
   const serverRootDir = resourceMapper.resolveFilePath(host.hostname)
   const existingIndexPage = path.join(serverRootDir, 'index.html')
-  const packageData = require('../package.json')
+  const packageData = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json')))
 
   if (!fs.existsSync(existingIndexPage)) {
     fs.mkdirp(serverRootDir)
-    await fsUtils.copyTemplateDir(templates.server, serverRootDir)
-    await templateUtils.processHandlebarFile(existingIndexPage, {
+    await copyTemplateDir(templates.server, serverRootDir)
+    await processHandlebarFile(existingIndexPage, {
       serverName: server ? server.name : host.hostname,
       serverDescription: server ? server.description : '',
       serverLogo: server ? server.logo : '',
@@ -78,7 +82,7 @@ async function ensureWelcomePage (argv) {
   // because this was not mandatory in before 5.0.0
   const existingRootAcl = path.join(serverRootDir, '.acl')
   if (!fs.existsSync(existingRootAcl)) {
-    await fsUtils.copyTemplateDir(path.join(templates.server, '.acl'), existingRootAcl)
+    await copyTemplateDir(path.join(templates.server, '.acl'), existingRootAcl)
   }
 }
 
@@ -156,12 +160,3 @@ function initTemplateDirs (configPath) {
     server: serverTemplatePath
   }
 }
-
-module.exports = {
-  ensureDirCopyExists,
-  ensureWelcomePage,
-  initConfigDir,
-  initDefaultViews,
-  initTemplateDirs,
-  printDebugInfo
-}