netlify-cli 17.13.0 → 17.13.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "17.13.0",
+  "version": "17.13.1",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -46,12 +46,12 @@
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
     "@netlify/blobs": "6.3.1",
-    "@netlify/build": "29.31.0",
-    "@netlify/build-info": "7.11.3",
-    "@netlify/config": "20.10.0",
+    "@netlify/build": "29.31.5",
+    "@netlify/build-info": "7.11.4",
+    "@netlify/config": "20.10.1",
     "@netlify/edge-bundler": "11.0.0",
     "@netlify/local-functions-proxy": "1.1.1",
-    "@netlify/zip-it-and-ship-it": "9.28.1",
+    "@netlify/zip-it-and-ship-it": "9.28.2",
     "@octokit/rest": "19.0.13",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",
@@ -116,9 +116,9 @@
     "log-symbols": "5.1.0",
     "log-update": "5.0.1",
     "multiparty": "4.2.3",
-    "netlify": "13.1.11",
-    "netlify-headers-parser": "7.1.2",
-    "netlify-redirect-parser": "14.2.0",
+    "netlify": "13.1.12",
+    "netlify-headers-parser": "7.1.3",
+    "netlify-redirect-parser": "14.2.1",
     "netlify-redirector": "0.5.0",
     "node-fetch": "2.6.12",
     "node-version-alias": "3.4.1",

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

@@ -2,20 +2,49 @@ import { readFile } from 'fs/promises';
 import { join } from 'path';
 import { fileURLToPath } from 'url';
 import { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN, nonNullable, chalk, log, warn, watchDebounced, isNodeError, } from '../../utils/command-helpers.js';
+import { MultiMap } from '../../utils/multimap.js';
 import { getPathInProject } from '../settings.js';
 import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.js';
 const featureFlags = { edge_functions_correct_order: true };
