@toptal/davinci-workflow 1.8.3 → 1.8.4-alpha-fx-2755-interactive-workflow-generation.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-workflow",
-  "version": "1.8.3",
+  "version": "1.8.4-alpha-fx-2755-interactive-workflow-generation.4+46405792",
   "description": "GH Workflow generator package for frontend applications",
   "publishConfig": {
     "access": "public"
@@ -30,12 +30,17 @@
     "url": "https://github.com/toptal/davinci/issues"
   },
   "dependencies": {
-    "@toptal/davinci-cli-shared": "1.5.2",
-    "@toptal/davinci-skeleton": "7.0.0",
+    "@toptal/davinci-cli-shared": "1.5.3-alpha-fx-2755-interactive-workflow-generation.4+46405792",
+    "@toptal/davinci-monorepo": "6.5.2-alpha-fx-2755-interactive-workflow-generation.4+46405792",
+    "@toptal/davinci-skeleton": "7.0.1-alpha-fx-2755-interactive-workflow-generation.23+46405792",
+    "chalk": "^4.1.2",
+    "cosmiconfig": "^7.0.1",
     "fs-extra": "^9.0.1",
+    "inquirer": "^8.2.4",
+    "inquirer-table-prompt": "^0.2.1",
+    "js-yaml": "^4.1.0",
     "lodash.kebabcase": "^4.1.1",
-    "ora": "^5.4.1",
-    "chalk": "^4.1.2",
-    "js-yaml": "^4.1.0"
-  }
+    "ora": "^5.4.1"
+  },
+  "gitHead": "46405792bfc49fdb4b954b2ca9ddbb9ce8660801"
 }

package/src/commands/new-workflow.js

@@ -1,16 +1,19 @@
 const { print } = require('@toptal/davinci-cli-shared')
+const {
+  utils: { checkIfMonorepo }
+} = require('@toptal/davinci-monorepo')
 const path = require('path')
 const fs = require('fs-extra')
 const ora = require('ora')
 const kebabCase = require('lodash.kebabcase')
 const {
-  prettifyCommands
+  prettifyCommands,
 } = require('@toptal/davinci-cli-shared/src/utils/print')
 
 const { WORKFLOWS_DIR, GITHUB_DIR } = require('../constants')
 const {
   copyWorkflowFromSkeleton,
-  getWorkflowSourceFilepath
+  getWorkflowSourceFilepath,
 } = require('../utils/skeleton')
 const { readYMLSecrets } = require('../utils/read-secrets')
 const generateMessageFromSecrets = require('../utils/generate-command-message')
@@ -77,7 +80,7 @@ const getWorkflowPostBuildFilename = workflowName => {
   return kebabCase(workflowName) + '.js'
 }
 
-const performPostBuildProcedure = async (filename, destDir) => {
+const performPostBuildProcedure = async (filename, destDir, workflowName) => {
   const postBuildFilePathname = path.join(
     require.resolve('@toptal/davinci-workflow'),
     '../',
@@ -96,9 +99,13 @@ const performPostBuildProcedure = async (filename, destDir) => {
     throw new Error('post build file must export a function')
   }
 
+  const isMonorepo = checkIfMonorepo()
+
   await executePostBuild({
     print,
-    destDir
+    destDir,
+    workflowName,
+    isMonorepo,
   })
 }
 
@@ -129,7 +136,8 @@ const createCommand = async workflowName => {
     // execute a possible post-build procedure
     await performPostBuildProcedure(
       getWorkflowPostBuildFilename(workflowName),
-      workflowsDir
+      workflowsDir,
+      fileName
     )
     // read and print mandatory ENV secrets that must be installed beforehand
     await printMandatorySecretsList(fileName)
@@ -165,7 +173,7 @@ const newWorkflowCommandCreator = {
 
     return createCommand(workflowName)
   },
-  help
+  help,
 }
 
 module.exports = newWorkflowCommandCreator

package/src/constants.js

@@ -21,11 +21,11 @@ const SECRET_DEFINITION = {
     'Jenkins Build Token. Necessary to execute Jenkins job',
   // alpha-package
   NPM_TOKEN_PUBLISH: 'NPM publish access token',
-  NPM_TOKEN_READ_ONLY: 'NPM read token'
+  NPM_TOKEN_READ_ONLY: 'NPM read token',
 }
 
 module.exports = {
   GITHUB_DIR,
   WORKFLOWS_DIR,
-  SECRET_DEFINITION
+  SECRET_DEFINITION,
 }

package/src/index.js

@@ -2,5 +2,5 @@ const newWorkflowCommandCreator = require('./commands/new-workflow')
 
 module.exports = {
   commands: [newWorkflowCommandCreator],
-  newWorkflowCommand: newWorkflowCommandCreator
+  newWorkflowCommand: newWorkflowCommandCreator,
 }

package/src/post-build/alpha-package.js

@@ -35,7 +35,7 @@ const executePostBuild = ({ destDir }) => {
       ' — it performs build&release of a new alpha package \n',
       !isScriptExist
         ? logText('New "build:package" script was added in package.json! \n')
-        : ''
+        : '',
     ].join('')
   )
 }

