netlify-cli 8.0.10 → 8.1.0-rc

package/src/utils/command-helpers.js

@@ -1,33 +1,121 @@
+// @ts-check
+const os = require('os')
 const process = require('process')
 const { format, inspect } = require('util')
 
-const Errors = require('@oclif/errors')
-const argv = require('minimist')(process.argv.slice(2))
-const omit = require('omit.js').default
+// eslint-disable-next-line local-rules/no-direct-chalk-import
+const { Instance: ChalkInstance } = require('chalk')
+const WSL = require('is-wsl')
+const { default: omit } = require('omit.js')
 
+const { name, version } = require('../../package.json')
 const { clearSpinner, startSpinner } = require('../lib/spinner')
 
-const chalkInstance = require('./chalk')
 const getGlobalConfig = require('./get-global-config')
 
+/** The parsed process argv without the binary only arguments and flags */
+const argv = process.argv.slice(2)
+/**
+ * Chalk instance for CLI that can be initialized with no colors mode
+ * needed for json outputs where we don't want to have colors
+ * @param  {boolean} noColors - disable chalk colors
+ * @return {object} - default or custom chalk instance
+ */
+const safeChalk = function (noColors) {
+  if (noColors) {
+    const colorlessChalk = new ChalkInstance({ level: 0 })
+    return colorlessChalk
+  }
+  return new ChalkInstance()
+}
+
+const chalk = safeChalk(argv.includes('--json'))
+
+const platform = WSL ? 'wsl' : os.platform()
+const arch = os.arch() === 'ia32' ? 'x86' : os.arch()
+
+const USER_AGENT = `${name}/${version} ${platform}-${arch} node-${process.version}`
+
 const { NETLIFY_AUTH_TOKEN } = process.env
 
-// 5 Minutes
-const TOKEN_TIMEOUT = 3e5
+// eslint-disable-next-line no-magic-numbers
+const NETLIFY_CYAN = chalk.rgb(40, 180, 170)
+
+const NETLIFYDEV = `${chalk.greenBright('◈')} ${NETLIFY_CYAN('Netlify Dev')} ${chalk.greenBright('◈')}`
+const NETLIFYDEVLOG = `${chalk.greenBright('◈')}`
+const NETLIFYDEVWARN = `${chalk.yellowBright('◈')}`
+const NETLIFYDEVERR = `${chalk.redBright('◈')}`
+
+// eslint-disable-next-line id-length
+const $ = NETLIFY_CYAN('$')
+const BANG = process.platform === 'win32' ? '»' : '›'
+
+/**
+ * Generates a CommandHelp section for the command
+ * @param {string} commandName
+ * @param {import('commander').Command} program
+ */
+const generateCommandsHelp = (commandName, program) => {
+  const cmds = program.commands.filter((cmd) => cmd.name().startsWith(`${commandName}:`))
+
+  if (cmds.length !== 0) {
+    const longestName = Math.max(...cmds.map((cmd) => cmd.name().length)) + 1
+    const table = cmds.map((cmd) => {
+      const spacer = Array.from({ length: longestName - cmd.name().length })
+        .fill()
+        .join(' ')
+
+      return `  ${$} ${cmd.name()}${spacer}  ${chalk.grey(cmd.description())}`
+    })
+    return `
+${chalk.bold('COMMANDS')}
+${table.join('\n')}`
+  }
+}
 
-const chalk = chalkInstance(argv.json)
+/**
+ * Generates the help output for the description
+ * @param {string} description
+ * @returns {string}
+ */
+const generateDescriptionHelp = (description) => `
+${chalk.bold('DESCRIPTION')}
+  ${description.split('\n').join('\n  ')}`
+
+/**
+ * Generates the help output for the examples
+ * @param {string[]} examples
+ * @returns {string}
+ */
+const generateExamplesHelp = (examples) => {
+  if (examples.length !== 0) {
+    return `
+${chalk.bold('EXAMPLES')}
+${examples.map((example) => `  ${$} ${example}`).join('\n')}`
+  }
+}
+
+// Poll Token timeout 5 Minutes
+const TOKEN_TIMEOUT = 3e5
 
