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

package/src/plugins_core/add.js

@@ -1,49 +0,0 @@
-import { listCorePlugins, isCorePlugin } from './list.js'
-
-// Add core plugins and user plugins together.
-// Do not allow user override of core plugins.
-export const addCorePlugins = function ({ netlifyConfig: { plugins }, constants }) {
-  const corePlugins = listCorePlugins(constants)
-  const allCorePlugins = corePlugins
-    .map((corePlugin) => addCoreProperties(corePlugin, plugins))
-    .filter((corePlugin) => !isOptionalCore(corePlugin, plugins))
-  const userPlugins = plugins.filter(isUserPlugin)
-  const allPlugins = [...userPlugins, ...allCorePlugins]
-  const pluginsOptions = allPlugins.map(normalizePluginOptions)
-  return pluginsOptions
-}
-
-const addCoreProperties = function (corePlugin, plugins) {
-  const inputs = getCorePluginInputs(corePlugin, plugins)
-  return { ...corePlugin, inputs, loadedFrom: 'core', origin: 'core' }
-}
-
-// Core plugins can get inputs too
-const getCorePluginInputs = function (corePlugin, plugins) {
-  const configuredCorePlugin = plugins.find((plugin) => plugin.package === corePlugin.package)
-  if (configuredCorePlugin === undefined) {
-    return {}
-  }
-
-  return configuredCorePlugin.inputs
-}
-
-// Optional core plugins requires user opt-in
-const isOptionalCore = function (pluginA, plugins) {
-  return pluginA.optional && plugins.every((pluginB) => pluginB.package !== pluginA.package)
-}
-
-const isUserPlugin = function (plugin) {
-  return !isCorePlugin(plugin.package)
-}
-
-const normalizePluginOptions = function ({
-  package: packageName,
-  pluginPath,
-  pinned_version: pinnedVersion,
-  loadedFrom,
-  origin,
-  inputs,
-}) {
-  return { packageName, pluginPath, pinnedVersion, loadedFrom, origin, inputs }
-}

package/src/plugins_core/build_command.js

@@ -1,75 +0,0 @@
-import { platform } from 'process'
-
-import { execa } from 'execa'
-
-import { addErrorInfo } from '../error/info.js'
-import { getBuildCommandDescription } from '../log/description.js'
-import { logBuildCommandStart } from '../log/messages/steps.js'
-import { getBuildCommandStdio, handleBuildCommandOutput } from '../log/stream.js'
-
-// Fire `build.command`
-const coreStep = async function ({
-  configPath,
-  buildDir,
-  nodePath,
-  childEnv,
-  logs,
-  netlifyConfig: {
-    build: { command: buildCommand, commandOrigin: buildCommandOrigin },
-  },
-}) {
-  logBuildCommandStart(logs, buildCommand)
-
-  const stdio = getBuildCommandStdio(logs)
-  const childProcess = execa(buildCommand, {
-    shell: SHELL,
-    cwd: buildDir,
-    preferLocal: true,
-    execPath: nodePath,
-    env: childEnv,
-    extendEnv: false,
-    stdio,
-  })
-
-  try {
-    const buildCommandOutput = await childProcess
-    handleBuildCommandOutput(buildCommandOutput, logs)
-    return {}
-  } catch (error) {
-    // In our test environment we use `stdio: 'pipe'` on the build command, meaning our `stdout/stderr` output are
-    // buffered and consequently added to `error.message`. To avoid this and end up with duplicated output in our
-    // logs/snapshots we need to rely on `error.shortMessage`.
-    error.message = error.shortMessage
-    handleBuildCommandOutput(error, logs)
-    addErrorInfo(error, { type: 'buildCommand', location: { buildCommand, buildCommandOrigin, configPath } })
-    throw error
-  }
-}
-
-// We use Bash on Unix and `cmd.exe` on Windows
-const SHELL = platform === 'win32' ? true : 'bash'
-
-const coreStepDescription = function ({
-  netlifyConfig: {
-    build: { commandOrigin: buildCommandOrigin },
-  },
-}) {
-  return getBuildCommandDescription(buildCommandOrigin)
-}
-
-const hasBuildCommand = function ({
-  netlifyConfig: {
-    build: { command: buildCommand },
-  },
-}) {
-  return buildCommand !== undefined && buildCommand !== ''
-}
-
-export const buildCommandCore = {
-  event: 'onBuild',
-  coreStep,
-  coreStepId: 'build_command',
-  coreStepName: 'build.command',
-  coreStepDescription,
-  condition: hasBuildCommand,
-}

package/src/plugins_core/deploy/buildbot_client.js

