@netlify/edge-bundler 14.9.5 → 14.9.7

package/dist/node/formats/tarball.js

@@ -1,4 +1,5 @@
 import { promises as fs } from 'fs';
+import { builtinModules } from 'module';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import commonPathPrefix from 'common-path-prefix';
@@ -17,25 +18,32 @@ export const bundle = async ({ buildID, deno, distDirectory, functions, importMa
         version: 1,
     };
     const entryPoints = functions.map((func) => func.path);
-    // Find the common path prefix for all entry points. When using a single
-    // entry point, `commonPathPrefix` returns an empty string, so we use
+    // Use deno info to get the module graph and identify which local files are actually needed.
+    // This avoids copying unnecessary files (like node_modules) that happen to be under commonPath.
+    // If module graph analysis fails, fall back to copying files from entry point directories.
+    const sourceFiles = await getRequiredSourceFiles(deno, entryPoints, importMap);
+    // Find the common path prefix for all source files (entry points + their local imports).
+    // This ensures imports to sibling directories (e.g., ../internal/) are included.
+    // When using a single file, `commonPathPrefix` returns an empty string, so we use
     // the path of the first entry point's directory.
-    const commonPath = commonPathPrefix(entryPoints) || path.dirname(entryPoints[0]);
+    const commonPath = commonPathPrefix(sourceFiles) || path.dirname(entryPoints[0]);
     // Build the manifest mapping function names to their relative paths
     for (const func of functions) {
         const relativePath = path.relative(commonPath, func.path);
         manifest.functions[func.name] = getUnixPath(relativePath);
     }
-    // Use deno info to get the module graph and identify which local files are actually needed.
-    // This avoids copying unnecessary files (like node_modules) that happen to be under commonPath.
-    // If module graph analysis fails, fall back to copying files from entry point directories.
-    const sourceFiles = await getRequiredSourceFiles(deno, entryPoints, importMap, commonPath);
     for (const sourceFile of sourceFiles) {
         const relativePath = path.relative(commonPath, sourceFile);
         const destPath = path.join(bundleDir.path, relativePath);
         await fs.mkdir(path.dirname(destPath), { recursive: true });
         await fs.copyFile(sourceFile, destPath);
     }
+    // Rewrite bare specifier imports to their resolved URLs so they can be
+    // resolved by Deno's --vendor flag at runtime without needing the customer's import map.
+    // At runtime, Deno discovers config from /platform/deno.json (the bootstrap entry
+    // point), not /function/deno.json, so the customer's import map is unreachable.
+    // This is because we boot Deno before we've mounted the customer's edge-functions directory, so it can't be used to resolve imports during the initial bundle phase.
+    await rewriteBareSpecifiers(bundleDir.path, sourceFiles, commonPath, importMap);
     // Vendor all dependencies in the bundle directory
     await deno.run([
         'install',
@@ -106,6 +114,77 @@ export const bundle = async ({ buildID, deno, distDirectory, functions, importMa
         hash,
     };
 };
+// Specifiers provided by the platform deno.json at runtime - no need to rewrite these.
+const PLATFORM_SPECIFIERS = new Set(['@netlify/edge-functions', 'netlify:edge']);
+// Source file extensions that may contain import statements.
+const REWRITABLE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.mts']);
+/**
+ * Rewrites bare specifier imports in copied source files to their resolved URLs
+ * from the import map. This allows Deno's --vendor flag to resolve these imports
+ * at runtime without needing the customer's import map (which is unreachable
+ * because Deno discovers config from the platform bootstrap directory, not the
+ * function directory).
+ *
+ * Only rewrites specifiers that:
+ * - Are bare package specifiers (not relative, absolute, or URL imports)
+ * - Resolve to http/https or npm: URLs in the import map
+ * - Are NOT node builtins or platform-provided imports
+ */
+async function rewriteBareSpecifiers(bundleDirPath, sourceFiles, commonPath, importMap) {
+    const contents = importMap.getContents();
+    const builtinSet = new Set(builtinModules);
+    // Collect bare specifiers that should be rewritten to URLs
+    const specifierEntries = Object.entries(contents.imports)
+        .filter(([specifier, url]) => {
+        // Skip node builtins
+        if (specifier.startsWith('node:') || builtinSet.has(specifier))
+            return false;
+        // Skip platform-provided specifiers (handled by platform deno.json)
+        if (PLATFORM_SPECIFIERS.has(specifier))
+            return false;
+        // Skip relative/absolute path specifiers
+        if (specifier.startsWith('.') || specifier.startsWith('/'))
+            return false;
+        // Only rewrite to http/https or npm: URLs
+        if (!url.startsWith('http://') && !url.startsWith('https://') && !url.startsWith('npm:'))
+            return false;
+        return true;
+    })
+        // Sort longest first so prefix mappings like "lodash/" match before "lodash"
+        .sort((a, b) => b[0].length - a[0].length);
+    for (const sourceFile of sourceFiles) {
+        if (!REWRITABLE_EXTENSIONS.has(path.extname(sourceFile)))
+            continue;
+        const relativePath = path.relative(commonPath, sourceFile);
+        const destPath = path.join(bundleDirPath, relativePath);
+        let source;
+        try {
+            source = await fs.readFile(destPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        let modified = source;
+        for (const [specifier, url] of specifierEntries) {
+            const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            // Escape $ in URL for use in replacement string
+            const safeUrl = url.replace(/\$/g, '$$$$');
+            for (const quote of ['"', "'"]) {
+                if (specifier.endsWith('/')) {
+                    // Prefix mapping: "specifier/subpath" -> "url/subpath"
+                    modified = modified.replace(new RegExp(`(\\bfrom\\s+|\\bimport\\s+|\\bimport\\s*\\(\\s*)${quote}${escaped}([^${quote}]*)${quote}`, 'g'), `$1${quote}${safeUrl}$2${quote}`);
+                }
+                else {
+                    // Exact mapping: "specifier" -> "url"
+                    modified = modified.replace(new RegExp(`(\\bfrom\\s+|\\bimport\\s+|\\bimport\\s*\\(\\s*)${quote}${escaped}${quote}`, 'g'), `$1${quote}${safeUrl}${quote}`);
+                }
+            }
+        }
+        if (modified !== source) {
+            await fs.writeFile(destPath, modified);
+        }
+    }
+}
 /**
  * Uses deno info to get the module graph and extract only the local source files
  * that are actually needed by the entry points. This avoids copying unnecessary
@@ -114,8 +193,7 @@ export const bundle = async ({ buildID, deno, distDirectory, functions, importMa
  * If deno info fails, falls back to copying files from the directories containing
  * the entry points (not the entire common path).
  */
-async function getRequiredSourceFiles(deno, entryPoints, importMap, commonPath) {
-    const commonPathUrl = pathToFileURL(commonPath + path.sep).href;
+async function getRequiredSourceFiles(deno, entryPoints, importMap) {
     const localFiles = new Set();
     const importMapDataUrl = importMap.withNodeBuiltins().toDataURL();
     // Run deno info for each entry point and combine the results
@@ -129,10 +207,9 @@ async function getRequiredSourceFiles(deno, entryPoints, importMap, commonPath)
                 pathToFileURL(entryPoint).href,
             ]);
             const graph = JSON.parse(stdout);
-            // Extract local files from the module graph
+            // Extract all local files from the module graph
             for (const module of graph.modules) {
-                // Only include local file:// URLs that are under the common path
-                if (module.specifier.startsWith('file://') && module.specifier.startsWith(commonPathUrl)) {
+                if (module.specifier.startsWith('file://')) {
                     const filePath = fileURLToPath(module.specifier);
                     localFiles.add(filePath);
                 }
@@ -142,11 +219,9 @@ async function getRequiredSourceFiles(deno, entryPoints, importMap, commonPath)
             // If deno info fails for this entry point, fall back to copying files
             // from its directory
             const dir = path.dirname(entryPoint);
-            if (dir.startsWith(commonPath)) {
-                const files = await listRecursively(dir);
-                for (const file of files) {
-                    localFiles.add(file);
-                }
+            const files = await listRecursively(dir);
+            for (const file of files) {
+                localFiles.add(file);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.9.5",
+  "version": "14.9.7",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -79,5 +79,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "76b0a932036a205140d5f2110f3ef7e90583fbb0"
+  "gitHead": "55f6d3568bcea071e679b4152c3273eb48223159"
 }