@jsreport/jsreport-cli 3.0.0 → 3.1.2

package/lib/commander/jsreportInstance.js

@@ -0,0 +1,98 @@
+const instanceHandler = require('../instanceHandler')
+const detectAndRegisterExtensionsCommands = require('../detectAndRegisterExtensionsCommands')
+
+module.exports.getInstance = function getInstance (commander, prevInstance, log, cwd) {
+  const args = Array.prototype.slice.call(arguments)
+
+  if (args.length === 3) {
+    return _getInstance_.bind(undefined, commander, prevInstance, log)
+  }
+
+  return _getInstance_(commander, prevInstance, log, cwd)
+
+  function _getInstance_ (commander, prevInstance, log, cwd) {
+    if (prevInstance) {
+      log('using jsreport instance passed from options')
+
+      return Promise.resolve(prevInstance)
+    }
+
+    commander.emit('instance.lookup')
+
+    if (cwd == null) {
+      cwd = commander.cwd
+    }
+
+    return (
+      instanceHandler
+        .find(cwd)
+        .then((instanceInfo) => {
+          if (instanceInfo.isDefault) {
+            commander.emit('instance.default', instanceInfo.instance)
+
+            log(
+              'no entry point was found, creating a default instance ' +
+            'using: require("' + instanceInfo.from + '")()'
+            )
+          } else {
+            commander.emit('instance.found', instanceInfo.instance)
+
+            log('using jsreport instance found in: ' + instanceInfo.entryPoint)
+          }
+
+          return instanceInfo.instance
+        })
+    )
+  }
+}
+
+module.exports.initInstance = function initInstance (commander, verbose, instance) {
+  const args = Array.prototype.slice.call(arguments)
+
+  if (args.length === 2) {
+    return _initInstance_.bind(undefined, commander, verbose)
+  }
+
+  return _initInstance_(commander, verbose, instance)
+
+  function _initInstance_ (commander, verbose, instance, forceVerbose) {
+    let verboseMode = verbose
+
+    commander.emit('instance.initializing')
+
+    if (forceVerbose === true) {
+      verboseMode = forceVerbose
+    }
+
+    return (
+      instanceHandler.initialize(instance, verboseMode)
+        .then((result) => {
+          commander.jsreportInstanceInitiated = instance
+
+          commander.emit('instance.initialized', result)
+
+          return result
+        })
+    )
+  }
+}
+
+module.exports.findAndLoadExtensionsCommands = async function findAndLoadExtensionsCommands (instance, commander, verbose) {
+  if (!instance || !instance.extensionsLoad) {
+    return
+  }
+
+  if (!verbose) {
+    if (instance.options.logger) {
+      instance.options.logger.silent = true
+    } else {
+      instance.options.logger = {
+        silent: true
+      }
+    }
+  }
+
+  await instance.extensionsLoad({ onlyLocation: true })
+
+  await detectAndRegisterExtensionsCommands(instance.extensionsManager.extensions, commander)
+}

package/lib/commander/registerCommand.js

