@netlify/build 28.0.1-beta → 28.1.0-framework-version-detection

package/src/log/old_version.js

@@ -1,41 +0,0 @@
-import { stdout } from 'process'
-
-import UpdateNotifier from 'update-notifier'
-
-import { ROOT_PACKAGE_JSON } from '../utils/json.js'
-
-// Many build errors happen in local builds that do not use the latest version
-// of `@netlify/build`. We print a warning message on those.
-// We only print this when Netlify CLI has been used. Programmatic usage might
-// come from a deep dependency calling `@netlify/build` and user might not be
-// able to take any upgrade action, making the message noisy.
-export const logOldCliVersionError = function ({ mode, testOpts }) {
-  if (mode !== 'cli') {
-    return
-  }
-
-  const corePackageJson = getCorePackageJson(testOpts)
-  UpdateNotifier({ pkg: corePackageJson, updateCheckInterval: 1 }).notify({
-    message: OLD_VERSION_MESSAGE,
-    shouldNotifyInNpmScript: true,
-  })
-}
-
-const getCorePackageJson = function (testOpts) {
-  // TODO: Find a way to test this without injecting code in the `src/`
-  if (testOpts.oldCliLogs) {
-    // `update-notifier` does not do anything if not in a TTY.
-    // In tests, we need to monkey patch this
-    // Mutation is required due to how `stdout.isTTY` works
-    // eslint-disable-next-line fp/no-mutation
-    stdout.isTTY = true
-
-    return { ...ROOT_PACKAGE_JSON, version: '0.0.1' }
-  }
-
-  return ROOT_PACKAGE_JSON
-}
-
-const OLD_VERSION_MESSAGE = `Please update netlify-cli to its latest version.
-If netlify-cli is already the latest version,
-please update your dependencies lock file instead.`

package/src/log/serialize.js

@@ -1,13 +0,0 @@
-import { dump } from 'js-yaml'
-
-export const serializeObject = function (object) {
-  return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd()
-}
-
-export const serializeArray = function (array) {
-  return array.map(addDash).join('\n')
-}
-
-const addDash = function (string) {
-  return ` - ${string}`
-}

package/src/log/stream.js

@@ -1,85 +0,0 @@
-import { stdout, stderr } from 'process'
-import { promisify } from 'util'
-
-// TODO: replace with `timers/promises` after dropping Node < 15.0.0
-const pSetTimeout = promisify(setTimeout)
-
-// We try to use `stdio: inherit` because it keeps `stdout/stderr` as `TTY`,
-// which solves many problems. However we can only do it in build.command.
-// Plugins have several events, so need to be switch on and off instead.
-// In buffer mode (`logs` not `undefined`), `pipe` is necessary.
-export const getBuildCommandStdio = function (logs) {
-  if (logs !== undefined) {
-    return 'pipe'
-  }
-
-  return 'inherit'
-}
-
-// Add build command output
-export const handleBuildCommandOutput = function ({ stdout: commandStdout, stderr: commandStderr }, logs) {
-  if (logs === undefined) {
-    return
-  }
-
-  pushBuildCommandOutput(commandStdout, logs.stdout)
-  pushBuildCommandOutput(commandStderr, logs.stderr)
-}
-
-const pushBuildCommandOutput = function (output, logsArray) {
-  if (output === '') {
-    return
-  }
-
-  logsArray.push(output)
-}
-
-// Start plugin step output
-export const pipePluginOutput = function (childProcess, logs) {
-  if (logs === undefined) {
-    return streamOutput(childProcess)
-  }
-
-  return pushOutputToLogs(childProcess, logs)
-}
-
-// Stop streaming/buffering plugin step output
-export const unpipePluginOutput = async function (childProcess, logs, listeners) {
-  // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
-  await pSetTimeout(0)
-
-  if (logs === undefined) {
-    return unstreamOutput(childProcess)
-  }
-
-  unpushOutputToLogs(childProcess, logs, listeners)
-}
-
-// Usually, we stream stdout/stderr because it is more efficient
-const streamOutput = function (childProcess) {
-  childProcess.stdout.pipe(stdout)
-  childProcess.stderr.pipe(stderr)
-}
-
-const unstreamOutput = function (childProcess) {
-  childProcess.stdout.unpipe(stdout)
-  childProcess.stderr.unpipe(stderr)
-}
-
-// In tests, we push to the `logs` array instead
-const pushOutputToLogs = function (childProcess, logs) {
-  const stdoutListener = logsListener.bind(null, logs.stdout)
-  const stderrListener = logsListener.bind(null, logs.stderr)
-  childProcess.stdout.on('data', stdoutListener)
-  childProcess.stderr.on('data', stderrListener)
-  return { stdoutListener, stderrListener }
-}
-
-const logsListener = function (logs, chunk) {
-  logs.push(chunk.toString().trimEnd())
-}
-
-const unpushOutputToLogs = function (childProcess, logs, { stdoutListener, stderrListener }) {
-  childProcess.stdout.removeListener('data', stdoutListener)
-  childProcess.stderr.removeListener('data', stderrListener)
-}

