@netlify/build 28.0.0-beta → 28.0.0

package/lib/utils/errors.js

@@ -0,0 +1,13 @@
+// Wrap an async function so it prepends an error message on exceptions.
+// This helps locate errors.
+export const addAsyncErrorMessage = function (asyncFunc, message) {
+    return async (...args) => {
+        try {
+            return await asyncFunc(...args);
+        }
+        catch (error) {
+            error.stack = `${message}: ${error.stack}`;
+            throw error;
+        }
+    };
+};

package/lib/utils/json.js

@@ -0,0 +1,15 @@
+import { promises as fs, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+const ROOT_PACKAGE_JSON_PATH = fileURLToPath(new URL('../../package.json', import.meta.url));
+// TODO: Replace with dynamic `import()` once it is supported without
+// experimental flags
+export const importJsonFile = async function (filePath) {
+    const fileContents = await fs.readFile(filePath);
+    return JSON.parse(fileContents);
+};
+const importJsonFileSync = function (filePath) {
+    // Use sync I/O so it is easier to migrate to `import()` later on
+    const fileContents = readFileSync(filePath, 'utf8');
+    return JSON.parse(fileContents);
+};
+export const ROOT_PACKAGE_JSON = importJsonFileSync(ROOT_PACKAGE_JSON_PATH);

package/{src → lib}/utils/omit.js

@@ -1,6 +1,5 @@
-import filterObj from 'filter-obj'
-
+import filterObj from 'filter-obj';
 // lodash.omit is 1400 lines of codes. filter-obj is much smaller and simpler.
 export const omit = function (obj, keys) {
-  return filterObj(obj, (key) => !keys.includes(key))
-}
+    return filterObj(obj, (key) => !keys.includes(key));
+};

package/lib/utils/package.js

@@ -0,0 +1,22 @@
+import { dirname } from 'path';
+import { readPackageUp } from 'read-pkg-up';
+// Retrieve `package.json` from a specific directory
+export const getPackageJson = async function (cwd, { normalize } = {}) {
+    const packageObj = await getPackageObj({ cwd, normalize });
+    if (packageObj === undefined) {
+        return { packageJson: {} };
+    }
+    const { path, packageJson } = packageObj;
+    const packageDir = dirname(path);
+    return { packageDir, packageJson };
+};
+const getPackageObj = async function ({ cwd, normalize = true }) {
+    try {
+        return await readPackageUp({ cwd, normalize });
+        // If the `package.json` is invalid and `normalize` is `true`, an error is
+        // thrown. We return `undefined` then.
+    }
+    catch {
+        // continue regardless error
+    }
+};

package/lib/utils/remove_falsy.js

@@ -0,0 +1,8 @@
+import filterObj from 'filter-obj';
+// Remove falsy values from object
+export const removeFalsy = function (obj) {
+    return filterObj(obj, isDefined);
+};
+const isDefined = function (key, value) {
+    return value !== undefined && value !== '';
+};

package/lib/utils/resolve.js

@@ -0,0 +1,41 @@
+import { createRequire } from 'module';
+import { async as resolveLib } from 'resolve';
+// TODO: use `import.resolve()` once it is available without any experimental
+// flags
+const require = createRequire(import.meta.url);
+// Like `resolvePath()` but does not throw
+export const tryResolvePath = async function (path, basedir) {
+    try {
+        const resolvedPath = await resolvePath(path, basedir);
+        return { path: resolvedPath };
+    }
+    catch (error) {
+        return { error };
+    }
+};
+// This throws if the package cannot be found
+export const resolvePath = async function (path, basedir) {
+    try {
+        return await resolvePathWithBasedir(path, basedir);
+        // Fallback.
+        // `resolve` sometimes gives unhelpful error messages.
+        // https://github.com/browserify/resolve/issues/223
+    }
+    catch {
+        return require.resolve(path, { paths: [basedir] });
+    }
+};
+// Like `require.resolve()` but as an external library.
+// We need to use `new Promise()` due to a bug with `utils.promisify()` on
+// `resolve`:
+//   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
+const resolvePathWithBasedir = function (path, basedir) {
+    return new Promise((resolve, reject) => {
+        resolveLib(path, { basedir }, (error, resolvedPath) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve(resolvedPath);
+        });
+    });
+};

