superuser.app 0.0.0

package/commands/profile.js

@@ -0,0 +1,58 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+const inquirer = require('inquirer');
+
+const SettingsManager = require('../helpers/settings_manager.js');
+const DrawTable = require('../helpers/draw_table.js');
+
+class ProfileCommand extends Command {
+
+  constructor() {
+    super('profile');
+  }
+
+  help () {
+    return {
+      description: 'Change your active profile',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const settings = SettingsManager.read(true);
+    const profiles = settings.profileList;
+
+    console.log();
+
+    const columns = ['email', 'host', 'active'];
+    const rows = profiles.map((p, i) => {
+      return {
+        email: p.email,
+        host: p.host || '',
+        active: i === 0
+          ? colors.bold.green('yes')
+          : ''
+      };
+    });
+
+    const index = await DrawTable.selectIndexFromTable(
+      'Choose your active profile',
+      columns,
+      rows
+    );
+
+    console.log();
+    if (index !== -1) {
+      SettingsManager.write(profiles[index]);
+    }
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = ProfileCommand;

package/commands/register.js

@@ -0,0 +1,127 @@
+const { Command } = require('cmnd');
+const io = require('io');
+const colors = require('colors/safe');
+const inquirer = require('inquirer');
+
+const constants = require('../helpers/constants.js');
+
+const LoginCommand = require('./login.js');
+
+class RegisterCommand extends Command {
+
+  constructor() {
+    super('register');
+  }
+
+  help () {
+    return {
+      description: 'Registers a new user account with the Superuser Package Registry',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    let host = (params.flags.h || [])[0] || constants.BASE_URL;
+    if (!host.startsWith('http://') && !host.startsWith('https://')) {
+      host = host.startsWith('localhost')
+        ? `http://${host}`
+        : `https://${host}`
+    }
+
+    let registerResult = await inquirer.prompt([
+      {
+        name: 'email',
+        type: 'input',
+        message: `E-mail`,
+        validate: e => {
+          if (!e.match(/^[^@]+@[^@]+\.[a-z0-9\-]+$/gi)) {
+            return 'Must be a valid e-mail address';
+          } else {
+            return true;
+          }
+        }
+      },
+      {
+        name: 'organization_name',
+        type: 'input',
+        message: `Username`,
+        validate: v => {
+          if (
+            v.match(/[a-z][a-z0-9\-]*[a-z0-9]/i) &&
+            v.indexOf('--') === -1
+          ) {
+            return true;
+          } else {
+            return 'must start with a letter, end with a letter or number, and contain only A-Z, a-z, 0-9 or -';
+          }
+        }
+      },
+      {
+        name: 'password',
+        type: 'password',
+        message: `Password`
+      },
+      {
+        name: 'repeat_password',
+        type: 'password',
+        message: `Repeat password`
+      }
+    ]);
+
+    let result = await io.post(
+      `${host}/users`,
+      null,
+      null,
+      registerResult
+    );
+
+    if (result.statusCode !== 200) {
+      const e = result.data.error;
+      const message = e.message;
+      const details = e.details || {};
+      const more = [];
+      if (Object.keys(details).length) {
+        for (const key in details) {
+          more.push(`- ${colors.bold(key)}: ${details[key].message}`);
+        }
+      }
+      throw new Error(
+        message +
+        (
+          more.length
+            ? '\n\n' + more.join('\n')
+            : ''
+        )
+      );
+    }
+
+    const user = result.data; // grab json {data:}
+
+    console.log();
+    console.log(colors.bold(`${colors.blue(`Registered`)} for ${colors.green('Superuser')} successfully!`));
+    console.log(`${colors.bold(`email`)}:      ${user.email}`);
+    console.log(`${colors.bold(`username`)}:   ${user.memberships[0].organization.name}`);
+    console.log(`${colors.bold(`created at`)}: ${user.created_at}`);
+
+    return LoginCommand.prototype.run.call(
+      this,
+      {
+        args: [],
+        flags: {
+          h: params.flags.h
+        },
+        vflags: {
+          email: [user.email],
+          password: [registerResult.password]
+        }
+      }
+    );
+
+  }
+
+}
+
+module.exports = RegisterCommand;

package/commands/run.js

@@ -0,0 +1,194 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+const io = require('io');
+const kill = require('tree-kill');
+
+const loadPackage = require('../helpers/load_package.js');
+const localServer = require('../helpers/local_server.js');
+
+const sleep = t => new Promise(r => setTimeout(() => r(1), t));
+const killProcess = pid => {
+  return new Promise((resolve, reject) => {
+    kill(pid, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+};
+
+class RunCommand extends Command {
+
+  constructor() {
+    super('run');
+  }
+
+  help() {
+    return {
+      description: 'Runs a function in the local project',
+      args: [],
+      flags: {
+        'm': 'Specify method, default is "get"',
+        'v': 'Verbose mode: shows URL, status code and arguments'
+      },
+      vflags: {
+        '*': 'Used to populate query and / or body parameters'
+      }
+    };
+  }
+
+  async run(params) {
+
+    // Use 8199 for test runs
+    const InstantPackage = await loadPackage(params, true);
+    const port = 8199;
+    const timeout = 5000;
+    const url = `http://localhost:${port}`;
+
+    // Validate arguments, default method is "get"
+    const method = ((params.flags['m'] || [])[0] || 'get').toLowerCase();
+    if (['get', 'post', 'put', 'delete', 'del'].indexOf(method) === -1) {
+      throw new Error(`Method "${method}" not supported.`);
+    }
+    if (method === 'del') {
+      method = 'delete';
+    }
+    const functionParams = Object.keys(params.vflags).reduce((functionParams, key) => {
+      functionParams[key] = params.vflags[key].join(' ');
+      return functionParams;
+    }, {});
+    let pathname = params.args[0] || '';
+    if (!pathname) {
+      throw new Error(
+        `Please provide a pathname as the first argument.\n` +
+        `Use "/" to execute the root method (index.js)`
+      );
+    }
+    if (pathname.startsWith('..')) {
+      throw new Error(`Invalid pathname: "${pathname}"`);
+    }
+    if (pathname.startsWith('.')) {
+      pathname = pathname.slice(1);
+    }
+    if (pathname.startsWith('/')) {
+      pathname = pathname.slice(1);
+    }
+
+    const proc = localServer.run({ port, isBackground: true });
+    let isConnected = false;
+    proc.stdout.on('data', data => {
+      const message = data.toString();
+
+      if (message.includes(`*** Listening on localhost:${port}`)) {
+        isConnected = true;
+      } else if (message.includes(`Unable to spawn HTTP Workers, listening on port ${port}`)) {
+        isConnected = true;
+      }
+    });
+
+    // Wait for connection or timeout
+    let isTimedOut = false
+    await Promise.race([
+      (async () => {
+        await sleep(timeout);
+        if (!isConnected) {
+          isTimedOut = true;
+          await killProcess(proc.pid);
+          throw new Error(
+            `Timed out waiting for development server.\n` +
+            `Are you sure you're not running another server on :${port}?\n` +
+            `To kill any processes running on this port on a unix system, use:\n` +
+            `$ lsof -ti :${port} | xargs kill -9`
+          );
+        }
+      })(),
+      (async () => {
+        while (!isConnected && !isTimedOut) {
+          await sleep(1);
+        }
+        return true;
+      })()
+    ]);
+
+    const queryParams = (method === 'get' || method === 'delete')
+      ? { ...functionParams }
+      : {};
+    queryParams._debug = true;
+    const bodyParams = (method === 'post' || method === 'put')
+      ? JSON.stringify(functionParams)
+      : '';
+
+    let result;
+    const streamResult = await io.request(
+      method.toUpperCase(),
+      `${url}/${pathname}`,
+      queryParams,
+      {},
+      bodyParams,
+      ({id, event, data}) => {
+        if (event === '@response') {
+          let json = JSON.parse(data);
+          result = json;
+        } else if (event === '@stdout') {
+          let json = JSON.parse(data);
+          json.split('\n').forEach(line => {
+            console.log(colors.grey(`${params.flags.v ? colors.bold(`stdout> `) : ''}${line}`));
+          });
+        } else if (event === '@stderr') {
+          let json = JSON.parse(data);
+          json.split('\n').forEach(line => {
+            console.log(colors.yellow(`${params.flags.v ? colors.bold(`stderr> `) : ''}${line}`));
+          });
+        } else {
+          console.log(colors.blue(`${colors.bold(`${event}> `)}${data}`));
+        }
+      }
+    );
+
+    // Handle non-event errors given by server
+    if (streamResult.statusCode === 500) {
+      const errorBody = streamResult.body.toString();
+      let errorMessage = errorBody;
+      // cut out the "Application Error: " prefix and only capture the first line
+      if (errorBody.startsWith('Application Error:')) {
+        errorMessage = errorBody.slice('Application Error: '.length);
+      }
+      // ignore the stack trace
+      errorMessage = errorMessage.split('\n')[0];
+      throw new Error(errorMessage);
+    }
+
+    // retrieve details
+    const body = result.body.toString();
+    let json;
+    try {
+      json = JSON.parse(body);
+    } catch (e) {
+      // do nothing
+    }
+
+    // Terminate process
+    await killProcess(proc.pid);
+    if (params.flags.v) {
+      console.log(colors.bold.green('location:  ') + `${url}/${pathname}`);
+      console.log(colors.bold.green('method:    ') + method.toUpperCase());
+      console.log(colors.bold.green('status:    ') + result.statusCode);
+      console.log(colors.bold.green('arguments: '));
+      console.log(JSON.stringify(functionParams, null, 2));
+      console.log(colors.bold.green('result:'));
+    }
+    if (json) {
+      console.log(JSON.stringify(json, null, 2));
+    } else {
+      console.log(body);
+    }
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = RunCommand;

package/commands/serve.js

@@ -0,0 +1,35 @@
+const { Command } = require('cmnd');
+
+const loadPackage = require('../helpers/load_package.js');
+const localServer = require('../helpers/local_server.js');
+
+class ServeCommand extends Command {
+
+  constructor() {
+    super('serve');
+  }
+
+  help () {
+    return {
+      description: 'Starts a development server using package.json["scripts"]["start"]',
+      args: [],
+      flags: {},
+      vflags: {
+        port: 'specify a port to run on'
+      }
+    };
+  }
+
+  async run (params) {
+
+    const InstantPackage = await loadPackage(params, true);
+
+    localServer.run({ port: 8100 });
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = ServeCommand;

package/commands/test.js

@@ -0,0 +1,68 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+const fs = require('fs');
+const childProcess = require('child_process');
+
+const loadPackage = require('../helpers/load_package.js');
+
+class TestCommand extends Command {
+
+  constructor() {
+    super('test');
+  }
+
+  help () {
+    return {
+      description: 'Runs tests using package.json["scripts"]["test"]',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const InstantPackage = await loadPackage(params, true);
+
+    console.log();
+    console.log(`Running tests ...`);
+    const pkgExists = fs.existsSync('package.json');
+    if (pkgExists) {
+      let pkg;
+      try {
+        pkg = JSON.parse(fs.readFileSync('package.json').toString());
+      } catch (e) {
+        throw new Error(`Could not read "package.json"`);
+      }
+      if (pkg?.scripts?.test) {
+        console.log(`Running script: ${colors.blue.bold(pkg.scripts.test)} ...`);
+        console.log();
+        const result = childProcess.spawnSync(
+          `${pkg.scripts.test} ${params.args.join(' ')}`,
+          {
+            stdio: 'inherit',
+            shell: true,
+            env: {...process.env, PATH: process.env.PATH + ':./node_modules/.bin'}
+          }
+        );
+        if (result.status === 0) {
+          console.log(colors.bold.green(`Success!`) + ` All tests passed.`);
+          console.log();
+        } else {
+          console.log(colors.bold.red(`Failure:`) + ` One or more of your tests failed.`);
+          console.log();
+        }
+      } else {
+        throw new Error(`Could not find "package.json"["scripts"]["test"]`);
+      }
+    } else {
+      throw new Error(`No "package.json" in this directory`);
+    }
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = TestCommand;