@netlify/build 29.0.1-rc → 29.0.2

package/lib/time/aggregate.js

@@ -0,0 +1,109 @@
+import { isNetlifyMaintainedPlugin } from '../plugins/internal.js';
+import { createTimer, TOP_PARENT_TAG } from './main.js';
+// Some timers are computed based on others:
+//   - `others` is `total` minus the other timers
+//   - `run_plugins` is the sum of all plugins
+//   - `run_netlify_build_per_type` aggregates timers but per system/plugin/user
+//   - each plugin timer is the sum of its event handlers
+export const addAggregatedTimers = function (timers) {
+    const timersA = addRunPluginsTimer(timers);
+    const timersB = addPluginTimers(timersA);
+    const timersC = addOthersTimers(timersB);
+    const timersD = addTypeTimers(timersC);
+    return timersD;
+};
+// Having a `total` timer is redundant since the buildbot already measures this.
+// The buildbot measurement is better since it includes the time to load Node.
+// Instead, we only use `total` to measure what did not get `measureDuration()`.
+const addOthersTimers = function (timers) {
+    const totalTimer = timers.find(isTotalTimer);
+    const timersA = timers.filter((timer) => !isTotalTimer(timer));
+    const topTimers = timersA.filter(isTopTimer);
+    const othersTimer = createOthersTimer(topTimers, totalTimer);
+    return [...timersA, othersTimer];
+};
+const isTotalTimer = function ({ stageTag, parentTag }) {
+    return stageTag === 'total' && parentTag === 'build_site';
+};
+const createOthersTimer = function (topTimers, { durationNs: totalTimerDurationNs }) {
+    const topTimersDurationNs = computeTimersDuration(topTimers);
+    const otherTimersDurationNs = Math.max(0, totalTimerDurationNs - topTimersDurationNs);
+    const othersTimer = createTimer(OTHERS_STAGE_TAG, otherTimersDurationNs);
+    return othersTimer;
+};
+const OTHERS_STAGE_TAG = 'others';
+// Measure the total time running plugins
+const addRunPluginsTimer = function (timers) {
+    const pluginsTimers = timers.filter(isPluginTimer);
+    return pluginsTimers.length === 0 ? timers : [...timers, createSumTimer(pluginsTimers, RUN_PLUGINS_STAGE_TAG)];
+};
+const RUN_PLUGINS_STAGE_TAG = 'run_plugins';
+// Retrieve one timer for each plugin, summing all its individual timers
+// (one per event handler)
+const addPluginTimers = function (timers) {
+    const timersA = timers.filter((timer) => !isCommunityPluginTimer(timer));
+    const pluginsTimers = timersA.filter(isPluginTimer);
+    if (pluginsTimers.length === 0) {
+        return timersA;
+    }
+    const pluginPackages = getPluginPackages(pluginsTimers);
+    const wholePluginsTimers = pluginPackages.map((pluginPackage) => getWholePluginTimer(pluginPackage, pluginsTimers));
+    return [...timersA, ...wholePluginsTimers];
+};
+// We only measure plugins maintained by us, not community
+const isCommunityPluginTimer = function (timer) {
+    return isPluginTimer(timer) && !isNetlifyMaintainedPlugin(getPluginTimerPackage(timer));
+};
+const getPluginPackages = function (pluginsTimers) {
+    const pluginPackages = pluginsTimers.map(getPluginTimerPackage);
+    return [...new Set(pluginPackages)];
+};
+const getWholePluginTimer = function (pluginPackage, pluginsTimers) {
+    const pluginTimers = pluginsTimers.filter((pluginTimer) => getPluginTimerPackage(pluginTimer) === pluginPackage);
+    const wholePluginsTimer = createSumTimer(pluginTimers, pluginPackage, RUN_PLUGINS_STAGE_TAG);
+    return wholePluginsTimer;
+};
+const getPluginTimerPackage = function ({ parentTag }) {
+    return parentTag;
+};
+// Check if a timer relates to a Build plugin
+const isPluginTimer = function ({ category }) {
+    return category === 'pluginEvent';
+};
+// Reports total time depending on whether it was system, plugin or user
+const addTypeTimers = function (timers) {
+    const topTimers = timers.filter(isTopTimer);
+    const typeTimers = TYPE_TIMERS.map(({ name, stages }) => getTypeTimer(name, stages, topTimers)).filter(Boolean);
+    return [...timers, ...typeTimers];
+};
+const TYPE_TIMERS = [
+    { name: 'system', stages: ['resolve_config', 'get_plugins_options', 'start_plugins', 'others'] },
+    { name: 'plugin', stages: ['load_plugins', 'run_plugins'] },
+    { name: 'user', stages: ['build_command', 'edge_functions_bundling', 'functions_bundling', 'deploy_site'] },
+];
+const getTypeTimer = function (name, stages, topTimers) {
+    const topTimersA = topTimers.filter(({ stageTag }) => stages.includes(stageTag));
+    if (topTimersA.length === 0) {
+        return;
+    }
+    const typeTimer = createSumTimer(topTimersA, name, 'run_netlify_build_per_type');
+    return typeTimer;
+};
+const isTopTimer = function ({ parentTag }) {
+    return parentTag === TOP_PARENT_TAG;
+};
+// Creates a timer that sums up the duration of several others
+const createSumTimer = function (timers, stageTag, parentTag) {
+    const durationNs = computeTimersDuration(timers);
+    const timer = createTimer(stageTag, durationNs, { parentTag });
+    return timer;
+};
+const computeTimersDuration = function (timers) {
+    return timers.map(getTimerDuration).reduce(reduceSum, 0);
+};
+const getTimerDuration = function ({ durationNs }) {
+    return durationNs;
+};
+const reduceSum = function (sum, number) {
+    return sum + number;
+};