@@ -0,0 +1,91 @@
+const createCustomCommandBuilder = require('./createCustomCommandBuilder')
+const executeCommand = require('./executeCommand')
+
+module.exports = function registerCommand (commander, rawCommandModule) {
+  const globalOptions = commander._globalOptions
+  const commandBuilder = rawCommandModule.builder || ((yargs) => (yargs))
+  const commandConfiguration = Object.assign({}, rawCommandModule.configuration)
+  let commandGlobalOptions = Object.assign([], commandConfiguration.globalOptions)
+
+  if (typeof rawCommandModule.command !== 'string' || !rawCommandModule.command) {
+    throw new Error('command module must have a .command property of type string')
+  }
+
+  // we do this because .command can include positional arguments like "command <requiredArg> [optionalArg]"
+  const commandName = rawCommandModule.command.split(' ')[0].trim()
+
+  if (typeof rawCommandModule.description !== 'string') {
+    throw new Error('command module must have a .description property of type string')
+  }
+
+  if (typeof rawCommandModule.handler !== 'function') {
+    throw new Error('command module must have a .handler property of type function')
+  }
+
+  if (commandBuilder != null && typeof commandBuilder !== 'function') {
+    throw new Error('command module .builder property must be a function')
+  }
+
+  if (commander._disabledCommands.indexOf(commandName) !== -1) {
+    return
+  }
+
+  if (commandGlobalOptions) {
+    commandGlobalOptions = commandGlobalOptions.map((opt) => {
+      if (globalOptions.options.indexOf(opt) === -1) {
+        return null
+      }
+
+      return opt
+    })
+
+    // removing invalid options
+    commandGlobalOptions.filter(Boolean)
+
+    // always add some options to global
+    globalOptions.alwaysGlobal.forEach((opt) => {
+      if (commandGlobalOptions.indexOf(opt) === -1) {
+        commandGlobalOptions.unshift(opt)
+      }
+    })
+  } else {
+    // always add some options to global
+    commandGlobalOptions = globalOptions.alwaysGlobal
+  }
+
+  commandConfiguration.globalOptions = commandGlobalOptions
+
+  const bindedHandler = executeCommand.bind(null, commander, commandName)
+
+  commander._commandsConfig[commandName] = commandConfiguration
+
+  const customCommandBuilder = createCustomCommandBuilder(commander, {
+    commandName,
+    commandDescription: rawCommandModule.description,
+    commandBuilder,
+    commandConfig: commandConfiguration,
+    globalOptions
+  })
+
+  const commandModule = Object.assign({}, rawCommandModule, {
+    builder: customCommandBuilder,
+    handler: async (argv) => {
+      const disableExit = commandConfiguration.disableProcessExit === true
+
+      try {
+        await bindedHandler(argv)
+      } catch (err) {
+        err.disableExit = disableExit
+        throw err
+      }
+    }
+  })
+
+  commander._cli.command(commandModule)
+
+  commander._commands[commandName] = rawCommandModule
+  commander._commandModules[commandName] = commandModule
+  commander._commandNames.push(commandName)
+
+  commander.emit('command.register', commandName, rawCommandModule)
+}

package/lib/commander/startCommand.js

