@netlify/build 27.20.4 → 27.20.6

package/lib/install/main.js

@@ -1,81 +1,67 @@
-import { homedir } from 'os'
-
-import { execa } from 'execa'
-import { pathExists } from 'path-exists'
-
-import { addErrorInfo } from '../error/info.js'
-
+import { homedir } from 'os';
+import { execa } from 'execa';
+import { pathExists } from 'path-exists';
+import { addErrorInfo } from '../error/info.js';
 // Install Node.js dependencies in a specific directory
 export const installDependencies = function ({ packageRoot, isLocal }) {
-  return runCommand({ packageRoot, isLocal, type: 'install' })
-}
-
+    return runCommand({ packageRoot, isLocal, type: 'install' });
+};
 // Add new Node.js dependencies, with exact semver ranges
 export const addExactDependencies = function ({ packageRoot, isLocal, packages }) {
-  return runCommand({ packageRoot, packages, isLocal, type: 'addExact' })
-}
-
+    return runCommand({ packageRoot, packages, isLocal, type: 'addExact' });
+};
 const runCommand = async function ({ packageRoot, packages = [], isLocal, type }) {
-  try {
-    const [command, ...args] = await getCommand({ packageRoot, type, isLocal })
-    await execa(command, [...args, ...packages], { cwd: packageRoot, all: true })
-  } catch (error) {
-    const message = getErrorMessage(error.all)
-    const errorA = new Error(`Error while installing dependencies in ${packageRoot}\n${message}`)
-    addErrorInfo(errorA, { type: 'dependencies' })
-    throw errorA
-  }
-}
-
+    try {
+        const [command, ...args] = await getCommand({ packageRoot, type, isLocal });
+        await execa(command, [...args, ...packages], { cwd: packageRoot, all: true });
+    }
+    catch (error) {
+        const message = getErrorMessage(error.all);
+        const errorA = new Error(`Error while installing dependencies in ${packageRoot}\n${message}`);
+        addErrorInfo(errorA, { type: 'dependencies' });
+        throw errorA;
+    }
+};
 // Retrieve the shell command to install or add dependencies
 const getCommand = async function ({ packageRoot, type, isLocal }) {
-  const manager = await getManager(type, packageRoot)
-  const command = COMMANDS[manager][type]
-  const commandA = addYarnCustomCache(command, manager, isLocal)
-  return commandA
-}
-
+    const manager = await getManager(type, packageRoot);
+    const command = COMMANDS[manager][type];
+    const commandA = addYarnCustomCache(command, manager, isLocal);
+    return commandA;
+};
 const getManager = async function (type, packageRoot) {
-  // `addDependencies()` always uses npm
-  if (type === 'addExact') {
-    return 'npm'
-  }
-
-  if (await pathExists(`${packageRoot}/yarn.lock`)) {
-    return 'yarn'
-  }
-
-  return 'npm'
-}
-
+    // `addDependencies()` always uses npm
+    if (type === 'addExact') {
+        return 'npm';
+    }
+    if (await pathExists(`${packageRoot}/yarn.lock`)) {
+        return 'yarn';
+    }
+    return 'npm';
+};
 const COMMANDS = {
-  npm: {
-    addExact: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund', '--save-exact'],
-    install: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund'],
-  },
-  yarn: {
-    install: ['yarn', 'install', '--no-progress', '--non-interactive'],
-  },
-}
-
+    npm: {
+        addExact: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund', '--save-exact'],
+        install: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund'],
+    },
+    yarn: {
+        install: ['yarn', 'install', '--no-progress', '--non-interactive'],
+    },
+};
 // In CI, yarn uses a custom cache folder
 const addYarnCustomCache = function (command, manager, isLocal) {
-  if (manager !== 'yarn' || isLocal) {
-    return command
-  }
-
-  return [...command, '--cache-folder', YARN_CI_CACHE_DIR]
-}
-
-const YARN_CI_CACHE_DIR = `${homedir()}/.yarn_cache`
-
+    if (manager !== 'yarn' || isLocal) {
+        return command;
+    }
+    return [...command, '--cache-folder', YARN_CI_CACHE_DIR];
+};
+const YARN_CI_CACHE_DIR = `${homedir()}/.yarn_cache`;
 // Retrieve message to add to install errors
 const getErrorMessage = function (allOutput) {
-  return allOutput.split('\n').filter(isNotNpmLogMessage).join('\n')
-}
-
+    return allOutput.split('\n').filter(isNotNpmLogMessage).join('\n');
+};
 // Debug logs shown at the end of npm errors is not useful in Netlify Build
 const isNotNpmLogMessage = function (line) {
-  return NPM_LOG_MESSAGES.every((message) => !line.includes(message))
-}
-const NPM_LOG_MESSAGES = ['complete log of this run', '-debug.log']
+    return NPM_LOG_MESSAGES.every((message) => !line.includes(message));
+};
+const NPM_LOG_MESSAGES = ['complete log of this run', '-debug.log'];

