@jsreport/jsreport-cli 3.0.0 → 3.1.2

package/README.md

@@ -7,6 +7,18 @@ See http://jsreport.net/learn/cli for documentation
 
 ## Changelog
 
+### 3.1.2
+
+- update deps to fix npm audit
+
+### 3.1.1
+
+- update deps to fix npm audit
+
+### 3.1.0
+
+internal refactor (use latest version of yargs)
+
 ### 3.0.0-beta.1
 
-Adaptations for the v3 APIs
+Adaptations for the v3 APIs

package/cli.js

@@ -19,7 +19,7 @@ if (!semver.satisfies(process.versions.node, cliPackageJson.engines.node)) {
 const path = require('path')
 const Liftoff = require('liftoff')
 const commander = require('./lib/commander')
-const { printError } = require('./lib/errorUtils')
+const { printError } = require('./lib/utils/error')
 const help = require('./lib/commands/help')
 const init = require('./lib/commands/init')
 const repair = require('./lib/commands/repair')
@@ -73,7 +73,7 @@ function initCLI (env) {
     globalCliHandler.start(args)
   } else {
     if (isCLIDev) {
-      localCommander = require(path.join(cwd, 'lib/commander.js'))(cwd, { cliName: 'jsreport' })
+      localCommander = require(path.join(cwd, 'lib/commander'))(cwd, { cliName: 'jsreport' })
     } else {
       // Check for semver difference between global cli and local installation
       if (semver.gt(cliPackageJson.version, env.modulePackage.version)) {
@@ -82,7 +82,7 @@ function initCLI (env) {
         console.log('Local jsreport-cli is', env.modulePackage.version)
       }
 
-      localCommander = require(path.join(path.dirname(env.modulePath), 'lib/commander.js'))(cwd, {
+      localCommander = require(path.join(path.dirname(env.modulePath), 'lib/commander'))(cwd, {
         cliName: 'jsreport'
       })
     }

package/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const commander = require('./lib/commander')
 const main = require('./lib/cliExtension')
 const keepAliveProcess = require('./lib/keepAliveProcess')

package/lib/cliExtension.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const path = require('path')
-const searchExtensionsCommands = require('./registerExtensionsCommands')
+const detectAndRegisterExtensionsCommands = require('./detectAndRegisterExtensionsCommands')
 
 module.exports = (reporter, definition) => {
   if (reporter.compilation) {
@@ -12,7 +12,7 @@ module.exports = (reporter, definition) => {
 
   reporter.cli = {
     findCommandsInExtensions: async () => {
-      const extensionsCommands = await searchExtensionsCommands(
+      const extensionsCommands = await detectAndRegisterExtensionsCommands(
         reporter.extensionsManager.extensions,
         { registerCommand: () => {} }
       )

package/lib/{createCommandParser.js → commander/createCommandParser.js}

@@ -1,9 +1,8 @@
-'use strict'
-
 const yargs = require('yargs')
 
-module.exports = function createCommandParser (instance, cliName) {
+module.exports = function createCommandParser (instance, _cliName) {
   let cli = instance || yargs([])
+  const cliName = _cliName || 'jsreport'
   const commandHelp = 'To show more information about a command, type: jsreport <command> -h'
 
   if (cliName != null && cliName !== '') {

package/lib/commander/createCustomCommandBuilder.js

@@ -0,0 +1,150 @@
+const getCommandEventName = require('./getCommandEventName')
+
+// wrapping builder to allow some customizations in the api for commands
+module.exports = (commander, {
+  commandName,
+  commandDescription,
+  commandBuilder,
+  commandConfig,
+  globalOptions
+}) => (yargs) => {
+  let shouldGenerateUsage = true
+  let originalUsageFn
+  let originalCheckFn
+  let originalOptionFn
+  let originalOptionsFn
+  let commandCheckFn
+
+  if (typeof yargs.usage === 'function') {
+    originalUsageFn = yargs.usage
+
+    // we expose .usage but just for the message case
+    yargs.usage = (msg) => {
+      shouldGenerateUsage = false
+      return originalUsageFn.apply(yargs, [msg])
+    }
+  }
+
+  if (typeof yargs.check === 'function') {
+    originalCheckFn = yargs.check
+
+    yargs.check = (fn) => {
+      commandCheckFn = fn
+      return yargs
+    }
+  }
+
+  if (typeof yargs.option === 'function') {
+    originalOptionFn = yargs.option
+
+    // default options to be global: false
+    yargs.option = (key, opt) => {
+      if (opt && opt.global == null) {
+        opt.global = false
+      }
+
+      return originalOptionFn.apply(yargs, [key, opt])
+    }
+  }
+
+  if (typeof yargs.options === 'function') {
+    originalOptionsFn = yargs.options
+
+    // default options to be global: false
+    yargs.options = (keyOrOpts, opt) => {
+      if (keyOrOpts && opt == null) {
+        Object.entries(keyOrOpts).forEach(([key, keyConf]) => {
+          if (keyConf && keyConf.global == null) {
+            keyConf.global = false
+          }
+        })
+      }
+
+      if (opt && opt.global == null) {
+        opt.global = false
+      }
+
+      return originalOptionFn.apply(yargs, [keyOrOpts, opt])
+    }
+  }
+
+  const modYargs = commandBuilder(yargs)
+
+  if (typeof yargs.usage === 'function') {
+    yargs.usage = originalUsageFn
+    modYargs.usage = originalUsageFn
+
+    if (shouldGenerateUsage) {
+      modYargs.usage(commandDescription + '\n\nUsage:\n\njsreport ' + commandName)
+    }
+  }
+
+  if (typeof yargs.check === 'function') {
+    yargs.check = originalCheckFn
+    modYargs.check = originalCheckFn
+  }
+
+  if (typeof yargs.option === 'function') {
+    yargs.option = originalOptionFn
+    modYargs.option = originalOptionFn
+  }
+
+  if (typeof yargs.options === 'function') {
+    yargs.options = originalOptionsFn
+    modYargs.options = originalOptionsFn
+  }
+
+  modYargs.check((...args) => {
+    const argv = args[0]
+
+    const unsupportedGlobalOptions = globalOptions.options.filter((opt) => {
+      return commandConfig.globalOptions.indexOf(opt) === -1
+    })
+
+    unsupportedGlobalOptions.forEach((opt) => {
+      if (argv[opt]) {
+        throw new Error(opt + ' global option is not supported in this command')
+      }
+    })
+
+    if (commandCheckFn) {
+      return commandCheckFn.apply(undefined, args)
+    }
+
+    return true
+  }, false)
+
+  if (typeof modYargs.fail === 'function') {
+    // making command strict and registering a generalized fail function
+    modYargs.fail((msg, err) => {
+      // do nothing when error comes from command promise itself,
+      // the propagation of error will be done automatically by promise chain
+      if (msg == null) {
+        return
+      }
+
+      let errForEvent = err
+
+      if (errForEvent == null) {
+        errForEvent = new Error(msg)
+      }
+
+      commander.emit('command.error', commandName, errForEvent)
+      commander.emit(getCommandEventName(commandName, 'error'), errForEvent)
+
+      const defaultErr = new Error(`${commandName} command error:\n${msg}\ntype jsreport ${commandName} -h to get help about usage and available options`)
+
+      defaultErr.cleanState = true
+
+      throw defaultErr
+    })
+  }
+
+  if (commandConfig.disableStrictOptions !== true) {
+    modYargs.strict()
+  } else {
+    modYargs.strict(false)
+  }
+
+  return modYargs
+}

package/lib/commander/createLogger.js

@@ -0,0 +1,51 @@
+
+module.exports = function createLogger (verboseMode) {
+  const logs = []
+
+  const logger = {
+    debug: (...messages) => {
+      const msg = messages.join(' ')
+
+      if (verboseMode) {
+        logs.push({
+          type: 'debug',
+          message: msg
+        })
+
+        console.log(...messages)
+      }
+    },
+    info: (...messages) => {
+      const msg = messages.join(' ')
+
+      logs.push({
+        type: 'info',
+        message: msg
+      })
+
+      console.log(...messages)
+    },
+    warn: (...messages) => {
+      const msg = messages.join(' ')
+
+      logs.push({
+        type: 'warn',
+        message: msg
+      })
+
+      console.error(...messages)
+    },
+    error: (...messages) => {
+      const msg = messages.join(' ')
+
+      logs.push({
+        type: 'error',
+        message: msg
+      })
+
+      console.error(...messages)
+    }
+  }
+
+  return { logger, getLogs: () => logs }
+}

package/lib/commander/executeCommand.js

@@ -0,0 +1,37 @@
+const getCommandEventName = require('./getCommandEventName')
+
+module.exports = async function executeCommand (commander, commandName, argv) {
+  const command = commander._commands[commandName]
+
+  if (!command) {
+    throw new Error(`"${commandName}" command is not a valid command`)
+  }
+
+  if (typeof command.handler !== 'function') {
+    throw new Error(`"${commandName}" command doesn't have a valid handler`)
+  }
+
+  const commandHandler = command.handler
+
+  commander.emit('command.init', commandName, argv)
+  commander.emit(getCommandEventName(commandName, 'init'), argv)
+
+  let resolveValue
+
+  try {
+    resolveValue = await commandHandler(argv)
+
+    commander.emit('command.success', commandName, resolveValue)
+    commander.emit(getCommandEventName(commandName, 'success'), resolveValue)
+
+    return resolveValue
+  } catch (errorInCommand) {
+    commander.emit('command.error', commandName, errorInCommand)
+    commander.emit(getCommandEventName(commandName, 'error'), errorInCommand)
+    // propagating error
+    throw errorInCommand
+  } finally {
+    commander.emit('command.finish', commandName)
+    commander.emit(getCommandEventName(commandName, 'finish'))
+  }
+}

package/lib/commander/getCommandEventName.js

@@ -0,0 +1,4 @@
+
+module.exports = function getCommandEventName (command, event) {
+  return `command.${command}.${event}`
+}

package/lib/commander/index.js

@@ -0,0 +1,279 @@
+// eslint-disable-next-line no-var
+var semver = require('semver')
+// eslint-disable-next-line no-var
+var cliPackageJson = require('../../package.json')
+
+if (!semver.satisfies(process.versions.node, cliPackageJson.engines.node)) {
+  console.error(
+    'jsreport cli requires to have installed a nodejs version of at least ' +
+    cliPackageJson.engines.node +
+    ' but you have installed version ' + process.versions.node + '. please update your nodejs version and try again'
+  )
+
+  process.exit(1)
+}
+
+const events = require('events')
+const isAbsoluteUrl = require('is-absolute-url')
+const createLogger = require('./createLogger')
+const createCommandParser = require('./createCommandParser')
+const registerCommand = require('./registerCommand')
+const executeCommand = require('./executeCommand')
+const startProcessing = require('./startProcessing')
+const daemonHandler = require('../daemonHandler')
+const keepAliveProcess = require('../keepAliveProcess')
+const getTempPaths = require('../utils/getTempPaths')
+const { printError } = require('../utils/error')
+
+const helpCmd = require('../commands/help')
+const initCmd = require('../commands/init')
+const repairCmd = require('../commands/repair')
+const winInstallCmd = require('../commands/win-install')
+const winUninstallCmd = require('../commands/win-uninstall')
+const configureCmd = require('../commands/configure')
+const startCmd = require('../commands/start')
+const renderCmd = require('../commands/render')
+const killCmd = require('../commands/kill')
+
+let BUILT_IN_COMMAND_MODULES = {
+  help: helpCmd,
+  init: initCmd,
+  repair: repairCmd,
+  'win-install': winInstallCmd,
+  'win-uninstall': winUninstallCmd,
+  configure: configureCmd,
+  start: startCmd,
+  render: renderCmd,
+  kill: killCmd
+}
+
+const AVAILABLE_GLOBAL_OPTIONS = {
+  options: [
+    'context',
+    'verbose',
+    // tempDirectory was added just for compatibility with jsreport.exe
+    'tempDirectory',
+    'serverUrl',
+    'user',
+    'password'
+  ],
+  alwaysGlobal: ['context', 'verbose', 'tempDirectory']
+}
+
+BUILT_IN_COMMAND_MODULES = Object.keys(BUILT_IN_COMMAND_MODULES).map((key) => BUILT_IN_COMMAND_MODULES[key])
+
+const tempPaths = getTempPaths()
+const CLI_PATH = tempPaths.cliPath
+const MAIN_SOCK_PATH = tempPaths.mainSockPath
+const WORKER_SOCK_PATH = tempPaths.workerSockPath
+
+tempPaths.createPaths()
+
+class Commander extends events.EventEmitter {
+  constructor (cwd, options = {}) {
+    super()
+
+    let cliHandler
+
+    this.cwd = cwd || process.cwd()
+
+    this.execution = options.execution
+
+    this.context = {
+      cwd: this.cwd,
+      sockPath: MAIN_SOCK_PATH,
+      workerSockPath: WORKER_SOCK_PATH,
+      staticPaths: options.staticPaths || {},
+      daemonHandler,
+      keepAliveProcess,
+      appInfo: options.appInfo
+    }
+
+    if (this.execution) {
+      if (!this.context.staticPaths.nssm) {
+        this.context.staticPaths.nssm = process.arch === 'x64' ? this.execution.resourceTempPath('nssm64.exe') : this.execution.resourceTempPath('nssm.exe')
+      }
+    }
+
+    this._commands = {}
+    this._commandModules = {}
+    this._commandNames = []
+    this._commandsConfig = {}
+
+    if (options.builtInCommands) {
+      this._builtInCommands = options.builtInCommands
+    } else {
+      this._builtInCommands = BUILT_IN_COMMAND_MODULES
+    }
+
+    if (options.disabledCommands) {
+      this._disabledCommands = options.disabledCommands
+    } else {
+      this._disabledCommands = []
+    }
+
+    this._globalOptions = AVAILABLE_GLOBAL_OPTIONS
+
+    this._builtInCommandNames = this._builtInCommands.map((cmdModule) => cmdModule.command)
+
+    this._showHelpWhenNoCommand = options.showHelpWhenNoCommand != null ? Boolean(options.showHelpWhenNoCommand) : true
+
+    // this option tell us that we should use this value as the instance
+    // and not try to look up for it
+    this._jsreportInstance = options.instance
+
+    // reference to the jsreport instance initiated, this variable will be set
+    // when the CLI has initialized a jsreport instance successfully
+    this.jsreportInstanceInitiated = null
+
+    // this option tell us that we should use this value as the instance version
+    // and not try to look up for it
+    this._jsreportVersion = options.jsreportVersion
+
+    // this option tell us that we should use this path as the executable
+    // to spawn when we need to use a daemonized process
+    this._daemonExecPath = options.daemonExecPath
+
+    // optional path to script being run in the daemonized process
+    this._daemonExecScriptPath = options.daemonExecScriptPath
+
+    // this option tell us that we should additionally pass this arguments
+    // to the executable when we need to use a daemonized process
+    this._daemonExecArgs = options.daemonExecArgs
+
+    // this option tell us that we should additionally pass this options
+    // to child_process.spawn when we need to use a daemonized process
+    this._daemonExecOpts = options.daemonExecOpts
+
+    if (this.execution) {
+      if (this._daemonExecOpts == null || this._daemonExecOpts.WinRunPath == null) {
+        this._daemonExecOpts = this._daemonExecOpts || {}
+        this._daemonExecOpts.WinRunPath = this.execution.resourceTempPath('WinRun.exe')
+      }
+    }
+
+    // lazy initialization of cli handler, commands will be activated when
+    // starting the parsing of cliHandler
+    if (options.cli) {
+      cliHandler = createCommandParser(options.cli, options.cliName)
+    } else {
+      cliHandler = (
+        createCommandParser(undefined, options.cliName)
+          .option('verbose', {
+            global: false,
+            alias: 'b',
+            description: 'Enables verbose mode',
+            type: 'boolean'
+          })
+          .option('tempDirectory', {
+            global: false,
+            description: 'Specifies the temp directory that will be used to store temp files and resources',
+            type: 'string'
+          })
+          .option('serverUrl', {
+            global: false,
+            alias: 's',
+            description: 'Specifies a url to a remote jsreport server, that server will be the target of the command (only if command support this mode)',
+            type: 'string',
+            requiresArg: true
+          })
+          .option('user', {
+            global: false,
+            alias: 'u',
+            description: 'Specifies a username for authentication against a jsreport server (Use if some command needs authentication information)',
+            type: 'string',
+            requiresArg: true
+          })
+          .option('password', {
+            global: false,
+            alias: 'p',
+            description: 'Specifies a password for authentication against a jsreport server (Use if some command needs authentication information)'
+          })
+          .check((argv, hash) => {
+            if (argv.serverUrl != null && !isAbsoluteUrl(argv.serverUrl)) {
+              const error = new Error('serverUrl option must be a valid absolute url')
+              error.cleanState = true
+              throw error
+            }
+
+            return true
+          })
+          .strict()
+      )
+    }
+
+    this._cli = cliHandler
+
+    this.cliName = this._cli.$0
+
+    // registering built-in commands
+    this._builtInCommands.forEach((commandModule) => this.registerCommand(commandModule))
+
+    setImmediate(() => this.emit('initialized'))
+
+    return this
+  }
+
+  getCommands () {
+    return this._commandNames
+  }
+
+  registerCommand (commandModule) {
+    registerCommand(this, commandModule)
+    return this
+  }
+
+  async executeCommand (commandName, argv) {
+    return executeCommand(this, commandName, argv)
+  }
+
+  start (args) {
+    const verboseMode = args.includes('--verbose') || args.includes('-b')
+    const { logger } = createLogger(verboseMode)
+
+    startProcessing(this, logger, args).then((resultInfo) => {
+      const commandHandled = resultInfo != null ? resultInfo.command : undefined
+      const disableExit = commandHandled != null && this._commandsConfig[commandHandled] ? this._commandsConfig[commandHandled].disableProcessExit === true : false
+
+      if (disableExit !== true) {
+        process.exit(0)
+      }
+    }).catch((err) => {
+      if (err.exitDirectly) {
+        return process.exit(1)
+      }
+
+      printError(err, logger)
+
+      if (err.disabledExit !== true) {
+        process.exit(1)
+      }
+    })
+  }
+
+  async startAndWait (args) {
+    const verboseMode = args != null && (args.includes('--verbose') || args.includes('-b'))
+    const { logger, getLogs } = createLogger(verboseMode)
+    let error
+
+    try {
+      await startProcessing(this, logger, args)
+    } catch (e) {
+      error = e
+
+      if (e.exitDirectly !== true) {
+        printError(e, logger)
+      }
+    }
+
+    const logs = getLogs()
+
+    return { error, logs }
+  }
+}
+
+module.exports = (cwd, options = {}) => new Commander(cwd, options)
+
+module.exports.cliPath = CLI_PATH
+module.exports.mainSockPath = MAIN_SOCK_PATH
+module.exports.workerSockPath = WORKER_SOCK_PATH