refactor(cmds): refactoring command invocation

This makes startup much faster and lighterweight at the
cost of a bit more layout complexity.

Author: zkat

bin/tink.js

@@ -1,21 +1,26 @@
 #!/usr/bin/env node
 
-require('../lib/node/index.js')
+require('../lib/node/extensions.js').overrideNode()
 
-const CMDS = new Map([
-  ['access', require('../lib/commands/access.jsx')],
-  ['add', require('../lib/commands/add.js')],
-  ['build', require('../lib/commands/build.js')],
-  ['deprecate', require('../lib/commands/deprecate.js')],
-  ['org', require('../lib/commands/org.jsx')],
-  ['ping', require('../lib/commands/ping.js')],
-  ['prepare', require('../lib/commands/prepare.js')],
-  ['profile', require('../lib/commands/profile.jsx')],
-  ['rm', require('../lib/commands/rm.js')],
-  ['shell', require('../lib/commands/shell.js')],
-  ['team', require('../lib/commands/team.js')],
-  ['view', require('../lib/commands/view.js')],
-  ['whoami', require('../lib/commands/whoami.js')]
+const CMDS = new Set([
+  'access',
+  'add',
+  'build',
+  'deprecate',
+  'org',
+  'ping',
+  'prepare',
+  'profile',
+  'rm',
+  'shell',
+  'team',
+  'view',
+  'whoami'
+])
+
+const ALIASES = new Map([
+  ['prep', 'prepare'],
+  ['sh', 'shell']
 ])
 
 if (require.main === module) {
@@ -26,22 +31,25 @@ module.exports = main
 function main (argv) {
   const log = require('npmlog')
   log.heading = 'tink'
-  const npmConfig = require('../lib/config.js')
-  return runCommandWithYargs(argv, log, npmConfig)
+  return runCommandWithYargs(argv, log)
 }
 
-function runCommandWithYargs (argv, log, npmConfig) {
-  // This code path costs ~200ms on startup.
+function runCommandWithYargs (argv, log) {
   let config = require('yargs')
     .demandCommand(1, 'Subcommand is required')
     .recommendCommands()
     .help()
     .alias('help', 'h')
     .alias('version', 'v')
     .completion()
-  for (const mod of CMDS.values()) {
-    config = config.command(mod)
+  if (ALIASES.has(argv[2])) {
+    config = config.command(require(`../lib/yargs-modules/${ALIASES.get(argv[2])}.js`))
+  } else if (CMDS.has(argv[2])) {
+    config = config.command(require(`../lib/yargs-modules/${argv[2]}.js`))
+  } else {
+    for (const mod of CMDS.values()) {
+      config = config.command(require(`../lib/yargs-modules/${mod}.js`))
+    }
   }
-  require('../lib/node/index.js')
   config = config.argv
 }

lib/commands/access.jsx

@@ -1,78 +1,20 @@
 'use strict'
 
-const Access = module.exports = {
-  command: 'access',
-  describe: 'access-related subcommands',
-  builder (y) {
-    return y.help().alias('help', 'h')
-      .options(Access.options)
-      .demandCommand(1, 'Access subcommand is required')
-      .recommendCommands()
-      .command(
-        'public <spec>',
-        'Set a package to be publicly accessible',
-        Access.options,
-        async argv => accessPublic(argv)
-      )
-      .command(
-        'restricted <spec>',
-        'Set a package to be restricted',
-        Access.options,
-        async argv => accessRestricted(argv)
-      )
-      .command(
-        'grant <permissions> <team> <spec>',
-        'Add the ability of users and teams to have read-only or ' +
-          'read-write access to a package',
-        Access.options,
-        async argv => accessGrant(argv)
-      )
-      .command(
-        'revoke <team> <spec>',
-        'Remove the ability of users and teams to have read-only or ' +
-          'read-write access to a package',
-        Access.options,
-        async argv => accessRevoke(argv)
-      )
-      .command(
-        'ls-packages [<entity>]',
-        'Show all of the packages a user or a team is able to access, along ' +
-          'with the access level, except for read-only public packages',
-        Access.options,
-        async argv => accessLsPackages(argv)
-      )
-      .command(
-        'ls-collaborators [<spec> [<user>]]',
-        'Show all of the access privileges for a package. Will only show ' +
-          'permissions for packages to which you have at least read access. ' +
-          'If <user> is passed in, the list is filtered only to teams that ' +
-          'user happens to belong to',
-        Access.options,
-        async argv => accessLsCollaborators(argv)
-      )
-      .command(
-        'edit <package>',
-        'Set the access privileges for a package at once using $EDITOR',
-        Access.options,
-        async argv => accessEdit(argv)
-      )
-  },
-  options: Object.assign(require('../common-opts.js', {}))
-}
-
 const figgyPudding = require('figgy-pudding')
-const npmConfig = require('../config.js')
 const libnpm = require('libnpm')
 
-const Config = figgyPudding({
+const ConfigOpts = figgyPudding({
+  entity: {},
   json: {},
   loglevel: {},
   parseable: {},
-  silent: {}
+  permissions: {},
+  silent: {},
+  spec: {},
+  team: {},
+  user: {}
 })
 
-const parseOpts = argv => Config(npmConfig(argv))
-
 const render = (opts, content = {}) => {
   const { h, renderToString } = require('ink') // eslint-disable-line
   const Table = require('ink-table').default
@@ -92,45 +34,54 @@ const render = (opts, content = {}) => {
   }
 }
 
-async function accessPublic (argv) {
-  await libnpm.access.public(argv.spec, parseOpts(argv))
+module.exports.public = accessPublic
+async function accessPublic (argv, opts) {
+  opts = ConfigOpts(opts)
+  await libnpm.access.public(opts.spec, opts)
 }
 
-async function accessRestricted (argv) {
-  await libnpm.access.restricted(argv.spec, parseOpts(argv))
+module.exports.restricted = accessRestricted
+async function accessRestricted (argv, opts) {
+  opts = ConfigOpts(opts)
+  await libnpm.access.restricted(opts.spec, opts)
 }
 
-async function accessGrant (argv) {
-  await access.grant(argv.spec, argv.team, argv.permissions, parseOpts(argv)) // eslint-disable-line
+module.exports.grant = accessGrant
+async function accessGrant (argv, opts) {
+  opts = ConfigOpts(opts)
+  await access.grant(opts.spec, opts.team, opts.permissions, opts) // eslint-disable-line
 }
 
-async function accessRevoke (argv) {
-  await libnpm.access.revoke(argv.spec, argv.team, parseOpts(argv))
+module.exports.revoke = accessRevoke
+async function accessRevoke (argv, opts) {
+  opts = ConfigOpts(opts)
+  await libnpm.access.revoke(opts.spec, opts.team, opts)
 }
 
-async function accessLsPackages (argv) {
+module.exports.lsPackages = accessLsPackages
+async function accessLsPackages (argv, opts) {
+  opts = ConfigOpts(opts)
   const getPackagesByCurrentUser = async () => {
-    const whoami = require('./whoami')
-    return whoami.handler(parseOpts(argv).concat({ silent: true }))
+    const whoami = require('./whoami.js')
+    return whoami([], opts.concat({ silent: true }))
   }
 
-  const entity = argv.entity
-    ? argv.entity
+  const entity = opts.entity
+    ? opts.entity
     : await getPackagesByCurrentUser()
 
-  const opts = parseOpts(argv)
-  // TODO: error when opts is used as 2nd param in .lsPackages
   const packages =
-    await libnpm.access.lsPackages(entity)
+    await libnpm.access.lsPackages(entity, opts)
   render(opts, packages)
 }
 
-async function accessLsCollaborators (argv) {
-  const opts = parseOpts(argv)
+module.exports.lsCollaborators = accessLsCollaborators
+async function accessLsCollaborators (argv, opts) {
+  opts = ConfigOpts(opts)
 
-  if (argv.spec) {
+  if (opts.spec) {
     const collaborators =
-      await libnpm.access.lsCollaborators(argv.spec, argv.user, opts)
+      await libnpm.access.lsCollaborators(opts.spec, opts.user, opts)
     render(opts, collaborators)
   } else {
     const prefix = await libnpm.getPrefix(process.cwd())
@@ -143,13 +94,14 @@ async function accessLsCollaborators (argv) {
 
       if (data) {
         const collaborators =
-          await libnpm.access.lsCollaborators(data.name, argv.user, opts)
+          await libnpm.access.lsCollaborators(data.name, opts.user, opts)
         render(opts, collaborators)
       }
     }
   }
 }
 
-async function accessEdit (argv) {
+module.exports.edit = accessEdit
+async function accessEdit (argv, opts) {
   // TODO: stub
 }

lib/commands/add.js

@@ -1,53 +1,27 @@
 'use strict'
 
-const Add = module.exports = {
-  command: 'add <pkg>',
-  describe: 'Add a dependency.',
-  builder (y) {
-    return y.help().alias('help', 'h')
-      .options(Add.options)
-  },
-  options: Object.assign(require('../common-opts.js', {
-    'development': {
-      alias: ['dev', 'D'],
-      describe: 'Add this dependency as a devDependency',
-      type: 'boolean'
-    },
-    'production': {
-      alias: ['prod', 'P'],
-      describe: 'Add this dependency as a regular dependency',
-      type: 'boolean',
-      default: true
-    },
-    'bundle': {
-      alias: ['bundled', 'B'],
-      describe: 'Add this dependency as a bundledDependency',
-      type: 'boolean'
-    }
-  })),
-  handler: async argv => add(argv)
-}
-
-async function add (argv) {
-  const BB = require('bluebird')
+const BB = require('bluebird')
 
-  const figgyPudding = require('figgy-pudding')
-  const npmConfig = require('../config.js')
-  const spawn = require('child_process').spawn
+const figgyPudding = require('figgy-pudding')
+const prepare = require('./prepare.js')
+const spawn = require('child_process').spawn
 
-  const AddConfig = figgyPudding({
-    log: {},
-    silent: {}
-  }, { other () { return true } })
+const AddConfig = figgyPudding({
+  log: {},
+  silent: {}
+}, { other () { return true } })
 
-  const opts = AddConfig(npmConfig(argv))
+module.exports = add
+async function add (argv, opts) {
+  opts = AddConfig(opts)
+  const packages = argv.concat(opts.packages)
 
   await new BB((resolve, reject) => {
     const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm'
     const child = spawn(npmBin, [
-      'add', opts.pkg, '--package-lock-only'
+      'add', ...packages, '--package-lock-only'
       // We add argv here to get npm to parse those options for us :D
-    ].concat(process.argv.slice(3).filter(x => {
+    ].concat(process.argv.slice(packages.length + 3).filter(x => {
       return !['--bundle', '--development', '--production'].find(y => y === x)
     }) || []), {
       env: process.env,
@@ -65,5 +39,5 @@ async function add (argv) {
       }
     })
   })
-  await require('./prepare.js').handler(opts)
+  await prepare(argv, opts)
 }

lib/commands/build.js

@@ -1,41 +1,31 @@
 'use strict'
-const Build = module.exports = {
-  command: 'build',
-  describe: 'Executes the configured build script, if present, or executes ' +
-    ' silently',
-  builder (y) {
-    return y.help().alias('help', 'h')
-      .options(Build.options)
-  },
-  options: Object.assign(require('../common-opts.js', {})),
-  handler: async argv => build(argv)
-}
 
-async function build (argv) {
-  const libnpm = require('libnpm')
-  const figgyPudding = require('figgy-pudding')
-  const npmConfig = require('../config.js')
+const libnpm = require('libnpm')
+const figgyPudding = require('figgy-pudding')
+
+const BuildConfig = figgyPudding({
+  log: { default: () => require('npmlog') },
+  dir: { default: () => process.cwd() },
+  production: { default: false },
+  nodeOptions: { default: {} },
+  config: { default: {} },
+  unsafePerm: { default: false },
+  scriptsPrependNodePath: { default: false },
+  ignoreScripts: { default: false },
+  user: {},
+  group: {},
+  stdio: {},
+  scriptShell: {}
+})
+
+module.exports = build
+async function build (argv, opts) {
+  opts = BuildConfig(opts)
 
-  const cwd = process.cwd()
-  const BuildConfig = figgyPudding({
-    log: {},
-    dir: { default: cwd },
-    production: { default: false },
-    nodeOptions: { default: {} },
-    config: { default: {} },
-    unsafePerm: { default: false },
-    scriptsPrependNodePath: { default: false },
-    ignoreScripts: { default: false },
-    user: {},
-    group: {},
-    stdio: {},
-    scriptShell: {}
-  })
-  const opts = BuildConfig(npmConfig(argv))
   const prefix = await libnpm.getPrefix(process.cwd())
   const packageJSON = `${prefix}/package.json`
   const pkg = await libnpm.readJSON(packageJSON)
 
-  await libnpm.runScript(pkg, 'build', cwd, opts)
+  await libnpm.runScript(pkg, 'build', opts.dir, opts)
   return true
 }