add missing .mjs files

Author: CI Fix

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));
+}

bin/lib/cli.mjs

@@ -0,0 +1,41 @@
+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 { 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;
+  }
+}

bin/lib/init.mjs

@@ -0,0 +1,85 @@
+import inquirer from 'inquirer';
+import fs from 'fs';
+import options from './options.mjs';
+import camelize from '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;
+});
+
+export default function (program) {
+  program
+    .command('init')
+    .option('--advanced', 'Ask for all the settings')
+    .description('create solid server configurations')
+    .action((opts) => {
+      let filteredQuestions = questions;
+      if (!opts.advanced) {
+        filteredQuestions = filteredQuestions.filter((option) => option.prompt);
+      }
+      inquirer.prompt(filteredQuestions)
+        .then((answers) => {
+          manipulateEmailSection(answers);
+          manipulateServerSection(answers);
+          cleanupAnswers(answers);
+          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];
+    }
+  });
+}

bin/lib/invalidUsernames.mjs

@@ -0,0 +1,136 @@
+import fs from 'fs-extra';
+import Handlebars from 'handlebars';
+import path from 'path';
+import { getAccountManager, loadConfig, loadUsernames } from './cli-utils.js';
+import { isValidUsername } from '../../lib/common/user-utils.js';
+import blacklistService from '../../lib/services/blacklist-service.js';
+import { initConfigDir, initTemplateDirs } from '../../lib/server-config.js';
+import { fromServerConfig } from '../../lib/models/oidc-manager.js';
+import EmailService from '../../lib/services/email-service.js';
+import SolidHost from '../../lib/models/solid-host.js';
+
+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', {
+        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));
+}

bin/lib/migrateLegacyResources.mjs

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import Path from 'path';
+import { promisify } from 'util';
+const readdir = promisify(fs.readdir);
+const lstat = promisify(fs.lstat);
+const rename = promisify(fs.rename);
+
+export default function (program) {
+  program
+    .command('migrate-legacy-resources')
+    .option('-p, --path <path>', 'Path to the data folder, defaults to \'data/\'')
+    .option('-s, --suffix <path>', 'The suffix to add to extensionless files, defaults to \'$.ttl\'')
+    .option('-v, --verbose', 'Path to the data folder')
+    .description('Migrate the data folder from node-solid-server 4 to node-solid-server 5')
+    .action(async (opts) => {
+      const verbose = opts.verbose;
+      const suffix = opts.suffix || '$.ttl';
+      let paths = opts.path ? [opts.path] : ['data', 'config/templates'];
+      paths = paths.map(path => path.startsWith(Path.sep) ? path : Path.join(process.cwd(), path));
+      try {
+        for (const path of paths) {
+          if (verbose) {
+            console.log(`Migrating files in ${path}`);
+          }
+          await migrate(path, suffix, verbose);
+        }
+      } catch (err) {
+        console.error(err);
+      }
+    });
+}
+
+async function migrate(path, suffix, verbose) {
+  const files = await readdir(path);
+  for (const file of files) {
+    const fullFilePath = Path.join(path, file);
+    const stat = await lstat(fullFilePath);
+    if (stat.isFile()) {
+      if (shouldMigrateFile(file)) {
+        const newFullFilePath = getNewFileName(fullFilePath, suffix);
+        if (verbose) {
+          console.log(`${fullFilePath}\n  => ${newFullFilePath}`);
+        }
+        await rename(fullFilePath, newFullFilePath);
+      }
+    } else {
+      if (shouldMigrateFolder(file)) {
+        await migrate(fullFilePath, suffix, verbose);
+      }
+    }
+  }
+}
+
+function getNewFileName(fullFilePath, suffix) {
+  return fullFilePath + suffix;
+}
+
+function shouldMigrateFile(filename) {
+  return filename.indexOf('.') < 0;
+}
+
+function shouldMigrateFolder(foldername) {
+  return foldername[0] !== '.';
+}