@netlify/build 18.22.0 → 18.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "18.22.0",
+  "version": "18.25.0",
   "description": "Netlify build module",
   "main": "src/core/main.js",
   "types": "types/index.d.ts",
@@ -61,7 +61,7 @@
     "@netlify/plugin-edge-handlers": "^1.11.22",
     "@netlify/plugins-list": "^4.2.0",
     "@netlify/run-utils": "^2.0.0",
-    "@netlify/zip-it-and-ship-it": "^4.29.4",
+    "@netlify/zip-it-and-ship-it": "^4.30.0",
     "@sindresorhus/slugify": "^1.1.0",
     "@ungap/from-entries": "^0.2.1",
     "ansi-escapes": "^4.3.2",

package/src/error/monitor/print.js

@@ -10,7 +10,14 @@ const printEventForTest = function (
     groupingHash,
     severity,
     unhandled,
-    _metadata: { location, plugin: { packageName, homepage } = {}, pluginPackageJson, env: { BUILD_ID } = {}, other },
+    _metadata: {
+      location,
+      plugin: { packageName, homepage } = {},
+      pluginPackageJson,
+      tsConfig,
+      env: { BUILD_ID } = {},
+      other,
+    },
   },
   logs,
 ) {
@@ -26,6 +33,7 @@ const printEventForTest = function (
       packageName,
       pluginPackageJson: pluginPackageJson !== undefined,
       homepage,
+      tsConfig,
       BUILD_ID,
       other,
     },

package/src/error/monitor/report.js

@@ -60,11 +60,11 @@ const getGroupingHash = function (group, error, type) {
   return `${group}\n${messageA}`
 }
 
-const getMetadata = function ({ location, plugin }, childEnv, groupingHash) {
+const getMetadata = function ({ location, plugin, tsConfig }, childEnv, groupingHash) {
   const pluginMetadata = getPluginMetadata({ location, plugin })
   const envMetadata = getEnvMetadata(childEnv)
   const locationMetadata = getLocationMetadata(location, envMetadata)
-  return { location: locationMetadata, ...pluginMetadata, env: envMetadata, other: { groupingHash } }
+  return { location: locationMetadata, ...pluginMetadata, tsConfig, env: envMetadata, other: { groupingHash } }
 }
 
 const getPluginMetadata = function ({ location, plugin }) {

package/src/error/parse/parse.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { serializeObject } = require('../../log/serialize')
 const { getErrorInfo } = require('../info')
 const { getTypeInfo } = require('../type')
 
@@ -17,7 +18,7 @@ const getFullErrorInfo = function ({ error, colors, debug }) {
     stack,
     errorProps,
     errorInfo,
-    errorInfo: { location = {}, plugin = {} },
+    errorInfo: { location = {}, plugin = {}, tsConfig },
     severity,
     title,
     stackType,
@@ -31,10 +32,28 @@ const getFullErrorInfo = function ({ error, colors, debug }) {
   const { message: messageA, stack: stackA } = getStackInfo({ message, stack, stackType, rawStack, severity, debug })
 
   const pluginInfo = getPluginInfo(plugin, location)
+  const tsConfigInfo = getTsConfigInfo(tsConfig)
   const locationInfo = getLocationInfo({ stack: stackA, location, locationType })
   const errorPropsA = getErrorProps({ errorProps, showErrorProps, colors })
 
-  return { ...basicErrorInfo, title: titleA, message: messageA, pluginInfo, locationInfo, errorProps: errorPropsA }
+  return {
+    ...basicErrorInfo,
+    title: titleA,
+    message: messageA,
+    tsConfigInfo,
+    pluginInfo,
+    locationInfo,
+    errorProps: errorPropsA,
+  }
+}
+
+// Serialize the `tsConfig` error information
+const getTsConfigInfo = function (tsConfig) {
+  if (tsConfig === undefined) {
+    return
+  }
+
+  return serializeObject(tsConfig)
 }
 
 // Parse error instance into all the basic properties containing information

package/src/error/parse/serialize_log.js

@@ -4,19 +4,20 @@ const { THEME } = require('../../log/theme')
 
 // Serialize an error object into a title|body string to print in logs
 const serializeLogError = function ({
-  fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, errorProps },
+  fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, tsConfigInfo, errorProps },
 }) {
-  const body = getBody({ message, pluginInfo, locationInfo, errorProps, severity })
+  const body = getBody({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity })
   return { title, body }
 }
 
-const getBody = function ({ message, pluginInfo, locationInfo, errorProps, severity }) {
+const getBody = function ({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity }) {
   if (severity === 'none') {
     return message
   }
 
   return Object.entries({
     message,
+    tsConfigInfo,
     pluginInfo,
     locationInfo,
     errorProps,
@@ -38,6 +39,7 @@ const LOG_BLOCK_NAMES = {
   message: 'Error message',
   pluginInfo: 'Plugin details',
   locationInfo: 'Error location',
+  tsConfigInfo: 'TypeScript configuration',
   errorProps: 'Error properties',
 }
 

package/src/log/messages/mutations.js

@@ -9,12 +9,23 @@ const { log, logMessage, logSubHeader } = require('../logger')
 
 const pReadFile = promisify(readFile)
 
-const logConfigMutations = function (logs, newConfigMutations) {
-  newConfigMutations.forEach(({ keysString, value }) => {
+const logConfigMutations = function (logs, newConfigMutations, debug) {
+  const configMutationsToLog = debug ? newConfigMutations : newConfigMutations.filter(shouldLogConfigMutation)
+  configMutationsToLog.forEach(({ keysString, value }) => {
     logConfigMutation(logs, keysString, value)
   })
 }
 
+// Some configuration mutations are only logged in debug mode
+const shouldLogConfigMutation = function ({ keysString }) {
+  return !HIDDEN_PROPS.some((hiddenProp) => keysString.startsWith(hiddenProp))
+}
+
+// `functions` is an object which can have thousands of properties, one per
+// function file. This can be very verbose, especially for plugins which create
+// many function files like Essential Next.js
+const HIDDEN_PROPS = ['functions']
+
 const logConfigMutation = function (logs, keysString, value) {
   const newValue = shouldHideConfigValue(keysString) ? '' : ` to ${inspect(value, { colors: false })}`
   log(logs, `Netlify configuration property "${keysString}" value changed${newValue}.`)

package/src/plugins/child/load.js

@@ -9,9 +9,9 @@ const { validatePlugin } = require('./validate')
 // This also validates the plugin.
 // Do it when parent requests it using the `load` event.
 // Also figure out the list of plugin steps. This is also passed to the parent.
-const load = function ({ pluginPath, inputs, packageJson }) {
+const load = async function ({ pluginPath, inputs, packageJson }) {
   registerTypeScript(pluginPath)
-  const logic = getLogic({ pluginPath, inputs })
+  const logic = await getLogic({ pluginPath, inputs })
 
   validatePlugin(logic)
 

package/src/plugins/child/logic.js

@@ -1,18 +1,21 @@
 'use strict'
 
+const { addTsErrorInfo } = require('./typescript')
+
 // Require the plugin file and fire its top-level function.
 // The returned object is the `logic` which includes all event handlers.
-const getLogic = function ({ pluginPath, inputs }) {
-  const logic = requireLogic(pluginPath)
+const getLogic = async function ({ pluginPath, inputs }) {
+  const logic = await requireLogic(pluginPath)
   const logicA = loadLogic({ logic, inputs })
   return logicA
 }
 
-const requireLogic = function (pluginPath) {
+const requireLogic = async function (pluginPath) {
   try {
     // eslint-disable-next-line node/global-require, import/no-dynamic-require
     return require(pluginPath)
   } catch (error) {
+    await addTsErrorInfo(error, pluginPath)
     error.message = `Could not import plugin:\n${error.message}`
     throw error
   }

package/src/plugins/child/typescript.js

@@ -2,8 +2,11 @@
 
 const { extname } = require('path')
 
+const execa = require('execa')
 const { register } = require('ts-node')
 
+const { addErrorInfo } = require('../../error/info')
+
 // Allow local plugins to be written with TypeScript.
 // Local plugins cannot be transpiled by the build command since they can be run
 // before it. Therefore, we type-check and transpile them automatically using
@@ -16,10 +19,32 @@ const registerTypeScript = function (pluginPath) {
   register()
 }
 
+// On TypeScript errors, adds information about the `ts-node` configuration,
+// which includes the resolved `tsconfig.json`.
+const addTsErrorInfo = async function (error, pluginPath) {
+  if (!isTypeScriptPlugin(pluginPath)) {
+    return
+  }
+
+  const { stdout } = await execa.command('ts-node --show-config')
+  const tsConfig = safeJsonParse(stdout)
+  addErrorInfo(error, { tsConfig })
+}
+
+// The output of `ts-node --show-config` should be JSON.
+// This is just a failsafe.
+const safeJsonParse = function (stdout) {
+  try {
+    return JSON.parse(stdout)
+  } catch (error) {
+    return { stdout, parsingError: error.message }
+  }
+}
+
 const isTypeScriptPlugin = function (pluginPath) {
   return TYPESCRIPT_EXTENSIONS.has(extname(pluginPath))
 }
 
 const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts'])
 
-module.exports = { registerTypeScript }
+module.exports = { registerTypeScript, addTsErrorInfo }

package/src/plugins_core/functions/feature_flags.js

@@ -3,7 +3,7 @@
 const getZisiFeatureFlags = (featureFlags) => ({
   buildGoSource: featureFlags.buildbot_build_go_functions,
   defaultEsModulesToEsbuild: featureFlags.buildbot_es_modules_esbuild,
-  nftTranspile: featureFlags.buildbot_zisi_trace_nft,
+  nftTranspile: featureFlags.buildbot_nft_transpile_esm || featureFlags.buildbot_zisi_trace_nft,
   parseWithEsbuild: featureFlags.buildbot_zisi_esbuild_parser,
   traceWithNft: featureFlags.buildbot_zisi_trace_nft,
 })

package/src/steps/update_config.js

@@ -29,7 +29,7 @@ const updateNetlifyConfig = async function ({
   }
 
   validateConfigMutations(newConfigMutations)
-  logConfigMutations(logs, newConfigMutations)
+  logConfigMutations(logs, newConfigMutations, debug)
   const configMutationsA = [...configMutations, ...newConfigMutations]
   const {
     config: netlifyConfigA,

package/types/config/inputs.d.ts

@@ -1,3 +1,7 @@
 import { JSONValue } from '../utils/json_value'
 
-export type PluginInputs = Partial<Record<string, JSONValue>>
+// 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/netlify_event_handler.d.ts

@@ -1,19 +1,29 @@
-import { PluginInputs } from './config/inputs'
+import { PluginInputs, StringKeys } from './config/inputs'
 import { NetlifyPluginOptions } from './netlify_plugin_options'
 
 interface NetlifyEventHandler<PluginOptions extends NetlifyPluginOptions = NetlifyPluginOptions> {
   (options: PluginOptions): void | Promise<void>
 }
 
-export type OnPreBuild<TInputs extends PluginInputs = PluginInputs> = NetlifyEventHandler<NetlifyPluginOptions<TInputs>>
-export type OnBuild<TInputs extends PluginInputs = PluginInputs> = NetlifyEventHandler<NetlifyPluginOptions<TInputs>>
-export type OnPostBuild<TInputs extends PluginInputs = PluginInputs> = NetlifyEventHandler<
+// 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 OnError<TInputs extends PluginInputs = PluginInputs> = NetlifyEventHandler<
+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 = PluginInputs> = NetlifyEventHandler<NetlifyPluginOptions<TInputs>>
-export type OnEnd<TInputs extends PluginInputs = PluginInputs> = NetlifyEventHandler<
+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 }
 >

package/types/netlify_plugin_options.d.ts

@@ -1,10 +1,10 @@
-import { PluginInputs } from './config/inputs'
+import { PluginInputs, StringKeys } from './config/inputs'
 import { NetlifyConfig } from './config/netlify_config'
 import { NetlifyPluginConstants } from './netlify_plugin_constants'
 import { NetlifyPluginUtils } from './options/netlify_plugin_utils'
 import { JSONValue } from './utils/json_value'
 
-export interface NetlifyPluginOptions<TInputs extends PluginInputs = PluginInputs> {
+export interface NetlifyPluginOptions<TInputs extends PluginInputs<StringKeys<TInputs>> = PluginInputs> {
   /**
    * If your plugin requires additional values from the user, you can specify these requirements in an `inputs` array in the plugin’s [`manifest.yml` file](https://docs.netlify.com/configure-builds/build-plugins/create-plugins/#anatomy-of-a-plugin).
    */