package/src/log/theme.js

@@ -1,26 +0,0 @@
-import chalk from 'chalk'
-
-// Color theme. Please use this instead of requiring chalk directly, to ensure
-// consistent colors.
-export const THEME = {
-  // Main headers
-  header: chalk.cyanBright.bold,
-  // Single lines used as subheaders
-  subHeader: chalk.cyan.bold,
-  // One of several words that should be highlighted inside a line
-  highlightWords: chalk.cyan,
-  // Same for errors
-  errorHeader: chalk.redBright.bold,
-  errorSubHeader: chalk.red.bold,
-  errorLine: chalk.redBright,
-  errorHighlightWords: chalk.redBright.bold,
-  // Same for warnings
-  warningHeader: chalk.yellowBright.bold,
-  warningSubHeader: chalk.yellow.bold,
-  warningLine: chalk.yellowBright,
-  warningHighlightWords: chalk.yellowBright.bold,
-  // One of several words that should be dimmed inside a line
-  dimWords: chalk.gray,
-  // No colors
-  none: (string) => string,
-}

package/src/plugins/child/diff.js

@@ -1,55 +0,0 @@
-import { isDeepStrictEqual } from 'util'
-
-import isPlainObj from 'is-plain-obj'
-import rfdc from 'rfdc'
-
-const clone = rfdc()
-
-// Copy `netlifyConfig` so we can compare before/after mutating it
-export const cloneNetlifyConfig = function (netlifyConfig) {
-  return clone(netlifyConfig)
-}
-
-// Diff `netlifyConfig` before and after mutating it to retrieve an array of
-// `configMutations` objects.
-// We need to keep track of the changes on `netlifyConfig` so they can be
-// processed later to:
-//  - Warn plugin authors when mutating read-only properties
-//  - Apply the change to `netlifyConfig` in the parent process so it can
-//    run `@netlify/config` to normalize and validate the new values
-// `configMutations` is passed to parent process as JSON
-export const getConfigMutations = function (netlifyConfig, netlifyConfigCopy, event) {
-  const configMutations = diffObjects(netlifyConfig, netlifyConfigCopy, [])
-  return configMutations.map((configMutation) => getConfigMutation(configMutation, event))
-}
-
-// We only recurse over plain objects, not arrays. Which means array properties
-// can only be modified all at once.
-const diffObjects = function (objA, objB, parentKeys) {
-  const allKeys = [...new Set([...Object.keys(objA), ...Object.keys(objB)])]
-  return allKeys.flatMap((key) => {
-    const valueA = objA[key]
-    const valueB = objB[key]
-    const keys = [...parentKeys, key]
-
-    if (isPlainObj(valueA) && isPlainObj(valueB)) {
-      return diffObjects(valueA, valueB, keys)
-    }
-
-    if (isDeepStrictEqual(valueA, valueB)) {
-      return []
-    }
-
-    return [{ keys, value: valueB }]
-  })
-}
-
-const getConfigMutation = function ({ keys, value }, event) {
-  const serializedKeys = keys.map(String)
-  return {
-    keys: serializedKeys,
-    keysString: serializedKeys.join('.'),
-    value,
-    event,
-  }
-}

