@netlify/edge-bundler 9.2.1 → 9.4.0

package/dist/node/bundler.js

@@ -158,6 +158,7 @@ const safelyVendorNPMSpecifiers = async ({ basePath, featureFlags, functions, im
             functions: functions.map(({ path }) => path),
             importMap,
             logger,
+            referenceTypes: false,
         });
     }
     catch (error) {

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,22 +1,21 @@
 /// <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;
     functions: string[];
     importMap: ImportMap;
     logger: Logger;
+    referenceTypes: boolean;
 }
-export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, logger, }: VendorNPMSpecifiersOptions) => Promise<{
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, referenceTypes, }: 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,67 @@
 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 { findUp } from 'find-up';
+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']);
+const slugifyPackageName = (specifier) => {
+    if (!specifier.startsWith('@'))
+        return specifier;
+    const [scope, pkg] = specifier.split('/');
+    return `${scope.replace('@', '')}__${pkg}`;
+};
+/**
+ * Returns the name of the `@types/` package used by a given specifier. Most of
+ * the times this is just the specifier itself, but scoped packages suffer a
+ * transformation (e.g. `@netlify/functions` -> `@types/netlify__functions`).
+ * https://github.com/DefinitelyTyped/DefinitelyTyped#what-about-scoped-packages
+ */
+const getTypesPackageName = (specifier) => path.join('@types', slugifyPackageName(specifier));
+/**
+ * Finds corresponding DefinitelyTyped packages (`@types/...`) and returns path to declaration file.
+ */
+const getTypePathFromTypesPackage = async (packageName, packageJsonPath) => {
+    const typesPackagePath = await findUp(`node_modules/${getTypesPackageName(packageName)}/package.json`, {
+        cwd: packageJsonPath,
+    });
+    if (!typesPackagePath) {
+        return undefined;
+    }
+    const { types, typings } = JSON.parse(await fs.readFile(typesPackagePath, 'utf8'));
+    const declarationPath = types !== null && types !== void 0 ? types : typings;
+    if (typeof declarationPath === 'string') {
+        return path.join(typesPackagePath, '..', declarationPath);
+    }
+    return undefined;
+};
+/**
+ * Starting from a `package.json` file, this tries detecting a TypeScript declaration file.
+ * It first looks at the `types` and `typings` fields in `package.json`.
+ * If it doesn't find them, it falls back to DefinitelyTyped packages (`@types/...`).
+ */
+const getTypesPath = async (packageJsonPath) => {
+    const { name, types, typings } = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    // this only looks at `.types` and `.typings` fields. there might also be data in `exports -> . -> types -> import/default`.
+    // we're ignoring that for now.
+    const declarationPath = types !== null && types !== void 0 ? types : typings;
+    if (typeof declarationPath === 'string') {
+        return path.join(packageJsonPath, '..', declarationPath);
+    }
+    return await getTypePathFromTypesPackage(name, packageJsonPath);
+};
+const safelyDetectTypes = async (packageJsonPath) => {
+    try {
+        return await getTypesPath(packageJsonPath);
+    }
+    catch {
+        return undefined;
+    }
+};
 // Workaround for https://github.com/evanw/esbuild/issues/1921.
 const banner = {
     js: `
@@ -19,72 +73,99 @@ 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
+ * @param referenceTypes Whether to detect typescript declarations and reference them in the output
+ */
+const getNPMSpecifiers = async (basePath, functions, importMap, referenceTypes) => {
+    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 };
+            return nftResolve(specifier, ...args);
+        },
+    });
+    const npmSpecifiers = [];
+    const npmSpecifiersWithExtraneousFiles = new Set();
+    for (const [filePath, reason] of reasons.entries()) {
+        const parents = [...reason.parents];
+        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);
+                }
+            });
+        }
+        // every dependency will have its `package.json` in `reasons` exactly once.
+        // by only looking at this file, we save us from doing duplicate work.
+        const isPackageJson = filePath.endsWith('package.json');
+        if (!isPackageJson)
+            continue;
+        const packageName = getPackageName(filePath);
+        if (packageName === undefined)
+            continue;
+        const isDirectDependency = parents.some((parentPath) => {
+            var _a, _b;
+            if (!parentPath.startsWith(`node_modules${path.sep}`))
+                return true;
+            // typically, edge functions have no direct dependency on the `package.json` of a module.
+            // it's the impl files that depend on `package.json`, so we need to check the parents of
+            // the `package.json` file as well to see if the module is a direct dependency.
+            const parents = [...((_b = (_a = reasons.get(parentPath)) === null || _a === void 0 ? void 0 : _a.parents) !== null && _b !== void 0 ? _b : [])];
+            return parents.some((parentPath) => !parentPath.startsWith(`node_modules${path.sep}`));
         });
-    },
-});
-export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, logger, }) => {
-    const specifiers = new Set();
+        // 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) {
+            npmSpecifiers.push({
+                specifier: packageName,
+                types: referenceTypes ? await safelyDetectTypes(path.join(basePath, filePath)) : undefined,
+            });
+        }
+    }
+    return {
+        npmSpecifiers,
+        npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
+    };
+};
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, referenceTypes, }) => {
     // 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,51 +175,25 @@ 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(), referenceTypes);
     // If we found no specifiers, there's nothing left to do here.
-    if (specifiers.size === 0) {
+    if (Object.keys(npmSpecifiers).length === 0) {
         return;
     }
-    // To bundle an entire module and all its dependencies, create a barrel file
+    // To bundle an entire module and all its dependencies, create a entrypoint 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, types }) => {
         const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
-        const filePath = path.join(temporaryDirectory.path, `barrel-${index}.js`);
+        const filePath = path.join(temporaryDirectory.path, `bundled-${slugifyPackageName(specifier)}.js`);
         await fs.writeFile(filePath, code);
-        return { filePath, specifier };
+        return { filePath, specifier, types };
     }));
     const entryPoints = ops.map(({ filePath }) => filePath);
-    // Bundle each of the barrel files we created. We'll end up with a compiled
-    // version of each of the barrel files, plus any chunks of shared code
+    // Bundle each of the entrypoints we created. We'll end up with a compiled
+    // version of each, plus any chunks of shared code
     // between them (such that a common module isn't bundled twice).
-    await build({
+    const { outputFiles } = await build({
         allowOverwrite: true,
         banner,
         bundle: true,
@@ -150,7 +205,17 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         platform: 'node',
         splitting: true,
         target: 'es2020',
+        write: false,
     });
+    await Promise.all(outputFiles.map(async (file) => {
+        var _a;
+        const types = (_a = ops.find((op) => path.basename(file.path) === path.basename(op.filePath))) === null || _a === void 0 ? void 0 : _a.types;
+        let content = file.text;
+        if (types) {
+            content = `/// <reference types="${path.relative(file.path, types)}" />\n${content}`;
+        }
+        await fs.writeFile(file.path, content);
+    }));
     // Add all Node.js built-ins to the import map, so any unprefixed specifiers
     // (e.g. `process`) resolve to the prefixed versions (e.g. `node:prefix`),
     // which Deno can process.