package/src/post-build/deploy-temploy.js

@@ -34,7 +34,7 @@ const executePostBuild = ({ destDir }) => {
       ' — it performs build & deploy a new temploy \n',
       !isScriptExist
         ? logText('New "build" script was added in package.json! \n')
-        : ''
+        : '',
     ].join('')
   )
 }

package/src/post-build/deploy.js

@@ -6,7 +6,7 @@ const logText = chalk.red.bold
 const yellowBoldText = chalk.yellow.bold
 const deployWorkflows = [
   'davinci-deploy-production.yml',
-  'davinci-deploy-staging.yml'
+  'davinci-deploy-staging.yml',
 ]
 
 const executePostBuild = async ({ destDir }) => {
@@ -53,7 +53,7 @@ const executePostBuild = async ({ destDir }) => {
       ' — it performs build & deploy to staging for the latest commit in the PR branch \n',
       !isScriptExist
         ? logText('New "build" script was added in package.json! \n')
-        : ''
+        : '',
     ].join('')
   )
 }

package/src/post-build/integration-tests.js

@@ -1,10 +1,116 @@
+const fs = require('fs')
 const chalk = require('chalk')
+const path = require('path')
+const {
+  utils: { getWorkspacesInfo },
+} = require('@toptal/davinci-monorepo')
+
+const filterWorkspacesByCommand = require('../utils/filter-workspaces-by-command')
+const setRootEnv = require('../utils/set-root-env')
+const getProgramConfig = require('../utils/get-program-config')
+const { readPackageJson } = require('../utils/skeleton')
+const {
+  promptParallelWorkersForMonorepo,
+  promptNumber,
+  promptConfirm,
+} = require('../utils/prompts')
 
 const CONFLUENCE_PAGE =
   'https://toptal-core.atlassian.net/l/c/qtXKBzvs#Generated-IT-Workflow'
 const yellowBoldText = chalk.yellow.bold
 
