@netlify/config 18.2.4 → 18.2.5

package/lib/bin/main.js

@@ -1,73 +1,59 @@
 #!/usr/bin/env node
-
-import { promises as fs } from 'fs'
-import { dirname } from 'path'
-import process from 'process'
-
-import fastSafeStringify from 'fast-safe-stringify'
-import omit from 'omit.js'
-
-import { isUserError } from '../error.js'
-import { resolveConfig } from '../main.js'
-
-import { parseFlags } from './flags.js'
-
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+import process from 'process';
+import fastSafeStringify from 'fast-safe-stringify';
+import omit from 'omit.js';
+import { isUserError } from '../error.js';
+import { resolveConfig } from '../main.js';
+import { parseFlags } from './flags.js';
 // CLI entry point
 const runCli = async function () {
-  try {
-    const { stable, output = DEFAULT_OUTPUT, ...flags } = parseFlags()
-    const result = await resolveConfig(flags)
-    await handleCliSuccess(result, stable, output)
-  } catch (error) {
-    handleCliError(error)
-  }
-}
-
-const DEFAULT_OUTPUT = '-'
-
+    try {
+        const { stable, output = DEFAULT_OUTPUT, ...flags } = parseFlags();
+        const result = await resolveConfig(flags);
+        await handleCliSuccess(result, stable, output);
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+};
+const DEFAULT_OUTPUT = '-';
 // The result is output as JSON on success (exit code 0)
 const handleCliSuccess = async function (result, stable, output) {
-  const resultA = serializeApi(result)
-  const resultB = omit.default(resultA, SECRET_PROPERTIES)
-  const stringifyFunc = stable ? fastSafeStringify.stableStringify : JSON.stringify
-  const resultJson = stringifyFunc(resultB, null, 2)
-  await outputResult(resultJson, output)
-  process.exitCode = 0
-}
-
+    const resultA = serializeApi(result);
+    const resultB = omit.default(resultA, SECRET_PROPERTIES);
+    const stringifyFunc = stable ? fastSafeStringify.stableStringify : JSON.stringify;
+    const resultJson = stringifyFunc(resultB, null, 2);
+    await outputResult(resultJson, output);
+    process.exitCode = 0;
+};
 const outputResult = async function (resultJson, output) {
-  if (output === '-') {
-    console.log(resultJson)
-    return
-  }
-
-  await fs.mkdir(dirname(output), { recursive: true })
-  await fs.writeFile(output, resultJson)
-}
-
+    if (output === '-') {
+        console.log(resultJson);
+        return;
+    }
+    await fs.mkdir(dirname(output), { recursive: true });
+    await fs.writeFile(output, resultJson);
+};
 // `api` is not JSON-serializable, so we remove it
 // We still indicate it as a boolean
 const serializeApi = function ({ api, ...result }) {
-  if (api === undefined) {
-    return result
-  }
-
-  return { ...result, hasApi: true }
-}
-
-const SECRET_PROPERTIES = ['token']
-
+    if (api === undefined) {
+        return result;
+    }
+    return { ...result, hasApi: true };
+};
+const SECRET_PROPERTIES = ['token'];
 const handleCliError = function (error) {
-  // Errors caused by users do not show stack traces and have exit code 1
-  if (isUserError(error)) {
-    console.error(error.message)
-    process.exitCode = 1
-    return
-  }
-
-  // Internal errors / bugs have exit code 2
-  console.error(error.stack)
-  process.exitCode = 2
-}
-
-runCli()
+    // Errors caused by users do not show stack traces and have exit code 1
+    if (isUserError(error)) {
+        console.error(error.message);
+        process.exitCode = 1;
+        return;
+    }
+    // Internal errors / bugs have exit code 2
+    console.error(error.stack);
+    process.exitCode = 2;
+};
+runCli();

package/lib/build_dir.js

