@netlify/edge-bundler 12.4.0 → 13.0.0

package/dist/node/bundler.test.js

@@ -402,6 +402,28 @@ test('Loads npm modules from bare specifiers', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
+test('Loads npm modules which use package.json.exports', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_exports');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        vendorDirectory: vendorDirectory.path,
+    });
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(func1).toBe('hello');
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});
 test('Loads npm modules in a monorepo setup', async () => {
     const systemLogger = vi.fn();
     const { basePath: rootPath, cleanup, distPath } = await useFixture('monorepo_npm_module');

package/dist/node/npm_dependencies.d.ts

@@ -16,7 +16,6 @@ export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, imp
         baseURL: import("url").URL;
         imports: Record<string, string>;
     };
-    npmSpecifiersWithExtraneousFiles: string[];
     outputFiles: string[];
 }>;
 export {};

package/dist/node/npm_dependencies.js

@@ -3,13 +3,15 @@ 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 { parseImports } from 'parse-imports';
 import tmp from 'tmp-promise';
 import { pathsBetween } from './utils/fs.js';
 const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.ctsx', '.mts', '.mtsx']);
+const slugifyFileName = (specifier) => {
+    return specifier.replace(/\//g, '_');
+};
 const slugifyPackageName = (specifier) => {
     if (!specifier.startsWith('@'))
         return specifier;
@@ -55,9 +57,20 @@ const getTypesPath = async (packageJsonPath) => {
     }
     return await getTypePathFromTypesPackage(name, packageJsonPath);
 };
-const safelyDetectTypes = async (packageJsonPath) => {
+function packageName(specifier) {
+    if (!specifier.startsWith('@'))
+        return specifier.split('/')[0];
+    const [scope, pkg] = specifier.split('/');
+    return `${scope}/${pkg}`;
+}
+const safelyDetectTypes = async (pkg, basePath) => {
     try {
-        return await getTypesPath(packageJsonPath);
+        const json = await findUp(`node_modules/${packageName(pkg)}/package.json`, {
+            cwd: basePath,
+        });
+        if (json) {
+            return await getTypesPath(json);
+        }
     }
     catch {
         return undefined;
@@ -81,92 +94,80 @@ const banner = {
   globalThis.Buffer = __nfyBuffer;
   `,
 };
+async function compileTypeScript(file) {
+    const compiled = await build({
+        bundle: false,
+        entryPoints: [file],
+        logLevel: 'silent',
+        platform: 'node',
+        write: false,
+    });
+    return compiled.outputFiles[0].text;
+}
+async function parseImportsForFile(file, rootPath) {
+    const source = TYPESCRIPT_EXTENSIONS.has(path.extname(file))
+        ? await compileTypeScript(file)
+        : await fs.readFile(file, 'utf-8');
+    return await parseImports(source, {
+        resolveFrom: rootPath,
+    });
+}
 /**
  * Parses a set of functions and returns a list of specifiers that correspond
  * to npm modules.
  */
 const getNPMSpecifiers = async ({ basePath, functions, importMap, environment, rootPath }) => {
+    var _a;
     const baseURL = pathToFileURL(basePath);
-    const { reasons } = await nodeFileTrace(functions, {
-        base: rootPath,
-        processCwd: 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;
-            }
-            return fs.readFile(filePath, 'utf8');
-        },
-        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 && resolvedImport.protocol === 'file:') {
-                const newSpecifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
-                return nftResolve(newSpecifier, ...args);
-            }
-            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);
+    for (const func of functions) {
+        const imports = await parseImportsForFile(func, rootPath);
+        for (const i of imports) {
+            // The non-null assertion is required because typescript can not infer that `moduleSpecifier.value` can be narrowed to a string.
+            // The narrowing is possible because `moduleSpecifier.value` will always be a string when `moduleSpecifier.isConstant` is true.
+            const specifier = i.moduleSpecifier.isConstant ? i.moduleSpecifier.value : i.moduleSpecifier.code;
+            switch (i.moduleSpecifier.type) {
+                case 'absolute': {
+                    npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [specifier], importMap, environment, rootPath })));
+                    break;
                 }
-            });
-        }
-        // 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}`));
-        });
-        // 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: environment === 'development' ? await safelyDetectTypes(path.join(basePath, filePath)) : undefined,
-            });
+                case 'relative': {
+                    const filePath = path.join(path.dirname(func), specifier);
+                    npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [filePath], importMap, environment, rootPath })));
+                    break;
+                }
+                case 'package': {
+                    // node: prefixed imports are detected as packages instead of as builtins
+                    // we don't want to try and bundle builtins so we ignore node: prefixed imports
+                    if (specifier.startsWith('node:')) {
+                        break;
+                    }
+                    const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
+                    if (matched) {
+                        if (resolvedImport.protocol === 'file:') {
+                            const newSpecifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
+                            npmSpecifiers.push(...(await getNPMSpecifiers({ basePath, functions: [newSpecifier], importMap, environment, rootPath })));
+                        }
+                    }
+                    else if (!((_a = resolvedImport === null || resolvedImport === void 0 ? void 0 : resolvedImport.protocol) === null || _a === void 0 ? void 0 : _a.startsWith('http'))) {
+                        const t = await safelyDetectTypes(specifier, basePath);
+                        npmSpecifiers.push({
+                            specifier: specifier,
+                            types: t,
+                        });
+                    }
+                    break;
+                }
+                case 'builtin':
+                case 'invalid':
+                case 'unknown': {
+                    // We don't bundle these types of modules
+                    break;
+                }
+            }
         }
     }
