@netlify/edge-bundler 14.9.4 → 14.9.6

package/dist/node/formats/tarball.d.ts

@@ -14,5 +14,5 @@ interface BundleTarballOptions {
     importMap: ImportMap;
     vendorDirectory?: string;
 }
-export declare const bundle: ({ basePath, buildID, deno, distDirectory, functions, importMap, vendorDirectory, }: BundleTarballOptions) => Promise<Bundle>;
+export declare const bundle: ({ buildID, deno, distDirectory, functions, importMap, vendorDirectory, }: BundleTarballOptions) => Promise<Bundle>;
 export {};

package/dist/node/formats/tarball.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'fs';
 import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import commonPathPrefix from 'common-path-prefix';
 import * as tar from 'tar';
 import tmp from 'tmp-promise';
@@ -8,55 +9,77 @@ import { listRecursively } from '../utils/fs.js';
 import { getFileHash } from '../utils/sha256.js';
 const TARBALL_EXTENSION = '.tar.gz';
 const getUnixPath = (input) => input.split(path.sep).join('/');
-export const bundle = async ({ basePath, buildID, deno, distDirectory, functions, importMap, vendorDirectory, }) => {
+export const bundle = async ({ buildID, deno, distDirectory, functions, importMap, vendorDirectory, }) => {
     const bundleDir = await tmp.dir({ unsafeCleanup: true });
     const cleanup = [bundleDir.cleanup];
-    let denoDir = vendorDirectory ? path.join(vendorDirectory, 'deno_dir') : undefined;
-    if (!denoDir) {
-        const tmpDir = await tmp.dir({ unsafeCleanup: true });
-        denoDir = tmpDir.path;
-        cleanup.push(tmpDir.cleanup);
-    }
     const manifest = {
         functions: {},
         version: 1,
     };
     const entryPoints = functions.map((func) => func.path);
-    // `deno bundle` does not return the paths of the files it emits, so we have
-    // to infer them. When multiple entry points are supplied, it will find the
-    // common path prefix and use that as the base directory in `outdir`. When
-    // using a single entry point, `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]);
+    // 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(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);
-        const bundledPath = path.format({
-            ...path.parse(relativePath),
-            base: undefined,
-            ext: '.js',
-        });
-        manifest.functions[func.name] = getUnixPath(bundledPath);
+        manifest.functions[func.name] = getUnixPath(relativePath);
+    }
+    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);
     }
+    // Vendor all dependencies in the bundle directory
     await deno.run([
-        'bundle',
+        'install',
         '--import-map',
         importMap.withNodeBuiltins().toDataURL(),
         '--quiet',
-        '--code-splitting',
         '--allow-import',
         '--node-modules-dir=manual',
-        '--outdir',
-        bundleDir.path,
-        ...functions.map((func) => func.path),
+        '--vendor',
+        '--entrypoint',
+        ...functions.map((func) => path.relative(commonPath, func.path)),
     ], {
-        cwd: basePath,
+        cwd: bundleDir.path,
     });
+    // Build prefix mappings to transform file:// URLs to relative paths
+    const npmVendorDir = '.netlify-npm-vendor';
+    const prefixes = {};
+    // Copy pre-bundled npm modules from vendorDirectory if present.
+    // This supports the legacy approach where npm packages are pre-bundled and mapped
+    // via import map. Modern code could use npm: specifiers instead, which Deno handles
+    // natively via `deno install --vendor`.
+    if (vendorDirectory) {
+        prefixes[pathToFileURL(vendorDirectory + path.sep).href] = `./${npmVendorDir}/`;
+        // Copy files from vendor directory
+        const vendorFiles = await listRecursively(vendorDirectory);
+        for (const vendorFile of vendorFiles) {
+            const relativePath = path.relative(vendorDirectory, vendorFile);
+            const destPath = path.join(bundleDir.path, npmVendorDir, relativePath);
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.copyFile(vendorFile, destPath);
+        }
+    }
+    // Map common path to relative paths
+    prefixes[pathToFileURL(commonPath + path.sep).href] = './';
+    // Get import map contents with file:// URLs transformed to relative paths
+    const importMapContents = importMap.getContents(prefixes);
+    // Create deno.json with import map contents for runtime resolution
+    const denoConfigPath = path.join(bundleDir.path, 'deno.json');
+    const denoConfigContents = JSON.stringify(importMapContents);
+    await fs.writeFile(denoConfigPath, denoConfigContents);
     const manifestPath = path.join(bundleDir.path, '___netlify-edge-functions.json');
     const manifestContents = JSON.stringify(manifest);
     await fs.writeFile(manifestPath, manifestContents);
-    const denoConfigPath = path.join(bundleDir.path, 'deno.json');
-    const denoConfigContents = JSON.stringify(importMap.getContentsWithRelativePaths());
-    await fs.writeFile(denoConfigPath, denoConfigContents);
     const tarballPath = path.join(distDirectory, buildID + TARBALL_EXTENSION);
     await fs.mkdir(path.dirname(tarballPath), { recursive: true });
     // List files to include in the tarball as paths relative to the bundle dir.
@@ -84,3 +107,45 @@ export const bundle = async ({ basePath, buildID, deno, distDirectory, functions
         hash,
     };
 };
+/**
+ * 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
+ * files (like node_modules, .next, etc.) that may be under the common path.
+ *
+ * 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) {
+    const localFiles = new Set();
+    const importMapDataUrl = importMap.withNodeBuiltins().toDataURL();
+    // Run deno info for each entry point and combine the results
+    for (const entryPoint of entryPoints) {
+        try {
+            const { stdout } = await deno.run([
+                'info',
+                '--json',
+                '--import-map',
+                importMapDataUrl,
+                pathToFileURL(entryPoint).href,
+            ]);
+            const graph = JSON.parse(stdout);
+            // Extract all local files from the module graph
+            for (const module of graph.modules) {
+                if (module.specifier.startsWith('file://')) {
+                    const filePath = fileURLToPath(module.specifier);
+                    localFiles.add(filePath);
+                }
+            }
+        }
+        catch {
+            // If deno info fails for this entry point, fall back to copying files
+            // from its directory
+            const dir = path.dirname(entryPoint);
+            const files = await listRecursively(dir);
+            for (const file of files) {
+                localFiles.add(file);
+            }
+        }
+    }
+    return Array.from(localFiles).sort();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.9.4",
+  "version": "14.9.6",
   "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": "39451b627207d82ce41919a1c9cd02a6ea6c4ad2"
+  "gitHead": "3b7249e4fd7ea006bf473b4953c17312369d1973"
 }