package/lib/install/missing.js

@@ -1,67 +1,54 @@
-import { promises as fs } from 'fs'
-import { normalize } from 'path'
-
-import { pathExists } from 'path-exists'
-import { isFile } from 'path-type'
-
-import { logInstallMissingPlugins } from '../log/messages/install.js'
-
-import { addExactDependencies } from './main.js'
-
+import { promises as fs } from 'fs';
+import { normalize } from 'path';
+import { pathExists } from 'path-exists';
+import { isFile } from 'path-type';
+import { logInstallMissingPlugins } from '../log/messages/install.js';
+import { addExactDependencies } from './main.js';
 // Automatically install plugins if not already installed.
 // Since this is done under the hood, we always use `npm` with specific `npm`
 // options. We do not allow configure the package manager nor its options.
 // Users requiring `yarn` or custom npm/yarn flags should install the plugin in
 // their `package.json`.
 export const installMissingPlugins = async function ({ missingPlugins, autoPluginsDir, mode, logs }) {
-  const packages = missingPlugins.map(getPackage)
-  logInstallMissingPlugins(logs, packages)
-
-  await createAutoPluginsDir(logs, autoPluginsDir)
-  await addExactDependencies({ packageRoot: autoPluginsDir, isLocal: mode !== 'buildbot', packages })
-}
-
+    const packages = missingPlugins.map(getPackage);
+    logInstallMissingPlugins(logs, packages);
+    await createAutoPluginsDir(logs, autoPluginsDir);
+    await addExactDependencies({ packageRoot: autoPluginsDir, isLocal: mode !== 'buildbot', packages });
+};
 // We pin the version without using semver ranges ^ nor ~
 const getPackage = function ({ packageName, expectedVersion }) {
-  return `${packageName}@${expectedVersion}`
-}
-
+    return `${packageName}@${expectedVersion}`;
+};
 const createAutoPluginsDir = async function (logs, autoPluginsDir) {
-  await ensureDir(logs, autoPluginsDir)
-  await createPackageJson(autoPluginsDir)
-}
-
+    await ensureDir(logs, autoPluginsDir);
+    await createPackageJson(autoPluginsDir);
+};
 // Create the directory if it does not exist
 const ensureDir = async function (logs, autoPluginsDir) {
-  if (await pathExists(autoPluginsDir)) {
-    return
-  }
-
-  // If `.netlify` exists but is not a directory, we remove it first
-  const autoPluginsParent = normalize(`${autoPluginsDir}/..`)
-  if (await isFile(autoPluginsParent)) {
-    await fs.unlink(autoPluginsParent)
-  }
-
-  await fs.mkdir(autoPluginsDir, { recursive: true })
-}
-
+    if (await pathExists(autoPluginsDir)) {
+        return;
+    }
+    // If `.netlify` exists but is not a directory, we remove it first
+    const autoPluginsParent = normalize(`${autoPluginsDir}/..`);
+    if (await isFile(autoPluginsParent)) {
+        await fs.unlink(autoPluginsParent);
+    }
+    await fs.mkdir(autoPluginsDir, { recursive: true });
+};
 // Create a dummy `package.json` so we can run `npm install` and get a lock file
 const createPackageJson = async function (autoPluginsDir) {
-  const packageJsonPath = `${autoPluginsDir}/package.json`
-  if (await pathExists(packageJsonPath)) {
-    return
-  }
-
-  const packageJsonContent = JSON.stringify(AUTO_PLUGINS_PACKAGE_JSON, null, 2)
-  await fs.writeFile(packageJsonPath, packageJsonContent)
-}
-
+    const packageJsonPath = `${autoPluginsDir}/package.json`;
+    if (await pathExists(packageJsonPath)) {
+        return;
+    }
+    const packageJsonContent = JSON.stringify(AUTO_PLUGINS_PACKAGE_JSON, null, 2);
+    await fs.writeFile(packageJsonPath, packageJsonContent);
+};
 const AUTO_PLUGINS_PACKAGE_JSON = {
-  name: 'netlify-local-plugins',
-  description: 'This directory contains Build plugins that have been automatically installed by Netlify.',
-  version: '1.0.0',
-  private: true,
-  author: 'Netlify',
-  license: 'MIT',
-}
+    name: 'netlify-local-plugins',
+    description: 'This directory contains Build plugins that have been automatically installed by Netlify.',
+    version: '1.0.0',
+    private: true,
+    author: 'Netlify',
+    license: 'MIT',
+};