package/lib/time/main.js

@@ -0,0 +1,31 @@
+import keepFuncProps from 'keep-func-props';
+import { startTimer, endTimer } from './measure.js';
+const DEFAULT_METRIC_NAME = 'buildbot.build.stage.duration';
+export const TOP_PARENT_TAG = 'run_netlify_build';
+// Initialize the `timers` array
+export const initTimers = function () {
+    return [];
+};
+// Wrap an async function to measure how long it takes.
+// The function must:
+//   - take a plain object as first argument. This must contain a `timers`.
+//   - return a plain object. This may or may not contain a modified `timers`.
+// The `durationNs` will be returned by the function. A new `timers` with the
+// additional duration timer will be returned as well.
+const kMeasureDuration = function (func, stageTag, { parentTag = undefined, category = undefined } = {}) {
+    return async function measuredFunc({ timers, ...opts }, ...args) {
+        const timerNs = startTimer();
+        const { timers: timersA = timers, ...returnObject } = await func({ timers, ...opts }, ...args);
+        const { tags = {} } = returnObject;
+        const durationNs = endTimer(timerNs);
+        const timer = createTimer(stageTag, durationNs, { parentTag, category, tags });
+        const timersB = [...timersA, timer];
+        return { ...returnObject, timers: timersB, durationNs };
+    };
+};
+// Ensure the wrapped function `name` is not `anonymous` in stack traces
+export const measureDuration = keepFuncProps(kMeasureDuration);
+// Create a new object representing a completed timer
+export const createTimer = function (stageTag, durationNs, { metricName = DEFAULT_METRIC_NAME, parentTag = TOP_PARENT_TAG, category = undefined, tags = undefined } = {}) {
+    return { metricName, stageTag, parentTag, durationNs, category, tags };
+};

package/lib/time/measure.js

@@ -0,0 +1,16 @@
+import { hrtime } from 'process';
+const NANOSECS_TO_SECS = 1e9;
+const NANOSECS_TO_MSECS = 1e6;
+/** Starts a timer */
+export const startTimer = hrtime;
+/** Stops a timer */
+export const endTimer = ([startSecs, startNsecs]) => {
+    const [endSecs, endNsecs] = hrtime();
+    const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs;
+    return durationNs;
+};
+/**
+ * statsd expects milliseconds integers.
+ * To prevent double rounding errors, rounding should only be applied once.
+ */
+export const roundTimerToMillisecs = (durationNs) => Math.round(durationNs / NANOSECS_TO_MSECS);

package/lib/time/report.js

