refactor: remove path-exists dependency and replace with node native fs.existsSync (#4839)

Author: Lukas Holzer

package-lock.json

@@ -75,7 +75,6 @@
     "netlify-redirect-parser": "^14.1.1",
     "omit.js": "^2.0.2",
     "p-locate": "^6.0.0",
-    "path-exists": "^5.0.0",
     "path-type": "^5.0.0",
     "toml": "^3.0.0",
     "tomlify-j0.4": "^3.0.0",

packages/config/package.json

@@ -1,13 +1,13 @@
 // We distinguish between errors thrown intentionally and uncaught exceptions
 // (such as bugs) with a `customErrorInfo.type` property.
-export const throwUserError = function (messageOrError, error) {
+export const throwUserError = function (messageOrError: string | Error, error?: Error) {
   const errorA = getError(messageOrError, error)
   errorA[CUSTOM_ERROR_KEY] = { type: USER_ERROR_TYPE }
   throw errorA
 }
 
 // Can pass either `message`, `error` or `message, error`
-const getError = function (messageOrError, error) {
+const getError = function (messageOrError: string | Error, error?: Error) {
   if (messageOrError instanceof Error) {
     return messageOrError
   }

packages/config/src/error.ts

@@ -1,18 +1,18 @@
+import { existsSync } from 'fs'
 import { resolve, relative, parse } from 'path'
 
 import { getProperty, setProperty, deleteProperty } from 'dot-prop'
-import { pathExists } from 'path-exists'
 
 import { throwUserError } from './error.js'
 import { mergeConfigs } from './merge.js'
 import { isTruthy } from './utils/remove_falsy.js'
 
 // Make configuration paths relative to `buildDir` and converts them to
 // absolute paths
-export const resolveConfigPaths = async function ({ config, repositoryRoot, buildDir, baseRelDir }) {
+export const resolveConfigPaths = function ({ config, repositoryRoot, buildDir, baseRelDir }) {
   const baseRel = baseRelDir ? buildDir : repositoryRoot
   const configA = resolvePaths(config, FILE_PATH_CONFIG_PROPS, baseRel, repositoryRoot)
-  const configB = await addDefaultPaths(configA, repositoryRoot, baseRel)
+  const configB = addDefaultPaths(configA, repositoryRoot, baseRel)
   return configB
 }
 
@@ -72,14 +72,11 @@ const getWindowsDrive = function (path) {
 
 // Some configuration properties have default values that are only set if a
 // specific directory/file exists in the build directory
-const addDefaultPaths = async function (config, repositoryRoot, baseRel) {
-  const defaultPathsConfigs = await Promise.all(
-    DEFAULT_PATHS.map(({ defaultPath, getConfig, propName }) =>
-      addDefaultPath({ repositoryRoot, baseRel, defaultPath, getConfig, propName }),
-    ),
-  )
-  const defaultPathsConfigsA = defaultPathsConfigs.filter(Boolean)
-  return mergeConfigs([...defaultPathsConfigsA, config])
+const addDefaultPaths = function (config, repositoryRoot, baseRel) {
+  const defaultPathsConfigs = DEFAULT_PATHS.map(({ defaultPath, getConfig, propName }) =>
+    addDefaultPath({ repositoryRoot, baseRel, defaultPath, getConfig, propName }),
+  ).filter(Boolean)
+  return mergeConfigs([...defaultPathsConfigs, config])
 }
 
 const DEFAULT_PATHS = [
@@ -101,10 +98,10 @@ const DEFAULT_PATHS = [
   },
 ]
 
-const addDefaultPath = async function ({ repositoryRoot, baseRel, defaultPath, getConfig, propName }) {
+const addDefaultPath = function ({ repositoryRoot, baseRel, defaultPath, getConfig, propName }) {
   const absolutePath = resolvePath(repositoryRoot, baseRel, defaultPath, propName)
 
-  if (!(await pathExists(absolutePath))) {
+  if (!existsSync(absolutePath)) {
     return
   }
 

packages/config/src/files.js

@@ -279,7 +279,7 @@ const normalizeConfigAndContext = function (config, origin) {
 const resolveFiles = async function ({ config, repositoryRoot, base, baseRelDir }) {
   const baseA = getBase(base, repositoryRoot, config)
   const buildDir = await getBuildDir(repositoryRoot, baseA)
-  const configA = await resolveConfigPaths({ config, repositoryRoot, buildDir, baseRelDir })
+  const configA = resolveConfigPaths({ config, repositoryRoot, buildDir, baseRelDir })
   const configB = addBase(configA, baseA)
   return { config: configB, buildDir, base: baseA }
 }

packages/config/src/main.js

@@ -1,6 +1,4 @@
-import { promises as fs } from 'fs'
-
-import { pathExists } from 'path-exists'
+import { existsSync, promises as fs } from 'fs'
 
 import { ensureConfigPriority } from '../context.js'
 import { addHeaders } from '../headers.js'
@@ -63,7 +61,7 @@ const saveConfig = async function (configPath, simplifiedConfig) {
 // Deletes `_headers/_redirects` since they are merged to `netlify.toml`,
 // to fix any priority problem.
 const deleteSideFile = async function (filePath) {
-  if (filePath === undefined || !(await pathExists(filePath))) {
+  if (filePath === undefined || !existsSync(filePath)) {
     return
   }
 
@@ -105,7 +103,7 @@ const backupFile = async function (original, backup) {
   // this makes sure we don't restore stale files
   await deleteNoError(backup)
 
-  if (!(await pathExists(original))) {
+  if (!existsSync(original)) {
     return
   }
 
@@ -121,7 +119,7 @@ const deleteNoError = async (path) => {
 }
 
 const copyOrDelete = async function (src, dest) {
-  if (await pathExists(src)) {
+  if (existsSync(src)) {
     await fs.copyFile(src, dest)
     return
   }

packages/config/src/mutations/update.js

@@ -1,8 +1,6 @@
-import { promises as fs } from 'fs'
+import { existsSync, promises as fs } from 'fs'
 import { dirname, relative, sep } from 'path'
 
-import { pathExists } from 'path-exists'
-
 // Retrieve `base` override.
 // This uses any directory below `repositoryRoot` and above (or equal to)
 // `cwd` that has a `.netlify` or `netlify.toml`. This allows Netlify CLI users
@@ -58,7 +56,7 @@ const locatePath = async function (paths) {
 }
 
 const returnIfExists = async function (path) {
-  if (!(await pathExists(path))) {
+  if (!existsSync(path)) {
     return
   }
 

packages/config/src/options/base.js

@@ -1,28 +1,32 @@
-import { promises as fs } from 'fs'
-
-import { pathExists } from 'path-exists'
+import { existsSync, promises as fs } from 'fs'
 
 import { throwUserError } from './error.js'
 import { throwOnInvalidTomlSequence } from './log/messages.js'
 import { parseToml } from './utils/toml.js'
 
-// Load the configuration file and parse it (TOML)
-export const parseConfig = async function (configPath) {
+/**
+ * Load the configuration file and parse it (TOML)
+ * @param configPath The path to the toml file
+ * @returns
+ */
+export const parseConfig = async function (configPath?: string) {
   if (configPath === undefined) {
     return {}
   }
 
-  if (!(await pathExists(configPath))) {
+  if (!existsSync(configPath)) {
     throwUserError('Configuration file does not exist')
   }
 
   return await readConfigPath(configPath)
 }
 
-// Same but `configPath` is required and `configPath` might point to a
-// non-existing file.
+/**
+ * Same but `configPath` is required and `configPath` might point to a
+ * non-existing file.
+ */
 export const parseOptionalConfig = async function (configPath) {
-  if (!(await pathExists(configPath))) {
+  if (!existsSync(configPath)) {
     return {}
   }
 
@@ -41,7 +45,9 @@ const readConfigPath = async function (configPath) {
   }
 }
 
-// Reach the configuration file's raw content
+/**
+ * Reach the configuration file's raw content
+ */
 const readConfig = async function (configPath) {
   try {
     return await fs.readFile(configPath, 'utf8')
@@ -60,10 +66,12 @@ const validateTomlBlackslashes = function (configString) {
   throwOnInvalidTomlSequence(invalidSequence)
 }
 
-// The TOML specification forbids unrecognized backslash sequences. However,
-// `toml-node` does not respect the specification and do not fail on those.
-// Therefore, we print a warning message.
-// This only applies to " and """ strings, not ' nor '''
-// Also, """ strings can use trailing backslashes.
+/**
+ * The TOML specification forbids unrecognized backslash sequences. However,
+ * `toml-node` does not respect the specification and do not fail on those.
+ * Therefore, we print a warning message.
+ * This only applies to " and """ strings, not ' nor '''
+ * Also, """ strings can use trailing backslashes.
+ */
 const INVALID_TOML_BLACKSLASH =
   /\n[a-zA-Z]+ *= *(?:(?:""".*(?<!\\)(\\[^"\\btnfruU\n]).*""")|(?:"(?!")[^\n]*(?<!\\)(\\[^"\\btnfruU])[^\n]*"))/su

packages/config/src/parse.js renamed to packages/config/src/parse.ts

@@ -1,14 +1,16 @@
+import { existsSync } from 'fs'
 import { resolve } from 'path'
 
 import { findUp } from 'find-up'
 import pLocate from 'p-locate'
-import { pathExists } from 'path-exists'
 
-// Configuration location can be:
-//  - a local path with the --config CLI flag
-//  - a `netlify.*` file in the `repositoryRoot/{base}`
-//  - a `netlify.*` file in the `repositoryRoot`
-//  - a `netlify.*` file in the current directory or any parent
+/**
+ * Configuration location can be:
+ * - a local path with the --config CLI flag
+ * - a `netlify.*` file in the `repositoryRoot/{base}`
+ * - a `netlify.*` file in the `repositoryRoot`
+ * - a `netlify.*` file in the current directory or any parent
+ */
 export const getConfigPath = async function ({ configOpt, cwd, repositoryRoot, configBase }) {
   const configPath = await pLocate(
     [
@@ -22,28 +24,32 @@ export const getConfigPath = async function ({ configOpt, cwd, repositoryRoot, c
   return configPath
 }
 
-// --config CLI flag
-const searchConfigOpt = function (cwd, configOpt) {
+/** --config CLI flag */
+const searchConfigOpt = function (cwd: string, configOpt?: string) {
   if (configOpt === undefined) {
     return
   }
 
   return resolve(cwd, configOpt)
 }
 
-// Look for `repositoryRoot/{base}/netlify.*`
-const searchBaseConfigFile = function (repositoryRoot, configBase) {
+/**
+ * Look for `repositoryRoot/{base}/netlify.*`
+ */
+const searchBaseConfigFile = function (repositoryRoot, configBase?: string) {
   if (configBase === undefined) {
     return
   }
 
   return searchConfigFile(configBase)
 }
 
-// Look for several file extensions for `netlify.*`
-const searchConfigFile = async function (cwd) {
+/**
+ * Look for several file extensions for `netlify.*`
+ */
+const searchConfigFile = function (cwd: string): string | undefined {
   const path = resolve(cwd, FILENAME)
-  if (!(await pathExists(path))) {
+  if (!existsSync(path)) {
     return
   }
   return path

packages/config/src/path.js renamed to packages/config/src/path.ts

@@ -1,10 +1,9 @@
-import { promises as fs } from 'fs'
+import { existsSync, promises as fs } from 'fs'
 import { fileURLToPath } from 'url'
 
 import { Fixture, normalizeOutput } from '@netlify/testing'
 import test from 'ava'
 import del from 'del'
-import { pathExists } from 'path-exists'
 
 import { updateConfig } from '../../lib/main.js'
 
@@ -50,19 +49,19 @@ const initFixtureDir = async function (fixtureName) {
 // Create temporary copies of `netlify.toml` and `redirects` from the fixture
 // directory to use in tests
 const copyIfExists = async function (fixturePath, tempPath) {
-  if (await pathExists(fixturePath)) {
+  if (existsSync(fixturePath)) {
     await fs.copyFile(fixturePath, tempPath)
     return
   }
 
-  if (await pathExists(tempPath)) {
+  if (existsSync(tempPath)) {
     await del(tempPath)
   }
 }
 
 test('updateConfig() saves netlify.toml', async (t) => {
   const { configPath } = await runUpdateConfig('save')
-  t.true(await pathExists(configPath))
+  t.true(existsSync(configPath))
 })
 
 test('updateConfig() updates the configuration so it can be read again', async (t) => {
@@ -73,7 +72,7 @@ test('updateConfig() updates the configuration so it can be read again', async (
 
 test('updateConfig() is a noop when where are no config mutations', async (t) => {
   const { configPath } = await runUpdateConfig('noop', { configMutations: [] })
-  t.false(await pathExists(configPath))
+  t.false(existsSync(configPath))
 })
 
 test('updateConfig() has higher priority than context properties', async (t) => {
@@ -91,19 +90,19 @@ test('updateConfig() merges with the existing netlify.toml', async (t) => {
 test('updateConfig() deletes _redirects when redirects were changed', async (t) => {
   const { redirectsPath } = await runUpdateConfig('redirects_change', { configMutations: [redirectsMutation] })
   t.is(typeof redirectsPath, 'string')
-  t.false(await pathExists(redirectsPath))
+  t.false(existsSync(redirectsPath))
 })
 
 test('updateConfig() deletes _redirects on changes even if redirects were not changed', async (t) => {
   const { redirectsPath } = await runUpdateConfig('redirects_no_change')
   t.is(typeof redirectsPath, 'string')
-  t.false(await pathExists(redirectsPath))
+  t.false(existsSync(redirectsPath))
 })
 
 test('updateConfig() does not delete _redirects if it does not exist', async (t) => {
   const { redirectsPath } = await runUpdateConfig('redirects_none')
   t.is(typeof redirectsPath, 'string')
-  t.false(await pathExists(redirectsPath))
+  t.false(existsSync(redirectsPath))
 })
 
 test('updateConfig() does not delete _redirects if redirectsPath not provided', async (t) => {
@@ -112,25 +111,25 @@ test('updateConfig() does not delete _redirects if redirectsPath not provided',
     redirectsPath: undefined,
   })
   t.is(typeof redirectsPath, 'string')
-  t.true(await pathExists(redirectsPath))
+  t.true(existsSync(redirectsPath))
 })
 
 test('updateConfig() deletes _headers when headers were changed', async (t) => {
   const { headersPath } = await runUpdateConfig('headers_change', { configMutations: [headersMutation] })
   t.is(typeof headersPath, 'string')
-  t.false(await pathExists(headersPath))
+  t.false(existsSync(headersPath))
 })
 
 test('updateConfig() deletes _headers on changes even if headers were not changed', async (t) => {
   const { headersPath } = await runUpdateConfig('headers_no_change')
   t.is(typeof headersPath, 'string')
-  t.false(await pathExists(headersPath))
+  t.false(existsSync(headersPath))
 })
 
 test('updateConfig() does not delete _headers if it does not exist', async (t) => {
   const { headersPath } = await runUpdateConfig('headers_none')
   t.is(typeof headersPath, 'string')
-  t.false(await pathExists(headersPath))
+  t.false(existsSync(headersPath))
 })
 
 test('updateConfig() does not delete _headers if headersPath not provided', async (t) => {
@@ -139,5 +138,5 @@ test('updateConfig() does not delete _headers if headersPath not provided', asyn
     headersPath: undefined,
   })
   t.is(typeof headersPath, 'string')
-  t.true(await pathExists(headersPath))
+  t.true(existsSync(headersPath))
 })