package/lib/log/colors.js

@@ -1,34 +1,27 @@
-import { inspect } from 'util'
-
-import supportsColor from 'supports-color'
-
+import { inspect } from 'util';
+import supportsColor from 'supports-color';
 // Plugin child processes use `stdio: 'pipe'` so they are always
 // non-interactive even if the parent is an interactive TTY. This means they
 // would normally lose colors. If the parent has colors, we pass an environment
 // variable to the child process to force colors.
 export const getParentColorEnv = function () {
-  if (!hasColors()) {
-    return {}
-  }
-
-  return { FORCE_COLOR: '1' }
-}
-
+    if (!hasColors()) {
+        return {};
+    }
+    return { FORCE_COLOR: '1' };
+};
 // Child processes and the buildbot relies on `FORCE_COLOR=1` to set colors.
 // However `utils.inspect()` (used by `console.log()`) uses
 // `process.stdout.hasColors` which is always `undefined` when the TTY is
 // non-interactive. So we need to set `util.inspect.defaultOptions.colors`
 // manually both in plugin processes.
 export const setInspectColors = function () {
-  if (!hasColors()) {
-    return
-  }
-
-  // `inspect.defaultOptions` requires direct mutation
-
-  inspect.defaultOptions.colors = true
-}
-
+    if (!hasColors()) {
+        return;
+    }
+    // `inspect.defaultOptions` requires direct mutation
+    inspect.defaultOptions.colors = true;
+};
 const hasColors = function () {
-  return supportsColor.stdout !== false
-}
+    return supportsColor.stdout !== false;
+};

package/lib/log/description.js