@@ -1,26 +1,22 @@
-import { isDirectory } from 'path-type'
-
-import { throwUserError } from './error.js'
-
+import { isDirectory } from 'path-type';
+import { throwUserError } from './error.js';
 // Retrieve the build directory used to resolve most paths.
 // This is (in priority order):
 //  - `build.base`
 //  - `--repositoryRoot`
 //  - the current directory (default value of `--repositoryRoot`)
 export const getBuildDir = async function (repositoryRoot, base) {
-  const buildDir = base === undefined ? repositoryRoot : base
-  await checkBuildDir(buildDir, repositoryRoot)
-  return buildDir
-}
-
+    const buildDir = base === undefined ? repositoryRoot : base;
+    await checkBuildDir(buildDir, repositoryRoot);
+    return buildDir;
+};
 // The build directory is used as the current directory of build commands and
 // build plugins. Therefore it must exist.
 // We already check `repositoryRoot` earlier in the code, so only need to check
 // `buildDir` when it is the base directory instead.
 const checkBuildDir = async function (buildDir, repositoryRoot) {
-  if (buildDir === repositoryRoot || (await isDirectory(buildDir))) {
-    return
-  }
-
-  throwUserError(`Base directory does not exist: ${buildDir}`)
-}
+    if (buildDir === repositoryRoot || (await isDirectory(buildDir))) {
+        return;
+    }
+    throwUserError(`Base directory does not exist: ${buildDir}`);
+};

package/lib/cached_config.js

@@ -1,5 +1,4 @@
-import { promises as fs } from 'fs'
-
+import { promises as fs } from 'fs';
 // Performance optimization when @netlify/config caller has already previously
 // called it and cached the result.
 // This is used by the buildbot which:
@@ -7,23 +6,21 @@ import { promises as fs } from 'fs'
 //  - later calls @netlify/build, which runs @netlify/config under the hood
 // This is also used by Netlify CLI.
 export const getCachedConfig = async function ({ cachedConfig, cachedConfigPath, token, api }) {
-  const parsedCachedConfig = await parseCachedConfig(cachedConfig, cachedConfigPath)
-  // The CLI does not print some properties when they are not serializable or
-  // are confidential. Those will be missing from `cachedConfig`. The caller
-  // must supply them again when using `cachedConfig`.
-  return parsedCachedConfig === undefined ? undefined : { token, ...parsedCachedConfig, api }
-}
-
+    const parsedCachedConfig = await parseCachedConfig(cachedConfig, cachedConfigPath);
+    // The CLI does not print some properties when they are not serializable or
+    // are confidential. Those will be missing from `cachedConfig`. The caller
+    // must supply them again when using `cachedConfig`.
+    return parsedCachedConfig === undefined ? undefined : { token, ...parsedCachedConfig, api };
+};
 // `cachedConfig` is a plain object while `cachedConfigPath` is a file path to
 // a JSON file. The former is useful in programmatic usage while the second one
 // is useful in CLI usage, to avoid hitting the OS limits if the configuration
 // file is too big.
 const parseCachedConfig = async function (cachedConfig, cachedConfigPath) {
-  if (cachedConfig !== undefined) {
-    return cachedConfig
-  }
-
-  if (cachedConfigPath !== undefined) {
-    return JSON.parse(await fs.readFile(cachedConfigPath))
-  }
-}
+    if (cachedConfig !== undefined) {
+        return cachedConfig;
+    }
+    if (cachedConfigPath !== undefined) {
+        return JSON.parse(await fs.readFile(cachedConfigPath));
+    }
+};

package/lib/case.js

@@ -1,37 +1,18 @@
 // Some properties can be optionally capitalized. We normalize them to lowercase
 export const normalizeConfigCase = function ({ Build, build = Build, ...config }) {
-  const buildA = normalizeBuildCase(build)
-  return { ...config, build: buildA }
-}
-
-const normalizeBuildCase = function ({
-  Base,
-  base = Base,
-  Command,
-  command = Command,
-  Edge_functions: EdgeFunctions,
-  edge_functions: edgeFunctions = EdgeFunctions,
-  Environment,
-  environment = Environment,
-  Functions,
-  functions = Functions,
-  Ignore,
-  ignore = Ignore,
-  Processing,
-  processing = Processing,
-  Publish,
-  publish = Publish,
-  ...build
-} = {}) {
-  return {
-    ...build,
-    base,
-    command,
-    edge_functions: edgeFunctions,
-    environment,
-    functions,
-    ignore,
-    processing,
-    publish,
-  }
-}
+    const buildA = normalizeBuildCase(build);
+    return { ...config, build: buildA };
+};
+const normalizeBuildCase = function ({ Base, base = Base, Command, command = Command, Edge_functions: EdgeFunctions, edge_functions: edgeFunctions = EdgeFunctions, Environment, environment = Environment, Functions, functions = Functions, Ignore, ignore = Ignore, Processing, processing = Processing, Publish, publish = Publish, ...build } = {}) {
+    return {
+        ...build,
+        base,
+        command,
+        edge_functions: edgeFunctions,
+        environment,
+        functions,
+        ignore,
+        processing,
+        publish,
+    };
+};