-const executePostBuild = () => {
+const getCoverageReportDir = config => config?.['report-dir'] ?? 'coverage'
+
+const getEnvForMonorepo = async (destDir, commands) => {
+  const rootDir = path.resolve(destDir, '../../')
+  const workspaces = await getWorkspacesInfo()
+
+  const filteredWorkspaces = filterWorkspacesByCommand(
+    rootDir,
+    workspaces,
+    commands
+  )
+
+  if (filteredWorkspaces.length === 0) {
+    throw new Error(
+      `There are no packages to run integration tests in. Following commands were not found: ${JSON.stringify(
+        commands
+      )}`
+    )
+  }
+
+  const { command, location } = filteredWorkspaces[0]
+
+  const coverageConfig = await getProgramConfig(
+    'nyc',
+    path.join(rootDir, location)
+  )
+
+  return {
+    PARALLEL_MATRIX: JSON.stringify(
+      await promptParallelWorkersForMonorepo(filteredWorkspaces)
+    ),
+    COMMAND: command,
+    COVERAGE_REPORT_DIR: getCoverageReportDir(coverageConfig),
+  }
+}
+
+const getEnvForSPA = async (destDir, commands) => {
+  const rootDir = path.resolve(destDir, '../../')
+
+  const pkg = readPackageJson(rootDir)
+  const command = Object.keys(pkg.scripts).find(script =>
+    commands.includes(script)
+  )
+  const coverageConfig = await getProgramConfig('nyc', path.join(rootDir))
+
+  if (!command) {
+    throw new Error(
+      `No command for integration tests was found. Searched for: ${JSON.stringify(
+        commands
+      )}`
+    )
+  }
+
+  return {
+    PARALLEL_GROUPS: await promptNumber(
+      'Input how many parallel workers you want for integration tests'
+    ),
+    COMMAND: command,
+    COVERAGE_REPORT_DIR: getCoverageReportDir(coverageConfig),
+  }
+}
+
+const executePostBuild = async ({ destDir, workflowName, isMonorepo }) => {
+  const workflowPath = path.join(destDir, workflowName)
+  // to support backward compatibility
+  const supportedCommands = ['test:integration:ci', 'test:ui:ci', 'test:e2e:ci']
+
+  try {
+    const dynamicEnv = isMonorepo
+      ? await getEnvForMonorepo(destDir, supportedCommands)
+      : await getEnvForSPA(destDir, supportedCommands)
+
+    const printCoverage = await promptConfirm(
+      'Do you want to print code coverage info in your PR? \nYour project must support code-coverage generation',
+      false
+    )
+
+    setRootEnv(
+      {
+        ...dynamicEnv,
+        PRINT_COVERAGE: printCoverage,
+      },
+      workflowPath
+    )
+
+    console.log(chalk.green('\nWorkflow has been updated.'))
+  } catch (e) {
+    fs.unlinkSync(workflowPath)
+    console.error(e.stack)
+    throw new Error(`Workflow failed to be generated: ${e.message}`)
+  }
+
   console.log(
     [
       chalk.green(
@@ -18,7 +124,7 @@ const executePostBuild = () => {
       ' to make it work in your CI\n',
       'Read more about customization here ',
       chalk.grey.bold(CONFLUENCE_PAGE),
-      '\n'
+      '\n',
     ].join('')
   )
 }

package/src/utils/filter-workspaces-by-command.js

@@ -0,0 +1,34 @@
+const path = require('path')
+const fs = require('fs')
+
+/**
+ * Return workspace packages that have specified
+ * command(s) in their package.json scripts
+ * @param {string} rootDir
+ * @param {Object<string, { location: string }>} workspaces
+ * @param {Array<string>} commands
+ * @return {Array<{ name: string, location: string, command: string }>}
+ */
+const filterWorkspacesByCommand = (rootDir, workspaces, commands) => {
+  return Object.entries(workspaces)
+    .map(([name, { location }]) => {
+      const packageJsonPath = path.join(rootDir, location, 'package.json')
+
+      if (!fs.existsSync(packageJsonPath)) {
+        return false
+      }
+
+      const pkg = require(packageJsonPath)
+
+      return {
+        name,
+        location,
+        command: Object.keys(pkg.scripts).find(script =>
+          commands.includes(script)
+        ),
+      }
+    })
+    .filter(({ command }) => command)
+}
+
+module.exports = filterWorkspacesByCommand

package/src/utils/generate-command-message.js

@@ -16,7 +16,7 @@ const generateMessageFromSecrets = secretsList => {
     '————————————————————————————————————————————————————————————————————————————————————————————————\n',
     'The following GH secrets',
     logText('must'),
-    'be specified in the repo to properly execute the command: \n\n'
+    'be specified in the repo to properly execute the command: \n\n',
   ].join(' ')
 
   message += secretsList.reduce((messageItem, secret) => {

package/src/utils/get-program-config.js

@@ -0,0 +1,42 @@
+const path = require('path')
+const { cosmiconfig } = require('cosmiconfig')
+
+/**
+ * Searches for and loads configuration for your program
+ * Looks for:
+ *   - a package.json property
+ *   - a JSON or YAML, extensionless "rc file"
+ *   - an "rc file" with the extensions .json, .yaml, .yml, .js, or .cjs
+ *   - a .config.js or .config.cjs CommonJS module
+ * @param program
+ * @param [defaultDir] - search up the directory tree from this folder
+ * @return {Promise<any|{extends}>}
+ */
+const getProgramConfig = async (program, defaultDir) => {
+  const explorer = cosmiconfig(program)
+
+  const defaultConfig = await explorer.search(defaultDir)
+
+  if (!defaultConfig) {
+    return
+  }
+
+  if (!defaultConfig.config.extends) {
+    return defaultConfig.config
+  }
+
+  const extendedConfig = await explorer.load(
+    path.join(defaultDir, defaultConfig.config.extends)
+  )
+
+  if (!extendedConfig) {
+    return defaultConfig.config
+  }
+
+  return {
+    ...defaultConfig.config,
+    ...extendedConfig.config
+  }
+}
+
+module.exports = getProgramConfig

package/src/utils/prompts.js

@@ -0,0 +1,86 @@
+const inquirer = require('inquirer')
+
+inquirer.registerPrompt('table', require('inquirer-table-prompt'))
+
+/**
+ * Show table prompt with selection of parallel workers for each package
+ * @param {Array<{ name: string, location: string, command: string }>} packages
+ * @param {string} [message]
+ * @return {Promise<Array<{ pkg: string, location: string, parallelGroups: number }>>}
+ */
+const promptParallelWorkersForMonorepo = async (packages, message = '') => {
+  const { parallelWorkers } = await inquirer.prompt([
+    {
+      type: 'table',
+      name: 'parallelWorkers',
+      message: `${
+        message ? message + '\n' : ''
+      }Here are packages that support integration tests. Select how many parallel workers you want in which package.\nIf you don't choose anything, package won't be included in integration testing`,
+      columns: Array.from({ length: 10 }, (_, index) => ({
+        name: index + 1,
+      })),
+      rows: packages.map(({ name }) => ({
+        name,
+      })),
+    },
+  ])
+
+  // At least one package needs to be selected for integration tests
+  // so if none is selected, show the prompt again
+  if (parallelWorkers.filter(Boolean).length === 0) {
+    return promptParallelWorkersForMonorepo(
+      packages,
+      'At least one package need to be selected for integration tests!'
+    )
+  }
+
+  return packages
+    .map(({ name, location }, index) => ({
+      pkg: name,
+      location,
+      parallelGroups: parallelWorkers[index],
+    }))
+    .filter(({ parallelGroups }) => parallelGroups)
+}
+
+/**
+ * Show number prompts
+ * @param {string} message
+ * @return {Promise<number>}
+ */
+const promptNumber = async message => {
+  const { numberValue } = await inquirer.prompt([
+    {
+      type: 'number',
+      name: 'numberValue',
+      message,
+    },
+  ])
+
+  return numberValue
+}
+
+/**
+ * Show confirmation prompt
+ * @param {string} message
+ * @param {boolean} [defaultValue]
+ * @return {Promise<boolean>}
+ */
+const promptConfirm = async (message, defaultValue) => {
+  const { confirmValue } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmValue',
+      message,
+      default: defaultValue,
+    },
+  ])
+
+  return confirmValue
+}
+
+module.exports = {
+  promptParallelWorkersForMonorepo,
+  promptNumber,
+  promptConfirm,
+}

package/src/utils/read-secrets.js

@@ -38,5 +38,5 @@ const readYMLSecrets = pathname => {
 
 module.exports = {
   readSecrets,
-  readYMLSecrets
+  readYMLSecrets,
 }

package/src/utils/set-root-env.js

@@ -0,0 +1,17 @@
+const yaml = require('js-yaml')
+const fs = require('fs')
+
+/**
+ * Set/replace root ENV variables in the workflow
+ * @param {Object<string, any>} env
+ * @param {string} workflowPath
+ */
+const setRootEnv = (env, workflowPath) => {
+  const workflow = yaml.load(fs.readFileSync(workflowPath, 'utf8'))
+
+  Object.assign(workflow.env, env)
+
+  fs.writeFileSync(workflowPath, yaml.dump(workflow))
+}
+
+module.exports = setRootEnv

package/src/utils/skeleton.js

@@ -45,5 +45,5 @@ module.exports = {
   readPackageJson,
   writePackageJson,
   getWorkflowSourceFilepath,
-  copyWorkflowFromSkeleton
+  copyWorkflowFromSkeleton,
 }

package/src/utils/workflows.js

@@ -23,5 +23,5 @@ const getWorkflowsDefinitions = () => {
 }
 
 module.exports = {
-  getWorkflowsDefinitions
+  getWorkflowsDefinitions,
 }

package/dist-package/package.json

@@ -1,41 +0,0 @@
-{
-  "name": "@toptal/davinci-workflow",
-  "version": "1.8.3",
-  "description": "GH Workflow generator package for frontend applications",
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "Github Actions",
-    "GH Workflows",
-    "generator"
-  ],
-  "author": "Toptal",
-  "homepage": "https://github.com/toptal/davinci/tree/master/packages/workflow#readme",
-  "license": "ISC",
-  "bin": {
-    "davinci-workflow": "./bin/davinci-workflow.js"
-  },
-  "main": "./src/index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/toptal/davinci.git"
-  },
-  "scripts": {
-    "build:package": "../../bin/build-package.js",
-    "prepublishOnly": "../../bin/prepublish.js",
-    "test": "echo \"Error: run tests from root\" && exit 1"
-  },
-  "bugs": {
-    "url": "https://github.com/toptal/davinci/issues"
-  },
-  "dependencies": {
-    "@toptal/davinci-cli-shared": "1.5.2",
-    "@toptal/davinci-skeleton": "7.0.0",
-    "fs-extra": "^9.0.1",
-    "lodash.kebabcase": "^4.1.1",
-    "ora": "^5.4.1",
-    "chalk": "^4.1.2",
-    "js-yaml": "^4.1.0"
-  }
-}