@netlify/config 18.2.4-rc → 18.2.4

package/lib/api/build_settings.js

@@ -0,0 +1,41 @@
+import { removeFalsy } from '../utils/remove_falsy.js'
+
+// Netlify UI build settings are used as default configuration values in
+// production. In local builds, we retrieve them with `getSite` (`siteInfo`)
+// instead.
+// This also includes UI-installed plugins.
+export const addBuildSettings = function ({
+  defaultConfig,
+  baseRelDir,
+  siteInfo: { build_settings: buildSettings, plugins },
+}) {
+  if (buildSettings === undefined) {
+    return { defaultConfig, baseRelDir }
+  }
+
+  const defaultConfigA = getDefaultConfig(buildSettings, defaultConfig, plugins)
+  const baseRelDirA = getBaseRelDir(buildSettings, baseRelDir)
+  return { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA }
+}
+
+// From the `getSite` API response to the corresponding configuration properties
+const getDefaultConfig = function (
+  { cmd: command, dir: publish, functions_dir: functionsDirectory, base },
+  { build, plugins = [], ...defaultConfig },
+  uiPlugins = [],
+) {
+  const siteBuild = removeFalsy({ command, publish, base })
+  const functions = functionsDirectory ? { functionsDirectory, functionsDirectoryOrigin: 'ui' } : {}
+  const uiPluginsA = uiPlugins.map(normalizeUiPlugin)
+  const pluginsA = [...uiPluginsA, ...plugins]
+  return { ...defaultConfig, build: { ...siteBuild, ...build }, plugins: pluginsA, ...functions }
+}
+
+// Make sure we know which fields we are picking from the API
+const normalizeUiPlugin = function ({ package: packageName, inputs, pinned_version: pinnedVersion }) {
+  return { package: packageName, inputs, pinned_version: pinnedVersion }
+}
+
+const getBaseRelDir = function ({ base_rel_dir: siteBaseRelDir }, baseRelDir = siteBaseRelDir) {
+  return Boolean(baseRelDir)
+}

package/lib/api/client.js

@@ -0,0 +1,15 @@
+import { NetlifyAPI } from 'netlify'
+
+import { removeUndefined } from '../utils/remove_falsy.js'
+
+// Retrieve Netlify API client, if an access token was passed
+export const getApiClient = function ({ token, offline, testOpts = {}, host, scheme, pathPrefix }) {
+  if (!token || offline) {
+    return
+  }
+
+  // TODO: find less intrusive way to mock HTTP requests
+  const parameters = removeUndefined({ scheme: testOpts.scheme || scheme, host: testOpts.host || host, pathPrefix })
+  const api = new NetlifyAPI(token, parameters)
+  return api
+}

package/lib/api/site_info.js

@@ -0,0 +1,67 @@
+import { getEnvelope } from '../env/envelope.js'
+import { throwUserError } from '../error.js'
+import { ERROR_CALL_TO_ACTION } from '../log/messages.js'
+
+// Retrieve Netlify Site information, if available.
+// Used to retrieve local build environment variables and UI build settings.
+// This is not used in production builds since the buildbot passes this
+// information instead.
+// Requires knowing the `siteId` and having the access `token`.
+// Silently ignore API errors. For example the network connection might be down,
+// but local builds should still work regardless.
+// eslint-disable-next-line complexity
+export const getSiteInfo = async function ({ api, siteId, mode, testOpts: { env: testEnv = true } = {} }) {
+  if (api === undefined || mode === 'buildbot' || !testEnv) {
+    const siteInfo = siteId === undefined ? {} : { id: siteId }
+    return { siteInfo, accounts: [], addons: [] }
+  }
+
+  const [siteInfo, accounts, addons] = await Promise.all([
+    getSite(api, siteId),
+    getAccounts(api),
+    getAddons(api, siteId),
+  ])
+
+  if (siteInfo.use_envelope) {
+    const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId })
+    // eslint-disable-next-line fp/no-mutation
+    siteInfo.build_settings.env = envelope
+  }
+
+  return { siteInfo, accounts, addons }
+}
+
+const getSite = async function (api, siteId) {
+  if (siteId === undefined) {
+    return {}
+  }
+
+  try {
+    const site = await api.getSite({ siteId })
+    return { ...site, id: siteId }
+  } catch (error) {
+    throwUserError(`Failed retrieving site data for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+  }
+}
+
+const getAccounts = async function (api) {
+  try {
+    const accounts = await api.listAccountsForUser()
+    return Array.isArray(accounts) ? accounts : []
+  } catch (error) {
+    throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+  }
+}
+
+const getAddons = async function (api, siteId) {
+  if (siteId === undefined) {
+    return []
+  }
+
+  try {
+    const addons = await api.listServiceInstancesForSite({ siteId })
+    return Array.isArray(addons) ? addons : []
+  } catch (error) {
+    throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`)
+  }
+}