+/**
+ * Helper method which, given a edge bundler graph module and an index of modules by path, traverses its dependency tree
+ * and returns an array of all of ist local dependencies
+ */
+function traverseLocalDependencies({ dependencies = [] }, modulesByPath) {
+    return dependencies.flatMap((dependency) => {
+        // We're interested in tracking local dependencies, so we only look at
+        // specifiers with the `file:` protocol.
+        if (dependency.code === undefined ||
+            typeof dependency.code.specifier !== 'string' ||
+            !dependency.code.specifier.startsWith('file://')) {
+            return [];
+        }
+        const { specifier: dependencyURL } = dependency.code;
+        const dependencyPath = fileURLToPath(dependencyURL);
+        const dependencyModule = modulesByPath.get(dependencyPath);
+        // No module indexed for this dependency
+        if (dependencyModule === undefined) {
+            return [dependencyPath];
+        }
+        // Keep traversing the child dependencies and return the current dependency path
+        return [...traverseLocalDependencies(dependencyModule, modulesByPath), dependencyPath];
+    });
+}
 export class EdgeFunctionsRegistry {
     constructor({ bundler, config, configPath, directories, env, getUpdatedConfig, importMapFromTOML, projectDir, runIsolate, servePath, }) {
         this.buildError = null;
         this.declarationsFromDeployConfig = [];
-        this.dependencyPaths = new Map();
+        // Mapping file URLs to names of functions that use them as dependencies.
+        this.dependencyPaths = new MultiMap();
         this.directoryWatchers = new Map();
-        this.functionPaths = new Map();
+        this.userFunctions = [];
         this.internalFunctions = [];
+        // a Map from `this.functions` that maps function paths to function
+        // names. This allows us to match modules against functions in O(1) time as
+        // opposed to O(n).
+        this.functionPaths = new Map();
         this.manifest = null;
         this.routes = [];
-        this.userFunctions = [];
         this.bundler = bundler;
         this.configPath = configPath;
         this.directories = directories;
@@ -26,12 +55,6 @@ export class EdgeFunctionsRegistry {
         this.importMapFromTOML = importMapFromTOML;
         this.declarationsFromTOML = EdgeFunctionsRegistry.getDeclarationsFromTOML(config);
         this.env = EdgeFunctionsRegistry.getEnvironmentVariables(env);
-        this.buildError = null;
-        this.directoryWatchers = new Map();
-        this.dependencyPaths = new Map();
-        this.functionPaths = new Map();
-        this.userFunctions = [];
-        this.internalFunctions = [];
         this.initialScan = this.doInitialScan();
         this.setupWatchers();
     }
@@ -263,39 +286,32 @@ export class EdgeFunctionsRegistry {
             }
             return;
         }
-        // Creating a Map from `this.functions` that maps function paths to function
-        // names. This allows us to match modules against functions in O(1) time as
-        // opposed to O(n).
-        // eslint-disable-next-line unicorn/prefer-spread
-        const functionPaths = new Map(Array.from(this.functions, (func) => [func.path, func.name]));
-        // Mapping file URLs to names of functions that use them as dependencies.
-        const dependencyPaths = new Map();
-        const { modules } = graph;
-        modules.forEach(({ dependencies = [], specifier }) => {
+        this.dependencyPaths = new MultiMap();
+        // Mapping file URLs to modules. Used by the traversal function.
+        const modulesByPath = new Map();
+        // a set of edge function modules that we'll use to start traversing the dependency tree from
+        const functionModules = new Set();
+        graph.modules.forEach((module) => {
+            // We're interested in tracking local dependencies, so we only look at
+            // specifiers with the `file:` protocol.
+            const { specifier } = module;
             if (!specifier.startsWith('file://')) {
                 return;
             }
             const path = fileURLToPath(specifier);
-            const functionMatch = functionPaths.get(path);
-            if (!functionMatch) {
-                return;
+            modulesByPath.set(path, module);
+            const functionName = this.functionPaths.get(path);
+            if (functionName) {
+                functionModules.add({ functionName, module });
             }
-            dependencies.forEach((dependency) => {
-                // We're interested in tracking local dependencies, so we only look at
-                // specifiers with the `file:` protocol.
-                if (dependency.code === undefined ||
-                    typeof dependency.code.specifier !== 'string' ||
-                    !dependency.code.specifier.startsWith('file://')) {
-                    return;
-                }
-                const { specifier: dependencyURL } = dependency.code;
-                const dependencyPath = fileURLToPath(dependencyURL);
-                const functions = dependencyPaths.get(dependencyPath) || [];
-                dependencyPaths.set(dependencyPath, [...functions, functionMatch]);
+        });
+        // We start from our functions and we traverse through their dependency tree
+        functionModules.forEach(({ functionName, module }) => {
+            const traversedPaths = traverseLocalDependencies(module, modulesByPath);
+            traversedPaths.forEach((dependencyPath) => {
+                this.dependencyPaths.add(dependencyPath, functionName);
             });
         });
-        this.dependencyPaths = dependencyPaths;
-        this.functionPaths = functionPaths;
     }
     /**
      * Thin wrapper for `#runIsolate` that skips running a build and returns an
@@ -357,9 +373,16 @@ export class EdgeFunctionsRegistry {
         });
         this.internalFunctions = internalFunctions;
         this.userFunctions = userFunctions;
+        // eslint-disable-next-line unicorn/prefer-spread
+        this.functionPaths = new Map(Array.from(this.functions, (func) => [func.path, func.name]));
         return { all: functions, new: newFunctions, deleted: deletedFunctions };
     }
     async setupWatchers() {
+        // While functions are guaranteed to be inside one of the configured
+        // directories, they might be importing files that are located in
+        // parent directories. So we watch the entire project directory for
+        // changes.
+        await this.setupWatcherForDirectory();
         if (!this.configPath) {
             return;
         }
@@ -372,11 +395,6 @@ export class EdgeFunctionsRegistry {
                 await this.checkForAddedOrDeletedFunctions();
             },
         });
-        // While functions are guaranteed to be inside one of the configured
-        // directories, they might be importing files that are located in
-        // parent directories. So we watch the entire project directory for
-        // changes.
-        await this.setupWatcherForDirectory();
     }
     async setupWatcherForDirectory() {
         const ignored = [`${this.servePath}/**`];

package/src/utils/multimap.js

@@ -0,0 +1,11 @@
+export class MultiMap {
+    constructor() {
+        this.map = new Map();
+    }
+    add(key, value) {
+        this.map.set(key, [...(this.map.get(key) ?? []), value]);
+    }
+    get(key) {
+        return this.map.get(key) ?? [];
+    }
+}