-const pollForToken = async ({ api, exitWithError, ticket }) => {
+/**
+ *
+ * @param {object} config
+ * @param {import('netlify').NetlifyAPI} config.api
+ * @param {object} config.ticket
+ * @returns
+ */
+const pollForToken = async ({ api, ticket }) => {
   const spinner = startSpinner({ text: 'Waiting for authorization...' })
   try {
     const accessToken = await api.getAccessToken(ticket, { timeout: TOKEN_TIMEOUT })
     if (!accessToken) {
-      exitWithError('Could not retrieve access token')
+      error('Could not retrieve access token')
     }
     return accessToken
-  } catch (error) {
-    if (error.name === 'TimeoutError') {
-      exitWithError(
+  } catch (error_) {
+    if (error_.name === 'TimeoutError') {
+      error(
         `Timed out waiting for authorization. If you do not have a ${chalk.bold.greenBright(
           'Netlify',
         )} account, please create one at ${chalk.magenta(
@@ -35,29 +123,22 @@ const pollForToken = async ({ api, exitWithError, ticket }) => {
         )}, then run ${chalk.cyanBright('netlify login')} again.`,
       )
     } else {
-      exitWithError(error)
+      error(error_)
     }
   } finally {
     clearSpinner({ spinner })
   }
 }
 
-const getCwd = () => argv.cwd || process.cwd()
-
-const getAuthArg = () => {
-  // If deploy command. Support shorthand 'a' flag
-  if (argv && argv._ && argv._[0] === 'deploy') {
-    return argv.auth || argv.a
-  }
-  return argv.auth
-}
-
-const getToken = async (authFromFlag) => {
-  const tokenFromFlag = authFromFlag || getAuthArg(argv)
-
+/**
+ * Get a netlify token
+ * @param {string} [tokenFromOptions] optional token from the provided --auth options
+ * @returns {Promise<[null|string, 'flag' | 'env' |'config' |'not found']>}
+ */
+const getToken = async (tokenFromOptions) => {
   // 1. First honor command flag --auth
-  if (tokenFromFlag) {
-    return [tokenFromFlag, 'flag']
+  if (tokenFromOptions) {
+    return [tokenFromOptions, 'flag']
   }
   // 2. then Check ENV var
   if (NETLIFY_AUTH_TOKEN && NETLIFY_AUTH_TOKEN !== 'null') {
@@ -75,33 +156,58 @@ const getToken = async (authFromFlag) => {
 
 // 'api' command uses JSON output by default
 // 'functions:invoke' need to return the data from the function as is
-const isDefaultJson = () => argv._[0] === 'functions:invoke' || (argv._[0] === 'api' && argv.list !== true)
+const isDefaultJson = () => argv[0] === 'functions:invoke' || (argv[0] === 'api' && !argv.includes('--list'))
 
+/**
+ * logs a json message
+ * @param {string|object} message
+ */
 const logJson = (message = '') => {
-  if (argv.json || isDefaultJson()) {
+  if (argv.includes('--json') || isDefaultJson()) {
     process.stdout.write(JSON.stringify(message, null, 2))
   }
 }
 
 const log = (message = '', ...args) => {
-  /* If  --silent or --json flag passed disable logger */
-  if (argv.silent || argv.json || isDefaultJson()) {
+  // If  --silent or --json flag passed disable logger
+  if (argv.includes('--json') || argv.includes('--silent') || isDefaultJson()) {
     return
   }
   message = typeof message === 'string' ? message : inspect(message)
   process.stdout.write(`${format(message, ...args)}\n`)
 }
 
+/**
+ * logs a warning message
+ * @param {string} message
+ */
 const warn = (message = '') => {
-  Errors.warn(message)
+  const bang = chalk.yellow(BANG)
+  log(` ${bang}   Warning: ${message}`)
 }
 
+/**
+ * throws an error or log it
+ * @param {string|Error} message
+ * @param {object} [options]
+ * @param {boolean} [options.exit]
+ */
 const error = (message = '', options = {}) => {
-  Errors.error(message, options)
+  const err = message instanceof Error ? message : new Error(message)
+  if (options.exit === false) {
+    const bang = chalk.red(BANG)
+    if (process.env.DEBUG) {
+      process.stderr.write(` ${bang}   Warning: ${err.stack.split('\n').join(`\n ${bang}   `)}`)
+    } else {
+      process.stderr.write(` ${bang}   ${err.name}: ${err.message}\n`)
+    }
+  } else {
+    throw err
+  }
 }
 
 const exit = (code = 0) => {
-  Errors.exit(code)
+  process.exit(code)
 }
 
 // When `build.publish` is not set by the user, the CLI behavior differs in
@@ -114,15 +220,22 @@ const normalizeConfig = (config) =>
     : config
 
 module.exports = {
-  argv,
-  getCwd,
-  pollForToken,
-  log,
-  logJson,
   getToken,
-  normalizeConfig,
-  chalk,
+  exit,
+  logJson,
+  log,
   warn,
   error,
-  exit,
+  chalk,
+  generateCommandsHelp,
+  generateDescriptionHelp,
+  generateExamplesHelp,
+  pollForToken,
+  normalizeConfig,
+  USER_AGENT,
+  NETLIFY_CYAN,
+  NETLIFYDEV,
+  NETLIFYDEVLOG,
+  NETLIFYDEVWARN,
+  NETLIFYDEVERR,
 }

package/src/utils/create-stream-promise.js

@@ -1,5 +1,10 @@
 const { Buffer } = require('buffer')
 
+const SEC_TO_MILLISEC = 1e3
+
+// 6 MiB
+const DEFAULT_BYTES_LIMIT = 6e6
+
 const createStreamPromise = function (stream, timeoutSeconds, bytesLimit = DEFAULT_BYTES_LIMIT) {
   return new Promise(function streamPromiseFunc(resolve, reject) {
     let data = []
@@ -41,9 +46,4 @@ const createStreamPromise = function (stream, timeoutSeconds, bytesLimit = DEFAU
   })
 }
 
-const SEC_TO_MILLISEC = 1e3
-
-// 6 MiB
-const DEFAULT_BYTES_LIMIT = 6e6
-
 module.exports = { createStreamPromise }

package/src/utils/deferred.js

@@ -1,3 +1,4 @@
+// @ts-check
 const createDeferred = () => {
   let resolveDeferred
   let rejectDeferred

package/src/utils/deploy/deploy-site.js

@@ -83,7 +83,7 @@ const deploySite = async (
 
   if (functionsWithNativeModules.length !== 0) {
     warn(`Modules with native dependencies\n
-${functionsWithNativeModules.map(({ name }) => `- ${name}`).join('\n')}    
+${functionsWithNativeModules.map(({ name }) => `- ${name}`).join('\n')}
 
 The serverless functions above use Node.js modules with native dependencies, which
 must be installed on a system with the same architecture as the function runtime. A

package/src/utils/deploy/index.js

@@ -0,0 +1,4 @@
+// @ts-check
+const { deploySite } = require('./deploy-site')
+
+module.exports = { deploySite }

package/src/utils/detect-server-settings.js

@@ -4,17 +4,15 @@ const path = require('path')
 const process = require('process')
 
 const { getFramework, listFrameworks } = require('@netlify/framework-info')
-const chalk = require('chalk')
 const fuzzy = require('fuzzy')
 const getPort = require('get-port')
 const isPlainObject = require('is-plain-obj')
 
 const { readFileAsyncCatchError } = require('../lib/fs')
 
-const { log } = require('./command-helpers')
+const { NETLIFYDEVWARN, chalk, log } = require('./command-helpers')
 const { acquirePort } = require('./dev')
 const { getInternalFunctionsDir } = require('./functions')
-const { NETLIFYDEVWARN } = require('./logo')
 
 const formatProperty = (str) => chalk.magenta(`'${str}'`)
 const formatValue = (str) => chalk.green(`'${str}'`)
@@ -106,14 +104,14 @@ const getDefaultDist = () => {
  *
  * @param {object} param0
  * @param {import('../commands/dev/types').DevConfig} param0.devConfig
- * @param {Record<string, string>} param0.flags
+ * @param {import('commander').OptionValues} param0.options
  * @param {string} param0.projectDir
  * @returns {Promise<import('./types').BaseServerSettings>}
  */
-const handleStaticServer = async ({ devConfig, flags, projectDir }) => {
+const handleStaticServer = async ({ devConfig, options, projectDir }) => {
   validateNumberProperty({ devConfig, property: 'staticServerPort' })
 
-  if (flags.dir) {
+  if (options.dir) {
     log(`${NETLIFYDEVWARN} Using simple static server because ${formatProperty('--dir')} flag was specified`)
   } else if (devConfig.framework === '#static') {
     log(
@@ -131,7 +129,7 @@ const handleStaticServer = async ({ devConfig, flags, projectDir }) => {
     )
   }
 
-  const dist = flags.dir || devConfig.publish || getDefaultDist()
+  const dist = options.dir || devConfig.publish || getDefaultDist()
   log(`${NETLIFYDEVWARN} Running static server from "${path.relative(path.dirname(projectDir), dist)}"`)
 
   const frameworkPort = await acquirePort({
@@ -263,19 +261,19 @@ const handleForcedFramework = async ({ devConfig, projectDir }) => {
 /**
  * Get the server settings based on the flags and the devConfig
  * @param {import('../commands/dev/types').DevConfig} devConfig
- * @param {Record<string, string>} flags
+ * @param {import('commander').OptionValues} options
  * @param {string} projectDir
  * @returns {Promise<import('./types').ServerSettings>}
  */
-const detectServerSettings = async (devConfig, flags, projectDir) => {
+const detectServerSettings = async (devConfig, options, projectDir) => {
   validateStringProperty({ devConfig, property: 'framework' })
 
   /** @type {Partial<import('./types').BaseServerSettings>} */
   let settings = {}
 
-  if (flags.dir || devConfig.framework === '#static') {
+  if (options.dir || devConfig.framework === '#static') {
     // serving files statically without a framework server
-    settings = await handleStaticServer({ flags, devConfig, projectDir })
+    settings = await handleStaticServer({ options, devConfig, projectDir })
   } else if (devConfig.framework === '#auto') {
     // this is the default CLI behavior
 
@@ -284,7 +282,7 @@ const detectServerSettings = async (devConfig, flags, projectDir) => {
 
     if (frameworkSettings === undefined && runDetection) {
       log(`${NETLIFYDEVWARN} No app server detected. Using simple static server`)
-      settings = await handleStaticServer({ flags, devConfig, projectDir })
+      settings = await handleStaticServer({ options, devConfig, projectDir })
     } else {
       validateFrameworkConfig({ devConfig })
       const { command, frameworkPort, dist, framework, env, pollingStrategies = [] } = frameworkSettings || {}

package/src/utils/dev.js

@@ -1,15 +1,14 @@
+// @ts-check
 const process = require('process')
 
-const chalk = require('chalk')
 const { get } = require('dot-prop')
 const getPort = require('get-port')
 const isEmpty = require('lodash/isEmpty')
 
 const { supportsBackgroundFunctions } = require('../lib/account')
 
-const { error: failAndExit, log, warn } = require('./command-helpers')
+const { NETLIFYDEVLOG, chalk, error, log, warn } = require('./command-helpers')
 const { loadDotEnvFiles } = require('./dot-env')
-const { NETLIFYDEVLOG } = require('./logo')
 
 // Possible sources of environment variables. For the purpose of printing log messages only. Order does not matter.
 const ENV_VAR_SOURCES = {
@@ -44,7 +43,7 @@ const ERROR_CALL_TO_ACTION =
 
 const validateSiteInfo = ({ site, siteInfo }) => {
   if (isEmpty(siteInfo)) {
-    failAndExit(`Failed retrieving site information for site ${chalk.yellow(site.id)}. ${ERROR_CALL_TO_ACTION}`)
+    error(`Failed retrieving site information for site ${chalk.yellow(site.id)}. ${ERROR_CALL_TO_ACTION}`)
   }
 }
 
@@ -52,8 +51,8 @@ const getAccounts = async ({ api }) => {
   try {
     const accounts = await api.listAccountsForUser()
     return accounts
-  } catch (error) {
-    failAndExit(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+  } catch (error_) {
+    error(`Failed retrieving user account: ${error_.message}. ${ERROR_CALL_TO_ACTION}`)
   }
 }
 
@@ -61,8 +60,8 @@ const getAddons = async ({ api, site }) => {
   try {
     const addons = await api.listServiceInstancesForSite({ siteId: site.id })
     return addons
-  } catch (error) {
-    failAndExit(`Failed retrieving addons for site ${chalk.yellow(site.id)}: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+  } catch (error_) {
+    error(`Failed retrieving addons for site ${chalk.yellow(site.id)}: ${error_.message}. ${ERROR_CALL_TO_ACTION}`)
   }
 }
 
@@ -89,8 +88,17 @@ const SYNCHRONOUS_FUNCTION_TIMEOUT = 10
 // default 15 minutes for background functions
 const BACKGROUND_FUNCTION_TIMEOUT = 900
 
-const getSiteInformation = async ({ flags = {}, api, site, siteInfo }) => {
-  if (site.id && !flags.offline) {
+/**
+ *
+ * @param {object} config
+ * @param {boolean} config.offline
+ * @param {*} config.api
+ * @param {*} config.site
+ * @param {*} config.siteInfo
+ * @returns
+ */
+const getSiteInformation = async ({ api, offline, site, siteInfo }) => {
+  if (site.id && !offline) {
     validateSiteInfo({ site, siteInfo })
     const [accounts, addons] = await Promise.all([getAccounts({ api }), getAddons({ api, site })])
 

package/src/utils/dot-env.js

@@ -1,8 +1,10 @@
+// @ts-check
+const { readFile } = require('fs').promises
 const path = require('path')
 
 const dotenv = require('dotenv')
 
-const { isFileAsync, readFileAsync } = require('../lib/fs')
+const { isFileAsync } = require('../lib/fs')
 
 const { warn } = require('./command-helpers')
 
@@ -32,7 +34,7 @@ const tryLoadDotEnvFiles = async ({ projectDir }) => {
           warning: `Failed reading env variables from file: ${filepath}: ${error.message}`,
         }
       }
-      const content = await readFileAsync(filepath)
+      const content = await readFile(filepath, 'utf-8')
       const env = dotenv.parse(content)
       return { file, env }
     }),

package/src/utils/{edge-handlers.js → functions/edge-handlers.js}

@@ -1,10 +1,11 @@
+// @ts-check
+const fs = require('fs').promises
 const path = require('path')
 
-const { cancelDeploy, uploadEdgeHandlers } = require('../lib/api')
-const { readFileAsyncCatchError, statAsync } = require('../lib/fs')
-const { startSpinner, stopSpinner } = require('../lib/spinner')
-
-const { error, warn } = require('./command-helpers')
+const { cancelDeploy, uploadEdgeHandlers } = require('../../lib/api')
+const { readFileAsyncCatchError } = require('../../lib/fs')
+const { startSpinner, stopSpinner } = require('../../lib/spinner')
+const { error } = require('../command-helpers')
 
 const MANIFEST_FILENAME = 'manifest.json'
 const EDGE_HANDLERS_FOLDER = '.netlify/edge-handlers'
@@ -12,7 +13,7 @@ const EDGE_HANDLERS_FOLDER = '.netlify/edge-handlers'
 const validateEdgeHandlerFolder = async ({ site }) => {
   try {
     const resolvedFolder = path.resolve(site.root, EDGE_HANDLERS_FOLDER)
-    const stat = await statAsync(resolvedFolder)
+    const stat = await fs.stat(resolvedFolder)
     if (!stat.isDirectory()) {
       error(`Edge Handlers folder ${EDGE_HANDLERS_FOLDER} must be a path to a directory`)
     }
@@ -77,7 +78,7 @@ const deployEdgeHandlers = async ({ api, deployId, silent, site }) => {
     } catch (error_) {
       const text = `Failed deploying Edge Handlers: ${error_.message}`
       stopSpinner({ spinner, text, error: true })
-      await cancelDeploy({ api, deployId, warn })
+      await cancelDeploy({ api, deployId })
       // no need to report the error again
       error('')
     }

package/src/utils/functions/functions.js

@@ -0,0 +1,36 @@
+// @ts-check
+const { resolve } = require('path')
+
+const { isDirectoryAsync, isFileAsync } = require('../../lib/fs')
+const { getPathInProject } = require('../../lib/settings')
+
+/**
+ * retrieves the function directory out of the flags or config
+ * @param {object} param
+ * @param {object} param.config
+ * @param {import('commander').OptionValues} param.options The options from the commander
+ * @param {string} [defaultValue]
+ * @returns {string}
+ */
+const getFunctionsDir = ({ config, options }, defaultValue) =>
+  options.functions ||
+  (config.dev && config.dev.functions) ||
+  config.functionsDirectory ||
+  (config.dev && config.dev.Functions) ||
+  defaultValue
+
+const getFunctionsManifestPath = async ({ base }) => {
+  const path = resolve(base, getPathInProject(['functions', 'manifest.json']))
+  const isFile = await isFileAsync(path)
+
+  return isFile ? path : null
+}
+
+const getInternalFunctionsDir = async ({ base }) => {
+  const path = resolve(base, getPathInProject(['functions-internal']))
+  const isDirectory = await isDirectoryAsync(path)
+
+  return isDirectory ? path : null
+}
+
+module.exports = { getFunctionsDir, getInternalFunctionsDir, getFunctionsManifestPath }

package/src/utils/{get-functions.js → functions/get-functions.js}

@@ -1,4 +1,5 @@
-const { fileExistsAsync } = require('../lib/fs')
+// @ts-check
+const { fileExistsAsync } = require('../../lib/fs')
 
 const getUrlPath = (functionName) => `/.netlify/functions/${functionName}`
 

package/src/utils/functions/index.js

@@ -1,27 +1,9 @@
-const { resolve } = require('path')
-
-const { isDirectoryAsync, isFileAsync } = require('../../lib/fs')
-const { getPathInProject } = require('../../lib/settings')
-
-const getFunctionsDir = ({ config, flags }, defaultValue) =>
-  flags.functions ||
-  (config.dev && config.dev.functions) ||
-  config.functionsDirectory ||
-  (config.dev && config.dev.Functions) ||
-  defaultValue
-
-const getFunctionsManifestPath = async ({ base }) => {
-  const path = resolve(base, getPathInProject(['functions', 'manifest.json']))
-  const isFile = await isFileAsync(path)
-
-  return isFile ? path : null
+const edgeHandlers = require('./edge-handlers')
+const functions = require('./functions')
+const getFunctions = require('./get-functions')
+
+module.exports = {
+  ...functions,
+  ...edgeHandlers,
+  ...getFunctions,
 }
-
-const getInternalFunctionsDir = async ({ base }) => {
-  const path = resolve(base, getPathInProject(['functions-internal']))
-  const isDirectory = await isDirectoryAsync(path)
-
-  return isDirectory ? path : null
-}
-
-module.exports = { getFunctionsDir, getInternalFunctionsDir, getFunctionsManifestPath }

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

@@ -1,8 +1,9 @@
+const { readFile } = require('fs').promises
+
 const Configstore = require('configstore')
 const memoizeOne = require('memoize-one')
 const { v4: uuidv4 } = require('uuid')
 
-const { readFileAsync } = require('../lib/fs')
 const { getLegacyPathInHome, getPathInHome } = require('../lib/settings')
 
 const globalConfigDefaults = {
@@ -19,7 +20,7 @@ const getGlobalConfigOnce = async function () {
   let legacyConfig
   // Read legacy config if exists
   try {
-    legacyConfig = JSON.parse(await readFileAsync(legacyPath))
+    legacyConfig = JSON.parse(await readFile(legacyPath))
   } catch {}
   // Use legacy config as default values
   const defaults = { ...globalConfigDefaults, ...legacyConfig }

package/src/utils/get-repo-data.js

@@ -1,3 +1,4 @@
+// @ts-check
 const { dirname } = require('path')
 const process = require('process')
 const util = require('util')

package/src/utils/gh-auth.js

@@ -1,3 +1,4 @@
+// @ts-check
 // A simple ghauth inspired library for getting a personal access token
 const http = require('http')
 const process = require('process')

package/src/utils/gitignore.js

@@ -1,8 +1,10 @@
+// @ts-check
+const { readFile, writeFile } = require('fs').promises
 const path = require('path')
 
 const parseIgnore = require('parse-gitignore')
 
-const { fileExistsAsync, readFileAsync, writeFileAsync } = require('../lib/fs')
+const { fileExistsAsync } = require('../lib/fs')
 
 const hasGitIgnore = async function (dir) {
   const gitIgnorePath = path.join(dir, '.gitignore')
@@ -16,14 +18,14 @@ const ensureNetlifyIgnore = async function (dir) {
 
   /* No .gitignore file. Create one and ignore .netlify folder */
   if (!(await hasGitIgnore(dir))) {
-    await writeFileAsync(gitIgnorePath, ignoreContent, 'utf8')
+    await writeFile(gitIgnorePath, ignoreContent, 'utf8')
     return false
   }
 
   let gitIgnoreContents
   let ignorePatterns
   try {
-    gitIgnoreContents = await readFileAsync(gitIgnorePath, 'utf8')
+    gitIgnoreContents = await readFile(gitIgnorePath, 'utf8')
     ignorePatterns = parseIgnore.parse(gitIgnoreContents)
   } catch (error) {
     // ignore
@@ -31,8 +33,8 @@ const ensureNetlifyIgnore = async function (dir) {
   /* Not ignoring .netlify folder. Add to .gitignore */
   if (!ignorePatterns || !ignorePatterns.patterns.some((pattern) => /(^|\/|\\)\.netlify($|\/|\\)/.test(pattern))) {
     const newContents = `${gitIgnoreContents}\n${ignoreContent}`
-    await writeFileAsync(gitIgnorePath, newContents, 'utf8')
+    await writeFile(gitIgnorePath, newContents, 'utf8')
   }
 }
 
-module.exports = ensureNetlifyIgnore
+module.exports = { ensureNetlifyIgnore }