solid-server 5.8.8 → 6.0.0-2caddca5

package/CHANGELOG.md

@@ -1,4 +1,20 @@
 # History
+## 6.0.0
+- CommonJs to ESM (.mjs)
+- support for mashlib >= 2.0.0
+- support solid-OIDC with WebID scope, es256, and rfc9702
+
+## 6.0.0 Upgrade Notes
+
+1.0 Automatically recreated
+- delete `.db/oidc/op/provider.json`
+- delete `config/templates/emails`
+  If not recreated then copy from `default-emails`
+  If there was some personalisation these need to be redone
+
+2.0 Manuel update the `index.html` in server root `data/<serverOrigin>/index.html`
+  edit `common/js/index-buttons.js` to `index-buttons.mjs`
+  
 ## 5.3.0
 - Support for webid-oidc with DPop tokens
 

package/README.md

@@ -146,6 +146,9 @@ also add to `config.json`
   "emailAuthPass": "gmailPass"
 ```
 
+### Upgrading from version <6.0.0
+Please take into account the [v6.0.0 upgrade notes](https://github.com/solid/node-solid-server/blob/master/CHANGELOG.md#600-upgrade-notes).
+
 ### Upgrading from version <5.3
 Please take into account the [v5.3 upgrade notes](https://github.com/solid/node-solid-server/blob/master/CHANGELOG.md#530-upgrade-notes).
 

package/bin/lib/cli-utils.mjs

@@ -0,0 +1,54 @@
+import fs from 'fs-extra'
+import { red, cyan, bold } from 'colorette'
+import { URL } from 'url'
+import LDP from '../../lib/ldp.mjs'
+import AccountManager from '../../lib/models/account-manager.mjs'
+import SolidHost from '../../lib/models/solid-host.mjs'
+
+export function getAccountManager (config, options = {}) {
+  const ldp = options.ldp || new LDP(config)
+  const host = options.host || SolidHost.from({ port: config.port, serverUri: config.serverUri })
+  return AccountManager.from({
+    host,
+    store: ldp,
+    multiuser: config.multiuser
+  })
+}
+
+export function loadConfig (program, options) {
+  let argv = {
+    ...options,
+    version: program.version()
+  }
+  const configFile = argv.configFile || './config.json'
+  try {
+    const file = fs.readFileSync(configFile)
+    const config = JSON.parse(file)
+    argv = { ...config, ...argv }
+  } catch (err) {
+    if (typeof argv.configFile !== 'undefined') {
+      if (!fs.existsSync(configFile)) {
+        console.log(red(bold('ERR')), 'Config file ' + configFile + " doesn't exist.")
+        process.exit(1)
+      }
+    }
+    if (fs.existsSync(configFile)) {
+      console.log(red(bold('ERR')), 'config file ' + configFile + " couldn't be parsed: " + err)
+      process.exit(1)
+    }
+    console.log(cyan(bold('TIP')), 'create a config.json: `$ solid init`')
+  }
+  return argv
+}
+
+export function loadAccounts ({ root, serverUri, hostname }) {
+  const files = fs.readdirSync(root)
+  hostname = hostname || new URL(serverUri).hostname
+  const isUserDirectory = new RegExp(`.${hostname}$`)
+  return files.filter(file => isUserDirectory.test(file))
+}
+
+export function loadUsernames ({ root, serverUri }) {
+  const hostname = new URL(serverUri).hostname
+  return loadAccounts({ root, hostname }).map(userDirectory => userDirectory.substr(0, userDirectory.length - hostname.length - 1))
+}

package/bin/lib/cli.mjs

@@ -0,0 +1,44 @@
+import { Command } from 'commander'
+import loadInit from './init.mjs'
+import loadStart from './start.mjs'
+import loadInvalidUsernames from './invalidUsernames.mjs'
+import loadMigrateLegacyResources from './migrateLegacyResources.mjs'
+import loadUpdateIndex from './updateIndex.mjs'
+import { spawnSync } from 'child_process'
+import path from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default function startCli (server) {
+  const program = new Command()
+  program.version(getVersion())
+
+  loadInit(program)
+  loadStart(program, server)
+  loadInvalidUsernames(program)
+  loadMigrateLegacyResources(program)
+  loadUpdateIndex(program)
+
+  program.parse(process.argv)
+  if (program.args.length === 0) program.help()
+}
+
+function getVersion () {
+  try {
+    const options = { cwd: __dirname, encoding: 'utf8' }
+    const { stdout } = spawnSync('git', ['describe', '--tags'], options)
+    const { stdout: gitStatusStdout } = spawnSync('git', ['status'], options)
+    const version = stdout.trim()
+    if (version === '' || gitStatusStdout.match('Not currently on any branch')) {
+      throw new Error('No git version here')
+    }
+    return version
+  } catch (e) {
+    const pkgPath = path.join(__dirname, '../../package.json')
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+    return pkg.version
+  }
+}

package/bin/lib/{init.js → init.mjs}

@@ -1,94 +1,93 @@
-const inquirer = require('inquirer')
-const fs = require('fs')
-const options = require('./options')
-const camelize = require('camelize')
-
-let questions = options
-  .map((option) => {
-    if (!option.type) {
-      if (option.flag) {
-        option.type = 'confirm'
-      } else {
-        option.type = 'input'
-      }
-    }
-
-    option.message = option.question || option.help
-    return option
-  })
-
-module.exports = function (program) {
-  program
-    .command('init')
-    .option('--advanced', 'Ask for all the settings')
-    .description('create solid server configurations')
-    .action((opts) => {
-      // Filter out advanced commands
-      if (!opts.advanced) {
-        questions = questions.filter((option) => option.prompt)
-      }
-
-      // Prompt to the user
-      inquirer.prompt(questions)
-        .then((answers) => {
-          manipulateEmailSection(answers)
-          manipulateServerSection(answers)
-          cleanupAnswers(answers)
-
-          // write config file
-          const config = JSON.stringify(camelize(answers), null, '  ')
-          const configPath = process.cwd() + '/config.json'
-
-          fs.writeFile(configPath, config, (err) => {
-            if (err) {
-              return console.log('failed to write config.json')
-            }
-            console.log('config created on', configPath)
-          })
-        })
-        .catch((err) => {
-          console.log('Error:', err)
-        })
-    })
-}
-
-function cleanupAnswers (answers) {
-  // clean answers
-  Object.keys(answers).forEach((answer) => {
-    if (answer.startsWith('use')) {
-      delete answers[answer]
-    }
-  })
-}
-
-function manipulateEmailSection (answers) {
-  // setting email
-  if (answers.useEmail) {
-    answers.email = {
-      host: answers['email-host'],
-      port: answers['email-port'],
-      secure: true,
-      auth: {
-        user: answers['email-auth-user'],
-        pass: answers['email-auth-pass']
-      }
-    }
-    delete answers['email-host']
-    delete answers['email-port']
-    delete answers['email-auth-user']
-    delete answers['email-auth-pass']
-  }
-}
-
-function manipulateServerSection (answers) {
-  answers.server = {
-    name: answers['server-info-name'],
-    description: answers['server-info-description'],
-    logo: answers['server-info-logo']
-  }
-  Object.keys(answers).forEach((answer) => {
-    if (answer.startsWith('server-info-')) {
-      delete answers[answer]
-    }
-  })
-}
+import inquirer from 'inquirer'
+import fs from 'fs'
+import options from './options.mjs'
+import camelize from 'camelize'
+
+const questions = options
+  .map((option) => {
+    if (!option.type) {
+      if (option.flag) {
+        option.type = 'confirm'
+      } else {
+        option.type = 'input'
+      }
+    }
+
+    option.message = option.question || option.help
+    return option
+  })
+
+export default function (program) {
+  program
+    .command('init')
+    .option('--advanced', 'Ask for all the settings')
+    .description('create solid server configurations')
+    .action((opts) => {
+      // Filter out advanced commands
+      let filtered = questions
+      if (!opts.advanced) {
+        filtered = filtered.filter((option) => option.prompt)
+      }
+
+      // Prompt to the user
+      inquirer.prompt(filtered)
+        .then((answers) => {
+          manipulateEmailSection(answers)
+          manipulateServerSection(answers)
+          cleanupAnswers(answers)
+
+          // write config file
+          const config = JSON.stringify(camelize(answers), null, '  ')
+          const configPath = process.cwd() + '/config.json'
+
+          fs.writeFile(configPath, config, (err) => {
+            if (err) {
+              return console.log('failed to write config.json')
+            }
+            console.log('config created on', configPath)
+          })
+        })
+        .catch((err) => {
+          console.log('Error:', err)
+        })
+    })
+}
+
+function cleanupAnswers (answers) {
+  Object.keys(answers).forEach((answer) => {
+    if (answer.startsWith('use')) {
+      delete answers[answer]
+    }
+  })
+}
+
+function manipulateEmailSection (answers) {
+  if (answers.useEmail) {
+    answers.email = {
+      host: answers['email-host'],
+      port: answers['email-port'],
+      secure: true,
+      auth: {
+        user: answers['email-auth-user'],
+        pass: answers['email-auth-pass']
+      }
+    }
+    delete answers['email-host']
+    delete answers['email-port']
+    delete answers['email-auth-user']
+    delete answers['email-auth-pass']
+  }
+}
+
+function manipulateServerSection (answers) {
+  answers.server = {
+    name: answers['server-info-name'],
+    description: answers['server-info-description'],
+    logo: answers['server-info-logo']
+  }
+  Object.keys(answers).forEach((answer) => {
+    if (answer.startsWith('server-info-')) {
+      delete answers[answer]
+    }
+  })
+}

package/bin/lib/{invalidUsernames.js → invalidUsernames.mjs}

@@ -1,148 +1,136 @@
-const fs = require('fs-extra')
-const Handlebars = require('handlebars')
-const path = require('path')
-
-const { getAccountManager, loadConfig, loadUsernames } = require('./cli-utils')
-const { isValidUsername } = require('../../lib/common/user-utils')
-const blacklistService = require('../../lib/services/blacklist-service')
-const { initConfigDir, initTemplateDirs } = require('../../lib/server-config')
-const { fromServerConfig } = require('../../lib/models/oidc-manager')
-
-const EmailService = require('../../lib/services/email-service')
-const SolidHost = require('../../lib/models/solid-host')
-
-module.exports = function (program) {
-  program
-    .command('invalidusernames')
-    .option('--notify', 'Will notify users with usernames that are invalid')
-    .option('--delete', 'Will delete users with usernames that are invalid')
-    .description('Manage usernames that are invalid')
-    .action(async (options) => {
-      const config = loadConfig(program, options)
-      if (!config.multiuser) {
-        return console.error('You are running a single user server, no need to check for invalid usernames')
-      }
-
-      const invalidUsernames = getInvalidUsernames(config)
-      const host = SolidHost.from({ port: config.port, serverUri: config.serverUri })
-      const accountManager = getAccountManager(config, { host })
-
-      if (options.notify) {
-        return notifyUsers(invalidUsernames, accountManager, config)
-      }
-
-      if (options.delete) {
-        return deleteUsers(invalidUsernames, accountManager, config, host)
-      }
-
-      listUsernames(invalidUsernames)
-    })
-}
-
-function backupIndexFile (username, accountManager, invalidUsernameTemplate, dateOfRemoval, supportEmail) {
-  const userDirectory = accountManager.accountDirFor(username)
-  const currentIndex = path.join(userDirectory, 'index.html')
-  const currentIndexExists = fs.existsSync(currentIndex)
-  const backupIndex = path.join(userDirectory, 'index.backup.html')
-  const backupIndexExists = fs.existsSync(backupIndex)
-  if (currentIndexExists && !backupIndexExists) {
-    fs.renameSync(currentIndex, backupIndex)
-    createNewIndexAcl(userDirectory)
-    createNewIndex(username, invalidUsernameTemplate, dateOfRemoval, supportEmail, currentIndex)
-    console.info(`index.html updated for user ${username}`)
-  }
-}
-
-function createNewIndex (username, invalidUsernameTemplate, dateOfRemoval, supportEmail, currentIndex) {
-  const newIndexSource = invalidUsernameTemplate({
-    username,
-    dateOfRemoval,
-    supportEmail
-  })
-  fs.writeFileSync(currentIndex, newIndexSource, 'utf-8')
-}
-
-function createNewIndexAcl (userDirectory) {
-  const currentIndexAcl = path.join(userDirectory, 'index.html.acl')
-  const backupIndexAcl = path.join(userDirectory, 'index.backup.html.acl')
-  const currentIndexSource = fs.readFileSync(currentIndexAcl, 'utf-8')
-  const backupIndexSource = currentIndexSource.replace(/index.html/g, 'index.backup.html')
-  fs.writeFileSync(backupIndexAcl, backupIndexSource, 'utf-8')
-}
-
-async function deleteUsers (usernames, accountManager, config, host) {
-  const oidcManager = fromServerConfig({
-    ...config,
-    host
-  })
-  const deletingUsers = usernames
-    .map(async username => {
-      try {
-        const user = accountManager.userAccountFrom({ username })
-        await oidcManager.users.deleteUser(user)
-      } catch (error) {
-        if (error.message !== 'No email given') {
-          // 'No email given' is an expected error that we want to ignore
-          throw error
-        }
-      }
-      const userDirectory = accountManager.accountDirFor(username)
-      await fs.remove(userDirectory)
-    })
-  await Promise.all(deletingUsers)
-  console.info(`Deleted ${deletingUsers.length} users succeeded`)
-}
-
-function getInvalidUsernames (config) {
-  const usernames = loadUsernames(config)
-  return usernames.filter(username => !isValidUsername(username) || !blacklistService.validate(username))
-}
-
-function listUsernames (usernames) {
-  if (usernames.length === 0) {
-    return console.info('No invalid usernames was found')
-  }
-  console.info(`${usernames.length} invalid usernames were found:${usernames.map(username => `\n- ${username}`)}`)
-}
-
-async function notifyUsers (usernames, accountManager, config) {
-  const twoWeeksFromNow = Date.now() + 14 * 24 * 60 * 60 * 1000
-  const dateOfRemoval = (new Date(twoWeeksFromNow)).toLocaleDateString()
-  const { supportEmail } = config
-
-  updateIndexFiles(usernames, accountManager, dateOfRemoval, supportEmail)
-  await sendEmails(config, usernames, accountManager, dateOfRemoval, supportEmail)
-}
-
-async function sendEmails (config, usernames, accountManager, dateOfRemoval, supportEmail) {
-  if (config.email && config.email.host) {
-    const configPath = initConfigDir(config)
-    const templates = initTemplateDirs(configPath)
-    const users = await Promise.all(await usernames.map(async username => {
-      const emailAddress = await accountManager.loadAccountRecoveryEmail({ username })
-      const accountUri = accountManager.accountUriFor(username)
-      return { username, emailAddress, accountUri }
-    }))
-    const emailService = new EmailService(templates.email, config.email)
-    const sendingEmails = users
-      .filter(user => !!user.emailAddress)
-      .map(user => emailService.sendWithTemplate('invalid-username', {
-        to: user.emailAddress,
-        accountUri: user.accountUri,
-        dateOfRemoval,
-        supportEmail
-      }))
-    const emailsSent = await Promise.all(sendingEmails)
-    console.info(`${emailsSent.length} emails sent to users with invalid usernames`)
-    return
-  }
-  console.info('You have not configured an email service.')
-  console.info('Please set it up to send users email about their accounts')
-}
-
-function updateIndexFiles (usernames, accountManager, dateOfRemoval, supportEmail) {
-  const invalidUsernameFilePath = path.join(process.cwd(), 'default-views', 'account', 'invalid-username.hbs')
-  const source = fs.readFileSync(invalidUsernameFilePath, 'utf-8')
-  const invalidUsernameTemplate = Handlebars.compile(source)
-  usernames.forEach(username => backupIndexFile(username, accountManager, invalidUsernameTemplate, dateOfRemoval, supportEmail))
-}
+import fs from 'fs-extra'
+import Handlebars from 'handlebars'
+import path from 'path'
+import { getAccountManager, loadConfig, loadUsernames } from './cli-utils.mjs'
+import { isValidUsername } from '../../lib/common/user-utils.mjs'
+import blacklistService from '../../lib/services/blacklist-service.mjs'
+import { initConfigDir, initTemplateDirs } from '../../lib/server-config.mjs'
+import { fromServerConfig } from '../../lib/models/oidc-manager.mjs'
+import EmailService from '../../lib/services/email-service.mjs'
+import SolidHost from '../../lib/models/solid-host.mjs'
+
+export default function (program) {
+  program
+    .command('invalidusernames')
+    .option('--notify', 'Will notify users with usernames that are invalid')
+    .option('--delete', 'Will delete users with usernames that are invalid')
+    .description('Manage usernames that are invalid')
+    .action(async (options) => {
+      const config = loadConfig(program, options)
+      if (!config.multiuser) {
+        return console.error('You are running a single user server, no need to check for invalid usernames')
+      }
+      const invalidUsernames = getInvalidUsernames(config)
+      const host = SolidHost.from({ port: config.port, serverUri: config.serverUri })
+      const accountManager = getAccountManager(config, { host })
+      if (options.notify) {
+        return notifyUsers(invalidUsernames, accountManager, config)
+      }
+      if (options.delete) {
+        return deleteUsers(invalidUsernames, accountManager, config, host)
+      }
+      listUsernames(invalidUsernames)
+    })
+}
+
+function backupIndexFile (username, accountManager, invalidUsernameTemplate, dateOfRemoval, supportEmail) {
+  const userDirectory = accountManager.accountDirFor(username)
+  const currentIndex = path.join(userDirectory, 'index.html')
+  const currentIndexExists = fs.existsSync(currentIndex)
+  const backupIndex = path.join(userDirectory, 'index.backup.html')
+  const backupIndexExists = fs.existsSync(backupIndex)
+  if (currentIndexExists && !backupIndexExists) {
+    fs.renameSync(currentIndex, backupIndex)
+    createNewIndexAcl(userDirectory)
+    createNewIndex(username, invalidUsernameTemplate, dateOfRemoval, supportEmail, currentIndex)
+    console.info(`index.html updated for user ${username}`)
+  }
+}
+
+function createNewIndex (username, invalidUsernameTemplate, dateOfRemoval, supportEmail, currentIndex) {
+  const newIndexSource = invalidUsernameTemplate({
+    username,
+    dateOfRemoval,
+    supportEmail
+  })
+  fs.writeFileSync(currentIndex, newIndexSource, 'utf-8')
+}
+
+function createNewIndexAcl (userDirectory) {
+  const currentIndexAcl = path.join(userDirectory, 'index.html.acl')
+  const backupIndexAcl = path.join(userDirectory, 'index.backup.html.acl')
+  const currentIndexSource = fs.readFileSync(currentIndexAcl, 'utf-8')
+  const backupIndexSource = currentIndexSource.replace(/index.html/g, 'index.backup.html')
+  fs.writeFileSync(backupIndexAcl, backupIndexSource, 'utf-8')
+}
+
+async function deleteUsers (usernames, accountManager, config, host) {
+  const oidcManager = fromServerConfig({ ...config, host })
+  const deletingUsers = usernames.map(async username => {
+    try {
+      const user = accountManager.userAccountFrom({ username })
+      await oidcManager.users.deleteUser(user)
+    } catch (error) {
+      if (error.message !== 'No email given') {
+        throw error
+      }
+    }
+    const userDirectory = accountManager.accountDirFor(username)
+    await fs.remove(userDirectory)
+  })
+  await Promise.all(deletingUsers)
+  console.info(`Deleted ${deletingUsers.length} users succeeded`)
+}
+
+function getInvalidUsernames (config) {
+  const usernames = loadUsernames(config)
+  return usernames.filter(username => !isValidUsername(username) || !blacklistService.validate(username))
+}
+
+function listUsernames (usernames) {
+  if (usernames.length === 0) {
+    return console.info('No invalid usernames was found')
+  }
+  console.info(`${usernames.length} invalid usernames were found:${usernames.map(username => `\n- ${username}`)}`)
+}
+
+async function notifyUsers (usernames, accountManager, config) {
+  const twoWeeksFromNow = Date.now() + 14 * 24 * 60 * 60 * 1000
+  const dateOfRemoval = (new Date(twoWeeksFromNow)).toLocaleDateString()
+  const { supportEmail } = config
+  updateIndexFiles(usernames, accountManager, dateOfRemoval, supportEmail)
+  await sendEmails(config, usernames, accountManager, dateOfRemoval, supportEmail)
+}
+
+async function sendEmails (config, usernames, accountManager, dateOfRemoval, supportEmail) {
+  if (config.email && config.email.host) {
+    const configPath = initConfigDir(config)
+    const templates = initTemplateDirs(configPath)
+    const users = await Promise.all(await usernames.map(async username => {
+      const emailAddress = await accountManager.loadAccountRecoveryEmail({ username })
+      const accountUri = accountManager.accountUriFor(username)
+      return { username, emailAddress, accountUri }
+    }))
+    const emailService = new EmailService(templates.email, config.email)
+    const sendingEmails = users
+      .filter(user => !!user.emailAddress)
+      .map(user => emailService.sendWithTemplate('invalid-username.mjs', {
+        to: user.emailAddress,
+        accountUri: user.accountUri,
+        dateOfRemoval,
+        supportEmail
+      }))
+    const emailsSent = await Promise.all(sendingEmails)
+    console.info(`${emailsSent.length} emails sent to users with invalid usernames`)
+    return
+  }
+  console.info('You have not configured an email service.')
+  console.info('Please set it up to send users email about their accounts')
+}
+
+function updateIndexFiles (usernames, accountManager, dateOfRemoval, supportEmail) {
+  const invalidUsernameFilePath = path.join(process.cwd(), 'default-views', 'account', 'invalid-username.hbs')
+  const source = fs.readFileSync(invalidUsernameFilePath, 'utf-8')
+  const invalidUsernameTemplate = Handlebars.compile(source)
+  usernames.forEach(username => backupIndexFile(username, accountManager, invalidUsernameTemplate, dateOfRemoval, supportEmail))
+}