@netlify/build 0.5.0 → 1.0.0-dl-test

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,30 @@
+import { closeClient, formatTags, startClient, validateStatsDOptions, } 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, framework) {
+    if (!validateStatsDOptions(statsdOpts)) {
+        return;
+    }
+    await sendTimers(addAggregatedTimers(timers), statsdOpts, framework);
+};
+const sendTimers = async function (timers, statsdOpts, framework) {
+    const client = await startClient(statsdOpts);
+    timers.forEach((timer) => {
+        sendTimer(timer, client, framework);
+    });
+    await closeClient(client);
+};
+const sendTimer = function (timer, client, framework) {
+    const { metricName, stageTag, parentTag, durationNs, tags } = timer;
+    const durationMs = roundTimerToMillisecs(durationNs);
+    const statsDTags = { stage: stageTag, parent: parentTag, ...tags };
+    // Do not add a framework tag if empty string or null/undefined
+    if (framework) {
+        statsDTags.framework = framework;
+    }
+    client.distribution(metricName, durationMs, formatTags(statsDTags));
+};

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,10 @@
+import { readFile } from 'fs/promises';
+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 readFile(filePath, 'utf-8');
+    return JSON.parse(fileContents);
+};
+export const ROOT_PACKAGE_JSON = (await importJsonFile(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,15 +1,19 @@
 {
   "name": "@netlify/build",
-  "version": "0.5.0",
+  "version": "1.0.0-dl-test",
   "description": "Netlify build module",
-  "main": "src/core/main.js",
+  "type": "module",
+  "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",
-    "!*.test.*",
-    "!*~"
+    "bin.js",
+    "lib/**/*.js",
+    "lib/**/*.yml",
+    "types/**/*.d.ts"
   ],
   "author": "Netlify Inc.",
   "contributors": [
@@ -17,71 +21,130 @@
     "Swyx <swyx@netlify.com> (https://www.swyx.io)"
   ],
   "scripts": {
-    "release:patch": "npm version patch && npm publish",
-    "release:minor": "npm version minor && npm publish",
-    "release:major": "npm version major && npm publish"
+    "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",
+    "javascript",
+    "windows",
+    "macos",
+    "linux",
+    "shell",
+    "bash",
+    "build",
+    "terminal",
+    "deployment",
+    "es6",
+    "serverless",
+    "ci",
+    "plugins",
+    "continuous-integration",
+    "continuous-deployment",
+    "continuous-delivery",
+    "continuous-testing",
+    "netlify-plugin",
+    "netlify"
+  ],
+  "homepage": "https://github.com/netlify/build",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/netlify/build.git",
+    "directory": "packages/build"
   },
-  "repository": "https://github.com/netlify/build",
   "bugs": {
     "url": "https://github.com/netlify/build/issues"
   },
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
-    "@netlify/cache-utils": "^0.4.1",
-    "@netlify/config": "^0.12.0",
-    "@netlify/functions-utils": "^0.2.4",
-    "@netlify/git-utils": "^0.2.2",
-    "@netlify/run-utils": "^0.1.1",
-    "@netlify/zip-it-and-ship-it": "^0.4.0-19",
-    "analytics": "0.3.1",
-    "array-flat-polyfill": "^1.0.1",
-    "chalk": "^3.0.0",
-    "clean-stack": "^2.2.0",
-    "execa": "^3.3.0",
-    "figures": "^3.2.0",
-    "filter-obj": "^2.0.1",
-    "global-cache-dir": "^1.0.1",
-    "got": "^9.6.0",
-    "indent-string": "^4.0.0",
-    "is-ci": "^2.0.0",
-    "is-plain-obj": "^2.1.0",
-    "js-yaml": "^3.13.1",
-    "locate-path": "^5.0.0",
-    "log-process-errors": "^5.1.2",
-    "make-dir": "^3.0.2",
-    "map-obj": "^4.1.0",
-    "netlify": "^4.1.7",
-    "os-name": "^3.1.0",
-    "p-event": "^4.1.0",
-    "p-reduce": "^2.1.0",
-    "path-exists": "^4.0.0",
-    "pkg-dir": "^4.2.0",
-    "pretty-ms": "^6.0.1",
-    "read-pkg-up": "^7.0.1",
+    "@netlify/cache-utils": "^5.1.3",
+    "@netlify/config": "^20.4.1",
+    "@netlify/edge-bundler": "8.13.2",
+    "@netlify/framework-info": "^9.8.6",
+    "@netlify/functions-utils": "^5.2.3",
+    "@netlify/git-utils": "^5.1.1",
+    "@netlify/plugins-list": "^6.68.0",
+    "@netlify/run-utils": "^5.1.0",
+    "@netlify/zip-it-and-ship-it": "9.2.1",
+    "@sindresorhus/slugify": "^2.0.0",
+    "ansi-escapes": "^6.0.0",
+    "chalk": "^5.0.0",
+    "clean-stack": "^4.0.0",
+    "execa": "^6.0.0",
+    "figures": "^4.0.0",
+    "filter-obj": "^3.0.0",
+    "got": "^12.0.0",
+    "hot-shots": "9.3.0",
+    "indent-string": "^5.0.0",
+    "is-plain-obj": "^4.0.0",
+    "js-yaml": "^4.0.0",
+    "keep-func-props": "^4.0.0",
+    "locate-path": "^7.0.0",
+    "log-process-errors": "^8.0.0",
+    "map-obj": "^5.0.0",
+    "memoize-one": "^6.0.0",
+    "os-name": "^5.0.0",
+    "p-event": "^5.0.0",
+    "p-every": "^2.0.0",
+    "p-filter": "^3.0.0",
+    "p-locate": "^6.0.0",
+    "p-reduce": "^3.0.0",
+    "path-exists": "^5.0.0",
+    "path-type": "^5.0.0",
+    "pkg-dir": "^6.0.0",
+    "pretty-ms": "^8.0.0",
+    "ps-list": "^8.0.0",
+    "read-pkg-up": "^9.0.0",
     "readdirp": "^3.4.0",
     "resolve": "^2.0.0-next.1",
-    "semver": "^7.1.3",
-    "string-width": "^4.2.0",
-    "strip-ansi": "^6.0.0",
-    "update-notifier": "^4.1.0",
-    "uuid": "^7.0.2",
-    "yargs": "^15.3.1"
+    "rfdc": "^1.3.0",
+    "safe-json-stringify": "^1.2.0",
+    "semver": "^7.0.0",
+    "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": "^5.0.0",
+    "uuid": "^8.0.0",
+    "yargs": "^17.6.0"
   },
   "devDependencies": {
+    "@netlify/nock-udp": "^3.1.2",
+    "@types/node": "^18.14.2",
     "atob": "^2.1.2",
-    "ava": "^2.4.0",
-    "cp-file": "^7.0.0",
+    "ava": "^4.0.0",
+    "c8": "^7.12.0",
+    "copyfiles": "^2.4.1",
     "cpy": "^8.1.0",
-    "del": "^5.1.0",
-    "get-bin-path": "^4.0.1",
-    "get-node": "^6.6.0",
-    "has-ansi": "^4.0.0",
-    "nock": "^11.9.1",
-    "path-key": "^3.1.1",
+    "del": "^6.0.0",
+    "fast-safe-stringify": "^2.0.7",
+    "get-bin-path": "^6.0.0",
+    "get-node": "^12.0.0",
+    "get-port": "^6.0.0",
+    "get-stream": "^6.0.0",
+    "has-ansi": "^5.0.0",
+    "moize": "^6.0.0",
+    "path-key": "^4.0.0",
+    "process-exists": "^5.0.0",
+    "sinon": "^13.0.0",
+    "tsd": "^0.24.1",
     "yarn": "^1.22.4"
   },
   "engines": {
-    "node": ">=8.3.0"
+    "node": "^14.16.0 || >=16.0.0"
+  },
+  "tsd": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
   }
 }