-    return {
-        npmSpecifiers,
-        npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
-    };
+    return npmSpecifiers;
 };
 export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, environment, rootPath = basePath, }) => {
     // The directories that esbuild will use when resolving Node modules. We must
@@ -178,7 +179,7 @@ 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();
-    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers({
+    const npmSpecifiers = await getNPMSpecifiers({
         basePath,
         functions,
         importMap: importMap.getContentsWithURLObjects(),
@@ -189,8 +190,8 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // 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(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, `bundled-${slugifyPackageName(specifier)}.js`);
+        const code = `import * as mod from "${specifier}";\nexport default mod.default;\nexport * from "${specifier}";`;
+        const filePath = path.join(temporaryDirectory.path, `bundled-${slugifyFileName(specifier)}.js`);
         await fs.writeFile(filePath, code);
         return { filePath, specifier, types };
     }));
@@ -269,7 +270,6 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         cleanup,
         directory: temporaryDirectory.path,
         importMap: newImportMap,
-        npmSpecifiersWithExtraneousFiles,
         outputFiles,
     };
 };

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

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

package/dist/node/server/server.js

@@ -42,7 +42,6 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         const features = {};
         const importMap = new ImportMap();
         await importMap.addFiles((_a = options.importMapPaths) !== null && _a !== void 0 ? _a : [], logger);
-        const npmSpecifiersWithExtraneousFiles = [];
         // we keep track of the files that are relevant to the user's code, so we can clean up leftovers from past executions later
         const relevantFiles = [stage2Path];
         const vendor = await vendorNPMSpecifiers({
@@ -57,7 +56,6 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         if (vendor) {
             features.npmModules = true;
             importMap.add(vendor.importMap);
-            npmSpecifiersWithExtraneousFiles.push(...vendor.npmSpecifiersWithExtraneousFiles);
             relevantFiles.push(...vendor.outputFiles);
         }
         await cleanDirectory(distDirectory, relevantFiles);
@@ -96,7 +94,6 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             features,
             functionsConfig,
             graph,
-            npmSpecifiersWithExtraneousFiles,
             success,
         };
     };

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

@@ -42,13 +42,12 @@ test('Starts a server and serves requests for edge functions', async () => {
         getFunctionsConfig: true,
         importMapPaths,
     };
-    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
+    const { features, functionsConfig, graph, success } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
-    expect(npmSpecifiersWithExtraneousFiles).toEqual(['dictionary']);
     const modules = graph === null || graph === void 0 ? void 0 : graph.modules.filter(({ kind, mediaType }) => kind === 'esm' && mediaType === 'TypeScript');
     for (const key in functions) {
         const graphEntry = modules === null || modules === void 0 ? void 0 : modules.some(({ local }) => local === functions[key].path);
@@ -85,7 +84,7 @@ test('Starts a server and serves requests for edge functions', async () => {
     });
     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');
+    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')}" />`);
 });
 test('Serves edge functions in a monorepo setup', async () => {
@@ -117,13 +116,12 @@ test('Serves edge functions in a monorepo setup', async () => {
         getFunctionsConfig: true,
         importMapPaths,
     };
-    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
+    const { features, functionsConfig, graph, success } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/func1' }]);
-    expect(npmSpecifiersWithExtraneousFiles).toEqual(['child-1']);
     for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
         expect(graphEntry).toBe(true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "12.4.0",
+  "version": "13.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -58,7 +58,6 @@
   },
   "dependencies": {
     "@import-maps/resolve": "^1.0.1",
-    "@vercel/nft": "0.27.7",
     "ajv": "^8.11.2",
     "ajv-errors": "^3.0.0",
     "better-ajv-errors": "^1.2.0",
@@ -74,11 +73,12 @@
     "node-stream-zip": "^1.15.0",
     "p-retry": "^5.1.1",
     "p-wait-for": "^5.0.0",
+    "parse-imports": "^2.2.1",
     "path-key": "^4.0.0",
     "semver": "^7.3.8",
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^9.0.0"
   },
-  "gitHead": "0e4628f57a0a7d02594b5070074445a4ff69b809"
+  "gitHead": "8d10878db3be9cfefe3162fd155c76595aba045e"
 }