@netlify/build 19.0.8 → 20.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "19.0.8",
+  "version": "20.0.3",
   "description": "Netlify build module",
   "main": "src/core/main.js",
   "types": "types/index.d.ts",
@@ -58,10 +58,10 @@
     "@netlify/config": "^16.0.0",
     "@netlify/functions-utils": "^3.0.0",
     "@netlify/git-utils": "^3.0.0",
-    "@netlify/plugin-edge-handlers": "^2.0.0",
+    "@netlify/plugin-edge-handlers": "^3.0.0",
     "@netlify/plugins-list": "^5.0.0",
     "@netlify/run-utils": "^3.0.0",
-    "@netlify/zip-it-and-ship-it": "^5.1.0",
+    "@netlify/zip-it-and-ship-it": "^5.2.0",
     "@sindresorhus/slugify": "^1.1.0",
     "ansi-escapes": "^4.3.2",
     "chalk": "^4.1.2",

package/src/plugins/child/load.js

@@ -11,9 +11,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 }) {
   const tsNodeService = registerTypeScript(pluginPath)
-  const logic = getLogic({ pluginPath, inputs, tsNodeService })
+  const logic = await getLogic({ pluginPath, inputs, tsNodeService })
 
   validatePlugin(logic)
 

package/src/plugins/child/logic.js

@@ -1,22 +1,43 @@
 'use strict'
 
+const { pathToFileURL } = require('url')
+
 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, tsNodeService }) {
-  const logic = requireLogic(pluginPath, tsNodeService)
+const getLogic = async function ({ pluginPath, inputs, tsNodeService }) {
+  const logic = await importLogic(pluginPath, tsNodeService)
   const logicA = loadLogic({ logic, inputs })
   return logicA
 }
 
-const requireLogic = function (pluginPath, tsNodeService) {
+const importLogic = async function (pluginPath, tsNodeService) {
   try {
-    // eslint-disable-next-line node/global-require, import/no-dynamic-require
-    return require(pluginPath)
+    // `ts-node` is not available programmatically for pure ES modules yet,
+    // which is currently making it impossible for local plugins to use both
+    // pure ES modules and TypeScript.
+    if (tsNodeService !== undefined) {
+      // eslint-disable-next-line node/global-require, import/no-dynamic-require
+      return require(pluginPath)
+    }
+
+    // `pluginPath` is an absolute file path but `import()` needs URLs.
+    // Converting those with `pathToFileURL()` is needed especially on Windows
+    // where the drive letter would not work with `import()`.
+    const returnValue = await import(pathToFileURL(pluginPath))
+    // Plugins should use named exports, but we still support default exports
+    // for backward compatibility with CommonJS
+    return returnValue.default === undefined ? returnValue : returnValue.default
   } catch (error) {
     addTsErrorInfo(error, tsNodeService)
-    error.message = `Could not import plugin:\n${error.message}`
+    // We must change `error.stack` instead of `error.message` because some
+    // errors thrown from `import()` access `error.stack` before throwing.
+    // `error.stack` is lazily instantiated by Node.js, so changing
+    // `error.message` afterwards would not modify `error.stack`. Therefore, the
+    // resulting stack trace, which is printed in the build logs, would not
+    // include the additional message prefix.
+    error.stack = `Could not import plugin:\n${error.stack}`
     throw error
   }
 }

package/src/plugins/child/validate.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const isPlainObj = require('is-plain-obj')
-
 const { addErrorInfo } = require('../../error/info')
 const { serializeArray } = require('../../log/serialize')
 const { EVENTS } = require('../events')
@@ -9,7 +7,9 @@ const { EVENTS } = require('../events')
 // Validate the shape of a plugin return value
 const validatePlugin = function (logic) {
   try {
-    if (!isPlainObj(logic)) {
+    // This validation must work with the return value of `import()` which has
+    // a `Module` prototype, not `Object`
+    if (typeof logic !== 'object' || logic === null) {
       throw new Error('Plugin must be an object or a function')
     }
 

package/types/index.d.ts

@@ -4,3 +4,4 @@ export { OnBuild, OnEnd, OnError, OnPostBuild, OnPreBuild, OnSuccess } from './n
 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/options/netlify_plugin_functions_util.d.ts

@@ -0,0 +1,32 @@
+import type { listFunctions, listFunctionsFiles } from '@netlify/zip-it-and-ship-it'
+
+type Resolved<T> = T extends Promise<infer U> ? U : T
+
+export type ListedFunction = Resolved<ReturnType<typeof listFunctions>>[0]
+export type ListedFunctionFile = Resolved<ReturnType<typeof listFunctionsFiles>>[0]
+
+export interface NetlifyPluginFunctionsUtil {
+  /**
+   * Returns the list of Netlify Functions main files as a Promise resolving to an array of objects with the following properties:
+   *
+   * - `name`: Function name, as used in the URL `https://{hostname}/.netlify/functions/{name}`
+   * - `mainFile`: absolute path to the Function's main file
+   * - `extension`: file extension of the Function's main file. For Go Functions, this might be an empty string.  For Node.js Functions, this is either `.js` or `.zip`.
+   * - `runtime` `"js" | "go"`: Function's language runtime. TypeScript Functions use the "js" runtime
+   */
+  list(): Promise<Array<ListedFunction>>
+
+  /**
+   * Same as `list()` except it also returns the files required by the Functions' main files. This is much slower. The object have the following additional member:
+   *
+   * - `srcFile`: absolute path to the file
+   */
+  listAll(): Promise<Array<ListedFunctionFile>>
+
+  /**
+   * Add a Functions file or directory to a build.
+   *
+   * @param path Path to the function file or directory.
+   */
+  add(path: string): Promise<void>
+}

package/types/options/netlify_plugin_utils.d.ts

@@ -1,5 +1,6 @@
 import { NetlifyPluginBuildUtil } from './netlify_plugin_build_util'
 import { NetlifyPluginCacheUtil } from './netlify_plugin_cache_util'
+import { NetlifyPluginFunctionsUtil } from './netlify_plugin_functions_util'
 import { NetlifyPluginGitUtil } from './netlify_plugin_git_util'
 import { NetlifyPluginRunUtil } from './netlify_plugin_run_util'
 import { NetlifyPluginStatusUtil } from './netlify_plugin_status_util'
@@ -10,4 +11,5 @@ export interface NetlifyPluginUtils {
   cache: NetlifyPluginCacheUtil
   run: NetlifyPluginRunUtil
   git: NetlifyPluginGitUtil
+  functions: NetlifyPluginFunctionsUtil
 }