netlify-cli 17.1.0 → 17.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "17.1.0",
+  "version": "17.2.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -48,7 +48,7 @@
     "@netlify/build": "29.25.0",
     "@netlify/build-info": "7.10.2",
     "@netlify/config": "20.9.0",
-    "@netlify/edge-bundler": "9.4.1",
+    "@netlify/edge-bundler": "^10.1.0",
     "@netlify/local-functions-proxy": "1.1.1",
     "@netlify/zip-it-and-ship-it": "9.25.7",
     "@octokit/rest": "19.0.13",
@@ -100,6 +100,7 @@
     "https-proxy-agent": "5.0.1",
     "inquirer": "6.5.2",
     "inquirer-autocomplete-prompt": "1.4.0",
+    "ipx": "^2.0.1",
     "is-docker": "3.0.0",
     "is-stream": "3.0.0",
     "is-wsl": "2.2.0",
@@ -108,7 +109,7 @@
     "jsonwebtoken": "9.0.1",
     "jwt-decode": "3.1.2",
     "lambda-local": "2.1.2",
-    "listr": "0.14.3",
+    "listr2": "^7.0.2",
     "locate-path": "7.2.0",
     "lodash": "4.17.21",
     "log-symbols": "5.1.0",

package/src/commands/dev/dev.mjs