package/lib/context.js

@@ -1,108 +1,86 @@
-import isPlainObj from 'is-plain-obj'
-import mapObj from 'map-obj'
-
-import { mergeConfigs } from './merge.js'
-import { normalizeBeforeConfigMerge } from './merge_normalize.js'
-import { validateContextsPluginsConfig } from './validate/context.js'
-import { validatePreContextConfig } from './validate/main.js'
-
+import isPlainObj from 'is-plain-obj';
+import mapObj from 'map-obj';
+import { mergeConfigs } from './merge.js';
+import { normalizeBeforeConfigMerge } from './merge_normalize.js';
+import { validateContextsPluginsConfig } from './validate/context.js';
+import { validatePreContextConfig } from './validate/main.js';
 // Validate and normalize `config.context.*`
 export const normalizeContextProps = function ({ config, config: { context: contextProps }, origin }) {
-  if (contextProps === undefined) {
-    return config
-  }
-
-  validatePreContextConfig(config)
-
-  const allContextProps = mapObj(contextProps, (key, contextConfig) => [key, addNamespace(contextConfig)])
-  const normalizedContextProps = mapObj(allContextProps, (key, contextConfig) => [
-    key,
-    normalizeBeforeConfigMerge(contextConfig, origin),
-  ])
-  return { ...config, context: normalizedContextProps }
-}
-
+    if (contextProps === undefined) {
+        return config;
+    }
+    validatePreContextConfig(config);
+    const allContextProps = mapObj(contextProps, (key, contextConfig) => [key, addNamespace(contextConfig)]);
+    const normalizedContextProps = mapObj(allContextProps, (key, contextConfig) => [
+        key,
+        normalizeBeforeConfigMerge(contextConfig, origin),
+    ]);
+    return { ...config, context: normalizedContextProps };
+};
 // Merge `config.context.{CONTEXT|BRANCH}.*` to `config.build.*` or `config.*`
 // CONTEXT is the `--context` CLI flag.
 // BRANCH is the `--branch` CLI flag.
-export const mergeContext = function ({
-  config: { context: contextProps, ...config },
-  config: { plugins },
-  context,
-  branch,
-  logs,
-}) {
-  if (contextProps === undefined) {
-    return config
-  }
-
-  const contexts = [context, branch]
-  validateContextsPluginsConfig({ contextProps, plugins, contexts, logs })
-  const filteredContextProps = contexts.map((key) => contextProps[key]).filter(Boolean)
-  return mergeConfigs([config, ...filteredContextProps])
-}
-
+export const mergeContext = function ({ config: { context: contextProps, ...config }, config: { plugins }, context, branch, logs, }) {
+    if (contextProps === undefined) {
+        return config;
+    }
+    const contexts = [context, branch];
+    validateContextsPluginsConfig({ contextProps, plugins, contexts, logs });
+    const filteredContextProps = contexts.map((key) => contextProps[key]).filter(Boolean);
+    return mergeConfigs([config, ...filteredContextProps]);
+};
 // `config.context.{context}.*` properties are merged either to `config.*` or
 // to `config.build.*`. We distinguish between both by checking the property
 // name.
