netlify-cli 10.18.0-rc2 → 11.1.0-rc.0

package/src/commands/build/build.js

@@ -1,6 +1,8 @@
+const process = require('process')
+
 // @ts-check
 const { getBuildOptions, runBuild } = require('../../lib/build')
-const { error, exit, generateNetlifyGraphJWT, getToken } = require('../../utils')
+const { error, exit, generateNetlifyGraphJWT, getEnvelopeEnv, getToken, normalizeContext } = require('../../utils')
 
 /**
  * @param {import('../../lib/build').BuildConfig} options
@@ -15,9 +17,14 @@ const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
   }
 }
 
-const injectNetlifyGraphEnv = async function (command, { api, buildOptions, site }) {
-  const siteData = await api.getSite({ siteId: site.id })
-  const authlifyTokenId = siteData && siteData.authlify_token_id
+const injectEnv = async function (command, { api, buildOptions, context, site, siteInfo }) {
+  const isUsingEnvelope = siteInfo && siteInfo.use_envelope
+  const authlifyTokenId = siteInfo && siteInfo.authlify_token_id
+
+  const { env } = buildOptions.cachedConfig
+  if (isUsingEnvelope) {
+    buildOptions.cachedConfig.env = await getEnvelopeEnv({ api, context, env, siteInfo })
+  }
 
   if (authlifyTokenId) {
     const netlifyToken = await command.authenticate()
@@ -48,12 +55,12 @@ const injectNetlifyGraphEnv = async function (command, { api, buildOptions, site
  */
 const build = async (options, command) => {
   command.setAnalyticsPayload({ dry: options.dry })
-
   // Retrieve Netlify Build options
   const [token] = await getToken()
 
+  const { cachedConfig, siteInfo } = command.netlify
   const buildOptions = await getBuildOptions({
-    cachedConfig: command.netlify.cachedConfig,
+    cachedConfig,
     token,
     options,
   })
@@ -61,7 +68,8 @@ const build = async (options, command) => {
   if (!options.offline) {
     checkOptions(buildOptions)
     const { api, site } = command.netlify
-    await injectNetlifyGraphEnv(command, { api, site, buildOptions })
+    const { context } = options
+    await injectEnv(command, { api, buildOptions, context, site, siteInfo })
   }
 
   const { exitCode } = await runBuild(buildOptions)
@@ -77,8 +85,13 @@ const createBuildCommand = (program) =>
   program
     .command('build')
     .description('(Beta) Build on your local machine')
+    .option(
+      '--context <context>',
+      'Specify a build context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
+      normalizeContext,
+      process.env.CONTEXT || 'production',
+    )
     .option('--dry', 'Dry run: show instructions without running them', false)
-    .option('--context [context]', 'Build context')
     .option('-o, --offline', 'disables any features that require network access', false)
     .addExamples(['netlify build'])
     .action(build)

package/src/commands/dev/dev-exec.js

@@ -1,6 +1,6 @@
 const execa = require('execa')
 
-const { injectEnvVariables } = require('../../utils')
+const { getEnvelopeEnv, injectEnvVariables, normalizeContext } = require('../../utils')
 
 /**
  * The dev:exec command
@@ -8,8 +8,14 @@ const { injectEnvVariables } = require('../../utils')
  * @param {import('../base-command').BaseCommand} command
  */
 const devExec = async (cmd, options, command) => {
-  const { cachedConfig, config, site } = command.netlify
-  await injectEnvVariables({ devConfig: { ...config.dev }, env: cachedConfig.env, site })
+  const { api, cachedConfig, config, site, siteInfo } = command.netlify
+
+  let { env } = cachedConfig
+  if (siteInfo.use_envelope) {
+    env = await getEnvelopeEnv({ api, context: options.context, env, siteInfo })
+  }
+
+  await injectEnvVariables({ devConfig: { ...config.dev }, env, site })
 
   await execa(cmd, command.args.slice(1), {
     stdio: 'inherit',
@@ -25,6 +31,12 @@ const createDevExecCommand = (program) =>
   program
     .command('dev:exec')
     .argument('<...cmd>', `the command that should be executed`)
+    .option(
+      '--context <context>',
+      'Specify a deploy context or branch for environment variables (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
+      normalizeContext,
+      'dev',
+    )
     .description(
       'Exec command\nRuns a command within the netlify dev environment, e.g. with env variables from any installed addons',
     )

package/src/commands/dev/dev.js

@@ -44,6 +44,7 @@ const {
   injectEnvVariables,
   log,
   normalizeConfig,
+  normalizeContext,
   openBrowser,
   processOnExit,
   startLiveTunnel,
@@ -433,7 +434,7 @@ const dev = async (options, command) => {
   }
 
   let { env } = cachedConfig
-  if (siteInfo.use_envelope) {
+  if (!options.offline && siteInfo.use_envelope) {
     env = await getEnvelopeEnv({ api, context: options.context, env, siteInfo })
   }
 
@@ -499,7 +500,7 @@ const dev = async (options, command) => {
   log(`${NETLIFYDEVWARN} Setting up local development server`)
 
   const devCommand = () => startFrameworkServer({ settings })
-  const startDevOptions = await getBuildOptions({
+  const startDevOptions = getBuildOptions({
     cachedConfig,
     options,
   })
@@ -647,7 +648,7 @@ const dev = async (options, command) => {
   printBanner({ url })
 }
 
-const getBuildOptions = ({ cachedConfig, options: { context, cwd, debug, dry, offline }, token }) => ({
+const getBuildOptions = ({ cachedConfig, options: { context, cwd = process.cwd(), debug, dry, offline }, token }) => ({
   cachedConfig,
   token,
   dry,
@@ -675,10 +676,11 @@ const createDevCommand = (program) => {
       `Local dev server\nThe dev command will run a local dev server with Netlify's proxy and redirect rules`,
     )
     .option('-c ,--command <command>', 'command to run')
-    .addOption(
-      new Option('--context <context>', 'Specify a deploy context for environment variables')
-        .choices(['production', 'deploy-preview', 'branch-deploy', 'dev'])
-        .default('dev'),
+    .option(
+      '--context <context>',
+      'Specify a deploy context or branch for environment variables (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
+      normalizeContext,
+      'dev',
     )
     .option('-p ,--port <port>', 'port of netlify dev', (value) => Number.parseInt(value))
     .option('--targetPort <port>', 'port of target app server', (value) => Number.parseInt(value))

package/src/commands/env/env-get.js

@@ -1,7 +1,7 @@
 // @ts-check
 const { Option } = require('commander')
 
-const { chalk, error, getEnvelopeEnv, log, logJson } = require('../../utils')
+const { chalk, error, getEnvelopeEnv, log, logJson, normalizeContext } = require('../../utils')
 
 /**
  * The env:get command
@@ -60,16 +60,23 @@ const createEnvGetCommand = (program) =>
   program
     .command('env:get')
     .argument('<name>', 'Environment variable name')
-    .addOption(
-      new Option('-c, --context <context>', 'Specify a deploy context')
-        .choices(['production', 'deploy-preview', 'branch-deploy', 'dev'])
-        .default('dev'),
+    .option(
+      '-c, --context <context>',
+      'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
+      normalizeContext,
+      'dev',
     )
     .addOption(
       new Option('-s, --scope <scope>', 'Specify a scope')
         .choices(['builds', 'functions', 'post_processing', 'runtime', 'any'])
         .default('any'),
     )
+    .addExamples([
+      'netlify env:get MY_VAR # get value for MY_VAR in dev context',
+      'netlify env:get --context production',
+      'netlify env:get --context branch:staging',
+      'netlify env:get --scope functions',
+    ])
     .description('Get resolved value of specified environment variable (includes netlify.toml)')
     .action(async (name, options, command) => {
       await envGet(name, options, command)

package/src/commands/env/env-import.js

@@ -15,7 +15,7 @@ const { exit, log, logJson, translateFromEnvelopeToMongo, translateFromMongoToEn
  * @returns {Promise<boolean>}
  */
 const envImport = async (fileName, options, command) => {
-  const { api, site } = command.netlify
+  const { api, cachedConfig, site } = command.netlify
   const siteId = site.id
 
   if (!siteId) {
@@ -37,10 +37,10 @@ const envImport = async (fileName, options, command) => {
     return false
   }
 
-  const siteData = await api.getSite({ siteId })
+  const { siteInfo } = cachedConfig
 
-  const importIntoService = siteData.use_envelope ? importIntoEnvelope : importIntoMongo
-  const finalEnv = await importIntoService({ api, importedEnv, options, siteData })
+  const importIntoService = siteInfo.use_envelope ? importIntoEnvelope : importIntoMongo
+  const finalEnv = await importIntoService({ api, importedEnv, options, siteInfo })
 
   // Return new environment variables of site if using json flag
   if (options.json) {
@@ -49,7 +49,7 @@ const envImport = async (fileName, options, command) => {
   }
 
   // List newly imported environment variables in a table
-  log(`site: ${siteData.name}`)
+  log(`site: ${siteInfo.name}`)
   const table = new AsciiTable(`Imported environment variables`)
 
   table.setHeading('Key', 'Value')
@@ -61,9 +61,9 @@ const envImport = async (fileName, options, command) => {
  * Updates the imported env in the site record
  * @returns {Promise<object>}
  */
-const importIntoMongo = async ({ api, importedEnv, options, siteData }) => {
-  const { env = {} } = siteData.build_settings
-  const siteId = siteData.id
+const importIntoMongo = async ({ api, importedEnv, options, siteInfo }) => {
+  const { env = {} } = siteInfo.build_settings
+  const siteId = siteInfo.id
 
   const finalEnv = options.replaceExisting ? importedEnv : { ...env, ...importedEnv }
 
@@ -86,10 +86,10 @@ const importIntoMongo = async ({ api, importedEnv, options, siteData }) => {
  * Saves the imported env in the Envelope service
  * @returns {Promise<object>}
  */
-const importIntoEnvelope = async ({ api, importedEnv, options, siteData }) => {
+const importIntoEnvelope = async ({ api, importedEnv, options, siteInfo }) => {
   // fetch env vars
-  const accountId = siteData.account_slug
-  const siteId = siteData.id
+  const accountId = siteInfo.account_slug
+  const siteId = siteInfo.id
   const dotEnvKeys = Object.keys(importedEnv)
   const envelopeVariables = await api.getEnvVars({ accountId, siteId })
   const envelopeKeys = envelopeVariables.map(({ key }) => key)

package/src/commands/env/env-list.js

@@ -5,7 +5,7 @@ const { Option } = require('commander')
 const inquirer = require('inquirer')
 const isEmpty = require('lodash/isEmpty')
 
-const { chalk, error, getEnvelopeEnv, getHumanReadableScopes, log, logJson } = require('../../utils')
+const { chalk, error, getEnvelopeEnv, getHumanReadableScopes, log, logJson, normalizeContext } = require('../../utils')
 
 const [logUpdatePromise, ansiEscapesPromise] = [import('log-update'), import('ansi-escapes')]
 
@@ -22,7 +22,7 @@ const getTable = ({ environment, hideValues, scopesColumn }) => {
         // Key
         key,
         // Value
-        hideValues ? MASK : variable.value,
+        hideValues ? MASK : variable.value || ' ',
         // Scope
         scopesColumn && getHumanReadableScopes(variable.scopes),
       ].filter(Boolean),
@@ -122,16 +122,23 @@ const envList = async (options, command) => {
 const createEnvListCommand = (program) =>
   program
     .command('env:list')
-    .addOption(
-      new Option('-c, --context <context>', 'Specify a deploy context')
-        .choices(['production', 'deploy-preview', 'branch-deploy', 'dev'])
-        .default('dev'),
+    .option(
+      '-c, --context <context>',
+      'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev")',
+      normalizeContext,
+      'dev',
     )
     .addOption(
       new Option('-s, --scope <scope>', 'Specify a scope')
         .choices(['builds', 'functions', 'post_processing', 'runtime', 'any'])
         .default('any'),
     )
+    .addExamples([
+      'netlify env:list # list dev context and any scope',
+      'netlify env:list --context production',
+      'netlify env:list --context branch:staging',
+      'netlify env:list --scope functions',
+    ])
     .description('Lists resolved environment variables for site (includes netlify.toml)')
     .action(async (options, command) => {
       await envList(options, command)

package/src/commands/env/env-set.js

@@ -1,5 +1,16 @@
 // @ts-check
-const { log, logJson, translateFromEnvelopeToMongo } = require('../../utils')
+const { Option } = require('commander')
+
+const {
+  AVAILABLE_CONTEXTS,
+  AVAILABLE_SCOPES,
+  chalk,
+  error,
+  log,
+  logJson,
+  normalizeContext,
+  translateFromEnvelopeToMongo,
+} = require('../../utils')
 
 /**
  * The env:set command
@@ -10,7 +21,9 @@ const { log, logJson, translateFromEnvelopeToMongo } = require('../../utils')
  * @returns {Promise<boolean>}
  */
 const envSet = async (key, value, options, command) => {
-  const { api, site } = command.netlify
+  const { context, scope } = options
+
+  const { api, cachedConfig, site } = command.netlify
   const siteId = site.id
 
   if (!siteId) {
@@ -18,11 +31,26 @@ const envSet = async (key, value, options, command) => {
     return false
   }
 
-  const siteData = await api.getSite({ siteId })
+  const { siteInfo } = cachedConfig
+  let finalEnv
 
   // Get current environment variables set in the UI
-  const setInService = siteData.use_envelope ? setInEnvelope : setInMongo
-  const finalEnv = await setInService({ api, siteData, key, value })
+  if (siteInfo.use_envelope) {
+    finalEnv = await setInEnvelope({ api, siteInfo, key, value, context, scope })
+  } else if (context || scope) {
+    error(
+      `To specify a context or scope, please run ${chalk.yellow(
+        'netlify open:admin',
+      )} to open the Netlify UI and opt in to the new environment variables experience from Site settings`,
+    )
+    return false
+  } else {
+    finalEnv = await setInMongo({ api, siteInfo, key, value })
+  }
+
+  if (!finalEnv) {
+    return false
+  }
 
   // Return new environment variables of site if using json flag
   if (options.json) {
@@ -30,22 +58,27 @@ const envSet = async (key, value, options, command) => {
     return false
   }
 
-  log(`Set environment variable ${key}=${value} for site ${siteData.name}`)
+  const withScope = scope ? ` scoped to ${chalk.white(scope)}` : ''
+  log(
+    `Set environment variable ${chalk.yellow(`${key}${value ? '=' : ''}${value}`)}${withScope} in the ${chalk.magenta(
+      context || 'all',
+    )} context`,
+  )
 }
 
 /**
  * Updates the env for a site record with a new key/value pair
  * @returns {Promise<object>}
  */
-const setInMongo = async ({ api, key, siteData, value }) => {
-  const { env = {} } = siteData.build_settings
+const setInMongo = async ({ api, key, siteInfo, value }) => {
+  const { env = {} } = siteInfo.build_settings
   const newEnv = {
     ...env,
     [key]: value,
   }
   // Apply environment variable updates
   await api.updateSite({
-    siteId: siteData.id,
+    siteId: siteInfo.id,
     body: {
       build_settings: {
         env: newEnv,
@@ -59,28 +92,55 @@ const setInMongo = async ({ api, key, siteData, value }) => {
  * Updates the env for a site configured with Envelope with a new key/value pair
  * @returns {Promise<object>}
  */
-const setInEnvelope = async ({ api, key, siteData, value }) => {
-  const accountId = siteData.account_slug
-  const siteId = siteData.id
+const setInEnvelope = async ({ api, context, key, scope, siteInfo, value }) => {
+  const accountId = siteInfo.account_slug
+  const siteId = siteInfo.id
   // fetch envelope env vars
   const envelopeVariables = await api.getEnvVars({ accountId, siteId })
-  const scopes = ['builds', 'functions', 'runtime', 'post_processing']
-  const values = [{ context: 'all', value }]
-  // check if we need to create or update
-  const exists = envelopeVariables.some((envVar) => envVar.key === key)
-  const method = exists ? api.updateEnvVar : api.createEnvVars
-  const body = exists ? { key, scopes, values } : [{ key, scopes, values }]
+  const contexts = context || ['all']
+  const scopes = scope || AVAILABLE_SCOPES
+
+  // if the passed context is unknown, it is actually a branch name
+  let values = contexts.map((ctx) =>
+    AVAILABLE_CONTEXTS.includes(ctx) ? { context: ctx, value } : { context: 'branch', context_parameter: ctx, value },
+  )
 
+  const existing = envelopeVariables.find((envVar) => envVar.key === key)
+
+  const params = { accountId, siteId, key }
   try {
-    await method({ accountId, siteId, key, body })
-  } catch (error) {
-    throw error.json ? error.json.msg : error
+    if (existing) {
+      if (!value) {
+        // eslint-disable-next-line prefer-destructuring
+        values = existing.values
+      }
+      if (context && scope) {
+        error(
+          'Setting the context and scope at the same time on an existing env var is not allowed. Run the set command separately for each update.',
+        )
+        return false
+      }
+      if (context) {
+        // update individual value(s)
+        await Promise.all(values.map((val) => api.setEnvVarValue({ ...params, body: val })))
+      } else {
+        // otherwise update whole env var
+        const body = { key, scopes, values }
+        await api.updateEnvVar({ ...params, body })
+      }
+    } else {
+      // create whole env var
+      const body = [{ key, scopes, values }]
+      await api.createEnvVars({ ...params, body })
+    }
+  } catch (error_) {
+    throw error_.json ? error_.json.msg : error_
   }
 
-  const env = translateFromEnvelopeToMongo(envelopeVariables)
+  const env = translateFromEnvelopeToMongo(envelopeVariables, context ? context[0] : 'dev')
   return {
     ...env,
-    [key]: value,
+    [key]: value || env[key],
   }
 }
 
@@ -94,7 +154,28 @@ const createEnvSetCommand = (program) =>
     .command('env:set')
     .argument('<key>', 'Environment variable key')
     .argument('[value]', 'Value to set to', '')
+    .option(
+      '-c, --context <context...>',
+      'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev") (default: all contexts)',
+      // spread over an array for variadic options
+      (context, previous = []) => [...previous, normalizeContext(context)],
+    )
+    .addOption(
+      new Option('-s, --scope <scope...>', 'Specify a scope (default: all scopes)').choices([
+        'builds',
+        'functions',
+        'post_processing',
+        'runtime',
+      ]),
+    )
     .description('Set value of environment variable')
+    .addExamples([
+      'netlify env:set VAR_NAME value # set in all contexts and scopes',
+      'netlify env:set VAR_NAME value --context production',
+      'netlify env:set VAR_NAME value --context production deploy-preview',
+      'netlify env:set VAR_NAME value --scope builds',
+      'netlify env:set VAR_NAME value --scope builds functions',
+    ])
     .action(async (key, value, options, command) => {
       await envSet(key, value, options, command)
     })

package/src/commands/env/env-unset.js

@@ -1,5 +1,13 @@
 // @ts-check
-const { log, logJson, translateFromEnvelopeToMongo } = require('../../utils')
+const {
+  AVAILABLE_CONTEXTS,
+  chalk,
+  error,
+  log,
+  logJson,
+  normalizeContext,
+  translateFromEnvelopeToMongo,
+} = require('../../utils')
 
 /**
  * The env:unset command
@@ -9,7 +17,8 @@ const { log, logJson, translateFromEnvelopeToMongo } = require('../../utils')
  * @returns {Promise<boolean>}
  */
 const envUnset = async (key, options, command) => {
-  const { api, site } = command.netlify
+  const { context } = options
+  const { api, cachedConfig, site } = command.netlify
   const siteId = site.id
 
   if (!siteId) {
@@ -17,10 +26,21 @@ const envUnset = async (key, options, command) => {
     return false
   }
 
-  const siteData = await api.getSite({ siteId })
-
-  const unsetInService = siteData.use_envelope ? unsetInEnvelope : unsetInMongo
-  const finalEnv = await unsetInService({ api, siteData, key })
+  const { siteInfo } = cachedConfig
+
+  let finalEnv
+  if (siteInfo.use_envelope) {
+    finalEnv = await unsetInEnvelope({ api, context, siteInfo, key })
+  } else if (context) {
+    error(
+      `To specify a context, please run ${chalk.yellow(
+        'netlify open:admin',
+      )} to open the Netlify UI and opt in to the new environment variables experience from Site settings`,
+    )
+    return false
+  } else {
+    finalEnv = await unsetInMongo({ api, siteInfo, key })
+  }
 
   // Return new environment variables of site if using json flag
   if (options.json) {
@@ -28,18 +48,18 @@ const envUnset = async (key, options, command) => {
     return false
   }
 
-  log(`Unset environment variable ${key} for site ${siteData.name}`)
+  log(`Unset environment variable ${chalk.yellow(key)} in the ${chalk.magenta(context || 'all')} context`)
 }
 
 /**
  * Deletes a given key from the env of a site record
  * @returns {Promise<object>}
  */
-const unsetInMongo = async ({ api, key, siteData }) => {
+const unsetInMongo = async ({ api, key, siteInfo }) => {
   // Get current environment variables set in the UI
   const {
     build_settings: { env = {} },
-  } = siteData
+  } = siteInfo
 
   const newEnv = env
 
@@ -48,7 +68,7 @@ const unsetInMongo = async ({ api, key, siteData }) => {
 
   // Apply environment variable updates
   await api.updateSite({
-    siteId: siteData.id,
+    siteId: siteInfo.id,
     body: {
       build_settings: {
         env: newEnv,
@@ -63,24 +83,48 @@ const unsetInMongo = async ({ api, key, siteData }) => {
  * Deletes a given key from the env of a site configured with Envelope
  * @returns {Promise<object>}
  */
-const unsetInEnvelope = async ({ api, key, siteData }) => {
-  const accountId = siteData.account_slug
-  const siteId = siteData.id
+const unsetInEnvelope = async ({ api, context, key, siteInfo }) => {
+  const accountId = siteInfo.account_slug
+  const siteId = siteInfo.id
   // fetch envelope env vars
   const envelopeVariables = await api.getEnvVars({ accountId, siteId })
+  const contexts = context || ['all']
+
+  const env = translateFromEnvelopeToMongo(envelopeVariables, context ? context[0] : 'dev')
 
   // check if the given key exists
-  const env = translateFromEnvelopeToMongo(envelopeVariables)
-  if (!env[key]) {
+  const variable = envelopeVariables.find((envVar) => envVar.key === key)
+  if (!variable) {
     // if not, no need to call delete; return early
     return env
   }
 
-  // delete the given key
+  const params = { accountId, siteId, key }
   try {
-    await api.deleteEnvVar({ accountId, siteId, key })
-  } catch (error) {
-    throw error.json ? error.json.msg : error
+    if (context) {
+      // if context(s) are passed, delete the matching contexts / branches, and the `all` context
+      const values = variable.values.filter((val) =>
+        [...contexts, 'all'].includes(val.context_parameter || val.context),
+      )
+      if (values) {
+        await Promise.all(values.map((value) => api.deleteEnvVarValue({ ...params, id: value.id })))
+        // if this was the `all` context, we need to create 3 values in the other contexts
+        if (values.length === 1 && values[0].context === 'all') {
+          const newContexts = AVAILABLE_CONTEXTS.filter((ctx) => !context.includes(ctx))
+          const allValue = values[0].value
+          await Promise.all(
+            newContexts
+              .filter((ctx) => ctx !== 'all')
+              .map((ctx) => api.setEnvVarValue({ ...params, body: { context: ctx, value: allValue } })),
+          )
+        }
+      }
+    } else {
+      // otherwise, if no context passed, delete the whole key
+      await api.deleteEnvVar({ accountId, siteId, key })
+    }
+  } catch (error_) {
+    throw error_.json ? error_.json.msg : error_
   }
 
   delete env[key]
@@ -98,6 +142,17 @@ const createEnvUnsetCommand = (program) =>
     .command('env:unset')
     .aliases(['env:delete', 'env:remove'])
     .argument('<key>', 'Environment variable key')
+    .option(
+      '-c, --context <context...>',
+      'Specify a deploy context or branch (contexts: "production", "deploy-preview", "branch-deploy", "dev") (default: all contexts)',
+      // spread over an array for variadic options
+      (context, previous = []) => [...previous, normalizeContext(context)],
+    )
+    .addExamples([
+      'netlify env:unset VAR_NAME # unset in all contexts',
+      'netlify env:unset VAR_NAME --context production',
+      'netlify env:unset VAR_NAME --context production deploy-preview',
+    ])
     .description('Unset an environment variable which removes it from the UI')
     .action(async (key, options, command) => {
       await envUnset(key, options, command)

package/src/functions-templates/javascript/scheduled-function/package.json

@@ -15,6 +15,6 @@
   "author": "Netlify",
   "license": "MIT",
   "dependencies": {
-    "@netlify/functions": "^1.1.0"
+    "@netlify/functions": "^1.2.0"
   }
 }