@@ -227,6 +227,7 @@ const dev = async (options, command) => {
     geoCountry: options.country,
     accountId,
     functionsRegistry,
+    repositoryRoot,
   })
 
   if (devConfig.autoLaunch !== false) {

package/src/commands/functions/functions-serve.mjs

@@ -71,7 +71,7 @@ export const createFunctionsServeCommand = (program) =>
   program
     .command('functions:serve')
     .alias('function:serve')
-    .description('(Beta) Serve functions locally')
+    .description('Serve functions locally')
     .option('-f, --functions <dir>', 'Specify a functions directory to serve')
     .option('-p, --port <port>', 'Specify a port for the functions server', (value) => Number.parseInt(value))
     .option('-o, --offline', 'disables any features that require network access')

package/src/commands/lm/lm-info.mjs

@@ -1,5 +1,5 @@
 // @ts-check
-import Listr from 'listr'
+import { Listr } from 'listr2'
 
 import {
   checkGitLFSVersionStep,

package/src/commands/lm/lm-setup.mjs

@@ -1,5 +1,5 @@
 // @ts-check
-import Listr from 'listr'
+import { Listr } from 'listr2'
 
 import { error } from '../../utils/command-helpers.mjs'
 import execa from '../../utils/execa.mjs'

package/src/lib/edge-functions/proxy.mjs

@@ -1,13 +1,13 @@
 // @ts-check
 import { Buffer } from 'buffer'
 import { rm } from 'fs/promises'
-import { join, relative, resolve } from 'path'
+import { join, resolve } from 'path'
 
 // eslint-disable-next-line import/no-namespace
 import * as bundler from '@netlify/edge-bundler'
 import getAvailablePort from 'get-port'
 
-import { NETLIFYDEVERR, NETLIFYDEVWARN, chalk, error as printError, log } from '../../utils/command-helpers.mjs'
+import { NETLIFYDEVERR, chalk, error as printError } from '../../utils/command-helpers.mjs'
 import { getGeoLocation } from '../geo-location.mjs'
 import { getPathInProject } from '../settings.mjs'
 import { startSpinner, stopSpinner } from '../spinner.mjs'
@@ -99,6 +99,7 @@ export const initializeProxy = async ({
   offline,
   passthroughPort,
   projectDir,
+  repositoryRoot,
   settings,
   siteInfo,
   state,
@@ -132,6 +133,7 @@ export const initializeProxy = async ({
     internalFunctions,
     port: isolatePort,
     projectDir,
+    repositoryRoot,
   })
   const hasEdgeFunctions = userFunctionsPath !== undefined || internalFunctionsPath
 
@@ -162,21 +164,7 @@ export const initializeProxy = async ({
     await registry.initialize()
 
     const url = new URL(req.url, `http://${LOCAL_HOST}:${mainPort}`)
-    const { functionNames, invocationMetadata, orphanedDeclarations } = registry.matchURLPath(url.pathname, req.method)
-
-    // If the request matches a config declaration for an Edge Function without
-    // a matching function file, we warn the user.
-    orphanedDeclarations.forEach((functionName) => {
-      log(
-        `${NETLIFYDEVWARN} Request to ${chalk.yellow(
-          url.pathname,
-        )} matches declaration for edge function ${chalk.yellow(
-          functionName,
-        )}, but there's no matching function file in ${chalk.yellow(
-          relative(projectDir, userFunctionsPath),
-        )}. Please visit ${chalk.blue('https://ntl.fyi/edge-create')} for more information.`,
-      )
-    })
+    const { functionNames, invocationMetadata } = registry.matchURLPath(url.pathname, req.method)
 
     if (functionNames.length === 0) {
       return
@@ -217,6 +205,7 @@ const prepareServer = async ({
   internalFunctions,
   port,
   projectDir,
+  repositoryRoot,
 }) => {
   // Merging internal with user-defined import maps.
   const importMapPaths = [...importMaps, config.functions['*'].deno_import_map]
@@ -243,6 +232,7 @@ const prepareServer = async ({
       importMapPaths,
       inspectSettings,
       port,
+      rootPath: repositoryRoot,
       servePath,
     })
     const registry = new EdgeFunctionsRegistry({

package/src/lib/edge-functions/registry.mjs

@@ -13,8 +13,14 @@ import {
 
 /** @typedef {import('@netlify/edge-bundler').Declaration} Declaration */
 /** @typedef {import('@netlify/edge-bundler').EdgeFunction} EdgeFunction */
+/**
+ * @typedef {"buildError" | "loaded" | "reloaded" | "reloading" | "removed"} EdgeFunctionEvent
+ */
 /** @typedef {import('@netlify/edge-bundler').FunctionConfig} FunctionConfig */
+/** @typedef {import('@netlify/edge-bundler').Manifest} Manifest */
+/** @typedef {import('@netlify/edge-bundler').ModuleGraph} ModuleGraph */
 /** @typedef {Awaited<ReturnType<typeof import('@netlify/edge-bundler').serve>>} RunIsolate */
+/** @typedef {Omit<Manifest["routes"][0], "pattern"> & { pattern: RegExp }} Route */
 
 const featureFlags = { edge_functions_correct_order: true }
 
@@ -46,12 +52,6 @@ export class EdgeFunctionsRegistry {
   /** @type {Declaration[]} */
   #declarationsFromDeployConfig
 
-  /** @type {Record<string, FunctionConfig>} */
-  #userFunctionConfigs = {}
-
-  /** @type {Record<string, FunctionConfig>} */
-  #internalFunctionConfigs = {}
-
   /** @type {Declaration[]} */
   #declarationsFromTOML
 
@@ -67,6 +67,9 @@ export class EdgeFunctionsRegistry {
   /** @type {Map<string, string>} */
   #functionPaths = new Map()
 
+  /** @type {Manifest | null} */
+  #manifest = null
+
   /** @type {EdgeFunction[]} */
   #userFunctions = []
 
@@ -76,6 +79,9 @@ export class EdgeFunctionsRegistry {
   /** @type {Promise<void>} */
   #initialScan
 
+  /** @type {Route[]} */
+  #routes = []
+
   /** @type {string} */
   #servePath
 
@@ -122,8 +128,6 @@ export class EdgeFunctionsRegistry {
     this.#env = EdgeFunctionsRegistry.#getEnvironmentVariables(env)
 
     this.#buildError = null
-    this.#userFunctionConfigs = {}
-    this.#internalFunctionConfigs = {}
     this.#directoryWatchers = new Map()
     this.#dependencyPaths = new Map()
     this.#functionPaths = new Map()
@@ -141,12 +145,12 @@ export class EdgeFunctionsRegistry {
   async #doInitialScan() {
     await this.#scanForFunctions()
 
-    this.#functions.forEach((func) => {
-      this.#logAddedFunction(func)
-    })
-
     try {
-      await this.#build()
+      const { warnings } = await this.#build()
+
+      this.#functions.forEach((func) => {
+        this.#logEvent('loaded', { functionName: func.name, warnings: warnings[func.name] })
+      })
     } catch {
       // no-op
     }
@@ -160,17 +164,16 @@ export class EdgeFunctionsRegistry {
   }
 
   /**
-   * @return {Promise<void>}
+   * @return {Promise<{warnings: Record<string, string[]>}>}
    */
   async #build() {
+    /**
+     * @type Record<string, string[]>
+     */
+    const warnings = {}
+
     try {
-      const { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success } = await this.#runIsolate(
-        this.#functions,
-        this.#env,
-        {
-          getFunctionsConfig: true,
-        },
-      )
+      const { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success } = await this.#runBuild()
 
       if (!success) {
         throw new Error('Build error')
@@ -182,18 +185,39 @@ export class EdgeFunctionsRegistry {
       // functionsConfig therefore contains first all internal functionConfigs and then user functionConfigs
       let index = 0
 
-      this.#internalFunctionConfigs = this.#internalFunctions.reduce(
+      /** @type {Record<string, FunctionConfig>} */
+      const internalFunctionConfigs = this.#internalFunctions.reduce(
         // eslint-disable-next-line no-plusplus
         (acc, func) => ({ ...acc, [func.name]: functionsConfig[index++] }),
         {},
       )
 
-      this.#userFunctionConfigs = this.#userFunctions.reduce(
+      /** @type {Record<string, FunctionConfig>} */
+      const userFunctionConfigs = this.#userFunctions.reduce(
         // eslint-disable-next-line no-plusplus
         (acc, func) => ({ ...acc, [func.name]: functionsConfig[index++] }),
         {},
       )
 
+      const { manifest, routes, unroutedFunctions } = this.#buildRoutes(internalFunctionConfigs, userFunctionConfigs)
+
+      this.#manifest = manifest
+      this.#routes = routes
+
+      unroutedFunctions.forEach((name) => {
+        warnings[name] = warnings[name] || []
+        warnings[name].push(
+          `Edge function is not accessible because it does not have a path configured. Learn more at https://ntl.fyi/edge-create.`,
+        )
+      })
+
+      for (const functionName in userFunctionConfigs) {
+        if ('paths' in userFunctionConfigs[functionName]) {
+          warnings[functionName] = warnings[functionName] || []
+          warnings[functionName].push(`Unknown 'paths' configuration property. Did you mean 'path'?`)
+        }
+      }
+
       this.#processGraph(graph)
 
       if (npmSpecifiersWithExtraneousFiles.length !== 0) {
@@ -203,6 +227,8 @@ export class EdgeFunctionsRegistry {
           `${NETLIFYDEVWARN} The following npm modules, which are directly or indirectly imported by an edge function, may not be supported: ${modules}. For more information, visit https://ntl.fyi/edge-functions-npm.`,
         )
       }
+
+      return { warnings }
     } catch (error) {
       this.#buildError = error
 
@@ -210,6 +236,38 @@ export class EdgeFunctionsRegistry {
     }
   }
 
+  /**
+   * Builds a manifest and corresponding routes for the functions in the
+   * registry, taking into account the declarations from the TOML, from
+   * the deploy configuration API, and from the in-source configuration
+   * found in both internal and user functions.
+   *
+   * @param {Record<string, FunctionConfig>} internalFunctionConfigs
+   * @param {Record<string, FunctionConfig>} userFunctionConfigs
+   */
+  #buildRoutes(internalFunctionConfigs, userFunctionConfigs) {
+    const declarations = this.#bundler.mergeDeclarations(
+      this.#declarationsFromTOML,
+      userFunctionConfigs,
+      internalFunctionConfigs,
+      this.#declarationsFromDeployConfig,
+      featureFlags,
+    )
+    const { declarationsWithoutFunction, manifest, unroutedFunctions } = this.#bundler.generateManifest({
+      declarations,
+      userFunctionConfig: userFunctionConfigs,
+      internalFunctionConfig: internalFunctionConfigs,
+      functions: this.#functions,
+      featureFlags,
+    })
+    const routes = [...manifest.routes, ...manifest.post_cache_routes].map((route) => ({
+      ...route,
+      pattern: new RegExp(route.pattern),
+    }))
+
+    return { declarationsWithoutFunction, manifest, routes, unroutedFunctions }
+  }
+
   /**
    * @returns {Promise<void>}
    */
@@ -221,14 +279,14 @@ export class EdgeFunctionsRegistry {
     }
 
     try {
-      await this.#build()
+      const { warnings } = await this.#build()
 
       deletedFunctions.forEach((func) => {
-        this.#logDeletedFunction(func)
+        this.#logEvent('removed', { functionName: func.name, warnings: warnings[func.name] })
       })
 
       newFunctions.forEach((func) => {
-        this.#logAddedFunction(func)
+        this.#logEvent('loaded', { functionName: func.name, warnings: warnings[func.name] })
       })
     } catch {
       // no-op
@@ -288,28 +346,21 @@ export class EdgeFunctionsRegistry {
       return
     }
 
-    const reason = this.#debug ? ` because ${chalk.underline(paths.join(','))} has changed` : ''
-
-    log(`${NETLIFYDEVLOG} ${chalk.magenta('Reloading')} edge functions${reason}...`)
+    this.#logEvent('reloading', {})
 
     try {
-      await this.#build()
-
+      const { warnings } = await this.#build()
       const functionNames = [...matchingFunctions]
 
       if (functionNames.length === 0) {
-        log(`${NETLIFYDEVLOG} ${chalk.green('Reloaded')} edge functions`)
+        this.#logEvent('reloaded', {})
       } else {
         functionNames.forEach((functionName) => {
-          log(
-            `${NETLIFYDEVLOG} ${chalk.green('Reloaded')} edge function ${chalk.yellow(
-              this.#getDisplayName(functionName),
-            )}`,
-          )
+          this.#logEvent('reloaded', { functionName, warnings: warnings[functionName] })
         })
       }
-    } catch {
-      log(`${NETLIFYDEVERR} ${chalk.red('Failed')} reloading edge function`)
+    } catch (error) {
+      this.#logEvent('buildError', { buildError: error?.message })
     }
   }
 
@@ -321,50 +372,72 @@ export class EdgeFunctionsRegistry {
   }
 
   /**
-   * @param {EdgeFunction} func
+   * Logs an event associated with functions.
+   *
+   * @param {EdgeFunctionEvent} event
+   * @param {object} data
+   * @param {Error} [data.buildError]
+   * @param {string} [data.functionName]
+   * @param {string[]} [data.warnings]
+   * @returns
    */
-  #logAddedFunction(func) {
-    log(`${NETLIFYDEVLOG} ${chalk.green('Loaded')} edge function ${chalk.yellow(this.#getDisplayName(func.name))}`)
-  }
+  #logEvent(event, { buildError, functionName, warnings = [] }) {
+    const subject = functionName
+      ? `edge function ${chalk.yellow(this.#getDisplayName(functionName))}`
+      : 'edge functions'
+    const warningsText =
+      warnings.length === 0 ? '' : ` with warnings:\n${warnings.map((warning) => `  - ${warning}`).join('\n')}`
 
-  /**
-   * @param {EdgeFunction} func
-   */
-  #logDeletedFunction(func) {
-    log(`${NETLIFYDEVLOG} ${chalk.magenta('Removed')} edge function ${chalk.yellow(this.#getDisplayName(func.name))}`)
+    if (event === 'buildError') {
+      log(`${NETLIFYDEVERR} ${chalk.red('Failed to load')} ${subject}: ${buildError}`)
+
+      return
+    }
+
+    if (event === 'loaded') {
+      const icon = warningsText ? NETLIFYDEVWARN : NETLIFYDEVLOG
+      const color = warningsText ? chalk.yellow : chalk.green
+
+      log(`${icon} ${color('Loaded')} ${subject}${warningsText}`)
+
+      return
+    }
+
+    if (event === 'reloaded') {
+      const icon = warningsText ? NETLIFYDEVWARN : NETLIFYDEVLOG
+      const color = warningsText ? chalk.yellow : chalk.green
+
+      log(`${icon} ${color('Reloaded')} ${subject}${warningsText}`)
+
+      return
+    }
+
+    if (event === 'reloading') {
+      log(`${NETLIFYDEVLOG} ${chalk.magenta('Reloading')} ${subject}...`)
+
+      return
+    }
+
+    if (event === 'removed') {
+      log(`${NETLIFYDEVLOG} ${chalk.magenta('Removed')} ${subject}`)
+    }
   }
 
   /**
+   * Returns the functions in the registry that should run for a given URL path
+   * and HTTP method, based on the routes registered for each function.
+   *
    * @param {string} urlPath
    * @param {string} method
    */
   matchURLPath(urlPath, method) {
-    const declarations = this.#bundler.mergeDeclarations(
-      this.#declarationsFromTOML,
-      this.#userFunctionConfigs,
-      this.#internalFunctionConfigs,
-      this.#declarationsFromDeployConfig,
-      featureFlags,
-    )
-    const manifest = this.#bundler.generateManifest({
-      declarations,
-      userFunctionConfig: this.#userFunctionConfigs,
-      internalFunctionConfig: this.#internalFunctionConfigs,
-      functions: this.#functions,
-      featureFlags,
-    })
-    const routes = [...manifest.routes, ...manifest.post_cache_routes].map((route) => ({
-      ...route,
-      pattern: new RegExp(route.pattern),
-    }))
-
     /** @type string[] */
     const functionNames = []
 
     /** @type number[] */
     const routeIndexes = []
 
-    routes.forEach((route, index) => {
+    this.#routes.forEach((route, index) => {
       if (route.methods && route.methods.length !== 0 && !route.methods.includes(method)) {
         return
       }
@@ -373,7 +446,7 @@ export class EdgeFunctionsRegistry {
         return
       }
 
-      const isExcluded = manifest.function_config[route.function]?.excluded_patterns?.some((pattern) =>
+      const isExcluded = this.#manifest?.function_config[route.function]?.excluded_patterns?.some((pattern) =>
         new RegExp(pattern).test(urlPath),
       )
 
@@ -385,55 +458,24 @@ export class EdgeFunctionsRegistry {
       routeIndexes.push(index)
     })
     const invocationMetadata = {
-      function_config: manifest.function_config,
+      function_config: this.#manifest?.function_config,
       req_routes: routeIndexes,
-      routes: manifest.routes.map((route) => ({ function: route.function, path: route.path, pattern: route.pattern })),
+      routes: this.#manifest?.routes.map((route) => ({
+        function: route.function,
+        path: route.path,
+        pattern: route.pattern,
+      })),
     }
-    const orphanedDeclarations = this.#matchURLPathAgainstOrphanedDeclarations(urlPath)
 
-    return { functionNames, invocationMetadata, orphanedDeclarations }
+    return { functionNames, invocationMetadata }
   }
 
   /**
+   * Takes the module graph returned from the server and tracks dependencies of
+   * each function.
    *
-   * @param {string} urlPath
-   * @returns {string[]}
+   * @param {ModuleGraph} graph
    */
