netlify-cli 8.0.10 → 8.1.0-rc

package/src/commands/env/env.js

@@ -0,0 +1,47 @@
+const { generateCommandsHelp, generateExamplesHelp } = require('../../utils')
+
+const { createEnvGetCommand } = require('./env-get')
+const { createEnvImportCommand } = require('./env-import')
+const { createEnvListCommand } = require('./env-list')
+const { createEnvSetCommand } = require('./env-set')
+const { createEnvUnsetCommand } = require('./env-unset')
+
+/**
+ * The env command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const env = (options, command) => {
+  command.help()
+}
+
+/**
+ * Creates the `netlify env` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createEnvCommand = (program) => {
+  createEnvGetCommand(program)
+  createEnvImportCommand(program)
+  createEnvListCommand(program)
+  createEnvSetCommand(program)
+  createEnvUnsetCommand(program)
+
+  return program
+    .command('env')
+    .description('(Beta) Control environment variables for the current site')
+    .addHelpText(
+      'after',
+      generateExamplesHelp([
+        'netlify env:list',
+        'netlify env:get VAR_NAME',
+        'netlify env:set VAR_NAME value',
+        'netlify env:unset VAR_NAME',
+        'netlify env:import fileName',
+      ]),
+    )
+    .addHelpText('after', generateCommandsHelp('env', program))
+    .action(env)
+}
+
+module.exports = { createEnvCommand }

package/src/commands/env/index.js

@@ -1,25 +1,5 @@
-const { isEmptyCommand } = require('../../utils/check-command-inputs')
-const Command = require('../../utils/command')
-const showHelp = require('../../utils/show-help')
+const { createEnvCommand } = require('./env')
 
-class EnvCommand extends Command {
-  run() {
-    const { args, flags } = this.parse(EnvCommand)
-
-    // Show help on empty sub command
-    if (isEmptyCommand(flags, args)) {
-      showHelp(this.id)
-    }
-  }
+module.exports = {
+  createEnvCommand,
 }
-
-EnvCommand.description = `(Beta) Control environment variables for the current site`
-EnvCommand.examples = [
-  'netlify env:list',
-  'netlify env:get VAR_NAME',
-  'netlify env:set VAR_NAME value',
-  'netlify env:unset VAR_NAME',
-  'netlify env:import fileName',
-]
-
-module.exports = EnvCommand

package/src/commands/functions/functions-build.js

@@ -0,0 +1,59 @@
+// @ts-check
+
+const { mkdir } = require('fs').promises
+
+const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
+
+const { NETLIFYDEVERR, NETLIFYDEVLOG, exit, getFunctionsDir, log } = require('../../utils')
+
+/**
+ * The functions:build command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const functionsBuild = async (options, command) => {
+  const { config } = command.netlify
+
+  const src = options.src || config.build.functionsSource
+  const dst = getFunctionsDir({ options, config })
+
+  if (src === dst) {
+    log(`${NETLIFYDEVERR} Source and destination for function build can't be the same`)
+    exit(1)
+  }
+
+  if (!src || !dst) {
+    if (!src)
+      log(
+        `${NETLIFYDEVERR} Error: You must specify a source folder with a --src flag or a functionsSource field in your config`,
+      )
+    if (!dst)
+      log(
+        `${NETLIFYDEVERR} Error: You must specify a destination functions folder with a --functions flag or a functions field in your config`,
+      )
+    exit(1)
+  }
+
+  await mkdir(dst, { recursive: true })
+
+  log(`${NETLIFYDEVLOG} Building functions`)
+  // @ts-ignore Seems that the typings of zip it and ship it are not correct
+  zipFunctions(src, dst, { skipGo: true })
+  log(`${NETLIFYDEVLOG} Functions built to `, dst)
+}
+
+/**
+ * Creates the `netlify functions:build` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createFunctionsBuildCommand = (program) =>
+  program
+    .command('functions:build')
+    .alias('function:build')
+    .description('Build functions locally')
+    .option('-f, --function <directory>', 'Specify a functions directory to build to')
+    .option('-s, --src <directory>', 'Specify the source directory for the functions')
+    .action(functionsBuild)
+
+module.exports = { createFunctionsBuildCommand }

package/src/commands/functions/{create.js → functions-create.js}

@@ -1,13 +1,12 @@
+// @ts-check
 const cp = require('child_process')
 const fs = require('fs')
+const { mkdir } = require('fs').promises
 const path = require('path')
 const process = require('process')
 const { promisify } = require('util')
 
-const { flags: flagsLib } = require('@oclif/command')
-const chalk = require('chalk')
 const copy = promisify(require('copy-template-dir'))
-const execa = require('execa')
 const findUp = require('find-up')
 const fuzzy = require('fuzzy')
 const inquirer = require('inquirer')
@@ -15,13 +14,20 @@ const inquirerAutocompletePrompt = require('inquirer-autocomplete-prompt')
 const fetch = require('node-fetch')
 const ora = require('ora')
 
-const { mkdirRecursiveSync } = require('../../lib/fs')
+const {
+  NETLIFYDEVERR,
+  NETLIFYDEVLOG,
+  NETLIFYDEVWARN,
+  chalk,
+  error,
+  execa,
+  generateExamplesHelp,
+  injectEnvVariables,
+  log,
+  readRepoURL,
+  validateRepoURL,
+} = require('../../utils')
 const { getAddons, getCurrentAddon, getSiteData } = require('../../utils/addons/prepare')
-const Command = require('../../utils/command')
-const { error, log } = require('../../utils/command-helpers')
-const { injectEnvVariables } = require('../../utils/dev')
-const { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN } = require('../../utils/logo')
-const { readRepoURL, validateRepoURL } = require('../../utils/read-repo-url')
 
 const templatesDir = path.resolve(__dirname, '../../functions-templates')
 
@@ -37,58 +43,22 @@ const languages = [
 ]
 
 /**
- * Be very clear what is the SOURCE (templates dir) vs the DEST (functions dir)
+ * prompt for a name if name not supplied
+ * @param {string} argumentName
+ * @param {import('commander').OptionValues} options
+ * @param {string} [defaultName]
+ * @returns
  */