package/src/plugins/child/error.js

@@ -1,32 +0,0 @@
-import logProcessErrors from 'log-process-errors'
-
-import { errorToJson } from '../../error/build.js'
-import { addDefaultErrorInfo, isBuildError } from '../../error/info.js'
-import { normalizeError } from '../../error/parse/normalize.js'
-import { sendEventToParent } from '../ipc.js'
-
-// Handle any top-level error and communicate it back to parent
-export const handleError = async function (error, verbose) {
-  const errorA = normalizeError(error)
-  addDefaultErrorInfo(errorA, { type: 'pluginInternal' })
-  const errorPayload = errorToJson(errorA)
-  await sendEventToParent('error', errorPayload, verbose, errorA)
-}
-
-// On uncaught exceptions and unhandled rejections, print the stack trace.
-// Also, prevent child processes from crashing on uncaught exceptions.
-export const handleProcessErrors = function () {
-  logProcessErrors({ log: handleProcessError, exitOn: [] })
-}
-
-const handleProcessError = async function (error, level, originalError) {
-  if (level !== 'error') {
-    console[level](error)
-    return
-  }
-
-  // Do not use log-process-errors prettification with errors thrown by `utils.build.*`
-  const errorA = isBuildError(originalError) ? originalError : error
-
-  await handleError(errorA)
-}

package/src/plugins/child/lazy.js

@@ -1,18 +0,0 @@
-import memoizeOne from 'memoize-one'
-
-// Add a `object[propName]` whose value is the return value of `getFunc()`, but
-// is only retrieved when accessed.
-export const addLazyProp = function (object, propName, getFunc) {
-  const mGetFunc = memoizeOne(getFunc, returnTrue)
-  // Mutation is required due to the usage of `Object.defineProperty()`
-  // eslint-disable-next-line fp/no-mutating-methods
-  Object.defineProperty(object, propName, {
-    get: mGetFunc,
-    enumerable: true,
-    configurable: true,
-  })
-}
-
-const returnTrue = function () {
-  return true
-}

package/src/plugins/child/load.js

@@ -1,29 +0,0 @@
-import filterObj from 'filter-obj'
-
-import { getLogic } from './logic.js'
-import { registerTypeScript } from './typescript.js'
-import { validatePlugin } from './validate.js'
-
-// Load context passed to every plugin method.
-// This also requires the plugin file and fire its top-level function.
-// This also validates the plugin.
-// Do it when parent requests it using the `load` event.
-// Also figure out the list of plugin steps. This is also passed to the parent.
-export const load = async function ({ pluginPath, inputs, packageJson, verbose }) {
-  const tsNodeService = registerTypeScript(pluginPath)
-  const logic = await getLogic({ pluginPath, inputs, tsNodeService })
-
-  validatePlugin(logic)
-
-  const methods = filterObj(logic, isEventHandler)
-  const events = Object.keys(methods)
-
-  // Context passed to every event handler
-  const context = { methods, inputs, packageJson, verbose }
-
-  return { events, context }
-}
-
-const isEventHandler = function (event, value) {
-  return typeof value === 'function'
-}

package/src/plugins/child/logic.js