-  #matchURLPathAgainstOrphanedDeclarations(urlPath) {
-    // `generateManifest` will only include functions for which there is both a
-    // function file and a config declaration, but we want to catch cases where
-    // a config declaration exists without a matching function file. To do that
-    // we compute a list of functions from the declarations (the `path` doesn't
-    // really matter).
-    const functions = this.#declarationsFromTOML.map((declaration) => ({ name: declaration.function, path: '' }))
-    const manifest = this.#bundler.generateManifest({
-      declarations: this.#declarationsFromTOML,
-      userFunctionConfig: this.#userFunctionConfigs,
-      internalFunctionConfig: this.#internalFunctionConfigs,
-      functions,
-      featureFlags,
-    })
-
-    const routes = [...manifest.routes, ...manifest.post_cache_routes].map((route) => ({
-      ...route,
-      pattern: new RegExp(route.pattern),
-    }))
-
-    const functionNames = routes
-      .filter((route) => {
-        const hasFunctionFile = this.#functions.some((func) => func.name === route.function)
-
-        if (hasFunctionFile) {
-          return false
-        }
-
-        return route.pattern.test(urlPath)
-      })
-      .map((route) => route.function)
-
-    return functionNames
-  }
-
   #processGraph(graph) {
     if (!graph) {
       warn('Could not process edge functions dependency graph. Live reload will not be available.')
@@ -485,6 +527,33 @@ export class EdgeFunctionsRegistry {
     this.#functionPaths = functionPaths
   }
 
+  /**
+   * Thin wrapper for `#runIsolate` that skips running a build and returns an
+   * empty response if there are no functions in the registry.
+   */
+  async #runBuild() {
+    if (this.#functions.length === 0) {
+      return {
+        functionsConfig: [],
+        graph: {
+          modules: [],
+        },
+        npmSpecifiersWithExtraneousFiles: [],
+        success: true,
+      }
+    }
+
+    const { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success } = await this.#runIsolate(
+      this.#functions,
+      this.#env,
+      {
+        getFunctionsConfig: true,
+      },
+    )
+
+    return { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success }
+  }
+
   /**
    * @returns {Promise<{all: EdgeFunction[], new: EdgeFunction[], deleted: EdgeFunction[]}>}
    */