@@ -1,102 +0,0 @@
-import net from 'net'
-import { normalize, resolve, relative } from 'path'
-import { promisify } from 'util'
-
-import { pEvent } from 'p-event'
-
-import { addErrorInfo } from '../../error/info.js'
-import { runsAfterDeploy } from '../../plugins/events.js'
-import { addAsyncErrorMessage } from '../../utils/errors.js'
-
-export const createBuildbotClient = function (buildbotServerSocket) {
-  const connectionOpts = getConnectionOpts(buildbotServerSocket)
-  const client = net.createConnection(connectionOpts)
-  return client
-}
-
-// Windows does not support Unix sockets well, so we also support `host:port`
-const getConnectionOpts = function (buildbotServerSocket) {
-  if (!buildbotServerSocket.includes(':')) {
-    return { path: buildbotServerSocket }
-  }
-
-  const [host, port] = buildbotServerSocket.split(':')
-  return { host, port }
-}
-
-const eConnectBuildbotClient = async function (client) {
-  await pEvent(client, 'connect')
-}
-
-export const connectBuildbotClient = addAsyncErrorMessage(eConnectBuildbotClient, 'Could not connect to buildbot')
-
-export const closeBuildbotClient = async function (client) {
-  if (client.destroyed) {
-    return
-  }
-
-  await promisify(client.end.bind(client))()
-}
-
-const cWritePayload = async function (buildbotClient, payload) {
-  await promisify(buildbotClient.write.bind(buildbotClient))(JSON.stringify(payload))
-}
-
-const writePayload = addAsyncErrorMessage(cWritePayload, 'Could not send payload to buildbot')
-
-const cGetNextParsedResponsePromise = async function (buildbotClient) {
-  const data = await pEvent(buildbotClient, 'data')
-  return JSON.parse(data)
-}
-
-const getNextParsedResponsePromise = addAsyncErrorMessage(
-  cGetNextParsedResponsePromise,
-  'Invalid response from buildbot',
-)
-
-export const deploySiteWithBuildbotClient = async function ({ client, events, buildDir, repositoryRoot, constants }) {
-  const action = shouldWaitForPostProcessing(events) ? 'deploySiteAndAwaitLive' : 'deploySite'
-  const deployDir = getDeployDir({ buildDir, repositoryRoot, constants })
-  const payload = { action, deployDir }
-
-  const [{ succeeded, values: { error, error_type: errorType } = {} }] = await Promise.all([
-    getNextParsedResponsePromise(client),
-    writePayload(client, payload),
-  ])
-
-  if (!succeeded) {
-    return handleDeployError(error, errorType)
-  }
-}
-
-// The file paths in the buildbot are relative to the repository root.
-// However, the file paths in Build plugins, including `constants.PUBLISH_DIR`
-// are relative to the build directory, which is different when there is a
-// base directory. This converts it.
-// We need to call `normalize()` in case the publish directory is the
-// repository root, so `deployDir` is "." not ""
-const getDeployDir = function ({ buildDir, repositoryRoot, constants: { PUBLISH_DIR } }) {
-  const absolutePublishDir = resolve(buildDir, PUBLISH_DIR)
-  const relativePublishDir = relative(repositoryRoot, absolutePublishDir)
-  const deployDir = normalize(relativePublishDir)
-  return deployDir
-}
-
-// We distinguish between user errors and system errors during deploys
-const handleDeployError = function (error, errorType) {
-  const errorA = new Error(`Deploy did not succeed: ${error}`)
-  const errorInfo =
-    errorType === 'user' ? { type: 'resolveConfig' } : { type: 'coreStep', location: { coreStepName: 'Deploy site' } }
-  addErrorInfo(errorA, errorInfo)
-  throw errorA
-}
-
-// We only wait for post-processing (last stage before site deploy) if the build
-// has some plugins that do post-deploy logic
-const shouldWaitForPostProcessing = function (events) {
-  return events.some(hasPostDeployLogic)
-}
-
-const hasPostDeployLogic = function (event) {
-  return runsAfterDeploy(event)
-}

package/src/plugins_core/deploy/index.js