package/lib/utils/runtime.js

@@ -0,0 +1,5 @@
+export const isRuntime = function (pluginOption) {
+    const { packageName } = pluginOption;
+    // Make this a bit more robust in the future
+    return ['@netlify/next-runtime', '@netlify/plugin-nextjs'].includes(packageName);
+};

package/lib/utils/semver.js

@@ -0,0 +1,28 @@
+import semver from 'semver';
+// Compare two versions by their major versions.
+// Takes into account the special rules for `0.*.*` and `0.0.*` versions.
+export const isPreviousMajor = function (versionA, versionB) {
+    return semver.lt(getMajor(versionA), getMajor(versionB));
+};
+// Remove minor/patch numbers
+const getMajor = function (version) {
+    return semver.minVersion(getMajorVersion(version)).version;
+};
+// According to semver, the second number is the major release number for
+// `0.*.*` versions and the third for `0.0.*`. This is how `^` behaves with the
+// `semver` module which is used by `npm`.
+export const getMajorVersion = function (version) {
+    if (!version || semver.clean(version) === null) {
+        return;
+    }
+    const majorVersion = semver.major(version);
+    if (majorVersion !== 0) {
+        return `${majorVersion}`;
+    }
+    const minorVersion = semver.minor(version);
+    if (minorVersion !== 0) {
+        return `${majorVersion}.${minorVersion}`;
+    }
+    const patchVersion = semver.patch(version);
+    return `${majorVersion}.${minorVersion}.${patchVersion}`;
+};

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@netlify/build",
-  "version": "28.0.0-beta",
+  "version": "28.0.0",
   "description": "Netlify build module",
   "type": "module",
-  "exports": "./src/core/main.js",
-  "main": "./src/core/main.js",
-  "types": "types/index.d.ts",
+  "exports": "./lib/core/main.js",
+  "main": "./lib/core/main.js",
+  "types": "./types/index.d.ts",
   "bin": {
-    "netlify-build": "./src/core/bin.js"
+    "netlify-build": "./bin.js"
   },
   "files": [
-    "src/**/*.js",
-    "src/**/*.yml",
+    "bin.js",
+    "lib/**/*.js",
+    "lib/**/*.yml",
     "types/**/*.d.ts"
   ],
   "author": "Netlify Inc.",
@@ -20,7 +21,13 @@
     "Swyx <swyx@netlify.com> (https://www.swyx.io)"
   ],
   "scripts": {
-    "prepublishOnly": "cd ../../ && npm run prepublishOnly"
+    "prebuild": "rm -rf lib",
+    "postbuild": "npx copyfiles \"src/**/*.yml\" lib/ -u 1",
+    "build": "tsc",
+    "pretest": "tsd .",
+    "test": "ava",
+    "test:ci": "c8 -r lcovonly -r text -r json ava",
+    "test:measure": "../../tools/tests-duration.js"
   },
   "keywords": [
     "nodejs",
@@ -56,16 +63,17 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
-    "@netlify/edge-bundler": "^1.4.2",
-    "@netlify/cache-utils": "^4.0.0",
-    "@netlify/config": "^18.1.1",
-    "@netlify/functions-utils": "^4.2.0",
-    "@netlify/git-utils": "^4.0.0",
-    "@netlify/plugins-list": "^6.29.0",
-    "@netlify/run-utils": "^4.0.0",
-    "@netlify/zip-it-and-ship-it": "6.0.0-beta",
+    "@netlify/cache-utils": "^5.0.0",
+    "@netlify/config": "^19.0.0",
+    "@netlify/edge-bundler": "^2.7.0",
+    "@netlify/functions-utils": "^5.0.0",
+    "@netlify/git-utils": "^5.0.0",
+    "@netlify/plugins-list": "^6.49.1",
+    "@netlify/run-utils": "^5.0.0",
+    "@netlify/zip-it-and-ship-it": "^7.1.2",
     "@sindresorhus/slugify": "^2.0.0",
-    "@types/node": "^16.0.0",
+    "ajv": "^8.11.0",
+    "ajv-errors": "^3.0.0",
     "ansi-escapes": "^5.0.0",
     "chalk": "^5.0.0",
     "clean-stack": "^4.0.0",
@@ -110,9 +118,12 @@
     "yargs": "^17.3.1"
   },
   "devDependencies": {
-    "@netlify/nock-udp": "^1.0.0",
+    "@netlify/nock-udp": "^3.0.0",
+    "@types/node": "^14.18.31",
     "atob": "^2.1.2",
     "ava": "^4.0.0",
+    "c8": "^7.12.0",
+    "copyfiles": "^2.4.1",
     "cpy": "^8.1.0",
     "del": "^6.0.0",
     "fast-safe-stringify": "^2.0.7",
@@ -126,9 +137,17 @@
     "path-key": "^4.0.0",
     "process-exists": "^5.0.0",
     "sinon": "^13.0.0",
+    "tsd": "^0.24.1",
+    "typescript": "^4.8.4",
     "yarn": "^1.22.4"
   },
   "engines": {
-    "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
-  }
+    "node": "^14.16.0 || >=16.0.0"
+  },
+  "tsd": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  },
+  "gitHead": "c4502f1c112e7f33d5e6fa053bfbe7dabdfe0160"
 }

