@toptal/davinci-cli-shared 2.1.2-alpha-GVF-262-disable-source-code-when-live-edit-8e8d1f53.14 → 2.1.2-alpha-chore-replace-vorpal-with-commander-0e62306b.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-cli-shared",
-  "version": "2.1.2-alpha-GVF-262-disable-source-code-when-live-edit-8e8d1f53.14+8e8d1f53",
+  "version": "2.1.2-alpha-chore-replace-vorpal-with-commander-0e62306b.27+0e62306b",
   "description": "Shared CLI code and CLI engine for davinci",
   "publishConfig": {
     "access": "public"
@@ -23,19 +23,20 @@
   "dependencies": {
     "analytics-node": "^6.2.0",
     "chalk": "^4.1.2",
+    "commander": "^10.0.0",
     "execa": "^5.1.1",
     "find-yarn-workspace-root": "^2.0.0",
+    "gradient-string": "^2.0.0",
     "inquirer": "^8.2.0",
     "isomorphic-git": "^1.21.0",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "read-pkg-up": "7.0.1",
     "semver": "^7.3.7",
-    "uuid": "^9.0.0",
-    "vorpal": "^1.12.0"
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@jest/globals": "28.1.0"
+    "@jest/globals": "^29.4.2"
   },
-  "gitHead": "8e8d1f534b3fc5c61c4b77aba24b5b1c00ea42ed"
+  "gitHead": "0e62306b491253cf0aafb2b3b74ac5494c95b4db"
 }

package/src/index.js

@@ -1,4 +1,4 @@
-import vorpal from 'vorpal'
+import { createArgument } from 'commander'
 
 import cliPrint from './utils/print.cjs'
 import { run, runSync } from './utils/run.js'
@@ -13,41 +13,38 @@ import {
   getDirectories,
 } from './utils/files.js'
 import { getPackagePackageJson, checkPrerequirement } from './utils/package.js'
-import commandsLoader from './commands.loader.js'
 import { identify, track } from './utils/metrics/metrics.js'
 import { gatherUsageData } from './utils/metrics/usage-data.js'
+import DavinciCommand from './lib/command.js'
 
 const { config: davinciProjectConfig } = davinciConfig
 
-const vorpalInstance = vorpal()
+const program = new DavinciCommand()
 