@@ -1,73 +0,0 @@
-import { saveUpdatedConfig, restoreUpdatedConfig } from '../../core/config.js'
-import { logDeploySuccess } from '../../log/messages/plugins.js'
-
-import {
-  createBuildbotClient,
-  connectBuildbotClient,
-  closeBuildbotClient,
-  deploySiteWithBuildbotClient,
-} from './buildbot_client.js'
-
-const coreStep = async function ({
-  buildDir,
-  configPath,
-  repositoryRoot,
-  constants,
-  buildbotServerSocket,
-  events,
-  logs,
-  featureFlags,
-  context,
-  branch,
-  configMutations,
-  headersPath,
-  redirectsPath,
-  debug,
-  saveConfig,
-}) {
-  const client = createBuildbotClient(buildbotServerSocket)
-  try {
-    await connectBuildbotClient(client)
-    await saveUpdatedConfig({
-      configMutations,
-      buildDir,
-      repositoryRoot,
-      configPath,
-      headersPath,
-      redirectsPath,
-      logs,
-      featureFlags,
-      context,
-      branch,
-      debug,
-      saveConfig,
-    })
-    await deploySiteWithBuildbotClient({ client, events, buildDir, repositoryRoot, constants })
-    await restoreUpdatedConfig({
-      configMutations,
-      buildDir,
-      repositoryRoot,
-      configPath,
-      headersPath,
-      redirectsPath,
-      saveConfig,
-    })
-    logDeploySuccess(logs)
-    return {}
-  } finally {
-    await closeBuildbotClient(client)
-  }
-}
-
-const shouldDeploy = function ({ buildbotServerSocket }) {
-  return buildbotServerSocket !== undefined
-}
-
-export const deploySite = {
-  event: 'onPostBuild',
-  coreStep,
-  coreStepId: 'deploy_site',
-  coreStepName: 'Deploy site',
-  coreStepDescription: () => 'Deploy site',
-  condition: shouldDeploy,
-}

package/src/plugins_core/edge_functions/index.js

@@ -1,107 +0,0 @@
-import { promises as fs } from 'fs'
-import { dirname, join, resolve } from 'path'
-
-import { bundle, find } from '@netlify/edge-bundler'
-import { pathExists } from 'path-exists'
-
-import { logFunctionsToBundle } from '../../log/messages/core_steps.js'
-
-import { parseManifest } from './lib/internal_manifest.js'
-
-// TODO: Replace this with a custom cache directory.
-const DENO_CLI_CACHE_DIRECTORY = '.netlify/plugins/deno-cli'
-const IMPORT_MAP_FILENAME = 'edge-functions-import-map.json'
-
-const coreStep = async function ({
-  buildDir,
-  constants: {
-    EDGE_FUNCTIONS_DIST: distDirectory,
-    EDGE_FUNCTIONS_SRC: srcDirectory,
-    INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory,
-    IS_LOCAL: isRunningLocally,
-  },
-  debug,
-  featureFlags,
-  logs,
-  netlifyConfig,
-}) {
-  const { edge_functions: configDeclarations = [] } = netlifyConfig
-  const distPath = resolve(buildDir, distDirectory)
-  const internalSrcPath = resolve(buildDir, internalSrcDirectory)
-  const distImportMapPath = join(dirname(internalSrcPath), IMPORT_MAP_FILENAME)
-  const srcPath = srcDirectory ? resolve(buildDir, srcDirectory) : undefined
-  const sourcePaths = [internalSrcPath, srcPath].filter(Boolean)
-
-  logFunctions({ internalSrcDirectory, internalSrcPath, logs, srcDirectory, srcPath })
-
-  const { declarations: internalDeclarations, importMap } = await parseManifest(internalSrcPath)
-  const declarations = [...configDeclarations, ...internalDeclarations]
-
-  // If we're running in buildbot and the feature flag is enabled, we set the
-  // Deno cache dir to a directory that is persisted between builds.
-  const cacheDirectory =
-    !isRunningLocally && featureFlags.edge_functions_cache_cli ? resolve(buildDir, DENO_CLI_CACHE_DIRECTORY) : undefined
-
-  // Edge Bundler expects the dist directory to exist.
-  await fs.mkdir(distPath, { recursive: true })
-
-  await bundle(sourcePaths, distPath, declarations, {
-    cacheDirectory,
-    debug,
-    distImportMapPath,
-    featureFlags,
-    importMaps: [importMap].filter(Boolean),
-  })
-
-  return {}
-}
-
-// We run this core step if at least one of the functions directories (the
-// one configured by the user or the internal one) exists. We use a dynamic
-// `condition` because the directories might be created by the build command
-// or plugins.
-const hasEdgeFunctionsDirectories = async function ({
-  buildDir,
-  constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC },
-}) {
-  const hasFunctionsSrc = EDGE_FUNCTIONS_SRC !== undefined && EDGE_FUNCTIONS_SRC !== ''
-
-  if (hasFunctionsSrc) {
-    return true
-  }
-
-  const internalFunctionsSrc = resolve(buildDir, INTERNAL_EDGE_FUNCTIONS_SRC)
-
-  return await pathExists(internalFunctionsSrc)
-}
-
-const logFunctions = async ({
-  internalSrcDirectory,
-  internalSrcPath,
-  logs,
-  srcDirectory: userFunctionsSrc,
-  srcPath,
-}) => {
-  const [userFunctions, internalFunctions] = await Promise.all([find([srcPath]), find([internalSrcPath])])
-  const userFunctionsSrcExists = await pathExists(srcPath)
-  const internalFunctionsSrc = internalSrcDirectory
-
-  logFunctionsToBundle({
-    logs,
-    userFunctions: userFunctions.map(({ name }) => name),
-    userFunctionsSrc,
-    userFunctionsSrcExists,
-    internalFunctions: internalFunctions.map(({ name }) => name),
-    internalFunctionsSrc,
-    type: 'Edge Functions',
-  })
-}
-
-export const bundleEdgeFunctions = {
-  event: 'onBuild',
-  coreStep,
-  coreStepId: 'edge_functions_bundling',
-  coreStepName: 'Edge Functions bundling',
-  coreStepDescription: () => 'Edge Functions bundling',
-  condition: hasEdgeFunctionsDirectories,
-}