@@ -1,26 +1,21 @@
 export const getBuildCommandDescription = function (buildCommandOrigin) {
-  return BUILD_COMMAND_DESCRIPTIONS[buildCommandOrigin]
-}
-
+    return BUILD_COMMAND_DESCRIPTIONS[buildCommandOrigin];
+};
 const BUILD_COMMAND_DESCRIPTIONS = {
-  ui: 'Build command from Netlify app',
-  config: 'build.command from netlify.toml',
-  inline: 'build.command from a plugin',
-}
-
+    ui: 'Build command from Netlify app',
+    config: 'build.command from netlify.toml',
+    inline: 'build.command from a plugin',
+};
 // Retrieve human-friendly plugin origin
 export const getPluginOrigin = function (loadedFrom, origin) {
-  const originName = PLUGIN_ORIGINS[origin]
-
-  if (loadedFrom === 'package.json') {
-    return `from ${originName} and package.json`
-  }
-
-  return `from ${originName}`
-}
-
+    const originName = PLUGIN_ORIGINS[origin];
+    if (loadedFrom === 'package.json') {
+        return `from ${originName} and package.json`;
+    }
+    return `from ${originName}`;
+};
 const PLUGIN_ORIGINS = {
-  core: 'core',
-  ui: 'Netlify app',
-  config: 'netlify.toml',
-}
+    core: 'core',
+    ui: 'Netlify app',
+    config: 'netlify.toml',
+};

package/lib/log/header.js

@@ -1,16 +1,14 @@
-import stringWidth from 'string-width'
-
+import stringWidth from 'string-width';
 // Print a rectangular header
 export const getHeader = function (message) {
-  const messageWidth = stringWidth(message)
-  const headerWidth = Math.max(HEADER_MIN_WIDTH, messageWidth)
-  const line = '─'.repeat(headerWidth + PADDING_WIDTH * 2)
-  const paddingLeft = ' '.repeat(PADDING_WIDTH)
-  const paddingRight = ' '.repeat(PADDING_WIDTH + headerWidth - messageWidth)
-  return `${line}
+    const messageWidth = stringWidth(message);
+    const headerWidth = Math.max(HEADER_MIN_WIDTH, messageWidth);
+    const line = '─'.repeat(headerWidth + PADDING_WIDTH * 2);
+    const paddingLeft = ' '.repeat(PADDING_WIDTH);
+    const paddingRight = ' '.repeat(PADDING_WIDTH + headerWidth - messageWidth);
+    return `${line}
 ${paddingLeft}${message}${paddingRight}
-${line}`
-}
-
-const HEADER_MIN_WIDTH = 60
-const PADDING_WIDTH = 2
+${line}`;
+};
+const HEADER_MIN_WIDTH = 60;
+const PADDING_WIDTH = 2;

package/lib/log/header_func.js

@@ -1,17 +1,13 @@
-import { parseErrorInfo } from '../error/parse/parse.js'
-
-import { logHeader, logErrorHeader } from './logger.js'
-
+import { parseErrorInfo } from '../error/parse/parse.js';
+import { logHeader, logErrorHeader } from './logger.js';
 // Retrieve successful or error header depending on whether `error` exists
 export const getLogHeaderFunc = function (error) {
-  if (error === undefined) {
-    return logHeader
-  }
-
-  const { severity } = parseErrorInfo(error)
-  if (severity === 'none') {
-    return logHeader
-  }
-
-  return logErrorHeader
-}
+    if (error === undefined) {
+        return logHeader;
+    }
+    const { severity } = parseErrorInfo(error);
+    if (severity === 'none') {
+        return logHeader;
+    }
+    return logErrorHeader;
+};

package/lib/log/logger.js