package/lib/base.js

@@ -0,0 +1,34 @@
+import { resolvePath } from './files.js'
+
+// Retrieve the first `base` directory used to load the first config file.
+export const getInitialBase = function ({
+  repositoryRoot,
+  defaultConfig: { build: { base: defaultBase } = {} },
+  inlineConfig: { build: { base: initialBase = defaultBase } = {} },
+}) {
+  return resolveBase(repositoryRoot, initialBase)
+}
+
+// Two config files can be used:
+//  - The first one, using the `config` property or doing a default lookup
+//    of `netlify.toml`
+//  - If the first one has a `base` property pointing to a directory with
+//    another `netlify.toml`, that second config file is used instead.
+// This retrieves the final `base` directory used:
+//  - To load the second config file
+//  - As the `buildDir`
+//  - To resolve file paths
+// If the second file has a `base` property, it is ignored, i.e. it is not
+// recursive.
+export const getBase = function (base, repositoryRoot, config) {
+  return base === undefined ? resolveBase(repositoryRoot, config.build.base) : base
+}
+
+const resolveBase = function (repositoryRoot, base) {
+  return resolvePath(repositoryRoot, repositoryRoot, base, 'build.base')
+}
+
+// Also `config.build.base`.
+export const addBase = function (config, base) {
+  return { ...config, build: { ...config.build, base } }
+}

package/lib/bin/flags.js