package/src/plugins_core/edge_functions/lib/internal_manifest.js

@@ -1,54 +0,0 @@
-import { promises as fs } from 'fs'
-import { dirname, join, resolve } from 'path'
-
-const parseManifest = async (internalSourceDirectory) => {
-  const manifestPath = join(internalSourceDirectory, 'manifest.json')
-
-  try {
-    const data = await fs.readFile(manifestPath)
-    const manifest = JSON.parse(data)
-
-    if (manifest.version !== 1) {
-      throw new Error('Unsupported manifest version')
-    }
-
-    const result = {
-      declarations: manifest.functions,
-    }
-
-    if (manifest.import_map) {
-      const importMapPath = resolve(dirname(manifestPath), manifest.import_map)
-      const importMap = await readImportMap(importMapPath)
-
-      return {
-        ...result,
-        importMap,
-      }
-    }
-
-    return result
-  } catch {
-    // no-op
-  }
-
-  return {
-    declarations: [],
-  }
-}
-
-const readImportMap = async (path) => {
-  try {
-    const data = await fs.readFile(path)
-    const importMap = JSON.parse(data)
-
-    return importMap
-  } catch {
-    // no-op
-  }
-
-  return {
-    imports: {},
-  }
-}
-
-export { parseManifest }

package/src/plugins_core/functions/error.js