-const addNamespace = (contextConfig) => Object.entries(contextConfig).reduce(addNamespacedProperty, {})
-
+const addNamespace = (contextConfig) => Object.entries(contextConfig).reduce(addNamespacedProperty, {});
 const addNamespacedProperty = function (contextConfig, [key, value]) {
-  return isBuildProperty(key, value)
-    ? { ...contextConfig, build: { ...contextConfig.build, [key]: value } }
-    : { ...contextConfig, [key]: value }
-}
-
+    return isBuildProperty(key, value)
+        ? { ...contextConfig, build: { ...contextConfig.build, [key]: value } }
+        : { ...contextConfig, [key]: value };
+};
 const isBuildProperty = function (key, value) {
-  return BUILD_PROPERTIES.has(key) && !isFunctionsConfig(key, value) && !isEdgeFunctionsConfig(key, value)
-}
-
+    return BUILD_PROPERTIES.has(key) && !isFunctionsConfig(key, value) && !isEdgeFunctionsConfig(key, value);
+};
 // All properties in `config.build.*`
 const BUILD_PROPERTIES = new Set([
-  'base',
-  'command',
-  'edge_functions',
-  'environment',
-  'functions',
-  'ignore',
-  'processing',
-  'publish',
-])
-
+    'base',
+    'command',
+    'edge_functions',
+    'environment',
+    'functions',
+    'ignore',
+    'processing',
+    'publish',
+]);
 // `config.functions` is a plain object while `config.build.functions` is a
 // string.
 const isFunctionsConfig = function (key, value) {
-  return key === 'functions' && isPlainObj(value)
-}
-
+    return key === 'functions' && isPlainObj(value);
+};
 // `config.edge_functions` is an array of objects while
 // `config.build.edge_functions` is a string.
 const isEdgeFunctionsConfig = function (key, value) {
-  return key === 'edge_functions' && Array.isArray(value)
-}
-
+    return key === 'edge_functions' && Array.isArray(value);
+};
 // Ensure that `inlineConfig` has higher priority than context properties by
 // assigining it to `context.*`. Still keep it at the top-level as well since
 // some properties are not handled context-sensitively by the API.
 // Takes into account that `context.{context}.build.*` is the same as
 // `context.{context}.*`
 export const ensureConfigPriority = function ({ build = {}, ...config }, context, branch) {
-  const base = {
-    ...config,
-    build,
-  }
-
-  // remove the redirects to not have context specific redirects.
-  // The redirects should be only on the root level.
-  // eslint-disable-next-line fp/no-delete, no-param-reassign
-  delete config.redirects
-
-  return {
-    ...base,
-    context: {
-      ...config.context,
-      [context]: { ...config, ...build, build },
-      [branch]: { ...config, ...build, build },
-    },
-  }
-}
+    const base = {
+        ...config,
+        build,
+    };
+    // remove the redirects to not have context specific redirects.
+    // The redirects should be only on the root level.
+    delete config.redirects;
+    return {
+        ...base,
+        context: {
+            ...config.context,
+            [context]: { ...config, ...build, build },
+            [branch]: { ...config, ...build, build },
+        },
+    };
+};

package/lib/default.js

@@ -1,31 +1,27 @@
-import { addBuildSettings } from './api/build_settings.js'
-import { logDefaultConfig } from './log/main.js'
-
+import { addBuildSettings } from './api/build_settings.js';
+import { logDefaultConfig } from './log/main.js';
 // Retrieve default configuration file. It has less priority and it also does
 // not get normalized, merged with contexts, etc.
 export const parseDefaultConfig = function ({ defaultConfig, base, baseRelDir, siteInfo, logs, debug }) {
-  const defaultConfigB = addDefaultConfigBase(defaultConfig, base)
-  const { defaultConfig: defaultConfigC, baseRelDir: baseRelDirA = DEFAULT_BASE_REL_DIR } = addBuildSettings({
-    defaultConfig: defaultConfigB,
-    baseRelDir,
-    siteInfo,
-  })
-  logDefaultConfig(defaultConfigC, { logs, debug, baseRelDir: baseRelDirA })
-  return { defaultConfig: defaultConfigC, baseRelDir: baseRelDirA }
-}
-
+    const defaultConfigB = addDefaultConfigBase(defaultConfig, base);
+    const { defaultConfig: defaultConfigC, baseRelDir: baseRelDirA = DEFAULT_BASE_REL_DIR } = addBuildSettings({
+        defaultConfig: defaultConfigB,
+        baseRelDir,
+        siteInfo,
+    });
+    logDefaultConfig(defaultConfigC, { logs, debug, baseRelDir: baseRelDirA });
+    return { defaultConfig: defaultConfigC, baseRelDir: baseRelDirA };
+};
 // When the `base` was overridden, add it to `defaultConfig` so it behaves
 // as if it had been specified in the UI settings
 const addDefaultConfigBase = function (defaultConfig, base) {
-  if (base === undefined) {
-    return defaultConfig
-  }
-
-  const { build = {} } = defaultConfig
-  return { ...defaultConfig, build: { ...build, base } }
-}
-
+    if (base === undefined) {
+        return defaultConfig;
+    }
+    const { build = {} } = defaultConfig;
+    return { ...defaultConfig, build: { ...build, base } };
+};
 // `baseRelDir` should default to `true` only if the option was not passed and
 // it could be retrieved from the `siteInfo`, which is why the default value
 // is assigned later than other properties.