@@ -1,57 +0,0 @@
-import { createRequire } from 'module'
-import { pathToFileURL } from 'url'
-
-import { addTsErrorInfo } from './typescript.js'
-
-const require = createRequire(import.meta.url)
-
-// Require the plugin file and fire its top-level function.
-// The returned object is the `logic` which includes all event handlers.
-export const getLogic = async function ({ pluginPath, inputs, tsNodeService }) {
-  const logic = await importLogic(pluginPath, tsNodeService)
-  const logicA = loadLogic({ logic, inputs })
-  return logicA
-}
-
-const importLogic = async function (pluginPath, tsNodeService) {
-  try {
-    // `ts-node` is not available programmatically for pure ES modules yet,
-    // which is currently making it impossible for local plugins to use both
-    // pure ES modules and TypeScript.
-    if (tsNodeService !== undefined) {
-      // eslint-disable-next-line import/no-dynamic-require
-      return require(pluginPath)
-    }
-
-    // `pluginPath` is an absolute file path but `import()` needs URLs.
-    // Converting those with `pathToFileURL()` is needed especially on Windows
-    // where the drive letter would not work with `import()`.
-    const returnValue = await import(pathToFileURL(pluginPath))
-    // Plugins should use named exports, but we still support default exports
-    // for backward compatibility with CommonJS
-    return returnValue.default === undefined ? returnValue : returnValue.default
-  } catch (error) {
-    addTsErrorInfo(error, tsNodeService)
-    // We must change `error.stack` instead of `error.message` because some
-    // errors thrown from `import()` access `error.stack` before throwing.
-    // `error.stack` is lazily instantiated by Node.js, so changing
-    // `error.message` afterwards would not modify `error.stack`. Therefore, the
-    // resulting stack trace, which is printed in the build logs, would not
-    // include the additional message prefix.
-    error.stack = `Could not import plugin:\n${error.stack}`
-    throw error
-  }
-}
-
-const loadLogic = function ({ logic, inputs }) {
-  if (typeof logic !== 'function') {
-    return logic
-  }
-
-  try {
-    return logic(inputs)
-  } catch (error) {
-    error.message = `Could not load plugin:\n${error.message}`
-    throw error
-  }
-}

package/src/plugins/child/main.js

@@ -1,51 +0,0 @@
-import { setInspectColors } from '../../log/colors.js'
-import { sendEventToParent, getEventsFromParent } from '../ipc.js'
-
-import { handleProcessErrors, handleError } from './error.js'
-import { load } from './load.js'
-import { run } from './run.js'
-
-// Boot plugin child process.
-const bootPlugin = async function () {
-  const state = { context: { verbose: false } }
-
-  try {
-    handleProcessErrors()
-    setInspectColors()
-
-    // We need to fire them in parallel because `process.send()` can be slow
-    // to await, i.e. parent might send `load` event before child `ready` event
-    // returns.
-    await Promise.all([handleEvents(state), sendEventToParent('ready', {}, false)])
-  } catch (error) {
-    await handleError(error, state.context.verbose)
-  }
-}
-
-// Wait for events from parent to perform plugin methods
-const handleEvents = async function (state) {
-  await getEventsFromParent((callId, eventName, payload) => handleEvent({ callId, eventName, payload, state }))
-}
-
-// Each event can pass `context` information to the next event
-const handleEvent = async function ({
-  callId,
-  eventName,
-  payload,
-  state,
-  state: {
-    context: { verbose },
-  },
-}) {
-  try {
-    const { context, ...response } = await EVENTS[eventName](payload, state.context)
-    state.context = { ...state.context, ...context }
-    await sendEventToParent(callId, response, verbose)
-  } catch (error) {
-    await handleError(error, verbose)
-  }
-}
-
-const EVENTS = { load, run }
-
-bootPlugin()

package/src/plugins/child/run.js

