@netlify/config 19.0.0-rc → 19.0.0

package/src/api/site_info.js

@@ -1,67 +0,0 @@
-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/src/bin/flags.js

@@ -1,181 +0,0 @@
-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/src/bin/main.js

@@ -1,73 +0,0 @@
-#!/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/src/case.js

@@ -1,37 +0,0 @@
-// 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/src/context.js

@@ -1,99 +0,0 @@
-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) {
-  return {
-    ...config,
-    build,
-    context: {
-      ...config.context,
-      [context]: { ...config, ...build, build },
-      [branch]: { ...config, ...build, build },
-    },
-  }
-}

package/src/default.js

@@ -1,31 +0,0 @@
-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/src/env/envelope.js

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

package/src/env/git.js

@@ -1,23 +0,0 @@
-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 git = async function (args, cwd) {
-  try {
-    const { stdout } = await execa('git', args, { cwd })
-    return stdout
-  } catch {}
-}