@@ -189,5 +254,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,
@@ -30,10 +31,12 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
                 functions: functions.map(({ path }) => path),
                 importMap,
                 logger,
+                referenceTypes: true,
             });
             if (vendor) {
                 features.npmModules = true;
                 importMap.add(vendor.importMap);
+                npmSpecifiersWithExtraneousFiles.push(...vendor.npmSpecifiersWithExtraneousFiles);
             }
         }
         try {
@@ -69,6 +72,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             features,
             functionsConfig,
             graph,
+            npmSpecifiersWithExtraneousFiles,
             success,
         };
     };

package/dist/node/server/server.test.js

@@ -1,7 +1,7 @@
+import { readFile } from 'fs/promises';
 import { join } from 'path';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
-import { tmpName } from 'tmp-promise';
 import { v4 as uuidv4 } from 'uuid';
 import { test, expect } from 'vitest';
 import { fixturesDir } from '../../test/util.js';
@@ -14,13 +14,16 @@ test('Starts a server and serves requests for edge functions', async () => {
     };
     const port = await getPort();
     const importMapPaths = [join(paths.internal, 'import_map.json'), join(paths.user, 'import-map.json')];
-    const servePath = await tmpName();
+    const servePath = join(basePath, '.netlify', 'edge-functions-serve');
     const server = await serve({
         basePath,
         bootstrapURL: 'https://edge.netlify.com/bootstrap/index-combined.ts',
         importMapPaths,
         port,
         servePath,
+        featureFlags: {
+            edge_functions_npm_modules: true,
+        },
     });
     const functions = [
         {
@@ -39,12 +42,13 @@ test('Starts a server and serves requests for edge functions', async () => {
     const options = {
         getFunctionsConfig: true,
     };
-    const { features, functionsConfig, graph, success } = await server(functions, {
+    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
-    expect(features).toEqual({});
+    expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
+    expect(npmSpecifiersWithExtraneousFiles).toEqual(['dictionary']);
     for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
         // @ts-expect-error TODO: Module graph is currently not typed
@@ -80,4 +84,8 @@ test('Starts a server and serves requests for edge functions', async () => {
         global: 'i love netlify',
         local: 'i love netlify',
     });
+    const idBarrelFile = await readFile(join(servePath, 'bundled-id.js'), 'utf-8');
+    expect(idBarrelFile).toContain(`/// <reference types="${join('..', '..', '..', 'node_modules', 'id', 'types.d.ts')}" />`);
+    const identidadeBarrelFile = await readFile(join(servePath, 'bundled-pt-committee__identidade.js'), 'utf-8');
+    expect(identidadeBarrelFile).toContain(`/// <reference types="${join('..', '..', '..', 'node_modules', '@types', 'pt-committee__identidade', 'index.d.ts')}" />`);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "9.2.1",
+  "version": "9.4.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",