-const DEFAULT_BASE_REL_DIR = true
+const DEFAULT_BASE_REL_DIR = true;

package/lib/env/envelope.js

@@ -1,24 +1,24 @@
 export const getEnvelope = async function ({ api, accountId, siteId }) {
-  if (accountId === undefined) {
-    return {}
-  }
-  try {
-    const environmentVariables = await api.getEnvVars({ accountId, siteId })
-    // eslint-disable-next-line fp/no-mutating-methods
-    const sortedEnvVarsFromDevContext = environmentVariables
-      .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
-      .reduce((acc, cur) => {
-        const envVar = cur.values.find((val) => ['dev', 'all'].includes(val.context))
-        if (envVar && envVar.value) {
-          return {
-            ...acc,
-            [cur.key]: envVar.value,
-          }
-        }
-        return acc
-      }, {})
-    return sortedEnvVarsFromDevContext
-  } catch {
-    return {}
-  }
-}
+    if (accountId === undefined) {
+        return {};
+    }
+    try {
+        const environmentVariables = await api.getEnvVars({ accountId, siteId });
+        const sortedEnvVarsFromDevContext = environmentVariables
+            .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
+            .reduce((acc, cur) => {
+            const envVar = cur.values.find((val) => ['dev', 'all'].includes(val.context));
+            if (envVar && envVar.value) {
+                return {
+                    ...acc,
+                    [cur.key]: envVar.value,
+                };
+            }
+            return acc;
+        }, {});
+        return sortedEnvVarsFromDevContext;
+    }
+    catch {
+        return {};
+    }
+};

package/lib/env/git.js

@@ -1,23 +1,23 @@
-import { execa } from 'execa'
-
-import { removeFalsy } from '../utils/remove_falsy.js'
-
+import { execa } from 'execa';
+import { removeFalsy } from '../utils/remove_falsy.js';
 // Retrieve git-related information for use in environment variables.
 // git is optional and there might be not git repository.
 // We purposely keep this decoupled from the git utility.
 export const getGitEnv = async function (buildDir, branch) {
-  const [COMMIT_REF, CACHED_COMMIT_REF] = await Promise.all([
-    git(['rev-parse', 'HEAD'], buildDir),
-    git(['rev-parse', 'HEAD^'], buildDir),
-  ])
-  const gitEnv = { BRANCH: branch, HEAD: branch, COMMIT_REF, CACHED_COMMIT_REF, PULL_REQUEST: 'false' }
-  const gitEnvA = removeFalsy(gitEnv)
-  return gitEnvA
-}
-
+    const [COMMIT_REF, CACHED_COMMIT_REF] = await Promise.all([
+        git(['rev-parse', 'HEAD'], buildDir),
+        git(['rev-parse', 'HEAD^'], buildDir),
+    ]);
+    const gitEnv = { BRANCH: branch, HEAD: branch, COMMIT_REF, CACHED_COMMIT_REF, PULL_REQUEST: 'false' };
+    const gitEnvA = removeFalsy(gitEnv);
+    return gitEnvA;
+};
 const git = async function (args, cwd) {
-  try {
-    const { stdout } = await execa('git', args, { cwd })
-    return stdout
-  } catch {}
-}
+    try {
+        const { stdout } = await execa('git', args, { cwd });
+        return stdout;
+    }
+    catch {
+        // continue regardless error
+    }
+};