package/types/config/build.d.ts

@@ -0,0 +1,52 @@
+/* eslint-disable camelcase -- some properties are named in snake case in this API */
+
+export interface Build {
+  /**
+   * Includes a site's [build command](https://docs.netlify.com/configure-builds/get-started/#definitions)
+   */
+  command?: string
+
+  /**
+   * the path to your static content folder
+   */
+  publish: string
+  base: string
+  services: Record<string, unknown>
+
+  /**
+   * Allows specifying a Bash command that will be run from the base directory to determine whether the site needs rebuilding or not.
+   * Check out our [ignore builds](https://docs.netlify.com/configure-builds/common-configurations/ignore-builds/) doc for more information on the default ignore behavior and details about constructing a custom ignore command.
+   */
+  ignore?: string
+
+  /**
+   * Includes the path to a site's [Edge Handlers directory](https://docs.netlify.com/edge-handlers/configure-and-build/#choose-an-edge-handlers-directory)
+   */
+  edge_handlers?: string
+  /**
+   * Contains a site's [environment variables](https://docs.netlify.com/configure-builds/environment-variables/#netlify-configuration-variables)
+   */
+  environment: Partial<Record<string, string>>
+  /**
+   * Includes options for [post processing](https://docs.netlify.com/configure-builds/file-based-configuration/#post-processing) HTML, CSS, JavaScript, and images
+   */
+  processing: {
+    skip_processing?: boolean
+    css: {
+      bundle?: boolean
+      minify?: boolean
+    }
+    js: {
+      bundle?: boolean
+      minify?: boolean
+    }
+    html: {
+      pretty_url?: boolean
+    }
+    images: {
+      compress?: boolean
+    }
+  }
+}
+
+/* eslint-enable camelcase */

package/types/config/functions.d.ts