@@ -1,28 +0,0 @@
-import { getNewEnvChanges, setEnvChanges } from '../../env/changes.js'
-import { logPluginMethodStart, logPluginMethodEnd } from '../../log/messages/ipc.js'
-
-import { cloneNetlifyConfig, getConfigMutations } from './diff.js'
-import { getUtils } from './utils.js'
-
-// Run a specific plugin event handler
-export const run = async function (
-  { event, error, constants, envChanges, netlifyConfig },
-  { methods, inputs, packageJson, verbose },
-) {
-  const method = methods[event]
-  const runState = {}
-  const utils = getUtils({ event, constants, runState })
-  const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig)
-  const runOptions = { utils, constants, inputs, netlifyConfig: netlifyConfigCopy, packageJson, error }
-
-  const envBefore = setEnvChanges(envChanges)
-
-  logPluginMethodStart(verbose)
-  await method(runOptions)
-  logPluginMethodEnd(verbose)
-
-  const newEnvChanges = getNewEnvChanges(envBefore, netlifyConfig, netlifyConfigCopy)
-
-  const configMutations = getConfigMutations(netlifyConfig, netlifyConfigCopy, event)
-  return { ...runState, newEnvChanges, configMutations }
-}

package/src/plugins/child/status.js

@@ -1,67 +0,0 @@
-import isPlainObj from 'is-plain-obj'
-import mapObj from 'map-obj'
-
-import { addErrorInfo } from '../../error/info.js'
-
-// Report status information to the UI
-export const show = function (runState, showArgs) {
-  validateShowArgs(showArgs)
-  const { title, summary, text } = removeEmptyStrings(showArgs)
-  runState.status = { state: 'success', title, summary, text }
-}
-
-// Validate arguments of `utils.status.show()`
-const validateShowArgs = function (showArgs) {
-  try {
-    validateShowArgsObject(showArgs)
-    const { title, summary, text, ...otherArgs } = showArgs
-    validateShowArgsKeys(otherArgs)
-    Object.entries({ title, summary, text }).forEach(validateStringArg)
-    validateShowArgsSummary(summary)
-  } catch (error) {
-    error.message = `utils.status.show() ${error.message}`
-    addErrorInfo(error, { type: 'pluginValidation' })
-    throw error
-  }
-}
-
-const validateShowArgsObject = function (showArgs) {
-  if (showArgs === undefined) {
-    throw new Error('requires an argument')
-  }
-
-  if (!isPlainObj(showArgs)) {
-    throw new Error('argument must be a plain object')
-  }
-}
-
-const validateShowArgsKeys = function (otherArgs) {
-  const otherKeys = Object.keys(otherArgs).map((arg) => `"${arg}"`)
-  if (otherKeys.length !== 0) {
-    throw new Error(`must only contain "title", "summary" or "text" properties, not ${otherKeys.join(', ')}`)
-  }
-}
-
-const validateStringArg = function ([key, value]) {
-  if (value !== undefined && typeof value !== 'string') {
-    throw new Error(`"${key}" property must be a string`)
-  }
-}
-
-const validateShowArgsSummary = function (summary) {
-  if (summary === undefined || summary.trim() === '') {
-    throw new Error('requires specifying a "summary" property')
-  }
-}
-
-const removeEmptyStrings = function (showArgs) {
-  return mapObj(showArgs, removeEmptyString)
-}
-
-const removeEmptyString = function (key, value) {
-  if (typeof value === 'string' && value.trim() === '') {
-    return [key]
-  }
-
-  return [key, value]
-}

package/src/plugins/child/typescript.js

@@ -1,45 +0,0 @@
-import { extname } from 'path'
-
-import { register } from 'ts-node'
-
-import { addErrorInfo } from '../../error/info.js'
-
-// Allow local plugins to be written with TypeScript.
-// Local plugins cannot be transpiled by the build command since they can be run
-// before it. Therefore, we type-check and transpile them automatically using
-// `ts-node`.
-export const registerTypeScript = function (pluginPath) {
-  if (!isTypeScriptPlugin(pluginPath)) {
-    return
-  }
-
-  return register()
-}
-
-// On TypeScript errors, adds information about the `ts-node` configuration,
-// which includes the resolved `tsconfig.json`.
-export const addTsErrorInfo = function (error, tsNodeService) {
-  if (tsNodeService === undefined) {
-    return
-  }
-
-  const {
-    config: {
-      raw: { compilerOptions },
-    },
-    options: realTsNodeOptions,
-  } = tsNodeService
-
-  // filter out functions as they cannot be serialized
-  const tsNodeOptions = Object.fromEntries(
-    Object.entries(realTsNodeOptions).filter(([, val]) => typeof val !== 'function'),
-  )
-
-  addErrorInfo(error, { tsConfig: { compilerOptions, tsNodeOptions } })
-}
-
-const isTypeScriptPlugin = function (pluginPath) {
-  return TYPESCRIPT_EXTENSIONS.has(extname(pluginPath))
-}
-
-const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts'])