@@ -1,163 +0,0 @@
-import readdirp from 'readdirp'
-
-import { addErrorInfo } from '../../error/info.js'
-
-const MODULE_NOT_FOUND_CODE = 'MODULE_NOT_FOUND'
-const MODULE_NOT_FOUND_ESBUILD_REGEXP = /^Could not resolve ['"]([^'"]+)/
-const MODULE_NOT_FOUND_REGEXP = /Cannot find module ['"]([^'"]+)/
-
-// Handle errors coming from zip-it-and-ship-it
-export const getZipError = async function (error, functionsSrc) {
-  const moduleNotFoundError = await getModuleNotFoundError(error, functionsSrc)
-
-  if (moduleNotFoundError) {
-    return moduleNotFoundError
-  }
-
-  if (isPackageJsonError(error)) {
-    return getPackageJsonError(error)
-  }
-
-  return error
-}
-
-const getModuleNotFoundError = async function (error, functionsSrc) {
-  const errorFromZisi = await getModuleNotFoundErrorFromZISI(error, functionsSrc)
-
-  if (errorFromZisi) {
-    return errorFromZisi
-  }
-
-  const errorFromEsbuild = await getModuleNotFoundErrorFromEsbuild(error, functionsSrc)
-
-  if (errorFromEsbuild) {
-    return errorFromEsbuild
-  }
-}
-
-const getModuleNotFoundErrorObject = async ({ error, functionsSrc, moduleNames }) => {
-  const message = await getModuleNotFoundMessage(functionsSrc, moduleNames)
-
-  error.message = `${message}\n\n${error.message}`
-  addErrorInfo(error, { type: 'dependencies' })
-
-  return error
-}
-
-const getModuleNotFoundMessage = async function (functionsSrc, moduleNames) {
-  if (moduleNames.length === 0 || !(await lacksNodeModules(functionsSrc))) {
-    return MODULE_NOT_FOUND_MESSAGE
-  }
-
-  if (moduleNames.filter(Boolean).some(isLocalPath)) {
-    return PATH_NOT_FOUND_MESSAGE
-  }
-
-  return getLocalInstallMessage(moduleNames)
-}
-
-const isLocalPath = function (moduleName) {
-  return moduleName.startsWith('.') || moduleName.startsWith('/')
-}
-
-const getModuleNotFoundErrorFromEsbuild = function (error, functionsSrc) {
-  const { errors = [] } = error
-  const modulesNotFound = errors.reduce((modules, errorObject) => {
-    const match = errorObject.text.match(MODULE_NOT_FOUND_ESBUILD_REGEXP)
-
-    if (!match) {
-      return modules
-    }
-
-    return [...modules, match[1]]
-  }, [])
-
-  if (modulesNotFound.length === 0) {
-    return
-  }
-
-  return getModuleNotFoundErrorObject({ error, functionsSrc, moduleNames: modulesNotFound })
-}
-
-const getModuleNotFoundErrorFromZISI = function (error, functionsSrc) {
-  if (!(error instanceof Error && error.code === MODULE_NOT_FOUND_CODE)) {
-    return
-  }
-
-  const moduleName = getModuleNameFromZISIError(error)
-
-  return getModuleNotFoundErrorObject({ error, functionsSrc, moduleNames: moduleName ? [moduleName] : [] })
-}
-
-// This error message always include the same words
-const getModuleNameFromZISIError = function (error) {
-  if (typeof error.message !== 'string') {
-    return
-  }
-
-  const result = MODULE_NOT_FOUND_REGEXP.exec(error.message)
-  if (result === null) {
-    return
-  }
-
-  return result[1]
-}
-
-// Netlify Functions has a `package.json` but no `node_modules`
-const lacksNodeModules = async function (functionsSrc) {
-  return (
-    functionsSrc !== undefined &&
-    (await hasFunctionRootFile('package.json', functionsSrc)) &&
-    !(await hasFunctionRootFile('node_modules', functionsSrc))
-  )
-}
-
-// Functions can be either files or directories, so we need to check on two
-// depth levels
-const hasFunctionRootFile = async function (filename, functionsSrc) {
-  const files = await readdirp.promise(functionsSrc, { depth: 1, fileFilter: filename })
-  return files.length !== 0
-}
-
-const MODULE_NOT_FOUND_MESSAGE = `A Netlify Function failed to require one of its dependencies.
-Please make sure it is present in the site's top-level "package.json".`
-const PATH_NOT_FOUND_MESSAGE = `A Netlify Function failed to require a local file.
-Please make sure the file exists and its path is correctly spelled.`
-
-// A common mistake is to assume Netlify Functions dependencies are
-// automatically installed. This checks for this pattern.
-const getLocalInstallMessage = function (modules) {
-  const genericMessage = `
-
-By default, dependencies inside a Netlify Function's "package.json" are not automatically installed.
-There are several ways to fix this problem:
-  - Removing your Function's "package.json" and adding the dependencies to the project's top-level "package.json" instead. This is the fastest and safest solution.
-  - Running "npm install" or "yarn" inside your Netlify Function in your build command.
-  - Adding the following plugin to your "netlify.toml":
-
-[[plugins]]
-package = "@netlify/plugin-functions-install-core"
-  `
-
-  if (modules.length === 1) {
-    return `A Netlify Function is using "${modules[0]}" but that dependency has not been installed yet.${genericMessage}`
-  }
-
-  const moduleNames = modules.map((name) => `"${name}"`).join(', ')
-
-  return `A Netlify Function is using dependencies that have not been installed yet: ${moduleNames}${genericMessage}`
-}
-
-// We need to load the site's `package.json` when bundling Functions. This is
-// because `optionalDependencies` can make `import()` fail, but we don't want
-// to error then. However, if the `package.json` is invalid, we fail the build.
-const isPackageJsonError = function (error) {
-  return PACKAGE_JSON_ORIGINAL_MESSAGES.some((msg) => error.message.includes(msg))
-}
-
-const PACKAGE_JSON_ORIGINAL_MESSAGES = ['is invalid JSON', 'in JSON at position']
-
-const getPackageJsonError = function (error) {
-  addErrorInfo(error, { type: 'resolveConfig' })
-  return error
-}

package/src/plugins_core/functions/feature_flags.js

@@ -1,6 +0,0 @@
-export const getZisiFeatureFlags = (featureFlags) => ({
-  ...featureFlags,
-  defaultEsModulesToEsbuild: featureFlags.buildbot_es_modules_esbuild,
-  parseWithEsbuild: featureFlags.buildbot_zisi_esbuild_parser,
-  traceWithNft: featureFlags.buildbot_zisi_trace_nft,
-})