package/types/config/netlify_config.d.ts

@@ -22,9 +22,9 @@ interface Header {
   values: Partial<Record<string, Many<string, 'mutable'>>>
 }
 
-interface EdgeHandler {
+interface EdgeFunction {
   path?: `/${string}`
-  handler: string
+  function: string
 }
 
 interface NetlifyPlugin {
@@ -44,9 +44,9 @@ interface NetlifyConfig {
    */
   headers: Header[]
   /**
-   * array of Edge Handlers with their modifiable options
+   * array of Edge Functions with their modifiable options
    */
-  edge_handlers: EdgeHandler[]
+  edge_functions: EdgeFunction[]
   /**
    * object with options for modifying [functions](https://docs.netlify.com/configure-builds/file-based-configuration/#functions)
    */

package/types/netlify_plugin_constants.d.ts

@@ -14,10 +14,10 @@ export interface NetlifyPluginConstants {
    */
   FUNCTIONS_SRC?: string
   /**
-   * the directory where internal Edge Handlers source code lives. This is where build plugins should place auto-generated handlers.
-   * `undefined` if the version of @netlify/build does not support internal Edge Handlers
+   * the directory where internal Edge Functions source code lives. This is where build plugins should place auto-generated functions.
+   * `undefined` if the version of @netlify/build does not support internal Edge Functions
    */
-  INTERNAL_EDGE_HANDLERS_SRC?: string
+  INTERNAL_EDGE_FUNCTIONS_SRC?: string
   /**
    * the directory where internal function source code lives. This is where build plugins should place auto-generated functions.
    * `undefined` if the version of @netlify/build does not support internal functions
@@ -28,14 +28,14 @@ export interface NetlifyPluginConstants {
    */
   FUNCTIONS_DIST: string
   /**
-   * the directory where built Edge Handlers are placed before deployment. Its value is always defined, but the target might not have been created yet.
+   * the directory where built Edge Functions are placed before deployment. Its value is always defined, but the target might not have been created yet.
    */
-  EDGE_HANDLERS_DIST: string
+  EDGE_FUNCTIONS_DIST: string
   /**
-   * the directory where Edge Handlers source code lives.
-   * `undefined` if no `netlify/edge-handlers` directory exists in the base directory and if not specified in `netlify.toml`.
+   * the directory where Edge Functions source code lives.
+   * `undefined` if no `netlify/edge-functions` directory exists.
    */
-  EDGE_HANDLERS_SRC?: string
+  EDGE_FUNCTIONS_SRC?: string
   /**
    * boolean indicating whether the build was [run locally](https://docs.netlify.com/cli/get-started/#run-builds-locally) or on Netlify
    */

package/src/core/bin.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-
-import process from 'process'
-
-import filterObj from 'filter-obj'
-import yargs from 'yargs'
-import { hideBin } from 'yargs/helpers'
-
-import { normalizeCliFeatureFlags } from './feature_flags.js'
-import { FLAGS } from './flags.js'
-import build from './main.js'
-import { FALLBACK_SEVERITY_ENTRY } from './severity.js'
-
-// CLI entry point.
-// Before adding logic to this file, please consider adding it to the main
-// programmatic command instead, so that the new logic is available when run
-// programmatically as well. This file should only contain logic that makes
-// sense only in CLI, such as CLI flags parsing and exit code.
-const runCli = async function () {
-  const flags = parseFlags()
-  const flagsA = filterObj(flags, isUserFlag)
-
-  const state = { done: false }
-  process.on('exit', onExit.bind(undefined, state))
-
-  const { severityCode, logs } = await build(flagsA)
-  printLogs(logs)
-  process.exitCode = severityCode
-
-  state.done = true
-}
-
-const parseFlags = function () {
-  const { featureFlags: cliFeatureFlags = '', ...flags } = yargs(hideBin(process.argv))
-    .options(FLAGS)
-    .usage(USAGE)
-    .parse()
-  const featureFlags = normalizeCliFeatureFlags(cliFeatureFlags)
-  return { ...flags, featureFlags }
-}
-
-const USAGE = `netlify-build [OPTIONS...]
-
-Run Netlify Build system locally.
-
-Options can also be specified as environment variables prefixed with
-NETLIFY_BUILD_. For example the environment variable NETLIFY_BUILD_DRY=true can
-be used instead of the CLI flag --dry.`
-
-// 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', 'dryRun'])
-
-// Used mostly for testing
-const printLogs = function (logs) {
-  if (logs === undefined) {
-    return
-  }
-
-  const allLogs = [logs.stdout.join('\n'), logs.stderr.join('\n')].filter(Boolean).join('\n\n')
-  console.log(allLogs)
-}
-
-// In theory, the main process should not exit until the main `build()` function
-// has completed. In practice, this might happen due to bugs.
-// Making the exit code not 0 in that case ensures the caller knows that the
-// build has completed when the exit code is 0. This `exit` event handlers
-// guarantees this.
-const onExit = function ({ done }, exitCode) {
-  if (done || exitCode !== 0) {
-    return
-  }
-
-  const [, processName] = process.argv
-  console.log(`${processName} exited with exit code ${exitCode} without finishing the build.`)
-
-  process.exitCode = FALLBACK_SEVERITY_ENTRY.severityCode
-}
-
-runCli()

package/src/core/config.js

@@ -1,186 +0,0 @@
-import { resolveConfig, updateConfig, restoreConfig } from '@netlify/config'
-import mapObj from 'map-obj'
-
-import { getChildEnv } from '../env/main.js'
-import { addApiErrorHandlers } from '../error/api.js'
-import { changeErrorType } from '../error/info.js'
-import { logBuildDir, logConfigPath, logConfig, logContext } from '../log/messages/config.js'
-import { logConfigOnUpload, logHeadersOnUpload, logRedirectsOnUpload } from '../log/messages/mutations.js'
-import { measureDuration } from '../time/main.js'
-import { getPackageJson } from '../utils/package.js'
-
-import { getUserNodeVersion } from './user_node_version.js'
-
-// Retrieve immutable options passed to `@netlify/config`.
-// This does not include options which might change during the course of the
-// build:
-//  - `cachedConfig` and `cachedConfigPath` are only used at the beginning of
-//    the build
-//  - If plugins change the configuration, `configMutations` is used instead
-// In both cases, almost all options should remain the same.
-export const getConfigOpts = function ({
-  config,
-  defaultConfig,
-  cwd,
-  repositoryRoot,
-  apiHost,
-  token,
-  siteId,
-  context,
-  branch,
-  baseRelDir,
-  envOpt,
-  mode,
-  offline,
-  deployId,
-  buildId,
-  testOpts,
-  featureFlags,
-}) {
-  return {
-    config,
-    defaultConfig,
-    cwd,
-    repositoryRoot,
-    context,
-    branch,
-    baseRelDir,
-    host: apiHost,
-    token,
-    siteId,
-    deployId,
-    buildId,
-    mode,
-    offline,
-    env: envOpt,
-    testOpts,
-    featureFlags,
-  }
-}
-
-// Retrieve configuration object
-const tLoadConfig = async function ({ configOpts, cachedConfig, cachedConfigPath, envOpt, debug, logs, nodePath }) {
-  const {
-    configPath,
-    headersPath,
-    redirectsPath,
-    buildDir,
-    repositoryRoot,
-    config: netlifyConfig,
-    context: contextA,
-    branch: branchA,
-    token: tokenA,
-    api,
-    siteInfo,
-    env,
-  } = await resolveInitialConfig(configOpts, cachedConfig, cachedConfigPath)
-  logConfigInfo({ logs, configPath, buildDir, netlifyConfig, context: contextA, debug })
-
-  const apiA = addApiErrorHandlers(api)
-  const envValues = mapObj(env, (key, { value }) => [key, value])
-  const childEnv = getChildEnv({ envOpt, env: envValues })
-  const [{ packageJson }, userNodeVersion] = await Promise.all([getPackageJson(buildDir), getUserNodeVersion(nodePath)])
-  return {
-    netlifyConfig,
-    configPath,
-    headersPath,
-    redirectsPath,
-    buildDir,
-    repositoryRoot,
-    packageJson,
-    userNodeVersion,
-    childEnv,
-    context: contextA,
-    branch: branchA,
-    token: tokenA,
-    api: apiA,
-    siteInfo,
-  }
-}
-
-export const loadConfig = measureDuration(tLoadConfig, 'resolve_config')
-
-// Retrieve initial configuration.
-// In the buildbot and CLI, we re-use the already parsed `@netlify/config`
-// return value which is passed as `cachedConfig`/`cachedConfigPath`.
-const resolveInitialConfig = async function (configOpts, cachedConfig, cachedConfigPath) {
-  return await resolveConfig({ ...configOpts, cachedConfig, cachedConfigPath })
-}
-
-const logConfigInfo = function ({ logs, configPath, buildDir, netlifyConfig, context, debug }) {
-  logBuildDir(logs, buildDir)
-  logConfigPath(logs, configPath)
-  logConfig({ logs, netlifyConfig, debug })
-  logContext(logs, context)
-}
-
-// Retrieve the configuration after it's been changed.
-// This ensures any configuration changes done by plugins is validated and
-// normalized.
-// We use `debug: false` to avoid any debug logs. Otherwise every configuration
-// change would create debug logs which would be too verbose.
-// Errors are propagated and assigned to the specific plugin or core step
-// which changed the configuration.
-export const resolveUpdatedConfig = async function (configOpts, configMutations) {
-  try {
-    return await resolveConfig({ ...configOpts, configMutations, debug: false })
-  } catch (error) {
-    changeErrorType(error, 'resolveConfig', 'pluginValidation')
-    throw error
-  }
-}
-
-// If the configuration was changed, persist it to `netlify.toml`.
-// If `netlify.toml` does not exist, create it inside repository root.
-// This is only done when `saveConfig` is `true`. This allows performing this
-// in the buildbot but not in local builds, since only the latter run in a
-// container and we want to avoid saving files on local machines.
-export const saveUpdatedConfig = async function ({
-  configMutations,
-  buildDir,
-  repositoryRoot,
-  configPath = `${repositoryRoot}/netlify.toml`,
-  headersPath,
-  redirectsPath,
-  logs,
-  featureFlags,
-  context,
-  branch,
-  debug,
-  saveConfig,
-}) {
-  if (!saveConfig) {
-    return
-  }
-
-  await updateConfig(configMutations, {
-    buildDir,
-    configPath,
-    headersPath,
-    redirectsPath,
-    context,
-    branch,
-    logs,
-    featureFlags,
-  })
-
-  await logConfigOnUpload({ logs, configPath, debug })
-  await logHeadersOnUpload({ logs, headersPath, debug })
-  await logRedirectsOnUpload({ logs, redirectsPath, debug })
-}
-
-export const restoreUpdatedConfig = async function ({
-  configMutations,
-  buildDir,
-  repositoryRoot,
-  configPath = `${repositoryRoot}/netlify.toml`,
-  headersPath,
-  redirectsPath,
-  saveConfig,
-}) {
-  if (!saveConfig) {
-    return
-  }
-
-  await restoreConfig(configMutations, { buildDir, configPath, headersPath, redirectsPath })
-}