superuser.app 0.0.0

package/commands/domains/verify.js

@@ -0,0 +1,130 @@
+const { Command } = require('cmnd');
+const io = require('io');
+const colors = require('colors/safe');
+const inquirer = require('inquirer');
+
+const constants = require('../../helpers/constants.js');
+const SettingsManager = require('../../helpers/settings_manager.js');
+const DrawTable = require('../../helpers/draw_table.js');
+
+class DomainsVerifyCommand extends Command {
+
+  constructor() {
+    super('domains', 'verify');
+  }
+
+  help () {
+    return {
+      description: 'Verify any pending domains',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const settings = SettingsManager.read(true);
+    const host = settings.activeProfile.host || constants.BASE_URL;
+
+    const verifyParams = {};
+
+    const result = await io.get(
+      `${host}/v1/custom_domains`,
+      settings.activeProfile.key,
+      null,
+      {verified: false, invalidated: false},
+    );
+
+    if (result.statusCode !== 200) {
+      const message = result.data?.error?.message || `Invalid statusCode: ${result.statusCode}`;
+      throw new Error(message);
+    }
+
+    const customDomains = result.data.data;
+
+    if (!customDomains.length) {
+      console.log();
+      console.log(`Looks like all your domains are verified!`);
+      console.log();
+      return;
+    }
+
+    const columns = [
+      'hostname',
+      'package',
+      'environment',
+      'verified_at'
+    ];
+
+    const rows = customDomains.map(customDomain => {
+      const packageName = `${customDomain.package.is_private ? 'private/' : ''}@${customDomain.package.organization.name}/${customDomain.package.name}`;
+      const environment = customDomain.environment;
+      return {
+        hostname: customDomain.hostname,
+        package: packageName,
+        environment: environment,
+        verified_at: customDomain.verified_at
+      }
+    });
+
+    console.log();
+    const index = await DrawTable.selectIndexFromTable('Choose a domain to verify', columns, rows);
+    const customDomain = customDomains[index];
+
+    if (index === -1) {
+      console.log();
+      return;
+    }
+
+    const tld = customDomain.hostname.split('.').slice(-2).join('.');
+    const subdomain = customDomain.hostname.split('.').length > 2
+      ? customDomain.hostname.split('.').slice(0, -2).join('.')
+      : '@';
+
+    console.log();
+    console.log(`In order to verify ${colors.bold(customDomain.hostname)},`);
+    console.log(`you must add the following TXT record to the domain ${colors.bold(tld)}:`);
+    console.log();
+    console.log(colors.bold('Type:'));
+    console.log('TXT');
+    console.log();
+    console.log(colors.bold('Name:'));
+    console.log(subdomain);
+    console.log();
+    console.log(colors.bold('Content:'));
+    console.log(customDomain.txt_record);
+    console.log();
+
+    const confirmResult = await inquirer.prompt({type: 'confirm', name: 'ok'});
+    if (!confirmResult.ok) {
+      throw new Error(`Aborted`);
+    }
+    
+    verifyParams.hostname = rows[index].hostname;
+    verifyParams.name = rows[index].package;
+    verifyParams.environment = rows[index].environment;
+
+    const verifyResult = await io.post(
+      `${host}/v1/custom_domains/verify`,
+      settings.activeProfile.key,
+      null,
+      verifyParams
+    );
+
+    if (verifyResult.statusCode !== 200) {
+      const message = verifyResult.data?.error?.message || `Invalid statusCode: ${verifyResult.statusCode}`;
+      throw new Error(message);
+    }
+
+    console.log();
+    console.log(`${colors.bold.green('Success!')} Domain ${colors.bold(verifyParams.hostname)} verified.`);
+    console.log();
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = DomainsVerifyCommand;

package/commands/g/endpoint.js

@@ -0,0 +1,32 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+
+const loadPackage = require('../../helpers/load_package.js');
+const generateEndpoint = require('../../helpers/generate/endpoint/_index.js');
+
+class GenerateEndpointCommand extends Command {
+
+  constructor() {
+    super('g', 'endpoint');
+  }
+
+  help () {
+    return {
+      description: 'Generates a new endpoint file in a directory of your choosing',
+      args: ['pathname'],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const InstantPackage = await loadPackage(params, true);
+    await generateEndpoint(InstantPackage, params);
+    return void 0;
+
+  }
+
+}
+
+module.exports = GenerateEndpointCommand;

package/commands/g/test.js

@@ -0,0 +1,42 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+
+const loadPackage = require('../../helpers/load_package.js');
+const generateTest = require('../../helpers/generate/test/_index.js');
+
+class GenerateTestCommand extends Command {
+
+  constructor() {
+    super('g', 'test');
+  }
+
+  help () {
+    return {
+      description: 'Generates new test',
+      args: ['test_name'],
+      flags: {},
+      vflags: {
+        endpoint: 'Generate a test for an endpoint'
+      }
+    };
+  }
+
+  async run (params) {
+
+    const InstantPackage = await loadPackage(params, true);
+
+    let specificity = [params.args[0], params.vflags.endpoint[0]];
+    let submitted = specificity.filter(v => v);
+    if (!submitted.length) {
+      throw new Error(`Must specify one of "test_name" or "--endpoint"`);
+    }
+
+    await generateTest(InstantPackage, params);
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = GenerateTestCommand;

package/commands/init.js

@@ -0,0 +1,220 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+const inquirer = require('inquirer');
+
+const fs = require('fs');
+const path = require('path');
+const childProcess = require('child_process');
+
+const loadPackage = require('../helpers/load_package.js');
+const fileWriter = require('../helpers/file_writer.js');
+const drawBox = require('../helpers/draw_box.js');
+
+const writeInitFiles = (pathname, pkg) => {
+  const files = fileWriter.readRecursive(pathname);
+  for (const filename in files) {
+    if (filename === '/package.json') {
+      let json;
+      try {
+        json = JSON.parse(files[filename].toString());
+      } catch (e) {
+        throw new Error(`Invalid "package.json" in init files`);
+      }
+      const scripts = json.scripts || {};
+      const mainDeps = json.dependencies || {};
+      const devDeps = json.devDependencies || {};
+      for (const key in scripts) {
+        fileWriter.writeJSON('package.json', `scripts.${key}`, scripts[key]);
+      }
+      console.log();
+      for (const [ deps, devMode ] of [[mainDeps, false], [devDeps, true]]) {
+        const depList = [];
+        for (const name in deps) {
+          depList.push(`${name}@${deps[name]}`);
+        }
+        if (depList.length) {
+          console.log(colors.bold.black(`Installing:`) + ` "${depList.join('", "')}" ...`);
+          const installString = `npm i ${depList.join(' ')} --save${devMode ? `-dev` : ``}`;
+          childProcess.execSync(installString, {stdio: 'inherit'});
+          console.log();
+        }
+      }
+    } else {
+      fileWriter.writeFile(filename, files[filename], false);
+    }
+  }
+  fileWriter.writeLine('.gitignore', '.DS_Store');
+  fileWriter.writeLine('.gitignore', 'node_modules/');
+  fileWriter.writeLine('.gitignore', '.env');
+  fileWriter.writeLine('.gitignore', '.env.*');
+};
+
+class InitCommand extends Command {
+
+  constructor() {
+    super('init');
+  }
+
+  help () {
+    return {
+      description: 'Initialize a new Superuser Package project',
+      args: [],
+      flags: {},
+      vflags: {
+        force: 'overwrites existing project'
+      }
+    };
+  }
+
+  async run (params) {
+
+    const force = ('force' in params.vflags);
+
+    console.log();
+    console.log(
+      drawBox.center(
+        `blue`,
+        `Welcome to ${colors.bold.green('🤖 Superuser')}!`,
+      )
+    );
+
+    const pkgExists = fs.existsSync('package.json');
+    const functExists = fs.existsSync('superuser.json');
+
+    console.log();
+    console.log(`🪄 You are about to initialize an ${colors.bold('Superuser Package')} in the current directory:`)
+    console.log(`   📂 ${colors.dim(process.cwd())}`);
+    console.log();
+    if ((pkgExists || functExists) && !force) {
+      throw new Error(
+        `You already have a project initialized here.\n` +
+        `If you want to overwrite it, use \`$ ibot init --force\``
+      );
+    } else {
+      console.log(`✨ We've detected you're starting from scratch`);
+      console.log();
+      let verifyResult = await inquirer.prompt([
+        {
+          name: 'verify',
+          type: 'confirm',
+          message: `Continue with initialization in this directory?`,
+          default: true
+        }
+      ]);
+      if (!verifyResult.verify) {
+        throw new Error(`Initialization aborted`);
+      }
+    }
+
+    let InstantPackage = await loadPackage(params);
+    if (!InstantPackage) {
+      console.log();
+      console.log(colors.bold.black(`Installing:`) + ` "@instant.dev/api@latest" (dev) ...`);
+      if ('link' in params.vflags) {
+        childProcess.execSync(`npm link @instant.dev/api`, {stdio: 'inherit'});
+      } else {
+        childProcess.execSync(`npm i @instant.dev/api --save-dev`, {stdio: 'inherit'});
+      }
+    }
+
+    let apiGatewayPackage;
+    try {
+      apiGatewayPackage = JSON.parse(
+        fs.readFileSync(
+          path.join(process.cwd(), 'node_modules', '@instant.dev/api', 'package.json')
+        ).toString()
+      );
+    } catch (e) {
+      throw new Error(`Could not load @instant.dev/api package`);
+    }
+    let apiGatewayName = apiGatewayPackage.name || '@instant.dev/api';
+    let apiGatewayVersion = apiGatewayPackage.version || 'latest';
+
+    const pkgString = pkgExists
+      ? fs.readFileSync('package.json').toString()
+      : JSON.stringify({devDependencies: {[apiGatewayName]: `^${apiGatewayVersion}`}});
+    let pkg;
+    try {
+      pkg = JSON.parse(pkgString);
+    } catch (e) {
+      console.error(e);
+      throw new Error(`Invalid JSON in "package.json"`);
+    }
+
+    let pathList = process.cwd().split(path.sep);
+    let functName = pathList.pop();
+    let orgName = pathList.pop();
+    if (orgName.startsWith('@')) {
+      orgName = orgName.slice(1);
+    }
+
+    console.log();
+    console.log(`✨ Let's name your project.`);
+    console.log();
+    let result = await inquirer.prompt([
+      {
+        name: 'name',
+        type: 'input',
+        message: 'Enter a project name',
+        validate: s => {
+          if (!s.match(/@[a-z0-9\-]+\/[a-z0-9\-]+/i)) {
+            return `must follow format @user/project and can only contain alphanumeric or - characters`;
+          } else {
+            return true;
+          }
+        },
+        default: [
+          '@' + orgName.replace(/[^a-z0-9\-]+/gi, '-'),
+          functName.replace(/[^a-z0-9\-]+/gi, '-')
+        ].join('/')
+      }
+    ]);
+    functName = result.name;
+
+    const filesRoot = path.join(__dirname, '..', 'src', 'init');
+    if (!fs.existsSync(filesRoot)) {
+      throw new Error(`No init template files found`);
+    }
+    writeInitFiles(filesRoot);
+    // Write package.json: make sure no publish to npm
+    fileWriter.writeJSON('package.json', 'private', true);
+    // Write superuser.json: default is public
+    fileWriter.writeJSON('superuser.json', 'name', functName);
+
+    // Now we reload InstantPackage to verify
+    InstantPackage = await loadPackage(null, true);
+
+    console.log();
+    console.log(`Project "${colors.bold.blue(functName)}" initialized successfully!`);
+    console.log();
+    console.log(
+      drawBox.left(
+        `green`,
+        ``,
+        colors.bold.green(`Success:`) + ` Instant tool package initialized!`,
+        `Here are some helpful commands to get started:`,
+        ``,
+        `(1) Create a set of endpoints for a path (create, read, update, destroy):`,
+        colors.grey.bold(`     $ ibot g:endpoint path/to/endpoint\n`),
+        `(2) Run your dev server:`,
+        colors.grey.bold(`     $ ibot serve`),
+        ``,
+        `For more information about ${colors.bold(`Superuser`)}:`,
+        `     Home    => ${colors.bold.underline.blue('https://instant.chat')}`,
+        `     GitHub  => ${colors.bold.underline.blue('https://github.com/instantbots')}`,
+        `     Discord => ${colors.bold.underline.blue('https://discord.gg/instant')}`,
+        `     X       => ${colors.bold.underline.blue('https://x.com/instantbots')}`,
+        ``,
+        colors.green.bold(`Happy building! :)`),
+        ``
+      )
+    );
+    console.log();
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = InitCommand;

package/commands/login.js

@@ -0,0 +1,123 @@
+const { Command } = require('cmnd');
+const io = require('io');
+const colors = require('colors/safe');
+const inquirer = require('inquirer');
+
+const SettingsManager = require('../helpers/settings_manager.js');
+const constants = require('../helpers/constants.js');
+
+class LoginCommand extends Command {
+
+  constructor() {
+    super('login');
+  }
+
+  help () {
+    return {
+      description: 'Login to the Superuser Package Registry',
+      args: [],
+      flags: {},
+      vflags: {
+        email: 'E-mail to login with',
+        password: 'Password to login with'
+      }
+    };
+  }
+
+  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 email = ((params.vflags.email || [])[0] || '').trim();
+    let password = ((params.vflags.password || [])[0] || '').trim();
+
+    const inquireList = [];
+    const requestParams = {};
+
+    if (!email) {
+      inquireList.push({
+        name: 'username',
+        type: 'input',
+        message: `E-mail / username`
+      });
+    } else {
+      requestParams['username'] = email;
+    }
+
+    if (!password) {
+      inquireList.push({
+        name: 'password',
+        type: 'password',
+        message: `Password`
+      });
+    } else {
+      requestParams['password'] = password;
+    }
+
+    let loginResult = await inquirer.prompt(inquireList);
+
+    const sendParams = {
+      ...requestParams,
+      ...loginResult,
+      grant_type: 'password'
+    };
+
+    let result = await io.post(
+      `${host}/auth`,
+      null,
+      null,
+      sendParams
+    );
+
+    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:}
+    const token = user.accessTokens[0];
+
+    console.log();
+    console.log(colors.bold(`${colors.cyan(`Logged in`)} to ${colors.green('Superuser')} successfully!`));
+    console.log(`${colors.bold(`email`)}:    ${user.email}`);
+    if (user.memberships && user.memberships.length) {
+      console.log(`${colors.bold(`username`)}: ${user.memberships[0].organization.name}`);
+    }
+    console.log(`${colors.bold(`login at`)}: ${token.created_at}`);
+    console.log();
+
+    const data = {email: user.email, key: token.key};
+    if (host !== constants.BASE_URL) {
+      data.host = host;
+    }
+
+    // Write settings
+    SettingsManager.write(data);
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = LoginCommand;

package/commands/me.js

@@ -0,0 +1,54 @@
+const { Command } = require('cmnd');
+const io = require('io');
+const colors = require('colors/safe');
+
+const constants = require('../helpers/constants.js');
+const SettingsManager = require('../helpers/settings_manager.js');
+
+class MeCommand extends Command {
+
+  constructor() {
+    super('me');
+  }
+
+  help () {
+    return {
+      description: 'Retrieve your currently logged in user data',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const settings = SettingsManager.read(true);
+    const host = settings.activeProfile.host || constants.BASE_URL;
+
+    console.log();
+    console.log(`Retrieving data for ${colors.bold(settings.activeProfile.email)} via ${colors.bold(host)}`);
+    console.log();
+
+    const result = await io.get(
+      `${host}/users/me`,
+      settings.activeProfile.key,
+      null,
+      {},
+    );
+
+    if (result.statusCode !== 200) {
+      const message = result.data?.error?.message || `Invalid statusCode: ${result.statusCode}`;
+      throw new Error(message);
+    }
+
+    const user = result.data;
+
+    console.log(JSON.stringify(user, null, 2));
+
+    return void 0;
+
+  }
+
+}
+
+module.exports = MeCommand;

package/commands/organizations/create.js

@@ -0,0 +1,68 @@
+const { Command } = require('cmnd');
+const colors = require('colors/safe');
+const inquirer = require('inquirer');
+const io = require('io');
+
+const constants = require('../../helpers/constants.js');
+const SettingsManager = require('../../helpers/settings_manager.js');
+const loadPackage = require('../../helpers/load_package.js');
+
+class CreateOrganizationsCommand extends Command {
+
+  constructor() {
+    super('organizations', 'create');
+  }
+
+  help () {
+    return {
+      description: 'Creates a new organization for a user',
+      args: [],
+      flags: {},
+      vflags: {}
+    };
+  }
+
+  async run (params) {
+
+    const settings = SettingsManager.read(true);
+    const host = settings.activeProfile.host || constants.BASE_URL;
+    const InstantPackage = await loadPackage(params, true);
+
+    console.log();
+    console.log(`Creating organization for ${colors.bold(settings.activeProfile.email)} on ${colors.bold(host)} ...`);
+    console.log();
+
+    let createParams = await inquirer.prompt([{
+      name: 'name',
+      message: `Organization name`
+    }]);
+
+    const name = createParams.name;
+    
+    const createResult = await io.post(
+      `${host}/v1/organizations`,
+      settings.activeProfile.key,
+      null,
+      {
+        name: name,
+      }
+    );
+
+    if (createResult.statusCode !== 200) {
+      if (createResult.data && createResult.data.error && createResult.data.error.message) {
+        throw new Error(createResult.data.error.message);
+      } else {
+        throw new Error(`Invalid response from server: statusCode ${createResult.statusCode}`);
+      }
+    }
+
+    console.log();
+    console.log(`Organization ${colors.bold(name)} created!`);
+    console.log();
+    return void 0;
+
+  }
+
+}
+
+module.exports = CreateOrganizationsCommand;