@@ -0,0 +1,234 @@
+const Yargs = require('yargs/yargs')
+const { nanoid } = require('nanoid')
+const createCommandParser = require('./createCommandParser')
+const jsreportInstance = require('./jsreportInstance')
+
+// check the command to see if we should handle jsreport instance
+// initialization first or just delegate the command to cli handler
+module.exports = async function startCommand (commander, commandName, args, options, onBeforeCLIParse) {
+  const logger = options.logger
+  const verbose = options.verbose
+  // creating a new context based on properties of commander's context
+  const context = Object.assign({}, commander.context)
+  const startImmediately = options.startImmediately === true || commander._commands[commandName] != null
+
+  // we need to handle the help option directly since there is a conflict
+  // in yargs when a custom command is called the same that the option used in .help()
+  // (that option registers an implicit command with the same name that the option passed)
+  if (commandName === 'help') {
+    // disable the implicit help command when the main command to execute is "help",
+    // this allows our custom command to run
+    commander._cli.help(false)
+  }
+
+  context.logger = logger
+
+  context.getCommandHelp = getCommandHelp(commander, commandName, verbose, context)
+
+  if (commander._daemonExecPath || commander._daemonExecArgs || commander._daemonExecOpts || commander._daemonExecScriptPath) {
+    context.daemonExec = {}
+
+    if (commander._daemonExecPath) {
+      context.daemonExec.path = commander._daemonExecPath
+    }
+
+    if (commander._daemonExecArgs) {
+      context.daemonExec.args = commander._daemonExecArgs
+    }
+
+    if (commander._daemonExecOpts) {
+      context.daemonExec.opts = commander._daemonExecOpts
+    }
+
+    if (commander._daemonExecScriptPath) {
+      context.daemonExec.scriptPath = commander._daemonExecScriptPath
+    }
+  }
+
+  if (startImmediately) {
+    // passing getInstance and initInstance as context
+    // to commands when they should ignore the entry point
+    context.getInstance = jsreportInstance.getInstance(commander, commander._jsreportInstance, logger.debug)
+    context.initInstance = jsreportInstance.initInstance(commander, verbose)
+
+    throwIfCommandIsNotValid(commander, commandName, onBeforeCLIParse)
+
+    const commandConfig = commander._commandsConfig[commandName]
+
+    if (commandConfig && commandConfig.globalOptions) {
+      commandConfig.globalOptions.forEach((optName) => {
+        commander._cli.global(optName)
+      })
+    }
+
+    onBeforeCLIParse()
+
+    // delegating the command to the CLI and activating it
+    await startCLI(logger, commander, commandName, args, context)
+
+    return
+  }
+
+  // at this point command was not found so we need to get jsreport instance and
+  // read extensions and look if any of those define the command
+  try {
+    logger.debug(`Searching for command "${commandName}" in extensions`)
+
+    let getInstancePromise
+
+    if (commander._jsreportInstance) {
+      getInstancePromise = Promise.resolve(commander._jsreportInstance)
+    } else {
+      getInstancePromise = jsreportInstance.getInstance(commander, null, logger.debug, commander.cwd)
+    }
+
+    const instanceOrFn = await getInstancePromise
+    const instance = typeof instanceOrFn === 'function' ? instanceOrFn() : instanceOrFn
+
+    context.getInstance = jsreportInstance.getInstance(commander, instance, logger.debug)
+    context.initInstance = jsreportInstance.initInstance(commander, verbose)
+
+    await jsreportInstance.findAndLoadExtensionsCommands(instance, commander, verbose)
+
+    throwIfCommandIsNotValid(commander, commandName, onBeforeCLIParse)
+
+    const commandConfig = commander._commandsConfig[commandName]
+
+    if (commandConfig && commandConfig.globalOptions) {
+      commandConfig.globalOptions.forEach((optName) => {
+        commander._cli.global(optName)
+      })
+    }
+
+    onBeforeCLIParse()
+  } catch (e) {
+    onBeforeCLIParse(e)
+    throw e
+  }
+
+  await startCLI(logger, commander, commandName, args, context)
+}
+
+async function startCLI (logger, commander, commandName, args, context) {
+  const cli = commander._cli
+
+  commander.emit('parsing', args, context)
+
+  let error
+  let output
+
+  try {
+    const result = await parseCLI(cli, args, context)
+    error = result.error
+    output = result.output
+  } catch (e) {
+    commander.emit('parsed', e, args, context)
+
+    const error = new Error(`An error ocurred while trying to execute "${commandName}" command`)
+    error.originalError = e
+
+    throw error
+  }
+
+  if (error) {
+    commander.emit('parsed', error, args, context)
+
+    if (output != null && output !== '') {
+      logger.error(output)
+    }
+
+    error.exitDirectly = true
+
+    throw error
+  }
+
+  commander.emit('parsed', null, args, context)
+
+  if (output != null && output !== '') {
+    logger.info(output)
+  }
+}
+
+async function parseCLI (cli, args, context) {
+  let error
+  let output
+
+  await cli.parseAsync(args, { context }, (_error, _argv, resultOutput) => {
+    output = resultOutput
+
+    if (_error) {
+      error = _error
+    }
+  })
+
+  return { error, output }
+}
+
+function getCommandHelp (commander, originCommandName, verbose, context) {
+  return async (command) => {
+    let customYargs
+    let out
+
+    if (!commander._commands[command]) {
+      let instance
+
+      try {
+        const instanceOrFn = await context.getInstance()
+        instance = typeof instanceOrFn === 'function' ? instanceOrFn() : instanceOrFn
+      } catch (e) {}
+
+      if (instance) {
+        await jsreportInstance.findAndLoadExtensionsCommands(instance, commander, verbose)
+      }
+    }
+
+    const commandModule = commander._commandModules[command]
+
+    if (commandModule) {
+      customYargs = createCommandParser(Yargs([]), commander.cliName).command(commandModule)
+    }
+
+    if (customYargs) {
+      let helpArg = '-h'
+
+      if (originCommandName === 'help') {
+        const randomHelpArg = nanoid(5)
+        customYargs.help(randomHelpArg).hide(randomHelpArg)
+        helpArg = randomHelpArg
+      }
+
+      const { error, output } = await parseCLI(customYargs, [command, helpArg], context)
+
+      if (error) {
+        throw error
+      }
+
+      out = output
+    } else {
+      const error = new Error(`"${command}" command not available to inspect information, to get the list of commands supported on your installation run "jsreport -h" and try again with a supported command`)
+      error.cleanState = true
+      error.notFound = true
+      throw error
+    }
+
+    return out
+  }
+}
+
+function throwIfCommandIsNotValid (commander, commandName, onBeforeThrow) {
+  if (!commander._commands[commandName]) {
+    const error = new Error(
+      '"' + commandName + '" command not found in this installation, ' +
+      'check that you are writing the command correctly or check if the command ' +
+      'is available in your installation, use "jsreport -h" to see the list of available commands'
+    )
+
+    error.cleanState = true
+
+    if (onBeforeThrow) {
+      onBeforeThrow(error)
+    }
+
+    throw error
+  }
+}

