@netlify/build 0.5.0 → 1.0.0-dl-test

package/src/core/commands.js

@@ -1,304 +0,0 @@
-const { platform } = require('process')
-
-const execa = require('execa')
-const pReduce = require('p-reduce')
-
-const { setEnvChanges } = require('../env/changes.js')
-const { addErrorInfo, getErrorInfo } = require('../error/info')
-const { reportBuildError } = require('../error/monitor/report')
-const { serializeErrorStatus } = require('../error/parse/serialize_status')
-const { logCommand, logBuildCommandStart, logCommandSuccess, logPluginError } = require('../log/main')
-const { pipeOutput, unpipeOutput } = require('../log/stream')
-const { startTimer, endTimer } = require('../log/timer')
-const { EVENTS } = require('../plugins/events')
-const { callChild } = require('../plugins/ipc')
-const { getSuccessStatus, addStatus } = require('../status/add')
-
-// Get commands for all events
-const getCommands = function(pluginsCommands, netlifyConfig) {
-  const commands = addBuildCommand(pluginsCommands, netlifyConfig)
-  const commandsA = sortCommands(commands)
-  const commandsCount = commandsA.filter(isSuccessCommand).length
-  return { commands: commandsA, commandsCount }
-}
-
-// Merge `build.command` with plugin event handlers
-const addBuildCommand = function(pluginsCommands, { build: { command: buildCommand } }) {
-  if (buildCommand === undefined) {
-    return pluginsCommands
-  }
-
-  return [{ event: 'onBuild', buildCommand }, ...pluginsCommands]
-}
-
-// Sort plugin commands by event order.
-const sortCommands = function(commands) {
-  return EVENTS.flatMap(event => commands.filter(command => command.event === event))
-}
-
-const isMainCommand = function({ event }) {
-  return event !== 'onEnd' && event !== 'onError'
-}
-
-const isEndCommand = function({ event }) {
-  return event === 'onEnd'
-}
-
-const isErrorCommand = function({ event }) {
-  return event === 'onError'
-}
-
-const isSuccessCommand = function({ event }) {
-  return isMainCommand({ event }) || isEndCommand({ event })
-}
-
-// Run all commands.
-// Each command can change some state: last `error`, environment variables changes,
-// list of `failedPlugins` (that ran `utils.build.failPlugin()`).
-// If an error arises, runs `onError` events.
-// Runs `onEnd` events at the end, whether an error was thrown or not.
-const runCommands = async function({
-  commands,
-  configPath,
-  buildDir,
-  nodePath,
-  childEnv,
-  errorMonitor,
-  netlifyConfig,
-}) {
-  const { index: commandsCount, error: errorA, statuses: statusesB } = await pReduce(
-    commands,
-    async (
-      { index, error, failedPlugins, envChanges, statuses },
-      { event, childProcess, package, packageJson, loadedFrom, origin, buildCommand },
-    ) => {
-      const { newIndex = index, newError = error, failedPlugin = [], newEnvChanges = {}, newStatus } = await runCommand(
-        {
-          event,
-          childProcess,
-          package,
-          packageJson,
-          loadedFrom,
-          origin,
-          buildCommand,
-          configPath,
-          buildDir,
-          nodePath,
-          index,
-          childEnv,
-          envChanges,
-          commands,
-          errorMonitor,
-          error,
-          failedPlugins,
-          netlifyConfig,
-        },
-      )
-      const statusesA = addStatus({ newStatus, statuses, event, package, packageJson })
-      return {
-        index: newIndex,
-        error: newError,
-        failedPlugins: [...failedPlugins, ...failedPlugin],
-        envChanges: { ...envChanges, ...newEnvChanges },
-        statuses: statusesA,
-      }
-    },
-    { index: 0, failedPlugins: [], envChanges: {}, statuses: [] },
-  )
-  return { commandsCount, error: errorA, statuses: statusesB }
-}
-
-// Run a command (shell or plugin)
-const runCommand = async function({
-  event,
-  childProcess,
-  package,
-  packageJson,
-  loadedFrom,
-  origin,
-  buildCommand,
-  configPath,
-  buildDir,
-  nodePath,
-  index,
-  childEnv,
-  envChanges,
-  commands,
-  errorMonitor,
-  error,
-  failedPlugins,
-  netlifyConfig,
-}) {
-  if (shouldSkipCommand({ event, package, error, failedPlugins })) {
-    return {}
-  }
-
-  const methodTimer = startTimer()
-
-  logCommand({ event, package, index, configPath, error })
-
-  const { newEnvChanges, newError, newStatus } = await fireCommand({
-    event,
-    childProcess,
-    package,
-    packageJson,
-    loadedFrom,
-    origin,
-    buildCommand,
-    configPath,
-    buildDir,
-    nodePath,
-    childEnv,
-    envChanges,
-    commands,
-    error,
-  })
-
-  const newValues =
-    newError === undefined
-      ? handleCommandSuccess({ event, package, newEnvChanges, newStatus, methodTimer })
-      : await handleCommandError({ newError, errorMonitor, buildCommand, netlifyConfig })
-  return { ...newValues, newIndex: index + 1 }
-}
-
-// If either:
-//   - an error was thrown by the current plugin or another one
-//   - the current plugin previously ran `utils.build.failPlugin()`, `failBuild()` or `cancelBuild()`
-// Then:
-//   - run `onError` event (otherwise not run)
-//   - run `onEnd` event (always run regardless)
-//   - skip other events
-const shouldSkipCommand = function({ event, package, error, failedPlugins }) {
-  const isError = error !== undefined || failedPlugins.includes(package)
-  return (isMainCommand({ event }) && isError) || (isErrorCommand({ event }) && !isError)
-}
-
-const fireCommand = function({
-  event,
-  childProcess,
-  package,
-  packageJson,
-  loadedFrom,
-  origin,
-  buildCommand,
-  configPath,
-  buildDir,
-  nodePath,
-  childEnv,
-  envChanges,
-  commands,
-  error,
-}) {
-  if (buildCommand !== undefined) {
-    return fireBuildCommand({ buildCommand, configPath, buildDir, nodePath, childEnv, envChanges })
-  }
-
-  return firePluginCommand({
-    event,
-    childProcess,
-    package,
-    packageJson,
-    loadedFrom,
-    origin,
-    envChanges,
-    commands,
-    error,
-  })
-}
-
-// Fire `build.command`
-const fireBuildCommand = async function({ buildCommand, configPath, buildDir, nodePath, childEnv, envChanges }) {
-  logBuildCommandStart(buildCommand)
-
-  const env = setEnvChanges(envChanges, { ...childEnv })
-  const childProcess = execa(buildCommand, {
-    shell: SHELL,
-    cwd: buildDir,
-    preferLocal: true,
-    execPath: nodePath,
-    env,
-    extendEnv: false,
-    stdio: 'inherit',
-  })
-
-  try {
-    await childProcess
-    return {}
-  } catch (newError) {
-    addErrorInfo(newError, { type: 'buildCommand', location: { buildCommand, configPath } })
-    return { newError }
-  }
-}
-
-// We use Bash on Unix and `cmd.exe` on Windows
-const SHELL = platform === 'win32' ? true : 'bash'
-
-// Fire a plugin command
-const firePluginCommand = async function({
-  event,
-  childProcess,
-  package,
-  packageJson,
-  loadedFrom,
-  origin,
-  envChanges,
-  commands,
-  error,
-}) {
-  pipeOutput(childProcess)
-
-  try {
-    const { newEnvChanges, status } = await callChild(
-      childProcess,
-      'run',
-      { event, error, envChanges },
-      { plugin: { packageJson, package }, location: { event, package, loadedFrom, origin } },
-    )
-    const newStatus = getSuccessStatus(status, { commands, event, package })
-    return { newEnvChanges, newStatus }
-  } catch (newError) {
-    return { newError }
-  } finally {
-    unpipeOutput(childProcess)
-  }
-}
-
-// `build.command` or plugin event handle success
-const handleCommandSuccess = function({ event, package, newEnvChanges, newStatus, methodTimer }) {
-  logCommandSuccess()
-
-  const timerName = package === undefined ? 'build.command' : `${package} ${event}`
-  endTimer(methodTimer, timerName)
-
-  return { newEnvChanges, newStatus }
-}
-
-// Handle shell or plugin error:
-//  - usually (`failFast`), propagate the error to make the build stop.
-//  - if onError and onEnd events (not `failFast`), wait until all event
-//    handlers of the same type have been triggered before propagating
-//  - if `utils.build.failPlugin()` was used, print an error and skip next event
-//    handlers of that plugin. But do not stop build.
-const handleCommandError = async function({ newError, errorMonitor, buildCommand, netlifyConfig }) {
-  // `build.command` do not report error statuses
-  if (buildCommand !== undefined) {
-    return { newError }
-  }
-
-  const { type, location: { package } = {} } = getErrorInfo(newError)
-  const newStatus = serializeErrorStatus(newError)
-
-  if (type === 'failPlugin') {
-    return handleFailPlugin({ newStatus, package, newError, errorMonitor, netlifyConfig })
-  }
-
-  return { newError, newStatus }
-}
-
-const handleFailPlugin = async function({ newStatus, package, newError, errorMonitor, netlifyConfig }) {
-  logPluginError(newError, netlifyConfig)
-  await reportBuildError(newError, errorMonitor)
-  return { failedPlugin: [package], newStatus }
-}
-
-module.exports = { getCommands, isSuccessCommand, runCommands }

