@netlify/edge-bundler 9.2.1 → 9.3.0

package/dist/node/bundler.test.js

@@ -123,7 +123,7 @@ test('Prints a nice error message when user tries importing an npm module and np
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
-        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/parent-2"'?`);
+        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/parent-1"'?`);
     }
     finally {
         await cleanup();

package/dist/node/import_map.d.ts

@@ -3,7 +3,7 @@ import { Logger } from './logger.js';
 type Imports = Record<string, string>;
 export interface ImportMapFile {
     baseURL: URL;
-    imports: Imports;
+    imports?: Imports;
     scopes?: Record<string, Imports>;
 }
 export declare class ImportMap {

package/dist/node/import_map.js

@@ -23,9 +23,6 @@ export class ImportMap {
     }
     async addFile(path, logger) {
         const source = await ImportMap.readFile(path, logger);
-        if (Object.keys(source.imports).length === 0) {
-            return;
-        }
         return this.add(source);
     }
     async addFiles(paths, logger) {

package/dist/node/import_map.test.js

@@ -5,6 +5,7 @@ import { pathToFileURL } from 'url';
 import tmp from 'tmp-promise';
 import { describe, test, expect } from 'vitest';
 import { ImportMap } from './import_map.js';
+import { getLogger } from './logger.js';
 test('Handles import maps with full URLs without specifying a base URL', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
     const inputFile1 = {
@@ -143,6 +144,30 @@ test('Writes import map file to disk', async () => {
     expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(pathToFileURL(expectedPath).toString());
 });
+test('Respects import map when it has only scoped key', async () => {
+    const file = await tmp.file();
+    const importMap = {
+        scopes: {
+            './foo': {
+                'alias:pets': './heart/pets/file.ts',
+            },
+        },
+    };
+    await fs.writeFile(file.path, JSON.stringify(importMap));
+    const map = new ImportMap();
+    await map.addFile(file.path, getLogger());
+    expect(map.getContents()).toEqual({
+        imports: {
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+        },
+        scopes: {
+            [pathToFileURL(join(file.path, '../foo')).href]: {
+                'alias:pets': pathToFileURL(join(file.path, '../heart/pets/file.ts')).href,
+            },
+        },
+    });
+});
 test('Clones an import map', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
     const inputFile1 = {

package/dist/node/npm_dependencies.d.ts

@@ -1,9 +1,6 @@
 /// <reference types="node" />
-import { ParsedImportMap } from '@import-maps/resolve';
-import { Plugin } from 'esbuild';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
-export declare const getDependencyTrackerPlugin: (specifiers: Set<string>, importMap: ParsedImportMap, baseURL: URL) => Plugin;
 interface VendorNPMSpecifiersOptions {
     basePath: string;
     directory?: string;
@@ -11,12 +8,13 @@ interface VendorNPMSpecifiersOptions {
     importMap: ImportMap;
     logger: Logger;
 }
-export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, logger, }: VendorNPMSpecifiersOptions) => Promise<{
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, }: VendorNPMSpecifiersOptions) => Promise<{
     cleanup: () => Promise<void>;
     directory: string;
     importMap: {
         baseURL: import("url").URL;
         imports: Record<string, string>;
     };
+    npmSpecifiersWithExtraneousFiles: string[];
 } | undefined>;
 export {};

package/dist/node/npm_dependencies.js

@@ -1,13 +1,13 @@
 import { promises as fs } from 'fs';
-import { builtinModules, createRequire } from 'module';
+import { builtinModules } from 'module';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { resolve } from '@import-maps/resolve';
+import { nodeFileTrace, resolve as nftResolve } from '@vercel/nft';
 import { build } from 'esbuild';
+import getPackageName from 'get-package-name';
 import tmp from 'tmp-promise';
-import { nodePrefix, npmPrefix } from '../shared/consts.js';
-const builtinModulesSet = new Set(builtinModules);
-const require = createRequire(import.meta.url);
+const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.cts', '.mts']);
 // Workaround for https://github.com/evanw/esbuild/issues/1921.
 const banner = {
     js: `
@@ -19,72 +19,83 @@ const banner = {
   let require=___nfyCreateRequire(import.meta.url);
   `,
 };
-// esbuild plugin that will traverse the code and look for imports of external
-// dependencies (i.e. Node modules). It stores the specifiers found in the Set
-// provided.
-export const getDependencyTrackerPlugin = (specifiers, importMap, baseURL) => ({
-    name: 'dependency-tracker',
-    setup(build) {
-        build.onResolve({ filter: /^(.*)$/ }, (args) => {
-            if (args.kind !== 'import-statement') {
-                return;
+/**
+ * Parses a set of functions and returns a list of specifiers that correspond
+ * to npm modules.
+ *
+ * @param basePath Root of the project
+ * @param functions Functions to parse
+ * @param importMap Import map to apply when resolving imports
+ */
+const getNPMSpecifiers = async (basePath, functions, importMap) => {
+    const baseURL = pathToFileURL(basePath);
+    const { reasons } = await nodeFileTrace(functions, {
+        base: basePath,
+        readFile: async (filePath) => {
+            // If this is a TypeScript file, we need to compile in before we can
+            // parse it.
+            if (TYPESCRIPT_EXTENSIONS.has(path.extname(filePath))) {
+                const compiled = await build({
+                    bundle: false,
+                    entryPoints: [filePath],
+                    logLevel: 'silent',
+                    platform: 'node',
+                    write: false,
+                });
+                return compiled.outputFiles[0].text;
             }
-            const result = {};
-            let specifier = args.path;
+            return fs.readFile(filePath, 'utf8');
+        },
+        // eslint-disable-next-line require-await
+        resolve: async (specifier, ...args) => {
             // Start by checking whether the specifier matches any import map defined
             // by the user.
             const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
             // If it does, the resolved import is the specifier we'll evaluate going
             // forward.
-            if (matched) {
-                if (resolvedImport.protocol !== 'file:') {
-                    return { external: true };
-                }
-                specifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
-                result.path = specifier;
-            }
-            // If the specifier is a Node.js built-in, we don't want to bundle it.
-            if (specifier.startsWith(nodePrefix) || builtinModulesSet.has(specifier)) {
-                return { external: true };
-            }
-            // We don't support the `npm:` prefix yet. Mark the specifier as external
-            // and the ESZIP bundler will handle the failure.
-            if (specifier.startsWith(npmPrefix)) {
-                return { external: true };
-            }
-            const isLocalImport = specifier.startsWith(path.sep) || specifier.startsWith('.') || path.isAbsolute(specifier);
-            // If this is a local import, return so that esbuild visits that path.
-            if (isLocalImport) {
-                return result;
-            }
-            const isRemoteURLImport = specifier.startsWith('https://') || specifier.startsWith('http://');
-            if (isRemoteURLImport) {
-                return { external: true };
-            }
-            // At this point we know we're dealing with a bare specifier that should
-            // be treated as an external module. We first try to resolve it, because
-            // in the event that it doesn't exist (e.g. user is referencing a module
-            // that they haven't installed) we won't even attempt to bundle it. This
-            // lets the ESZIP bundler handle and report the missing import instead of
-            // esbuild, which is a better experience for the user.
-            try {
-                require.resolve(specifier, { paths: [args.resolveDir] });
-                specifiers.add(specifier);
+            if (matched && resolvedImport.protocol === 'file:') {
+                const newSpecifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
+                return nftResolve(newSpecifier, ...args);
             }
-            catch {
-                // no-op
-            }
-            // Mark the specifier as external, because we don't want to traverse the
-            // entire module tree — i.e. if user code imports module `foo` and that
-            // imports `bar`, we only want to add `foo` to the list of specifiers,
-            // since the whole module — including its dependencies like `bar` —
-            // will be bundled.
-            return { external: true };
-        });
-    },
-});
-export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, logger, }) => {
-    const specifiers = new Set();
+            return nftResolve(specifier, ...args);
+        },
+    });
+    const npmSpecifiers = new Set();
+    const npmSpecifiersWithExtraneousFiles = new Set();
+    reasons.forEach((reason, filePath) => {
+        const packageName = getPackageName(filePath);
+        if (packageName === undefined) {
+            return;
+        }
+        const parents = [...reason.parents];
+        const isDirectDependency = parents.some((parentPath) => !parentPath.startsWith(`node_modules${path.sep}`));
+        // We're only interested in capturing the specifiers that are first-level
+        // dependencies. Because we'll bundle all modules in a subsequent step,
+        // any transitive dependencies will be handled then.
+        if (isDirectDependency) {
+            const specifier = getPackageName(filePath);
+            npmSpecifiers.add(specifier);
+        }
+        const isExtraneousFile = reason.type.every((type) => type === 'asset');
+        // An extraneous file is a dependency that was traced by NFT and marked
+        // as not being statically imported. We can't process dynamic importing
+        // at runtime, so we gather the list of modules that may use these files
+        // so that we can warn users about this caveat.
+        if (isExtraneousFile) {
+            parents.forEach((path) => {
+                const specifier = getPackageName(path);
+                if (specifier) {
+                    npmSpecifiersWithExtraneousFiles.add(specifier);
+                }
+            });
+        }
+    });
+    return {
+        npmSpecifiers: [...npmSpecifiers],
+        npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
+    };
+};
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, }) => {
     // The directories that esbuild will use when resolving Node modules. We must
     // set these manually because esbuild will be operating from a temporary
     // directory that will not live inside the project root, so the normal
@@ -94,41 +105,15 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // project directory. If a custom directory has been specified, we use it.
     // Otherwise, create a random temporary directory.
     const temporaryDirectory = directory ? { path: directory } : await tmp.dir();
-    // Do a first pass at bundling to gather a list of specifiers that should be
-    // loaded as npm dependencies, because they either use the `npm:` prefix or
-    // they are bare specifiers. We'll collect them in `specifiers`.
-    try {
-        const { errors, warnings } = await build({
-            banner,
-            bundle: true,
-            entryPoints: functions,
-            logLevel: 'silent',
-            nodePaths,
-            outdir: temporaryDirectory.path,
-            platform: 'node',
-            plugins: [getDependencyTrackerPlugin(specifiers, importMap.getContentsWithURLObjects(), pathToFileURL(basePath))],
-            write: false,
-            format: 'esm',
-        });
-        if (errors.length !== 0) {
-            logger.system('ESBuild errored while tracking dependencies in edge function:', errors);
-        }
-        if (warnings.length !== 0) {
-            logger.system('ESBuild warned while tracking dependencies in edge function:', warnings);
-        }
-    }
-    catch (error) {
-        logger.system('Could not track dependencies in edge function:', error);
-        logger.user('An error occurred when trying to scan your edge functions for npm modules, which is an experimental feature. If you are loading npm modules, please share the link to this deploy in https://ntl.fyi/edge-functions-npm. If you are not loading npm modules, you can ignore this message.');
-    }
+    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers(basePath, functions, importMap.getContentsWithURLObjects());
     // If we found no specifiers, there's nothing left to do here.
-    if (specifiers.size === 0) {
+    if (npmSpecifiers.length === 0) {
         return;
     }
     // To bundle an entire module and all its dependencies, create a barrel file
     // where we re-export everything from that specifier. We do this for every
     // specifier, and each of these files will become entry points to esbuild.
-    const ops = await Promise.all([...specifiers].map(async (specifier, index) => {
+    const ops = await Promise.all(npmSpecifiers.map(async (specifier, index) => {
         const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
         const filePath = path.join(temporaryDirectory.path, `barrel-${index}.js`);
         await fs.writeFile(filePath, code);
@@ -189,5 +174,6 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         cleanup,
         directory: temporaryDirectory.path,
         importMap: newImportMap,
+        npmSpecifiersWithExtraneousFiles,
     };
 };

package/dist/node/server/server.d.ts

@@ -39,6 +39,7 @@ export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, d
     features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
     graph: any;
+    npmSpecifiersWithExtraneousFiles: string[];
     success: boolean;
 }>>;
 export {};

package/dist/node/server/server.js

@@ -23,6 +23,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         });
         const features = {};
         const importMap = baseImportMap.clone();
+        const npmSpecifiersWithExtraneousFiles = [];
         if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_npm_modules) {
             const vendor = await vendorNPMSpecifiers({
                 basePath,
@@ -34,6 +35,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             if (vendor) {
                 features.npmModules = true;
                 importMap.add(vendor.importMap);
+                npmSpecifiersWithExtraneousFiles.push(...vendor.npmSpecifiersWithExtraneousFiles);
             }
         }
         try {
@@ -69,6 +71,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             features,
             functionsConfig,
             graph,
+            npmSpecifiersWithExtraneousFiles,
             success,
         };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "9.2.1",
+  "version": "9.3.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -74,6 +74,7 @@
   },
   "dependencies": {
     "@import-maps/resolve": "^1.0.1",
+    "@vercel/nft": "^0.24.3",
     "ajv": "^8.11.2",
     "ajv-errors": "^3.0.0",
     "better-ajv-errors": "^1.2.0",
@@ -82,6 +83,7 @@
     "esbuild": "0.19.4",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
+    "get-package-name": "^2.2.0",
     "get-port": "^6.1.2",
     "is-path-inside": "^4.0.0",
     "jsonc-parser": "^3.2.0",