package/lib/commander/startProcessing.js

@@ -0,0 +1,208 @@
+const yargs = require('yargs')
+const prompt = require('prompt')
+const startCommand = require('./startCommand')
+const jsreportInstance = require('./jsreportInstance')
+const cliPackageJson = require('../../package.json')
+
+module.exports = async function startProcessing (commander, logger, args) {
+  process.env.JSREPORT_CLI = true
+
+  if (!Array.isArray(args) && typeof args !== 'string') {
+    throw new Error('args must be an array or string')
+  }
+
+  commander.emit('starting')
+
+  const userArgv = yargs([]).help(false).version(false).parse(args)
+
+  const versionRequired = userArgv.version || userArgv.v
+  const helpRequired = userArgv.help || userArgv.h
+  const needsPassword = userArgv.password || userArgv.p
+  const verboseMode = userArgv.verbose || userArgv.b
+
+  if (userArgv._.length === 0) {
+    const willShowHelpExplicitly = commander._showHelpWhenNoCommand && !versionRequired && !helpRequired
+
+    commander.emit('started', null, { handled: versionRequired || helpRequired || willShowHelpExplicitly, mainCommand: null })
+
+    commander.emit('parsing', args, commander.context)
+
+    let instance
+
+    try {
+      instance = await jsreportInstance.getInstance(commander, commander._jsreportInstance, () => {}, commander.cwd)
+    } catch (e) {}
+
+    if (instance && (helpRequired || willShowHelpExplicitly)) {
+      await jsreportInstance.findAndLoadExtensionsCommands(instance, commander, verboseMode)
+    }
+
+    let parsed = false
+    let output
+
+    // activating CLI
+    try {
+      try {
+        // we run the cli for it to handle args validation and handle help arg, and we can extract the output
+        // from the run directly
+        await commander._cli.parseAsync(args, (_error, _argv, resultOutput) => {
+          // we need to use callback to be able to capture output (important for the default help)
+          // unfortunately using the callback just pass the validation arg error here in the callback
+          // for does not propagate to the parseAsync and does not make it to fail
+          if (_error) {
+            if (resultOutput != null && resultOutput !== '') {
+              logger.error(resultOutput)
+            }
+
+            _error.exitDirectly = true
+
+            throw _error
+          }
+
+          output = resultOutput
+        })
+      } catch (error) {
+        error.exitDirectly = true
+        throw error
+      }
+
+      commander.emit('parsed', null, args, commander.context)
+
+      parsed = true
+
+      if (versionRequired) {
+        let instanceToEvaluate
+
+        if (commander._jsreportVersion) {
+          instanceToEvaluate = {
+            version: commander._jsreportVersion
+          }
+        } else {
+          if (typeof instance === 'function') {
+            instanceToEvaluate = instance()
+          } else {
+            instanceToEvaluate = instance
+          }
+        }
+
+        return handleVersionOption(instanceToEvaluate, logger)
+      }
+
+      if (
+        willShowHelpExplicitly &&
+        !args.includes('--help') &&
+        !args.includes('-h')
+      ) {
+        output = await commander._cli.getHelp()
+      }
+
+      if (output != null && output !== '') {
+        logger.info(output)
+      }
+    } catch (e) {
+      if (!parsed) {
+        commander.emit('parsed', e, args, commander.context)
+      }
+
+      throw e
+    }
+
+    return
+  }
+
+  const mainCommandReceived = userArgv._[0]
+
+  const startImmediately = (
+    // if command is built-in and version or help options is activated
+    (commander._builtInCommandNames.indexOf(mainCommandReceived) !== -1 && (versionRequired || helpRequired))
+  )
+
+  const optionsForStart = {
+    startImmediately,
+    logger,
+    verbose: verboseMode
+  }
+
+  const commandConfiguration = commander._commandsConfig[mainCommandReceived] || {}
+
+  let beforeCLIParseCbCalled = false
+
+  const onBeforeCLIParse = (err) => {
+    if (beforeCLIParseCbCalled) {
+      return
+    }
+
+    beforeCLIParseCbCalled = true
+
+    const isSupportedCommand = commander._commandNames.indexOf(mainCommandReceived) !== -1
+
+    if (err) {
+      return commander.emit('started', err, null)
+    }
+
+    commander.emit('started', null, {
+      handled: isSupportedCommand || versionRequired || (isSupportedCommand && helpRequired),
+      mainCommand: mainCommandReceived
+    })
+  }
+
+  if (
+    needsPassword &&
+    commandConfiguration.globalOptions &&
+    commandConfiguration.globalOptions.indexOf('password') !== -1
+  ) {
+    if (typeof needsPassword === 'string') {
+      // we add middleware to pre-define the "p/password" option to
+      commander._cli.middleware((argv) => {
+        argv.p = needsPassword
+        argv.password = needsPassword
+      }, true)
+    } else {
+      await new Promise((resolve, reject) => {
+        prompt.start()
+
+        prompt.message = ''
+
+        prompt.get([{
+          name: 'password',
+          description: 'Password',
+          message: 'Password can\'t be empty',
+          type: 'string',
+          hidden: true,
+          required: true
+        }], (err, result) => {
+          if (err) {
+            const errorToReject = new Error('No value for password option')
+            errorToReject.cleanState = true
+
+            commander.emit('started', errorToReject, null)
+
+            return reject(errorToReject)
+          }
+
+          // we add middleware to pre-define the "p/password" option to
+          commander._cli.middleware((argv) => {
+            argv.p = result.password
+            argv.password = result.password
+          }, true)
+
+          resolve()
+        })
+      })
+    }
+  }
+
+  await startCommand(commander, mainCommandReceived, args, optionsForStart, onBeforeCLIParse)
+
+  return { command: mainCommandReceived }
+}
+
+function handleVersionOption (instance, logger) {
+  let versionOutput = `cli version: ${cliPackageJson.version}`
+
+  if (instance) {
+    versionOutput = `jsreport version: ${instance.version}\n${versionOutput}`
+  }
+
+  logger.info(versionOutput)
+}