-class FunctionsCreateCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(FunctionsCreateCommand)
-
-    const functionsDir = await ensureFunctionDirExists(this)
-
-    /* either download from URL or scaffold from template */
-    const mainFunc = flags.url ? downloadFromURL : scaffoldFromTemplate
-    await mainFunc(this, flags, args, functionsDir)
-  }
-}
-
-FunctionsCreateCommand.args = [
-  {
-    name: 'name',
-    description: 'name of your new function file inside your functions directory',
-  },
-]
-
-FunctionsCreateCommand.description = `Create a new function locally`
-
-FunctionsCreateCommand.examples = [
-  'netlify functions:create',
-  'netlify functions:create hello-world',
-  'netlify functions:create --name hello-world',
-]
-FunctionsCreateCommand.aliases = ['function:create']
-FunctionsCreateCommand.flags = {
-  name: flagsLib.string({ char: 'n', description: 'function name' }),
-  url: flagsLib.string({ char: 'u', description: 'pull template from URL' }),
-  language: flagsLib.string({ char: 'l', description: 'function language' }),
-  ...FunctionsCreateCommand.flags,
-}
-module.exports = FunctionsCreateCommand
-
-/**
- * all subsections of code called from the main logic flow above
- */
-
-// prompt for a name if name not supplied
-const getNameFromArgs = async function (args, flags, defaultName) {
-  if (flags.name) {
-    if (args.name) {
+const getNameFromArgs = async function (argumentName, options, defaultName) {
+  if (options.name) {
+    if (argumentName) {
       throw new Error('function name specified in both flag and arg format, pick one')
     }
-    return flags.name
+    return options.name
   }
 
-  if (args.name) {
-    return args.name
+  if (argumentName) {
+    return argumentName
   }
 
   const { name } = await inquirer.prompt([
@@ -155,7 +125,10 @@ const formatRegistryArrayForInquirer = function (lang) {
   return registry
 }
 
-// pick template from our existing templates
+/**
+ * pick template from our existing templates
+ * @param {import('commander').OptionValues} config
+ */
 const pickTemplate = async function ({ language: languageFromFlag }) {
   const specialCommands = [
     new inquirer.Separator(),
@@ -218,11 +191,11 @@ const DEFAULT_PRIORITY = 999
 
 /**
  * Get functions directory (and make it if necessary)
- * @param {FunctionsCreateCommand} context
- * @returns {string | never} - functions directory or throws an error
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<string|never>} - functions directory or throws an error
  */
-const ensureFunctionDirExists = async function (context) {
-  const { api, config, site } = context.netlify
+const ensureFunctionDirExists = async function (command) {
+  const { api, config, site } = command.netlify
   const siteId = site.id
   let functionsDirHolder = config.functionsDirectory
 
@@ -248,6 +221,7 @@ const ensureFunctionDirExists = async function (context) {
     try {
       log(`${NETLIFYDEVLOG} updating site settings with ${chalk.magenta.inverse(functionsDirHolder)}`)
 
+      // @ts-ignore Typings of API are not correct
       await api.updateSite({
         siteId: site.id,
         body: {
@@ -278,11 +252,17 @@ const ensureFunctionDirExists = async function (context) {
   return functionsDirHolder
 }
 
-// Download files from a given github URL
-const downloadFromURL = async function (context, flags, args, functionsDir) {
-  const folderContents = await readRepoURL(flags.url)
-  const [functionName] = flags.url.split('/').slice(-1)
-  const nameToUse = await getNameFromArgs(args, flags, functionName)
+/**
+ * Download files from a given github URL
+ * @param {import('../base-command').BaseCommand} command
+ * @param {import('commander').OptionValues} options
+ * @param {string} argumentName
+ * @param {string} functionsDir
+ */
+const downloadFromURL = async function (command, options, argumentName, functionsDir) {
+  const folderContents = await readRepoURL(options.url)
+  const [functionName] = options.url.split('/').slice(-1)
+  const nameToUse = await getNameFromArgs(argumentName, options, functionName)
 
   const fnFolder = path.join(functionsDir, nameToUse)
   if (fs.existsSync(`${fnFolder}.js`) && fs.lstatSync(`${fnFolder}.js`).isFile()) {
@@ -293,7 +273,7 @@ const downloadFromURL = async function (context, flags, args, functionsDir) {
   }
 
   try {
-    mkdirRecursiveSync(fnFolder)
+    await mkdir(fnFolder, { recursive: true })
   } catch {
     // Ignore
   }
@@ -321,8 +301,8 @@ const downloadFromURL = async function (context, flags, args, functionsDir) {
     // eslint-disable-next-line node/global-require, import/no-dynamic-require
     const { onComplete, addons = [] } = require(fnTemplateFile)
 
-    await installAddons(context, addons, path.resolve(fnFolder))
-    await handleOnComplete({ context, onComplete })
+    await installAddons(command, addons, path.resolve(fnFolder))
+    await handleOnComplete({ command, onComplete })
     // delete
     fs.unlinkSync(fnTemplateFile)
   }
@@ -385,10 +365,16 @@ const installDeps = async ({ functionPackageJson, functionPath, functionsDir })
   }
 }
 
-// no --url flag specified, pick from a provided template
-const scaffoldFromTemplate = async function (context, flags, args, functionsDir) {
+/**
+ * no --url flag specified, pick from a provided template
+ * @param {import('../base-command').BaseCommand} command
+ * @param {import('commander').OptionValues} options
+ * @param {string} argumentName
+ * @param {string} functionsDir
+ */
+const scaffoldFromTemplate = async function (command, options, argumentName, functionsDir) {
   // pull the rest of the metadata from the template
-  const chosenTemplate = await pickTemplate(flags)
+  const chosenTemplate = await pickTemplate(options)
   if (chosenTemplate === 'url') {
     const { chosenUrl } = await inquirer.prompt([
       {
@@ -400,11 +386,11 @@ const scaffoldFromTemplate = async function (context, flags, args, functionsDir)
         // this has some nuance i have ignored, eg crossenv and i18n concerns
       },
     ])
-    flags.url = chosenUrl.trim()
+    options.url = chosenUrl.trim()
     try {
-      await downloadFromURL(context, flags, args, functionsDir)
+      await downloadFromURL(command, options, argumentName, functionsDir)
     } catch (error_) {
-      error(`$${NETLIFYDEVERR} Error downloading from URL: ${flags.url}`)
+      error(`$${NETLIFYDEVERR} Error downloading from URL: ${options.url}`)
       error(error_)
       process.exit(1)
     }
@@ -420,7 +406,7 @@ const scaffoldFromTemplate = async function (context, flags, args, functionsDir)
       )
     }
 
-    const name = await getNameFromArgs(args, flags, templateName)
+    const name = await getNameFromArgs(argumentName, options, templateName)
 
     log(`${NETLIFYDEVLOG} Creating function ${chalk.cyan.inverse(name)}`)
     const functionPath = ensureFunctionPathIsOk(functionsDir, name)
@@ -436,7 +422,7 @@ const scaffoldFromTemplate = async function (context, flags, args, functionsDir)
       const filename = path.basename(filePath)
 
       if (!omittedFromOutput.has(filename)) {
-        context.log(`${NETLIFYDEVLOG} ${chalk.greenBright('Created')} ${filePath}`)
+        log(`${NETLIFYDEVLOG} ${chalk.greenBright('Created')} ${filePath}`)
       }
 
       fs.chmodSync(path.resolve(filePath), TEMPLATE_PERMISSIONS)
@@ -458,8 +444,8 @@ const scaffoldFromTemplate = async function (context, flags, args, functionsDir)
       spinner.succeed(`Installed dependencies for ${name}`)
     }
 
-    await installAddons(context, addons, path.resolve(functionPath))
-    await handleOnComplete({ context, onComplete })
+    await installAddons(command, addons, path.resolve(functionPath))
+    await handleOnComplete({ command, onComplete })
   }
 }
 
@@ -484,20 +470,27 @@ const createFunctionAddon = async function ({ addonName, addons, api, siteData,
   }
 }
 
-const injectEnvVariablesFromContext = async ({ context }) => {
-  const { netlify, warn } = context
-  const { cachedConfig, site } = netlify
-  await injectEnvVariables({ env: cachedConfig.env, site, warn })
-}
-
-const handleOnComplete = async ({ context, onComplete }) => {
+/**
+ *
+ * @param {object} config
+ * @param {import('../base-command').BaseCommand} config.command
+ * @param {(command: import('../base-command').BaseCommand) => any} config.onComplete
+ */
+const handleOnComplete = async ({ command, onComplete }) => {
   if (onComplete) {
-    await injectEnvVariablesFromContext({ context })
-    await onComplete.call(context)
+    await injectEnvVariables({ env: command.netlify.cachedConfig.env, site: command.netlify.site })
+    await onComplete.call(command)
   }
 }
-
-const handleAddonDidInstall = async ({ addonCreated, addonDidInstall, context, fnPath }) => {
+/**
+ *
+ * @param {object} config
+ * @param {*} config.addonCreated
+ * @param {*} config.addonDidInstall
+ * @param {import('../base-command').BaseCommand} config.command
+ * @param {string} config.fnPath
+ */
+const handleAddonDidInstall = async ({ addonCreated, addonDidInstall, command, fnPath }) => {
   if (!addonCreated || !addonDidInstall) {
     return
   }
@@ -515,16 +508,23 @@ const handleAddonDidInstall = async ({ addonCreated, addonDidInstall, context, f
     return
   }
 
-  await injectEnvVariablesFromContext({ context })
+  await injectEnvVariables({ env: command.netlify.cachedConfig.env, site: command.netlify.site })
   addonDidInstall(fnPath)
 }
 
-const installAddons = async function (context, functionAddons, fnPath) {
+/**
+ *
+ * @param {import('../base-command').BaseCommand} command
+ * @param {*} functionAddons
+ * @param {*} fnPath
+ * @returns
+ */
+const installAddons = async function (command, functionAddons, fnPath) {
   if (functionAddons.length === 0) {
     return
   }
 
-  const { api, site } = context.netlify
+  const { api, site } = command.netlify
   const siteId = site.id
   if (!siteId) {
     log('No site id found, please run inside a site directory or `netlify link`')
@@ -545,7 +545,7 @@ const installAddons = async function (context, functionAddons, fnPath) {
         siteData,
       })
 
-      await handleAddonDidInstall({ addonCreated, addonDidInstall, context, fnPath })
+      await handleAddonDidInstall({ addonCreated, addonDidInstall, command, fnPath })
     } catch (error_) {
       error(`${NETLIFYDEVERR} Error installing addon: `, error_)
     }
@@ -563,3 +563,42 @@ const ensureFunctionPathIsOk = function (functionsDir, name) {
   }
   return functionPath
 }
+
+/**
+ * The functions:create command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const functionsCreate = async (name, options, command) => {
+  const functionsDir = await ensureFunctionDirExists(command)
+
+  /* either download from URL or scaffold from template */
+  const mainFunc = options.url ? downloadFromURL : scaffoldFromTemplate
+  await mainFunc(command, options, name, functionsDir)
+}
+
+/**
+ * Creates the `netlify functions:create` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createFunctionsCreateCommand = (program) =>
+  program
+    .command('functions:create')
+    .alias('function:create')
+    .argument('[name]', 'name of your new function file inside your functions directory')
+    .description('Create a new function locally')
+    .option('-n, --name <name>', 'function name')
+    .option('-u, --url <url>', 'pull template from URL')
+    .option('-l, --language <lang>', 'function language')
+    .addHelpText(
+      'after',
+      generateExamplesHelp([
+        'netlify functions:create',
+        'netlify functions:create hello-world',
+        'netlify functions:create --name hello-world',
+      ]),
+    )
+    .action(functionsCreate)
+
+module.exports = { createFunctionsCreateCommand }