netlify-cli 16.5.1 → 16.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "16.5.1",
+  "version": "16.6.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -44,13 +44,13 @@
   "dependencies": {
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
-    "@netlify/build": "29.21.2",
-    "@netlify/build-info": "7.9.0",
+    "@netlify/build": "29.22.1",
+    "@netlify/build-info": "7.10.0",
     "@netlify/config": "20.9.0",
     "@netlify/edge-bundler": "9.1.0",
     "@netlify/local-functions-proxy": "1.1.1",
-    "@netlify/serverless-functions-api": "1.7.3",
-    "@netlify/zip-it-and-ship-it": "9.19.0",
+    "@netlify/serverless-functions-api": "1.8.0",
+    "@netlify/zip-it-and-ship-it": "9.23.0",
     "@octokit/rest": "19.0.13",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",

package/src/lib/functions/form-submissions-handler.mjs

@@ -29,7 +29,12 @@ const getFormHandler = function ({ functionsRegistry }) {
 
 export const createFormSubmissionHandler = function ({ functionsRegistry, siteUrl }) {
   return async function formSubmissionHandler(req, res, next) {
-    if (req.url.startsWith('/.netlify/') || req.method !== 'POST') return next()
+    if (
+      req.url.startsWith('/.netlify/') ||
+      req.method !== 'POST' ||
+      (await functionsRegistry.getFunctionForURLPath(req.url, req.method))
+    )
+      return next()
 
     const fakeRequest = new Readable({
       read() {

package/src/lib/functions/netlify-function.mjs

@@ -1,4 +1,5 @@
 // @ts-check
+import { basename, extname } from 'path'
 import { version as nodeVersion } from 'process'
 
 import CronParser from 'cron-parser'
@@ -7,6 +8,7 @@ import semver from 'semver'
 import { error as errorExit } from '../../utils/command-helpers.mjs'
 import { BACKGROUND } from '../../utils/functions/get-functions.mjs'
 
+const TYPESCRIPT_EXTENSIONS = new Set(['.cts', '.mts', '.ts'])
 const V2_MIN_NODE_VERSION = '18.0.0'
 
 // Returns a new set with all elements of `setA` that don't exist in `setB`.
@@ -57,6 +59,35 @@ export default class NetlifyFunction {
     this.srcFiles = new Set()
   }
 
+  get filename() {
+    if (!this.buildData?.mainFile) {
+      return null
+    }
+
+    return basename(this.buildData.mainFile)
+  }
+
+  getRecommendedExtension() {
+    if (this.buildData?.runtimeAPIVersion !== 2) {
+      return
+    }
+
+    const extension = this.buildData?.mainFile ? extname(this.buildData.mainFile) : undefined
+    const moduleFormat = this.buildData?.outputModuleFormat
+
+    if (moduleFormat === 'esm') {
+      return
+    }
+
+    if (extension === '.ts') {
+      return '.mts'
+    }
+
+    if (extension === '.js') {
+      return '.mjs'
+    }
+  }
+
   hasValidName() {
     // same as https://github.com/netlify/bitballoon/blob/fbd7881e6c8e8c48e7a0145da4ee26090c794108/app/models/deploy.rb#L482
     // eslint-disable-next-line unicorn/better-regex
@@ -73,6 +104,14 @@ export default class NetlifyFunction {
     return !(this.buildData?.runtimeAPIVersion === 2 && semver.lt(nodeVersion, V2_MIN_NODE_VERSION))
   }
 
+  isTypeScript() {
+    if (this.filename === null) {
+      return false
+    }
+
+    return TYPESCRIPT_EXTENSIONS.has(extname(this.filename))
+  }
+
   async getNextRun() {
     if (!(await this.isScheduled())) {
       return null
@@ -111,7 +150,7 @@ export default class NetlifyFunction {
         throw new Error(
           `Function requires Node.js version ${V2_MIN_NODE_VERSION} or above, but ${nodeVersion.slice(
             1,
-          )} is installed. Refer to https://ntl.fyi/functions-node18 for information on how to update.`,
+          )} is installed. Refer to https://ntl.fyi/functions-runtime for information on how to update.`,
         )
       }
 
@@ -123,6 +162,12 @@ export default class NetlifyFunction {
     }
   }
 
+  async getBuildData() {
+    await this.buildQueue
+
+    return this.buildData
+  }
+
   // Compares a new set of source files against a previous one, returning an
   // object with two Sets, one with added and the other with deleted files.
   getSrcFilesDiff(newSrcFiles) {
@@ -167,7 +212,8 @@ export default class NetlifyFunction {
   async matchURLPath(rawPath, method) {
     await this.buildQueue
 
-    const path = (rawPath.endsWith('/') ? rawPath.slice(0, -1) : rawPath).toLowerCase()
+    let path = rawPath !== '/' && rawPath.endsWith('/') ? rawPath.slice(0, -1) : rawPath
+    path = path.toLowerCase()
     const { routes = [] } = this.buildData
     return routes.find(({ expression, literal, methods }) => {
       if (methods.length !== 0 && !methods.includes(method)) {
@@ -188,6 +234,10 @@ export default class NetlifyFunction {
     })
   }
 
+  get runtimeAPIVersion() {
+    return this.buildData?.runtimeAPIVersion ?? 1
+  }
+
   get url() {
     // This line fixes the issue here https://github.com/netlify/cli/issues/4116
     // Not sure why `settings.port` was used here nor does a valid reference exist.

package/src/lib/functions/registry.mjs

@@ -1,12 +1,22 @@
 // @ts-check
 import { mkdir } from 'fs/promises'
-import { extname, isAbsolute, join, resolve } from 'path'
+import { createRequire } from 'module'
+import { basename, extname, isAbsolute, join, resolve } from 'path'
 import { env } from 'process'
 
 import { listFunctions } from '@netlify/zip-it-and-ship-it'
 import extractZip from 'extract-zip'
 
-import { chalk, log, NETLIFYDEVERR, NETLIFYDEVLOG, warn, watchDebounced } from '../../utils/command-helpers.mjs'
+import {
+  chalk,
+  log,
+  getTerminalLink,
+  NETLIFYDEVERR,
+  NETLIFYDEVLOG,
+  NETLIFYDEVWARN,
+  warn,
+  watchDebounced,
+} from '../../utils/command-helpers.mjs'
 import { INTERNAL_FUNCTIONS_FOLDER, SERVE_FUNCTIONS_FOLDER } from '../../utils/functions/functions.mjs'
 import { BACKGROUND_FUNCTIONS_WARNING } from '../log.mjs'
 import { getPathInProject } from '../settings.mjs'
@@ -14,10 +24,25 @@ import { getPathInProject } from '../settings.mjs'
 import NetlifyFunction from './netlify-function.mjs'
 import runtimes from './runtimes/index.mjs'
 
+export const DEFAULT_FUNCTION_URL_EXPRESSION = /^\/.netlify\/(functions|builders)\/([^/]+).*/
+const TYPES_PACKAGE = '@netlify/functions'
 const ZIP_EXTENSION = '.zip'
 
+/**
+ * @typedef {"buildError" | "extracted" | "loaded" | "missing-types-package" | "reloaded" | "reloading" | "removed"} FunctionEvent
+ */
+
 export class FunctionsRegistry {
-  constructor({ capabilities, config, debug = false, isConnected = false, projectRoot, settings, timeouts }) {
+  constructor({
+    capabilities,
+    config,
+    debug = false,
+    isConnected = false,
+    logLambdaCompat,
+    projectRoot,
+    settings,
+    timeouts,
+  }) {
     this.capabilities = capabilities
     this.config = config
     this.debug = debug
@@ -26,25 +51,78 @@ export class FunctionsRegistry {
     this.timeouts = timeouts
     this.settings = settings
 
-    // An object to be shared among all functions in the registry. It can be
-    // used to cache the results of the build function — e.g. it's used in
-    // the `memoizedBuild` method in the JavaScript runtime.
+    /**
+     * An object to be shared among all functions in the registry. It can be
+     * used to cache the results of the build function — e.g. it's used in
+     * the `memoizedBuild` method in the JavaScript runtime.
+     *
+     * @type {Record<string, unknown>}
+     */
     this.buildCache = {}
 
-    // File watchers for parent directories where functions live — i.e. the
-    // ones supplied to `scan()`. This is a Map because in the future we
-    // might have several function directories.
+    /**
+     * File watchers for parent directories where functions live — i.e. the
+     * ones supplied to `scan()`. This is a Map because in the future we
+     * might have several function directories.
+     *
+     * @type {Map<string, Awaited<ReturnType<watchDebounced>>>}
+     */
     this.directoryWatchers = new Map()
 
-    // The functions held by the registry. Maps function names to instances of
-    // `NetlifyFunction`.
+    /**
+     * The functions held by the registry
+     *
+     * @type {Map<string, NetlifyFunction>}
+     */
     this.functions = new Map()
 
-    // File watchers for function files. Maps function names to objects built
-    // by the `watchDebounced` utility.
+    /**
+     * File watchers for function files. Maps function names to objects built
+     * by the `watchDebounced` utility.
+     *
+     * @type {Map<string, Awaited<ReturnType<watchDebounced>>>}
+     */
     this.functionWatchers = new Map()
+
+    /**
+     * Keeps track of whether we've checked whether `TYPES_PACKAGE` is
+     * installed.
+     */
+    this.hasCheckedTypesPackage = false
+
+    /**
+     * Whether to log V1 functions as using the "Lambda compatibility mode"
+     *
+     * @type {boolean}
+     */
+    this.logLambdaCompat = Boolean(logLambdaCompat)
+  }
+
+  checkTypesPackage() {
+    if (this.hasCheckedTypesPackage) {
+      return
+    }
+
+    this.hasCheckedTypesPackage = true
+
+    const require = createRequire(this.projectRoot)
+
+    try {
+      require.resolve(TYPES_PACKAGE, { paths: [this.projectRoot] })
+    } catch (error) {
+      if (error?.code === 'MODULE_NOT_FOUND') {
+        FunctionsRegistry.logEvent('missing-types-package', {})
+      }
+    }
   }
 
+  /**
+   * Runs before `scan` and calls any `onDirectoryScan` hooks defined by the
+   * runtime before the directory is read. This gives runtime the opportunity
+   * to run additional logic when a directory is scanned.
+   *
+   * @param {string} directory
+   */
   static async prepareDirectoryScan(directory) {
     await mkdir(directory, { recursive: true })
 
@@ -62,23 +140,45 @@ export class FunctionsRegistry {
     )
   }
 
+  /**
+   * Builds a function and sets up the appropriate file watchers so that any
+   * changes will trigger another build.
+   *
+   * @param {NetlifyFunction} func
+   * @param {boolean} [firstLoad ]
+   * @returns
+   */
   async buildFunctionAndWatchFiles(func, firstLoad = false) {
     if (!firstLoad) {
-      log(`${NETLIFYDEVLOG} ${chalk.magenta('Reloading')} function ${chalk.yellow(func.displayName)}...`)
+      FunctionsRegistry.logEvent('reloading', { func })
     }
 
     const { error: buildError, includedFiles, srcFilesDiff } = await func.build({ cache: this.buildCache })
 
     if (buildError) {
-      log(
-        `${NETLIFYDEVERR} ${chalk.red('Failed to load')} function ${chalk.yellow(func.displayName)}: ${
-          buildError.message
-        }`,
-      )
+      FunctionsRegistry.logEvent('buildError', { func })
     } else {
-      const verb = firstLoad ? 'Loaded' : 'Reloaded'
+      const event = firstLoad ? 'loaded' : 'reloaded'
+      const recommendedExtension = func.getRecommendedExtension()
+
+      if (recommendedExtension) {
+        const { filename } = func
+        const newFilename = filename ? `${basename(filename, extname(filename))}${recommendedExtension}` : null
+        const action = newFilename
+          ? `rename the function file to ${chalk.underline(
+              newFilename,
+            )}. Refer to https://ntl.fyi/functions-runtime for more information`
+          : `refer to https://ntl.fyi/functions-runtime`
+        const warning = `The function is using the legacy CommonJS format. To start using ES modules, ${action}.`
+
+        FunctionsRegistry.logEvent(event, { func, warnings: [warning] })
+      } else {
+        FunctionsRegistry.logEvent(event, { func })
+      }
+    }
 
-      log(`${NETLIFYDEVLOG} ${chalk.green(verb)} function ${chalk.yellow(func.displayName)}`)
+    if (func.isTypeScript()) {
+      this.checkTypesPackage()
     }
 
     // If the build hasn't resulted in any files being added or removed, there
@@ -107,7 +207,6 @@ export class FunctionsRegistry {
     // we create a new watcher and watch them.
     if (srcFilesDiff.added.size !== 0) {
       const filesToWatch = [...srcFilesDiff.added, ...includedFiles]
-
       const newWatcher = await watchDebounced(filesToWatch, {
         onChange: () => {
           this.buildFunctionAndWatchFiles(func, false)
@@ -118,11 +217,53 @@ export class FunctionsRegistry {
     }
   }
 
+  /**
+   * Returns a function by name.
+   *
+   * @param {string} name
+   */
   get(name) {
     return this.functions.get(name)
   }
 
-  async getFunctionForURLPath(urlPath, method) {
+  /**
+   * Returns the first function in the registry that matches a given URL path
+   * and an HTTP method. If no match is found, `undefined` is returned.
+   *
+   * @param {string} url
+   * @param {string} method
+   */
+  async getFunctionForURLPath(url, method) {
+    // We're constructing a URL object just so that we can extract the path from
+    // the incoming URL. It doesn't really matter that we don't have the actual
+    // local URL with the correct port.
+    const urlPath = new URL(url, 'http://localhost').pathname
+    const defaultURLMatch = urlPath.match(DEFAULT_FUNCTION_URL_EXPRESSION)
+
+    if (defaultURLMatch) {
+      const func = this.get(defaultURLMatch[2])
+
+      if (!func) {
+        return
+      }
+
+      const { routes = [] } = await func.getBuildData()
+
+      if (routes.length !== 0) {
+        const paths = routes.map((route) => chalk.underline(route.pattern)).join(', ')
+
+        warn(
+          `Function ${chalk.yellow(func.name)} cannot be invoked on ${chalk.underline(
+            urlPath,
+          )}, because the function has the following URL paths defined: ${paths}`,
+        )
+
+        return
+      }
+
+      return { func, route: null }
+    }
+
     for (const func of this.functions.values()) {
       const route = await func.matchURLPath(urlPath, method)
 
@@ -132,7 +273,90 @@ export class FunctionsRegistry {
     }
   }
 
-  async registerFunction(name, funcBeforeHook) {
+  /**
+   * Logs an event associated with functions.
+   *
+   * @param {FunctionEvent} event
+   * @param {object} data
+   * @param {NetlifyFunction} [data.func]
+   * @param {string[]} [data.warnings]
+   * @returns
+   */
+  static logEvent(event, { func, warnings = [] }) {
+    let warningsText = ''
+
+    if (warnings.length !== 0) {
+      warningsText = ` with warnings:\n${warnings.map((warning) => `  - ${warning}`).join('\n')}`
+    }
+
+    if (event === 'buildError') {
+      log(
+        `${NETLIFYDEVERR} ${chalk.red('Failed to load')} function ${chalk.yellow(func?.displayName)}: ${
+          func?.buildError?.message
+        }`,
+      )
+    }
+
+    if (event === 'extracted') {
+      log(
+        `${NETLIFYDEVLOG} ${chalk.green('Extracted')} function ${chalk.yellow(func?.displayName)} from ${
+          func?.mainFile
+        }.`,
+      )
+
+      return
+    }
+
+    if (event === 'loaded') {
+      const icon = warningsText ? NETLIFYDEVWARN : NETLIFYDEVLOG
+      const color = warningsText ? chalk.yellow : chalk.green
+      const mode =
+        func?.runtimeAPIVersion === 1 && this.logLambdaCompat
+          ? ` in ${getTerminalLink('Lambda compatibility mode', 'https://ntl.fyi/lambda-compat')}`
+          : ''
+
+      log(`${icon} ${color('Loaded')} function ${chalk.yellow(func?.displayName)}${mode}${warningsText}`)
+
+      return
+    }
+
+    if (event === 'missing-types-package') {
+      log(
+        `${NETLIFYDEVWARN} For a better experience with TypeScript functions, consider installing the ${chalk.underline(
+          TYPES_PACKAGE,
+        )} package. Refer to https://ntl-fyi/function-types for more information.`,
+      )
+    }
+
+    if (event === 'reloaded') {
+      const icon = warningsText ? NETLIFYDEVWARN : NETLIFYDEVLOG
+      const color = warningsText ? chalk.yellow : chalk.green
+
+      log(`${icon} ${color('Reloaded')} function ${chalk.yellow(func?.displayName)}${warningsText}`)
+
+      return
+    }
+
+    if (event === 'reloading') {
+      log(`${NETLIFYDEVLOG} ${chalk.magenta('Reloading')} function ${chalk.yellow(func?.displayName)}...`)
+
+      return
+    }
+
+    if (event === 'removed') {
+      log(`${NETLIFYDEVLOG} ${chalk.magenta('Removed')} function ${chalk.yellow(func?.displayName)}`)
+    }
+  }
+
+  /**
+   * Adds a function to the registry
+   *
+   * @param {string} name
+   * @param {NetlifyFunction} funcBeforeHook
+   * @param {boolean} [isReload]
+   * @returns
+   */
+  async registerFunction(name, funcBeforeHook, isReload = false) {
     const { runtime } = funcBeforeHook
 
     // The `onRegister` hook allows runtimes to modify the function before it's
@@ -160,7 +384,7 @@ export class FunctionsRegistry {
       const unzippedDirectory = await this.unzipFunction(func)
 
       if (this.debug) {
-        log(`${NETLIFYDEVLOG} ${chalk.green('Extracted')} function ${chalk.yellow(name)} from ${func.mainFile}.`)
+        FunctionsRegistry.logEvent('extracted', { func })
       }
 
       func.mainFile = join(unzippedDirectory, `${func.name}.js`)
@@ -168,15 +392,27 @@ export class FunctionsRegistry {
 
     this.functions.set(name, func)
 
-    this.buildFunctionAndWatchFiles(func, true)
+    this.buildFunctionAndWatchFiles(func, !isReload)
   }
 
-  // This function is here so we can mock it in tests
+  /**
+   * A proxy to zip-it-and-ship-it's `listFunctions` method. It exists just so
+   * that we can mock it in tests.
+   * @param  {Parameters<listFunctions>} args
+   * @returns
+   */
   // eslint-disable-next-line class-methods-use-this
   async listFunctions(...args) {
     return await listFunctions(...args)
   }
 
+  /**
+   * Takes a list of directories and scans for functions. It keeps tracks of
+   * any functions in those directories that we've previously seen, and takes
+   * care of registering and unregistering functions as they come and go.
+   *
+   * @param {string[]} relativeDirs
+   */
   async scan(relativeDirs) {
     const directories = relativeDirs.filter(Boolean).map((dir) => (isAbsolute(dir) ? dir : join(this.projectRoot, dir)))
 
@@ -199,15 +435,16 @@ export class FunctionsRegistry {
     // the previous list but are missing from the new one. We unregister them.
     const deletedFunctions = [...this.functions.values()].filter((oldFunc) => {
       const isFound = functions.some(
-        (newFunc) => newFunc.name === oldFunc.name && newFunc.runtime === oldFunc.runtime.name,
+        (newFunc) => newFunc.name === oldFunc.name && newFunc.mainFile === oldFunc.mainFile,
       )
 
       return !isFound
     })
 
-    await Promise.all(deletedFunctions.map((func) => this.unregisterFunction(func.name)))
+    await Promise.all(deletedFunctions.map((func) => this.unregisterFunction(func)))
 
-    await Promise.all(
+    const deletedFunctionNames = new Set(deletedFunctions.map((func) => func.name))
+    const addedFunctions = await Promise.all(
       // zip-it-and-ship-it returns an array sorted based on which extension should have precedence,
       // where the last ones precede the previous ones. This is why
       // we reverse the array so we get the right functions precedence in the CLI.
@@ -238,16 +475,38 @@ export class FunctionsRegistry {
           settings: this.settings,
         })
 
-        await this.registerFunction(name, func)
+        // If a function we're registering was also unregistered in this run,
+        // then it was a rename. Let's flag it as such so that the messaging
+        // is adjusted accordingly.
+        const isReload = deletedFunctionNames.has(name)
+
+        await this.registerFunction(name, func, isReload)
+
+        return func
       }),
     )
+    const addedFunctionNames = new Set(addedFunctions.filter(Boolean).map((func) => func?.name))
+
+    deletedFunctions.forEach((func) => {
+      // If a function we've unregistered was also registered in this run, then
+      // it was a rename that we've already logged. Nothing to do in this case.
+      if (addedFunctionNames.has(func.name)) {
+        return
+      }
+
+      FunctionsRegistry.logEvent('removed', { func })
+    })
 
     await Promise.all(directories.map((path) => this.setupDirectoryWatcher(path)))
   }
 
-  // This watcher looks at files being added or removed from a functions
-  // directory. It doesn't care about files being changed, because those
-  // will be handled by each functions' watcher.
+  /**
+   * Creates a watcher that looks at files being added or removed from a
+   * functions directory. It doesn't care about files being changed, because
+   * those will be handled by each functions' watcher.
+   *
+   * @param {string} directory
+   */
   async setupDirectoryWatcher(directory) {
     if (this.directoryWatchers.has(directory)) {
       return
@@ -266,18 +525,30 @@ export class FunctionsRegistry {
     this.directoryWatchers.set(directory, watcher)
   }
 
-  async unregisterFunction(name) {
-    this.functions.delete(name)
+  /**
+   * Removes a function from the registry and closes its file watchers.
+   *
+   * @param {NetlifyFunction} func
+   */
+  async unregisterFunction(func) {
+    const { name } = func
 
-    log(`${NETLIFYDEVLOG} ${chalk.magenta('Removed')} function ${chalk.yellow(name)}.`)
+    this.functions.delete(name)
 
     const watcher = this.functionWatchers.get(name)
 
     if (watcher) {
       await watcher.close()
     }
+
+    this.functionWatchers.delete(name)
   }
 
+  /**
+   * Takes a zipped function and extracts its contents to an internal directory.
+   *
+   * @param {NetlifyFunction} func
+   */
   async unzipFunction(func) {
     const targetDirectory = resolve(
       this.projectRoot,

package/src/lib/functions/runtimes/js/builders/zisi.mjs

@@ -57,6 +57,8 @@ const buildFunction = async ({
     entryFilename,
     includedFiles,
     inputs,
+    mainFile,
+    outputModuleFormat,
     path: functionPath,
     routes,
     runtimeAPIVersion,
@@ -82,7 +84,7 @@ const buildFunction = async ({
 
   clearFunctionsCache(targetDirectory)
 
-  return { buildPath, includedFiles, routes, runtimeAPIVersion, srcFiles, schedule }
+  return { buildPath, includedFiles, outputModuleFormat, mainFile, routes, runtimeAPIVersion, srcFiles, schedule }
 }
 
 /**

package/src/lib/functions/runtimes/js/index.mjs

@@ -4,7 +4,6 @@ import { pathToFileURL } from 'url'
 import { Worker } from 'worker_threads'
 
 import lambdaLocal from 'lambda-local'
-import winston from 'winston'
 
 import detectNetlifyLambdaBuilder from './builders/netlify-lambda.mjs'
 import detectZisiBuilder, { parseFunctionForMetadata } from './builders/zisi.mjs'
@@ -14,12 +13,7 @@ export const name = 'js'
 
 let netlifyLambdaDetectorCache
 
-const logger = winston.createLogger({
-  levels: winston.config.npm.levels,
-  transports: [new winston.transports.Console({ level: 'warn' })],
-})
-
-lambdaLocal.setLogger(logger)
+lambdaLocal.getLogger().level = 'alert'
 
 // The netlify-lambda builder can't be enabled or disabled on a per-function
 // basis and its detection mechanism is also quite expensive, so we detect