@@ -0,0 +1,24 @@
+import { closeClient, startClient } from '../report/statsd.js';
+import { addAggregatedTimers } from './aggregate.js';
+import { roundTimerToMillisecs } from './measure.js';
+// Record the duration of a build phase, for monitoring.
+// Sends to statsd daemon.
+export const reportTimers = async function ({ timers, statsdOpts: { host, port }, framework }) {
+    if (host === undefined) {
+        return;
+    }
+    const timersA = addAggregatedTimers(timers);
+    await sendTimers({ timers: timersA, host, port, framework });
+};
+const sendTimers = async function ({ timers, host, port, framework }) {
+    const client = await startClient(host, port);
+    timers.forEach((timer) => {
+        sendTimer({ timer, client, framework });
+    });
+    await closeClient(client);
+};
+const sendTimer = function ({ timer: { metricName, stageTag, parentTag, durationNs, tags }, client, framework }) {
+    const durationMs = roundTimerToMillisecs(durationNs);
+    const frameworkTag = framework === undefined ? {} : { framework };
+    client.distribution(metricName, durationMs, { stage: stageTag, parent: parentTag, ...tags, ...frameworkTag });
+};

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, 'utf-8');
+    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, 'utf-8');
+    return JSON.parse(fileContents);
+};
+export const ROOT_PACKAGE_JSON = importJsonFileSync(ROOT_PACKAGE_JSON_PATH);

package/lib/utils/omit.js

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

package/lib/utils/package.js

@@ -0,0 +1,24 @@
+import { dirname } from 'path';
+import { readPackageUp } from 'read-pkg-up';
+/**
+ * Retrieve `package.json` from a specific directory
+ */
+export const getPackageJson = async function (cwd, options = {}) {
+    const result = {
+        packageJson: {},
+    };
+    try {
+        const readResult = await readPackageUp({
+            cwd,
+            ...Object.assign({ normalize: true }, options),
+        });
+        if (readResult) {
+            result.packageJson = readResult.packageJson;
+            result.packageDir = dirname(readResult.path);
+        }
+    }
+    catch {
+        // continue regardless error
+    }
+    return result;
+};

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": "29.0.1-rc",
+  "version": "29.0.2",
   "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,14 @@
     "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:dev": "ava -w",
+    "test:ci": "c8 -r lcovonly -r text -r json ava",
+    "test:measure": "../../tools/tests-duration.js"
   },
   "keywords": [
     "nodejs",
@@ -56,18 +64,15 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
-    "@netlify/edge-bundler": "^1.12.1",
-    "@netlify/cache-utils": "^4.0.0",
-    "@netlify/config": "^18.1.4",
-    "@netlify/functions-utils": "^4.2.3",
-    "@netlify/git-utils": "^4.0.0",
-    "@netlify/plugins-list": "^6.36.0",
-    "@netlify/run-utils": "^4.0.0",
-    "@netlify/zip-it-and-ship-it": "5.13.4",
+    "@netlify/cache-utils": "^5.0.2",
+    "@netlify/config": "^20.0.2",
+    "@netlify/edge-bundler": "5.3.2",
+    "@netlify/functions-utils": "^5.0.5",
+    "@netlify/git-utils": "^5.0.2",
+    "@netlify/plugins-list": "^6.58.0",
+    "@netlify/run-utils": "^5.0.2",
+    "@netlify/zip-it-and-ship-it": "^7.1.3",
     "@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",
@@ -104,17 +109,22 @@
     "string-width": "^5.0.0",
     "strip-ansi": "^7.0.0",
     "supports-color": "^9.0.0",
+    "terminal-link": "^3.0.0",
     "tmp-promise": "^3.0.2",
     "ts-node": "^10.6.0",
-    "typescript": "^4.5.4",
+    "typescript": "^4.8.4",
     "update-notifier": "^5.0.0",
     "uuid": "^8.0.0",
-    "yargs": "^17.3.1"
+    "yargs": "^17.6.0"
   },
   "devDependencies": {
-    "@netlify/nock-udp": "^1.0.0",
+    "@netlify/nock-udp": "^3.0.1",
+    "@types/node": "^14.18.31",
+    "@types/statsd-client": "^0.4.3",
     "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",
@@ -128,9 +138,16 @@
     "path-key": "^4.0.0",
     "process-exists": "^5.0.0",
     "sinon": "^13.0.0",
+    "tsd": "^0.24.1",
     "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": "60dd08db0498f62bf087428679444014f5b464f7"
 }

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()