@@ -0,0 +1,181 @@
+import process from 'process'
+
+import filterObj from 'filter-obj'
+import yargs from 'yargs'
+import { hideBin } from 'yargs/helpers'
+
+import { normalizeCliFeatureFlags } from '../options/feature_flags.js'
+
+// Parse CLI flags
+export const parseFlags = function () {
+  const { featureFlags: cliFeatureFlags = '', ...flags } = yargs(hideBin(process.argv))
+    .options(FLAGS)
+    .usage(USAGE)
+    .parse()
+  const featureFlags = normalizeCliFeatureFlags(cliFeatureFlags)
+  const flagsA = { ...flags, featureFlags }
+  const flagsB = filterObj(flagsA, isUserFlag)
+  return flagsB
+}
+
+const jsonParse = function (value) {
+  return value === undefined ? undefined : JSON.parse(value)
+}
+
+// List of CLI flags
+const FLAGS = {
+  config: {
+    string: true,
+    describe: `Path to the configuration file.
+Defaults to any netlify.toml in the git repository root directory or the base directory`,
+  },
+  defaultConfig: {
+    string: true,
+    describe: `JSON configuration object containing default values.
+Each configuration default value is used unless overriden through the main configuration file.
+Default: none.`,
+    coerce: jsonParse,
+    hidden: true,
+  },
+  cachedConfig: {
+    string: true,
+    describe: `JSON configuration object returned by @netlify/config when --output=/ is used
+or when using @netlify/config programmatically.
+This is done as a performance optimization to cache the configuration loading logic.
+Default: none.`,
+    coerce: jsonParse,
+    hidden: true,
+  },
+  cachedConfigPath: {
+    string: true,
+    describe: `File path to the JSON configuration object returned by @netlify/config
+when --output=/path is used.
+This is done as a performance optimization to cache the configuration loading logic.
+Default: none.`,
+    hidden: true,
+  },
+  inlineConfig: {
+    string: true,
+    describe: `JSON configuration object overriding the configuration file and other settings.
+Default: none.`,
+    coerce: jsonParse,
+    hidden: true,
+  },
+  configMutations: {
+    array: true,
+    describe: `Array of changes to apply to the configuration.
+Each change must be an object with three properties:
+  - "keys": array of keys targetting the property to change
+  - "value": new value of that property
+  - "event": build event when this change was applied, e.g. "onPreBuild"
+Default: empty array.`,
+    coerce: jsonParse,
+    hidden: true,
+  },
+  cwd: {
+    string: true,
+    describe: `Current directory. Used to retrieve the configuration file.
+Default: current directory`,
+  },
+  repositoryRoot: {
+    string: true,
+    describe: `Git repository root directory. Used to retrieve the configuration file.
+Default: automatically guessed`,
+  },
+  output: {
+    string: true,
+    describe: `Where to output the JSON result.
+Default: "-" (stdout)`,
+  },
+  stable: {
+    boolean: true,
+    describe: `Sort keys printed in the output.
+Default: false`,
+    default: false,
+  },
+  token: {
+    string: true,
+    describe: `Netlify API token for authentication.
+The NETLIFY_AUTH_TOKEN environment variable can be used as well.`,
+  },
+  host: {
+    string: true,
+    describe: `Host of the Netlify API.`,
+    hidden: true,
+  },
+  scheme: {
+    string: true,
+    describe: `Scheme/protocol of the Netlify API.`,
+    hidden: true,
+  },
+  pathPrefix: {
+    string: true,
+    describe: `Base path prefix of the Netlify API.`,
+    hidden: true,
+  },
+  siteId: {
+    string: true,
+    describe: `Netlify Site ID.`,
+  },
+  context: {
+    string: true,
+    describe: `Build context.
+Default: 'production'`,
+  },
+  branch: {
+    string: true,
+    describe: `Repository branch.
+Default: automatically guessed`,
+  },
+  baseRelDir: {
+    boolean: true,
+    describe: `Feature flag meant for backward compatibility.
+When enabled, if the 'build.base' configuration property is defined, it is used
+to try to retrieve a second configuration file and discard the first one.
+Default: true`,
+    hidden: true,
+  },
+  mode: {
+    string: true,
+    describe: `Environment in which this is loaded. Can be:
+  - 'buildbot': within Netlify Buildbot
+  - 'cli': within Netlify CLI
+  - 'require': through import('@netlify/config')`,
+    hidden: true,
+  },
+  debug: {
+    boolean: true,
+    describe: 'Print debugging information',
+    hidden: true,
+  },
+  testOpts: {
+    describe: 'Options for testing only',
+    hidden: true,
+  },
+  featureFlags: {
+    describe: 'Comma-separated list of feature flags to enable unreleased features',
+    hidden: true,
+  },
+  offline: {
+    boolean: true,
+    describe: `Do not send requests to the Netlify API to retrieve site settings.
+Default: false`,
+  },
+  buffer: {
+    boolean: true,
+    describe: 'Buffer output instead of streaming it',
+    hidden: true,
+  },
+}
+
+const USAGE = `netlify-config [OPTIONS...]
+
+Retrieve and resolve the Netlify configuration.
+The result is printed as a JSON object on stdout.`
+
+// Remove `yargs`-specific options, shortcuts, dash-cased and aliases
+const isUserFlag = function (key, value) {
+  return value !== undefined && !INTERNAL_KEYS.has(key) && key.length !== 1 && !key.includes('-')
+}
+
+const INTERNAL_KEYS = new Set(['help', 'version', '_', '$0'])

package/lib/bin/main.js

@@ -0,0 +1,73 @@
+#!/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'
+
+// 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 = '-'
+
+// 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 outputResult = async function (resultJson, output) {
+  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']
+
+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()

package/lib/build_dir.js

@@ -0,0 +1,26 @@
+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
+}
+
+// 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}`)
+}

package/lib/cached_config.js

@@ -0,0 +1,29 @@
+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:
+//  - first calls @netlify/config since it needs configuration property
+//  - 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 }
+}
+
+// `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))
+  }
+}

package/lib/case.js

@@ -0,0 +1,37 @@
+// 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,
+  }
+}

package/lib/context.js

@@ -0,0 +1,108 @@
+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 }
+}
+
+// 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])
+}
+
+// `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 addNamespacedProperty = function (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)
+}
+
+// All properties in `config.build.*`
+const BUILD_PROPERTIES = new Set([
+  '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)
+}
+
+// `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)
+}
+
+// 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 },
+    },
+  }
+}

package/lib/default.js

@@ -0,0 +1,31 @@
+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 }
+}
+
+// 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 } }
+}
+
+// `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

package/lib/env/envelope.js

@@ -0,0 +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 {}
+  }
+}