package/lib/commands/_initializeApp.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const path = require('path')
 const fs = require('fs')
 const install = require('npm-install-package')

package/lib/commands/configure.js

@@ -1,8 +1,6 @@
-'use strict'
-
 const path = require('path')
 const fs = require('fs')
-const nanoid = require('nanoid')
+const { nanoid } = require('nanoid')
 const inquirer = require('inquirer')
 
 const description = 'Generates a jsreport configuration file (*.config.json) based on some questions'

package/lib/commands/help.js

@@ -1,13 +1,12 @@
-'use strict'
-
 const cliui = require('cliui')
 const chalk = require('chalk')
 const omit = require('lodash.omit')
 
 const description = 'Prints information about a command or topic'
 const command = 'help'
+const positionalArgs = '[commandOrTopic]'
 
-exports.command = command
+exports.command = `${command} ${positionalArgs}`
 exports.description = description
 
 function getExamples (command) {
@@ -55,7 +54,7 @@ exports.builder = (yargs) => {
           return true
         }
 
-        if (!argv || !argv._[1]) {
+        if (!argv || !argv.commandOrTopic) {
           throw new Error('"commandOrTopic" argument is required')
         }
 
@@ -70,7 +69,7 @@ exports.handler = async (argv) => {
   const logger = context.logger
   const getInstance = context.getInstance
   const initInstance = context.initInstance
-  let commandOrTopic = argv._[1]
+  let commandOrTopic = argv.commandOrTopic
   let helpResult
 
   const getCommandHelp = context.getCommandHelp
@@ -135,8 +134,8 @@ exports.handler = async (argv) => {
       }
     }
 
-    if (helpResult) {
-      helpResult = { output: helpResult.output }
+    if (helpResult != null && typeof helpResult === 'string') {
+      helpResult = { output: helpResult }
     }
   }
 
@@ -442,7 +441,7 @@ function printProperties (ui, props, {
         required: schema.items.required
       })
 
-      ui.div({ text: '{', padding: getPadding(level + 1) })
+      ui.div({ text: '}', padding: getPadding(level + 1) })
       ui.div({ text: `]${!isLastKey ? ',' : ''}`, padding: content.padding })
     } else if (schema.type === 'array' && Array.isArray(schema.items)) {
       printProperties(ui, schema.items.map((s, idx) => {