-export const bootstrap = (options = {}) => {
-  return vorpalInstance.parse(process.argv, options)
+export const bootstrap = () => {
+  return program.parse(process.argv)
 }
 
-export const execCommand = (...args) => {
-  return vorpalInstance.exec(...args)
-}
+export const getProgram = () => program
 
-export const help = helpText => {
-  return vorpalInstance.help(helpText)
-}
+export const loadCommands = (
+  commandCreators,
+  packageName,
+  parentCommand = program
+) => {
+  parentCommand.setPackageName(packageName)
 
-export const catchErrorCommand = callback => {
-  /* eslint-disable promise/catch-or-return, promise/valid-params */
-  vorpalInstance
-    .catch('[commands...]', 'Catches incorrect commands')
-    .action((args, cb) => {
-      callback(args, cb)
-    })
+  parentCommand.createCommands(commandCreators)
 }
 
-export const loadCommands = (commandCreators, packageCommand) => {
-  commandsLoader(commandCreators, vorpalInstance, packageCommand)
+export {
+  davinciProjectConfig,
+  run,
+  runSync,
+  convertToCLIParameters,
+  createArgument,
 }
 
-export { davinciProjectConfig, run, runSync, convertToCLIParameters }
-
 export const packageUtils = {
   getPackagePackageJson,
   checkPrerequirement,
@@ -84,13 +81,12 @@ export default {
   runSync,
   prompt,
   convertToCLIParameters,
-  execCommand,
-  catchErrorCommand,
-  help,
   packageUtils,
   metrics: {
     identify,
     track,
     gatherUsageData,
   },
+  createArgument,
+  getProgram,
 }

package/src/lib/__snapshots__/command.test.js.snap

@@ -0,0 +1,166 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`DavinciCommand createCommandFromLegacy creates a new command from legacy data 1`] = `
+DavinciCommand {
+  "_actionHandler": [Function],
+  "_addImplicitHelpCommand": undefined,
+  "_aliases": [],
+  "_allowExcessArguments": true,
+  "_allowUnknownOption": true,
+  "_args": [
+    Argument {
+      "_name": "templateName",
+      "argChoices": [
+        "component",
+        "page",
+      ],
+      "defaultValue": undefined,
+      "defaultValueDescription": undefined,
+      "description": "Name of template",
+      "parseArg": [Function],
+      "required": true,
+      "variadic": false,
+    },
+    Argument {
+      "_name": "appName",
+      "argChoices": undefined,
+      "defaultValue": undefined,
+      "defaultValueDescription": undefined,
+      "description": "Application Name: folder name for the new application",
+      "parseArg": undefined,
+      "required": true,
+      "variadic": false,
+    },
+  ],
+  "_argsDescription": undefined,
+  "_combineFlagAndOptionalValue": true,
+  "_defaultCommandName": null,
+  "_description": "description",
+  "_enablePositionalOptions": false,
+  "_events": {
+    "option:flag": [Function],
+  },
+  "_eventsCount": 1,
+  "_executableDir": null,
+  "_executableFile": null,
+  "_executableHandler": false,
+  "_exitCallback": null,
+  "_hasHelpOption": true,
+  "_helpCommandDescription": "display help for command",
+  "_helpCommandName": "help",
+  "_helpCommandnameAndArgs": "help [command]",
+  "_helpConfiguration": {},
+  "_helpDescription": "display help for command",
+  "_helpFlags": "-h, --help",
+  "_helpLongFlag": "--help",
+  "_helpShortFlag": "-h",
+  "_hidden": false,
+  "_lifeCycleHooks": {},
+  "_maxListeners": undefined,
+  "_name": "child",
+  "_optionValueSources": {
+    "flag": "default",
+  },
+  "_optionValues": {
+    "flag": false,
+  },
+  "_outputConfiguration": {
+    "getErrHelpWidth": [Function],
+    "getOutHelpWidth": [Function],
+    "outputError": [Function],
+    "writeErr": [Function],
+    "writeOut": [Function],
+  },
+  "_packageName": null,
+  "_passThroughOptions": false,
+  "_scriptPath": null,
+  "_showHelpAfterError": false,
+  "_showSuggestionAfterError": true,
+  "_storeOptionsAsProperties": false,
+  "_summary": "",
+  "args": [],
+  "commands": [],
+  "options": [
+    Option {
+      "argChoices": undefined,
+      "conflictsWith": [],
+      "defaultValue": false,
+      "defaultValueDescription": undefined,
+      "description": "description",
+      "envVar": undefined,
+      "flags": "-f, --flag",
+      "hidden": false,
+      "implied": undefined,
+      "long": "--flag",
+      "mandatory": false,
+      "negate": false,
+      "optional": false,
+      "parseArg": undefined,
+      "presetArg": undefined,
+      "required": false,
+      "short": "-f",
+      "variadic": false,
+    },
+  ],
+  "parent": DavinciCommand {
+    "_actionHandler": null,
+    "_addImplicitHelpCommand": undefined,
+    "_aliases": [],
+    "_allowExcessArguments": true,
+    "_allowUnknownOption": false,
+    "_args": [],
+    "_argsDescription": undefined,
+    "_combineFlagAndOptionalValue": true,
+    "_defaultCommandName": "child",
+    "_description": "",
+    "_enablePositionalOptions": false,
+    "_events": {},
+    "_eventsCount": 0,
+    "_executableDir": null,
+    "_executableFile": null,
+    "_executableHandler": false,
+    "_exitCallback": null,
+    "_hasHelpOption": true,
+    "_helpCommandDescription": "display help for command",
+    "_helpCommandName": "help",
+    "_helpCommandnameAndArgs": "help [command]",
+    "_helpConfiguration": {},
+    "_helpDescription": "display help for command",
+    "_helpFlags": "-h, --help",
+    "_helpLongFlag": "--help",
+    "_helpShortFlag": "-h",
+    "_hidden": false,
+    "_lifeCycleHooks": {},
+    "_maxListeners": undefined,
+    "_name": "parent",
+    "_optionValueSources": {},
+    "_optionValues": {},
+    "_outputConfiguration": {
+      "getErrHelpWidth": [Function],
+      "getOutHelpWidth": [Function],
+      "outputError": [Function],
+      "writeErr": [Function],
+      "writeOut": [Function],
+    },
+    "_packageName": null,
+    "_passThroughOptions": false,
+    "_scriptPath": null,
+    "_showHelpAfterError": false,
+    "_showSuggestionAfterError": true,
+    "_storeOptionsAsProperties": false,
+    "_summary": "",
+    "args": [],
+    "commands": [
+      [Circular],
+    ],
+    "options": [],
+    "parent": null,
+    "processedArgs": [],
+    "rawArgs": [],
+    Symbol(kCapture): false,
+  },
+  "processedArgs": [],
+  "rawArgs": [],
+  Symbol(kCapture): false,
+}
+`;

package/src/lib/command.js

@@ -0,0 +1,138 @@
+import { Argument, Command } from 'commander'
+
+import { createMetricsSidecar } from '../utils/metrics/sidecar.js'
+
+/**
+ * A higher-order function that wraps the provided `action` function and adds telemetry to it.
+ * The telemetry consists of creating a metrics sidecar and finishing it when the `action` function is done.
+ *
+ * @param {Function} action The action to be wrapped
+ * @returns {Function} A new function that wraps the provided `action` function
+ */
+export const withTelemetry =
+  action =>
+  async (...args) => {
+    const command = args[args.length - 1]
+    const commandName = command.getFullCommandName()
+    const packageName = command.getPackageName()
+
+    const metricsSidecar = await createMetricsSidecar(commandName, packageName)
+
+    try {
+      return await action(...args)
+    } finally {
+      metricsSidecar.finish()
+    }
+  }
+
+/**
+ * A custom implementation of the `Command` class from the `commander` package,
+ * with added functionality for telemetry and package names.
+ */
+class DavinciCommand extends Command {
+  constructor(name, packageName = null) {
+    super(name)
+
+    this._packageName = packageName
+  }
+
+  addCommand(cmd, opts) {
+    super.addCommand(cmd, opts)
+
+    cmd._packageName = this._packageName
+
+    return this
+  }
+
+  /**
+   * Creates a new `DavinciCommand` instance with the provided `name`.
+   *
+   * @param {string} name The name of the new command
+   * @returns {DavinciCommand} The newly created `DavinciCommand` instance
+   */
+  createCommand(name) {
+    return new DavinciCommand(name, this._packageName)
+  }
+
+  /**
+   * Creates a new command from legacy data.
+   *
+   * @param {Object} data The legacy data for the new command
+   * @returns {DavinciCommand} The newly created `DavinciCommand` instance
+   */
+  createCommandFromLegacy({
+    command,
+    description = '',
+    args = [],
+    options = [],
+    allowUnknownOptions = false,
+    action,
+    isDefault = false,
+  }) {
+    const currentCommand = this.command(command, { isDefault })
+
+    args.forEach(argument => {
+      if (argument instanceof Argument) {
+        currentCommand.addArgument(argument)
+      } else {
+        currentCommand.argument(...argument)
+      }
+    })
+
+    options.forEach(option =>
+      currentCommand.option(option.name, option.label, option.default)
+    )
+
+    if (allowUnknownOptions) {
+      currentCommand.allowUnknownOption()
+    }
+
+    currentCommand.description(description).action(action)
+
+    return currentCommand
+  }
+
+  createCommands(commandCreators) {
+    commandCreators.forEach(commandCreator => {
+      if (typeof commandCreator === 'function') {
+        this.addCommand(commandCreator(this))
+      } else if (!(commandCreator instanceof Command)) {
+        // legacy
+        this.createCommandFromLegacy(commandCreator)
+      } else {
+        this.addCommand(commandCreator)
+      }
+    })
+  }
+
+  action(fn) {
+    super.action(withTelemetry(fn))
+
+    return this
+  }
+
+  setPackageName(packageName) {
+    this._packageName = packageName
+  }
+
+  getPackageName() {
+    return this._packageName
+  }
+
+  getFullCommandName() {
+    const result = []
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    for (let command = this; command; command = command.parent) {
+      if (!command.parent) {
+        continue
+      }
+
+      result.unshift(command._name)
+    }
+
+    return result.join(' ')
+  }
+}
+
+export default DavinciCommand

package/src/lib/command.test.js

@@ -0,0 +1,107 @@
+import { jest } from '@jest/globals'
+import { createArgument } from 'commander'
+
+jest.unstable_mockModule('../utils/metrics/sidecar.js', () => ({
+  createMetricsSidecar: jest.fn(),
+}))
+
+const { createMetricsSidecar } = await import('../utils/metrics/sidecar.js')
+const { default: DavinciCommand, withTelemetry } = await import('./command.js')
+
+describe('DavinciCommand', () => {
+  let finish
+
+  beforeEach(() => {
+    finish = jest.fn()
+
+    createMetricsSidecar.mockResolvedValue({
+      finish,
+    })
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('withTelemetry', () => {
+    let command
+
+    beforeEach(() => {
+      command = {
+        getFullCommandName: jest.fn().mockReturnValue('FULL_COMMAND_NAME+1'),
+        getPackageName: jest.fn().mockReturnValue('PACKAGE_NAME+1'),
+      }
+    })
+
+    it('calls the action function with the provided arguments', async () => {
+      const action = jest.fn()
+      const args = [1, 2, command]
+
+      await withTelemetry(action)(...args)
+
+      expect(action).toHaveBeenCalledWith(...args)
+      expect(action).toHaveBeenCalledTimes(1)
+    })
+
+    it('creates a metrics sidecar with the correct command name and package name', async () => {
+      const action = jest.fn()
+
+      await withTelemetry(action)(1, 2, command)
+
+      expect(createMetricsSidecar).toHaveBeenCalledWith(
+        'FULL_COMMAND_NAME+1',
+        'PACKAGE_NAME+1'
+      )
+    })
+
+    describe('when the action function is done', () => {
+      it('calls finish method', async () => {
+        const action = jest.fn()
+
+        await withTelemetry(action)(1, 2, {
+          getFullCommandName: () => {},
+          getPackageName: () => {},
+        })
+
+        expect(finish).toHaveBeenCalledTimes(1)
+        expect(finish).toHaveBeenCalledWith()
+      })
+    })
+  })
+
+  describe('createCommand', () => {
+    it('creates a new DavinciCommand instance with the correct name and package name', () => {
+      const parentCommand = new DavinciCommand('parent', 'foo')
+      const childCommand = parentCommand.createCommand('child')
+
+      expect(childCommand.name()).toBe('child')
+      expect(childCommand.getPackageName()).toBe('foo')
+    })
+  })
+
+  describe('createCommandFromLegacy', () => {
+    it('creates a new command from legacy data', () => {
+      const parentCommand = new DavinciCommand('parent')
+      const command = parentCommand.createCommandFromLegacy({
+        command: 'child',
+        description: 'description',
+        args: [
+          createArgument('<templateName>', 'Name of template').choices([
+            'component',
+            'page',
+          ]),
+          [
+            '<appName>',
+            'Application Name: folder name for the new application',
+          ],
+        ],
+        options: [{ name: '-f, --flag', label: 'description', default: false }],
+        allowUnknownOptions: true,
+        action: jest.fn(),
+        isDefault: true,
+      })
+
+      expect(command).toMatchSnapshot()
+    })
+  })
+})

package/src/utils/convert-to-cli-parameters.js

@@ -1,5 +1,7 @@
 export const convertToCLIParameters = options =>
-  Object.entries(options).flatMap(([option, value]) => {
+  Object.entries(options)
+    .filter(([, value]) => value !== undefined)
+    .flatMap(([option, value]) => {
     if (typeof value === 'boolean') {
       return [`--${!value ? 'no-' : ''}${option}`]
     }

package/src/utils/print.cjs

@@ -1,5 +1,6 @@
 const chalk = require('chalk')
 const util = require('util')
+const gradient = require('gradient-string')
 
 const isObject = obj => typeof obj === 'object'
 const inspectObject = obj =>
@@ -10,6 +11,8 @@ const inspectObject = obj =>
 const prettifyObjectIfExist = args =>
   args.map(arg => (isObject(arg) ? inspectObject(arg) : arg))
 
+const davinciGradient = gradient("#204ECF", "#00CC83")
+
 const cyan = (...args) => {
   console.log(chalk.cyan(...prettifyObjectIfExist(args)))
 }
@@ -69,4 +72,5 @@ module.exports = {
   grey,
   generatePadding,
   prettifyCommands,
+  davinciGradient,
 }

package/src/commands.loader.js

@@ -1,46 +0,0 @@
-import { createMetricsSidecar } from './utils/metrics/sidecar.js'
-import toVorpalArgs from './utils/to-vorpal-args.js'
-
-const commandsLoader = (commandCreators, vorpalInstance, commandName) => {
-  commandCreators.forEach(commandCreator => {
-    const {
-      command: commandDescription,
-      description,
-      options = [],
-      allowUnknownOptions = false,
-      action,
-      help,
-    } = commandCreator
-
-    const commandInstance = vorpalInstance
-      .command(commandDescription)
-      .parse((commandText, args) =>
-        commandText.replace(args, toVorpalArgs(args))
-      )
-
-    options.forEach(option => commandInstance.option(option.name, option.label))
-
-    if (help) {
-      commandInstance.help(help)
-    }
-
-    if (allowUnknownOptions) {
-      commandInstance.allowUnknownOptions()
-    }
-
-    commandInstance.description(description).action(async (...args) => {
-      const metricsSidecar = await createMetricsSidecar(
-        commandDescription,
-        commandName
-      )
-
-      try {
-        return await action(...args)
-      } finally {
-        metricsSidecar.finish()
-      }
-    })
-  })
-}
-
-export default commandsLoader