package/src/core/config.js

@@ -1,130 +0,0 @@
-const {
-  env: { NETLIFY_AUTH_TOKEN },
-  execPath,
-} = require('process')
-
-const resolveConfig = require('@netlify/config')
-
-const { addApiErrorHandlers } = require('../error/api')
-const { addErrorInfo } = require('../error/info')
-const { logFlags, logBuildDir, logConfigPath, logConfig, logContext } = require('../log/main')
-const { removeFalsy } = require('../utils/remove_falsy')
-
-const { getConstants } = require('./constants')
-
-// Normalize CLI flags
-const normalizeFlags = function(flags) {
-  const flagsA = removeFalsy(flags)
-  logFlags(flagsA)
-
-  const flagsB = { ...DEFAULT_FLAGS, ...flagsA }
-  const flagsC = removeFalsy(flagsB)
-  return flagsC
-}
-
-// Default values of CLI flags
-const DEFAULT_FLAGS = {
-  nodePath: execPath,
-  token: NETLIFY_AUTH_TOKEN,
-  mode: 'require',
-}
-
-// Retrieve configuration object
-const loadConfig = async function({
-  config,
-  defaultConfig,
-  cachedConfig,
-  cwd,
-  repositoryRoot,
-  dry,
-  nodePath,
-  token,
-  siteId,
-  context,
-  branch,
-  baseRelDir,
-  mode,
-}) {
-  const {
-    configPath,
-    buildDir,
-    config: netlifyConfig,
-    context: contextA,
-    branch: branchA,
-    api,
-    siteInfo,
-  } = await resolveFullConfig({
-    config,
-    defaultConfig,
-    cachedConfig,
-    cwd,
-    repositoryRoot,
-    context,
-    branch,
-    baseRelDir,
-    token,
-    siteId,
-    mode,
-  })
-  logBuildDir(buildDir)
-  logConfigPath(configPath)
-  logConfig(netlifyConfig)
-  logContext(contextA)
-
-  const apiA = addApiErrorHandlers(api)
-  const constants = await getConstants({ configPath, buildDir, netlifyConfig, siteInfo, mode })
-  return {
-    netlifyConfig,
-    configPath,
-    buildDir,
-    nodePath,
-    api: apiA,
-    token,
-    dry,
-    siteInfo,
-    constants,
-    context: contextA,
-    branch: branchA,
-    mode,
-  }
-}
-
-// Retrieve configuration file and related information
-// (path, build directory, etc.)
-const resolveFullConfig = async function({
-  config,
-  defaultConfig,
-  cachedConfig,
-  cwd,
-  repositoryRoot,
-  context,
-  branch,
-  baseRelDir,
-  token,
-  siteId,
-  mode,
-}) {
-  try {
-    return await resolveConfig({
-      config,
-      defaultConfig,
-      cachedConfig,
-      cwd,
-      repositoryRoot,
-      context,
-      branch,
-      baseRelDir,
-      token,
-      siteId,
-      mode,
-    })
-  } catch (error) {
-    if (error.type === 'userError') {
-      delete error.type
-      addErrorInfo(error, { type: 'resolveConfig' })
-    }
-    throw error
-  }
-}
-
-module.exports = { normalizeFlags, loadConfig }