package/src/plugins/child/utils.js

@@ -1,56 +0,0 @@
-import { bindOpts as cacheBindOpts } from '@netlify/cache-utils'
-import { add as functionsAdd, list as functionsList, listAll as functionsListAll } from '@netlify/functions-utils'
-import { getGitUtils } from '@netlify/git-utils'
-import { run, runCommand } from '@netlify/run-utils'
-
-import { failBuild, failPlugin, cancelBuild, failPluginWithWarning } from '../error.js'
-import { isSoftFailEvent } from '../events.js'
-
-import { addLazyProp } from './lazy.js'
-import { show } from './status.js'
-
-// Retrieve the `utils` argument.
-export const getUtils = function ({
-  event,
-  constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR },
-  runState,
-}) {
-  // eslint-disable-next-line fp/no-mutation
-  run.command = runCommand
-
-  const build = getBuildUtils(event)
-  const cache = getCacheUtils(CACHE_DIR)
-  const functions = getFunctionsUtils(FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC)
-  const status = getStatusUtils(runState)
-  const utils = { build, cache, run, functions, status }
-  addLazyProp(utils, 'git', () => getGitUtils())
-  return utils
-}
-
-const getBuildUtils = function (event) {
-  if (isSoftFailEvent(event)) {
-    return {
-      failPlugin,
-      failBuild: failPluginWithWarning.bind(null, 'failBuild', event),
-      cancelBuild: failPluginWithWarning.bind(null, 'cancelBuild', event),
-    }
-  }
-
-  return { failBuild, failPlugin, cancelBuild }
-}
-
-const getCacheUtils = function (CACHE_DIR) {
-  return cacheBindOpts({ cacheDir: CACHE_DIR })
-}
-
-const getFunctionsUtils = function (FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC) {
-  const functionsDirectories = [INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC].filter(Boolean)
-  const add = (src) => functionsAdd(src, INTERNAL_FUNCTIONS_SRC, { fail: failBuild })
-  const list = functionsList.bind(null, functionsDirectories, { fail: failBuild })
-  const listAll = functionsListAll.bind(null, functionsDirectories, { fail: failBuild })
-  return { add, list, listAll }
-}
-
-const getStatusUtils = function (runState) {
-  return { show: show.bind(undefined, runState) }
-}

package/src/plugins/child/validate.js

@@ -1,34 +0,0 @@
-import { addErrorInfo } from '../../error/info.js'
-import { serializeArray } from '../../log/serialize.js'
-import { EVENTS } from '../events.js'
-
-// Validate the shape of a plugin return value
-export const validatePlugin = function (logic) {
-  try {
-    // This validation must work with the return value of `import()` which has
-    // a `Module` prototype, not `Object`
-    if (typeof logic !== 'object' || logic === null) {
-      throw new Error('Plugin must be an object or a function')
-    }
-
-    Object.entries(logic).forEach(([propName, value]) => {
-      validateEventHandler(value, propName)
-    })
-  } catch (error) {
-    addErrorInfo(error, { type: 'pluginValidation' })
-    throw error
-  }
-}
-
-// All other properties are event handlers
-const validateEventHandler = function (value, propName) {
-  if (!EVENTS.includes(propName)) {
-    throw new Error(`Invalid event '${propName}'.
-Please use a valid event name. One of:
-${serializeArray(EVENTS)}`)
-  }
-
-  if (typeof value !== 'function') {
-    throw new TypeError(`Invalid event handler '${propName}': must be a function`)
-  }
-}