@@ -1,161 +1,130 @@
-import { createWriteStream } from 'fs'
-
-import figures from 'figures'
-import indentString from 'indent-string'
-
-import { getHeader } from './header.js'
-import { serializeObject, serializeArray } from './serialize.js'
-import { THEME } from './theme.js'
-
+import { createWriteStream } from 'fs';
+import figures from 'figures';
+import indentString from 'indent-string';
+import { getHeader } from './header.js';
+import { serializeObject, serializeArray } from './serialize.js';
+import { THEME } from './theme.js';
 // When the `buffer` option is true, we return logs instead of printing them
 // on the console. The logs are accumulated in a `logs` array variable.
 export const getBufferLogs = function ({ buffer = false }) {
-  if (!buffer) {
-    return
-  }
-
-  return { stdout: [], stderr: [] }
-}
-
+    if (!buffer) {
+        return;
+    }
+    return { stdout: [], stderr: [] };
+};
 // Core logging utility, used by the other methods.
 // This should be used instead of `console.log()` as it allows us to instrument
 // how any build logs is being printed.
 export const log = function (logs, string, { indent = false, color } = {}) {
-  const stringA = indent ? indentString(string, INDENT_SIZE) : string
-  const stringB = String(stringA).replace(EMPTY_LINES_REGEXP, EMPTY_LINE)
-  const stringC = color === undefined ? stringB : color(stringB)
-
-  if (logs !== undefined) {
-    // `logs` is a stateful variable
-
-    logs.stdout.push(stringC)
-    return
-  }
-
-  console.log(stringC)
-}
-
-const INDENT_SIZE = 2
-
+    const stringA = indent ? indentString(string, INDENT_SIZE) : string;
+    const stringB = String(stringA).replace(EMPTY_LINES_REGEXP, EMPTY_LINE);
+    const stringC = color === undefined ? stringB : color(stringB);
+    if (logs !== undefined) {
+        // `logs` is a stateful variable
+        logs.stdout.push(stringC);
+        return;
+    }
+    console.log(stringC);
+};
+const INDENT_SIZE = 2;
 // We need to add a zero width space character in empty lines. Otherwise the
 // buildbot removes those due to a bug: https://github.com/netlify/buildbot/issues/595