@@ -0,0 +1,36 @@
+type GlobPattern = string
+
+/* eslint-disable camelcase -- some properties are named in snake case in this API */
+type FunctionsObject = {
+  /**
+   * a list of additional paths to include in the function bundle. Although our build system includes statically referenced files (like `import * from "./some-file.js"`) by default, `included_files` lets you specify additional files or directories and reference them dynamically in function code. You can use `*` to match any character or prefix an entry with `!` to exclude files. Paths are relative to the [base directory](https://docs.netlify.com/configure-builds/get-started/#definitions-1).
+   */
+  included_files?: string[]
+} & (
+  | {
+      /**
+       * the function bundling method used in [`@netlify/zip-it-and-ship-it`](https://github.com/netlify/zip-it-and-ship-it).
+       */
+      node_bundler?: 'zisi' | 'nft'
+    }
+  | {
+      /**
+       * the function bundling method used in [`@netlify/zip-it-and-ship-it`](https://github.com/netlify/zip-it-and-ship-it).
+       */
+      node_bundler?: 'esbuild' | 'none'
+
+      /**
+       * a list of Node.js modules that are copied to the bundled artifact without adjusting their source or references during the bundling process.
+       * This property helps handle dependencies that can’t be inlined, such as modules with native add-ons.
+       */
+      external_node_modules?: string[]
+
+      ignored_node_modules?: string[]
+    }
+)
+/* eslint-enable camelcase */
+
+export type Functions = {
+  '*': FunctionsObject
+  [pattern: GlobPattern]: FunctionsObject
+}

package/types/config/inputs.d.ts

@@ -0,0 +1,7 @@
+import { JSONValue } from '../utils/json_value'
+
+// Helper type to be used as a workaround for the fact that `interface`s don't have implicit
+// index signatures: https://github.com/microsoft/TypeScript/issues/15300
+export type StringKeys<TObject extends object> = keyof TObject & string
+
+export type PluginInputs<Keys extends string = string> = Partial<Record<Keys, JSONValue>>

package/types/config/netlify_config.d.ts

@@ -0,0 +1,58 @@
+import { Many } from '../utils/many'
+
+import { Build } from './build'
+import { Functions } from './functions'
+import { PluginInputs } from './inputs'
+
+type HttpStatusCode = number
+
+interface Redirect {
+  from: string
+  to?: string
+  status?: HttpStatusCode
+  force?: boolean
+  signed?: string
+  query?: Partial<Record<string, string>>
+  headers?: Partial<Record<string, string>>
+  conditions?: Partial<Record<'Language' | 'Role' | 'Country' | 'Cookie', readonly string[]>>
+}
+
+interface Header {
+  for: string
+  values: Partial<Record<string, Many<string, 'mutable'>>>
+}
+
+interface EdgeFunction {
+  path?: `/${string}`
+  function: string
+}
+
+interface NetlifyPlugin {
+  package: string
+  inputs: PluginInputs
+}
+
+/* eslint-disable camelcase -- some properties are named in snake case in this API */
+
+interface NetlifyConfig {
+  /**
+   * array of redirects with their modifiable options
+   */
+  redirects: Redirect[]
+  /**
+   * array of headers with their modifiable options
+   */
+  headers: Header[]
+  /**
+   * array of Edge Functions with their modifiable options
+   */
+  edge_functions: EdgeFunction[]
+  /**
+   * object with options for modifying [functions](https://docs.netlify.com/configure-builds/file-based-configuration/#functions)
+   */
+  functions: Functions
+  build: Build
+  plugins: readonly NetlifyPlugin[]
+}
+
+/* eslint-enable camelcase */

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export { NetlifyPlugin } from './netlify_plugin'
+export { NetlifyPluginOptions } from './netlify_plugin_options'
+export { OnBuild, OnEnd, OnError, OnPostBuild, OnPreBuild, OnSuccess } from './netlify_event_handler'
+export { NetlifyConfig } from './config/netlify_config'
+export { NetlifyPluginUtils } from './options'
+export { NetlifyPluginConstants } from './netlify_plugin_constants'
+export { ListedFunction, ListedFunctionFile } from './options/netlify_plugin_functions_util'

package/types/netlify_event_handler.d.ts

@@ -0,0 +1,29 @@
+import { PluginInputs, StringKeys } from './config/inputs'
+import { NetlifyPluginOptions } from './netlify_plugin_options'
+
+interface NetlifyEventHandler<PluginOptions extends NetlifyPluginOptions = NetlifyPluginOptions> {
+  (options: PluginOptions): void | Promise<void>
+}
+
+// To allow interfaces to be used as generics, since they lack implicit index signatures, we have to do some type shenanigans
+// to get TypeScript to behave as we want - only letting the keys of `TInputs` through, and thus not requiring a full index
+// signature on `TInputs`.
+// Related issues: https://github.com/microsoft/TypeScript/issues/15300, https://github.com/netlify/build/issues/3838
+export type OnPreBuild<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> = NetlifyEventHandler<
+  NetlifyPluginOptions<TInputs>
+>
+export type OnBuild<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> = NetlifyEventHandler<
+  NetlifyPluginOptions<TInputs>
+>
+export type OnPostBuild<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> = NetlifyEventHandler<
+  NetlifyPluginOptions<TInputs>
+>
+export type OnError<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> = NetlifyEventHandler<
+  NetlifyPluginOptions<TInputs> & { error: Error }
+>
+export type OnSuccess<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> = NetlifyEventHandler<
+  NetlifyPluginOptions<TInputs>
+>
+export type OnEnd<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> = NetlifyEventHandler<
+  NetlifyPluginOptions<TInputs> & { error?: Error }
+>