package/src/core/constants.js

@@ -1,86 +0,0 @@
-const { tmpdir } = require('os')
-const { relative, normalize } = require('path')
-const {
-  env: { DEPLOY_ID },
-} = require('process')
-
-const { getCacheDir } = require('@netlify/cache-utils')
-const mapObj = require('map-obj')
-
-// Retrieve constants passed to plugins
-const getConstants = async function({
-  configPath,
-  buildDir,
-  netlifyConfig: {
-    build: { publish = buildDir, functions },
-  },
-  siteInfo: { id: siteId },
-  mode,
-}) {
-  const isLocal = mode !== 'buildbot'
-  const functionsDist = getFunctionsDist(isLocal)
-  const cacheDir = await getCacheDir({ mode })
-
-  const constants = {
-    /**
-     * Path to the Netlify configuration file
-     */
-    CONFIG_PATH: configPath,
-    /**
-     * Directory that contains the deploy-ready HTML files and assets generated by the build
-     */
-    PUBLISH_DIR: publish,
-    /**
-     * The directory where function source code lives
-     */
-    FUNCTIONS_SRC: functions,
-    /**
-     * The directory where built serverless functions are placed before deployment
-     */
-    FUNCTIONS_DIST: functionsDist,
-    /**
-     * Path to the Netlify build cache folder
-     */
-    CACHE_DIR: cacheDir,
-    /**
-     * Boolean indicating whether the build was run locally (Netlify CLI) or in the production CI
-     */
-    IS_LOCAL: isLocal,
-    /**
-     * The Netlify Site ID
-     */
-    SITE_ID: siteId,
-  }
-  const constantsA = mapObj(constants, (key, path) => [key, normalizePath(path, buildDir, key)])
-  return constantsA
-}
-
-const LOCAL_FUNCTIONS_DIST = '.netlify/functions/'
-const getFunctionsDist = function(isLocal) {
-  if (isLocal) {
-    return LOCAL_FUNCTIONS_DIST
-  }
-
-  return `${tmpdir()}/zisi-${DEPLOY_ID}`
-}
-
-// The current directory is `buildDir`. Most constants are inside this `buildDir`.
-// Instead of passing absolute paths, we pass paths relative to `buildDir`, so
-// that logs are less verbose.
-const normalizePath = function(path, buildDir, key) {
-  if (path === undefined || NOT_PATHS.includes(key)) {
-    return path
-  }
-
-  const pathA = normalize(path)
-
-  if (pathA.startsWith(buildDir) && pathA !== buildDir) {
-    return relative(buildDir, pathA)
-  }
-
-  return pathA
-}
-
-const NOT_PATHS = ['IS_LOCAL', 'SITE_ID']
-
-module.exports = { getConstants }

package/src/core/dry.js

@@ -1,23 +0,0 @@
-const { logDryRunStart, logDryRunCommand, logDryRunEnd } = require('../log/main')
-
-const { isSuccessCommand } = require('./commands')
-
-// If the `dry` flag is specified, do a dry run
-const doDryRun = function({ commands, commandsCount, configPath }) {
-  const successCommands = commands.filter(isSuccessCommand)
-  const eventWidth = Math.max(...successCommands.map(getEventLength))
-
-  logDryRunStart(eventWidth, commandsCount)
-
-  successCommands.forEach((command, index) => {
-    logDryRunCommand({ command, index, configPath, eventWidth, commandsCount })
-  })
-
-  logDryRunEnd()
-}
-
-const getEventLength = function({ event }) {
-  return event.length
-}
-
-module.exports = { doDryRun }