-const EMPTY_LINES_REGEXP = /^\s*$/gm
-const EMPTY_LINE = '\u{200B}'
-
+const EMPTY_LINES_REGEXP = /^\s*$/gm;
+const EMPTY_LINE = '\u{200B}';
 const serializeIndentedArray = function (array) {
-  return serializeArray(array.map(serializeIndentedItem))
-}
-
+    return serializeArray(array.map(serializeIndentedItem));
+};
 const serializeIndentedItem = function (item) {
-  return indentString(item, INDENT_SIZE + 1).trimStart()
-}
-
+    return indentString(item, INDENT_SIZE + 1).trimStart();
+};
 export const logError = function (logs, string, opts) {
-  log(logs, string, { color: THEME.errorLine, ...opts })
-}
-
+    log(logs, string, { color: THEME.errorLine, ...opts });
+};
 export const logWarning = function (logs, string, opts) {
-  log(logs, string, { color: THEME.warningLine, ...opts })
-}
-
+    log(logs, string, { color: THEME.warningLine, ...opts });
+};
 // Print a message that is under a header/subheader, i.e. indented
 export const logMessage = function (logs, string, opts) {
-  log(logs, string, { indent: true, ...opts })
-}
-
+    log(logs, string, { indent: true, ...opts });
+};
 // Print an object
 export const logObject = function (logs, object, opts) {
-  logMessage(logs, serializeObject(object), opts)
-}
-
+    logMessage(logs, serializeObject(object), opts);
+};
 // Print an array
 export const logArray = function (logs, array, opts) {
-  logMessage(logs, serializeIndentedArray(array), { color: THEME.none, ...opts })
-}
-
+    logMessage(logs, serializeIndentedArray(array), { color: THEME.none, ...opts });
+};
 // Print an array of errors
 export const logErrorArray = function (logs, array, opts) {
-  logMessage(logs, serializeIndentedArray(array), { color: THEME.errorLine, ...opts })
-}
-
+    logMessage(logs, serializeIndentedArray(array), { color: THEME.errorLine, ...opts });
+};
 // Print an array of warnings
 export const logWarningArray = function (logs, array, opts) {
-  logMessage(logs, serializeIndentedArray(array), { color: THEME.warningLine, ...opts })
-}
-
+    logMessage(logs, serializeIndentedArray(array), { color: THEME.warningLine, ...opts });
+};
 // Print a main section header
 export const logHeader = function (logs, string, opts) {
-  log(logs, `\n${getHeader(string)}`, { color: THEME.header, ...opts })
-}
-
+    log(logs, `\n${getHeader(string)}`, { color: THEME.header, ...opts });
+};
 // Print a main section header, when an error happened
 export const logErrorHeader = function (logs, string, opts) {
-  logHeader(logs, string, { color: THEME.errorHeader, ...opts })
-}
-
+    logHeader(logs, string, { color: THEME.errorHeader, ...opts });
+};
 // Print a sub-section header
 export const logSubHeader = function (logs, string, opts) {
-  log(logs, `\n${figures.pointer} ${string}`, { color: THEME.subHeader, ...opts })
-}
-
+    log(logs, `\n${figures.pointer} ${string}`, { color: THEME.subHeader, ...opts });
+};
 // Print a sub-section header, when an error happened
 export const logErrorSubHeader = function (logs, string, opts) {
-  logSubHeader(logs, string, { color: THEME.errorSubHeader, ...opts })
-}
-
+    logSubHeader(logs, string, { color: THEME.errorSubHeader, ...opts });
+};
 // Print a sub-section header, when a warning happened
 export const logWarningSubHeader = function (logs, string, opts) {
-  logSubHeader(logs, string, { color: THEME.warningSubHeader, ...opts })
-}
-
+    logSubHeader(logs, string, { color: THEME.warningSubHeader, ...opts });
+};
 // Combines an array of elements into a single string, separated by a space,
 // and with basic serialization of non-string types
 const reduceLogLines = function (lines) {
-  return lines
-    .map((input) => {
-      if (input instanceof Error) {
-        return `${input.message} ${input.stack}`
-      }
-
-      if (typeof input === 'object') {
-        try {
-          return JSON.stringify(input)
-        } catch {
-          // Value could not be serialized to JSON, so we return the string
-          // representation.
-          return String(input)
+    return lines
+        .map((input) => {
+        if (input instanceof Error) {
+            return `${input.message} ${input.stack}`;
         }
-      }
-
-      return String(input)
+        if (typeof input === 'object') {
+            try {
+                return JSON.stringify(input);
+            }
+            catch {
+                // Value could not be serialized to JSON, so we return the string
+                // representation.
+                return String(input);
+            }
+        }
+        return String(input);
     })
-    .join(' ')
-}
-
+        .join(' ');
+};
 // Builds a function for logging data to the system logger (i.e. hidden from
 // the user-facing build logs)
 export const getSystemLogger = function (logs, debug, systemLogFile) {
-  // If the `debug` flag is used, we return a function that pipes system logs
-  // to the regular logger, as the intention is for them to end up in stdout.
-  if (debug) {
-    return (...args) => log(logs, reduceLogLines(args))
-  }
-
-  // If there's not a file descriptor configured for system logs and `debug`
-  // is not set, we return a no-op function that will swallow the errors.
-  if (!systemLogFile) {
-    return () => {
-      // no-op
+    // If the `debug` flag is used, we return a function that pipes system logs
+    // to the regular logger, as the intention is for them to end up in stdout.
+    if (debug) {
+        return (...args) => log(logs, reduceLogLines(args));
+    }
+    // If there's not a file descriptor configured for system logs and `debug`
+    // is not set, we return a no-op function that will swallow the errors.
+    if (!systemLogFile) {
+        return () => {
+            // no-op
+        };
     }
-  }
-
-  // Return a function that writes to the file descriptor configured for system
-  // logs.
-  const fileDescriptor = createWriteStream(null, { fd: systemLogFile })
-
-  fileDescriptor.on('error', () => {
-    logError(logs, 'Could not write to system log file')
-  })
-
-  return (...args) => fileDescriptor.write(`${reduceLogLines(args)}\n`)
-}
+    // Return a function that writes to the file descriptor configured for system
+    // logs.
+    const fileDescriptor = createWriteStream(null, { fd: systemLogFile });
+    fileDescriptor.on('error', () => {
+        logError(logs, 'Could not write to system log file');
+    });
+    return (...args) => fileDescriptor.write(`${reduceLogLines(args)}\n`);
+};