@netlify/edge-bundler 8.20.0 → 9.1.0

package/dist/node/bundler.test.js

@@ -105,7 +105,7 @@ test('Adds a custom error property to user errors during bundling', async () =>
         await cleanup();
     }
 });
-test('Prints a nice error message when user tries importing NPM module', async () => {
+test('Prints a nice error message when user tries importing an npm module and npm support is disabled', async () => {
     expect.assertions(2);
     const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
     const sourceDirectory = join(basePath, 'functions');
@@ -120,7 +120,31 @@ test('Prints a nice error message when user tries importing NPM module', async (
     }
     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-1"'?`);
+        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"'?`);
+    }
+    finally {
+        await cleanup();
+    }
+});
+test('Prints a nice error message when user tries importing an npm module and npm support is enabled', async () => {
+    expect.assertions(2);
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_scheme');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    try {
+        await bundle([sourceDirectory], distPath, declarations, {
+            basePath,
+            featureFlags: { edge_functions_npm_modules: true },
+        });
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(BundleError);
+        expect(error.message).toEqual(`There was an error when loading the 'p-retry' npm module. Support for npm modules in edge functions is an experimental feature. Refer to https://ntl.fyi/edge-functions-npm for more information.`);
     }
     finally {
         await cleanup();
@@ -373,7 +397,7 @@ test('Handles imports with the `node:` prefix', async () => {
     expect(func1).toBe('ok');
     await cleanup();
 });
-test('Loads npm modules from bare specifiers with and without the `npm:` prefix', async () => {
+test('Loads npm modules from bare specifiers', async () => {
     const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
     const sourceDirectory = join(basePath, 'functions');
     const declarations = [

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

@@ -15,5 +15,5 @@ interface BundleESZIPOptions {
     importMap: ImportMap;
     vendorDirectory?: string;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, featureFlags, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
 export { bundleESZIP as bundle };

package/dist/node/formats/eszip.js

@@ -6,7 +6,7 @@ import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, featureFlags, functions, importMap, vendorDirectory, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const importMapPrefixes = {
@@ -33,7 +33,9 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
         await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
     }
     catch (error) {
-        throw wrapBundleError(wrapNpmImportError(error), { format: 'eszip' });
+        throw wrapBundleError(wrapNpmImportError(error, Boolean(featureFlags.edge_functions_npm_modules)), {
+            format: 'eszip',
+        });
     }
     const hash = await getFileHash(destPath);
     return { extension, format: BundleFormat.ESZIP2, hash };

package/dist/node/import_map.d.ts

@@ -9,11 +9,12 @@ export interface ImportMapFile {
 export declare class ImportMap {
     rootPath: string | null;
     sources: ImportMapFile[];
-    constructor(sources?: ImportMapFile[], rootURL?: string | null);
+    constructor(sources?: ImportMapFile[], rootPath?: string | null);
     add(source: ImportMapFile): void;
     addFile(path: string, logger: Logger): Promise<void>;
     addFiles(paths: (string | undefined)[], logger: Logger): Promise<void>;
     static applyPrefixesToImports(imports: Imports, prefixes: Record<string, string>): Imports;
+    clone(): ImportMap;
     static convertImportsToURLObjects(imports: Imports): Record<string, URL>;
     static convertScopesToURLObjects(scopes: Record<string, Imports>): Record<string, Record<string, URL>>;
     static applyPrefixesToPath(path: string, prefixes: Record<string, string>): string;

package/dist/node/import_map.js

@@ -11,8 +11,8 @@ const INTERNAL_IMPORTS = {
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.
 export class ImportMap {
-    constructor(sources = [], rootURL = null) {
-        this.rootPath = rootURL ? fileURLToPath(rootURL) : null;
+    constructor(sources = [], rootPath = null) {
+        this.rootPath = rootPath;
         this.sources = [];
         sources.forEach((file) => {
             this.add(file);
@@ -44,6 +44,9 @@ export class ImportMap {
             [key]: ImportMap.applyPrefixesToPath(value, prefixes),
         }), {});
     }
+    clone() {
+        return new ImportMap(this.sources, this.rootPath);
+    }
     static convertImportsToURLObjects(imports) {
         return Object.entries(imports).reduce((acc, [key, value]) => ({
             ...acc,

package/dist/node/import_map.test.js

@@ -121,7 +121,7 @@ test('Throws when an import map uses a relative path to reference a file outside
             'alias:file': '../file.js',
         },
     };
-    const map = new ImportMap([inputFile1], pathToFileURL(cwd()).toString());
+    const map = new ImportMap([inputFile1], cwd());
     expect(() => map.getContents()).toThrowError(`Import map cannot reference '${join(cwd(), '..', 'file.js')}' as it's outside of the base directory '${cwd()}'`);
 });
 test('Writes import map file to disk', async () => {
@@ -143,3 +143,45 @@ 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('Clones an import map', () => {
+    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
+    const inputFile1 = {
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            'alias:jamstack': 'https://jamstack.org',
+        },
+    };
+    const inputFile2 = {
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            'alias:pets': 'https://petsofnetlify.com/',
+        },
+    };
+    const map1 = new ImportMap([inputFile1, inputFile2]);
+    const map2 = map1.clone();
+    map2.add({
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            netlify: 'https://netlify.com',
+        },
+    });
+    expect(map1.getContents()).toStrictEqual({
+        imports: {
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'alias:jamstack': 'https://jamstack.org/',
+            'alias:pets': 'https://petsofnetlify.com/',
+        },
+        scopes: {},
+    });
+    expect(map2.getContents()).toStrictEqual({
+        imports: {
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'alias:jamstack': 'https://jamstack.org/',
+            'alias:pets': 'https://petsofnetlify.com/',
+            netlify: 'https://netlify.com/',
+        },
+        scopes: {},
+    });
+});

package/dist/node/npm_dependencies.js

@@ -11,9 +11,9 @@ const require = createRequire(import.meta.url);
 // Workaround for https://github.com/evanw/esbuild/issues/1921.
 const banner = {
     js: `
-  import {createRequire as ___nfyCreateRequire} from "module";
-  import {fileURLToPath as ___nfyFileURLToPath} from "url";
-  import {dirname as ___nfyPathDirname} from "path";
+  import {createRequire as ___nfyCreateRequire} from "node:module";
+  import {fileURLToPath as ___nfyFileURLToPath} from "node:url";
+  import {dirname as ___nfyPathDirname} from "node:path";
   let __filename=___nfyFileURLToPath(import.meta.url);
   let __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));
   let require=___nfyCreateRequire(import.meta.url);
@@ -44,16 +44,12 @@ export const getDependencyTrackerPlugin = (specifiers, importMap, baseURL) => ({
             if (specifier.startsWith(nodePrefix) || builtinModulesSet.has(specifier)) {
                 return { external: true };
             }
-            // If the specifier has the `npm:` prefix, strip it and use the rest of
-            // the specifier to resolve the module.
+            // 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)) {
-                const canonicalPath = specifier.slice(npmPrefix.length);
-                return build.resolve(canonicalPath, {
-                    kind: args.kind,
-                    resolveDir: args.resolveDir,
-                });
+                return { external: true };
             }
-            const isLocalImport = specifier.startsWith(path.sep) || specifier.startsWith('.');
+            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;
@@ -92,8 +88,8 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // resolution logic won't work.
     const nodePaths = [path.join(basePath, 'node_modules')];
     // We need to create some files on disk, which we don't want to write to the
-    // project directory. If a custom directory has been specified, which happens
-    // only in tests, we use it. Otherwise, create a random temporary directory.
+    // 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
@@ -119,20 +115,19 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     if (specifiers.size === 0) {
         return;
     }
-    logger.user('You are using npm modules in Edge Functions, which is an experimental feature. Learn more at https://ntl.fyi/edge-functions-npm.');
-    // To bundle an entire module and all its dependencies, we create a stub file
+    // 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 be the entry points to esbuild.
+    // specifier, and each of these files will become entry points to esbuild.
     const ops = await Promise.all([...specifiers].map(async (specifier, index) => {
         const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
-        const filePath = path.join(temporaryDirectory.path, `stub-${index}.js`);
+        const filePath = path.join(temporaryDirectory.path, `barrel-${index}.js`);
         await fs.writeFile(filePath, code);
         return { filePath, specifier };
     }));
     const entryPoints = ops.map(({ filePath }) => filePath);
-    // Bundle each of the stub files we've created. We'll end up with a compiled
-    // version of each of the stub files, plus any chunks of shared code between
-    // stubs (such that a common module isn't bundled twice).
+    // 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
+    // between them (such that a common module isn't bundled twice).
     await build({
         allowOverwrite: true,
         banner,
@@ -164,7 +159,6 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
             return {
                 ...acc,
                 [op.specifier]: url,
-                [npmPrefix + op.specifier]: url,
             };
         }, builtIns),
     };

package/dist/node/npm_import_error.d.ts

@@ -1,5 +1,5 @@
 declare class NPMImportError extends Error {
-    constructor(originalError: Error, moduleName: string);
+    constructor(originalError: Error, moduleName: string, supportsNPM: boolean);
 }
-declare const wrapNpmImportError: (input: unknown) => unknown;
+declare const wrapNpmImportError: (input: unknown, supportsNPM: boolean) => unknown;
 export { NPMImportError, wrapNpmImportError };

package/dist/node/npm_import_error.js

@@ -1,23 +1,27 @@
 class NPMImportError extends Error {
-    constructor(originalError, moduleName) {
-        super(`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/${moduleName}"'?`);
+    constructor(originalError, moduleName, supportsNPM) {
+        let message = `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/${moduleName}"'?`;
+        if (supportsNPM) {
+            message = `There was an error when loading the '${moduleName}' npm module. Support for npm modules in edge functions is an experimental feature. Refer to https://ntl.fyi/edge-functions-npm for more information.`;
+        }
+        super(message);
         this.name = 'NPMImportError';
         this.stack = originalError.stack;
         // https://github.com/microsoft/TypeScript-wiki/blob/8a66ecaf77118de456f7cd9c56848a40fe29b9b4/Breaking-Changes.md#implicit-any-error-raised-for-un-annotated-callback-arguments-with-no-matching-overload-arguments
         Object.setPrototypeOf(this, NPMImportError.prototype);
     }
 }
-const wrapNpmImportError = (input) => {
+const wrapNpmImportError = (input, supportsNPM) => {
     if (input instanceof Error) {
         const match = input.message.match(/Relative import path "(.*)" not prefixed with/);
         if (match !== null) {
             const [, moduleName] = match;
-            return new NPMImportError(input, moduleName);
+            return new NPMImportError(input, moduleName, supportsNPM);
         }
         const schemeMatch = input.message.match(/Error: Module not found "npm:(.*)"/);
         if (schemeMatch !== null) {
             const [, moduleName] = schemeMatch;
-            return new NPMImportError(input, moduleName);
+            return new NPMImportError(input, moduleName, supportsNPM);
         }
     }
     return input;

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

@@ -6,8 +6,9 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
+import type { FeatureFlags } from '../feature_flags.js';
 import { LogFunction } from '../logger.js';
-type FormatFunction = (name: string) => string;
+export type FormatFunction = (name: string) => string;
 interface StartServerOptions {
     getFunctionsConfig?: boolean;
 }
@@ -17,10 +18,12 @@ interface InspectSettings {
     address?: string;
 }
 interface ServeOptions {
+    basePath: string;
     bootstrapURL: string;
     certificatePath?: string;
     debug?: boolean;
     distImportMapPath?: string;
+    featureFlags?: FeatureFlags;
     inspectSettings?: InspectSettings;
     importMapPaths?: string[];
     onAfterDownload?: OnAfterDownloadHook;
@@ -28,12 +31,13 @@ interface ServeOptions {
     formatExportTypeError?: FormatFunction;
     formatImportError?: FormatFunction;
     port: number;
+    servePath: string;
     systemLogger?: LogFunction;
 }
-declare const serve: ({ bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, servePath, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+    features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
     graph: any;
     success: boolean;
 }>>;
-export { serve };
-export type { FormatFunction };
+export {};

package/dist/node/server/server.js

@@ -1,12 +1,12 @@
-import { tmpName } from 'tmp-promise';
 import { DenoBridge } from '../bridge.js';
 import { getFunctionConfig } from '../config.js';
 import { generateStage2 } from '../formats/javascript.js';
 import { ImportMap } from '../import_map.js';
 import { getLogger } from '../logger.js';
+import { vendorNPMSpecifiers } from '../npm_dependencies.js';
 import { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
-const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, formatExportTypeError, formatImportError, importMap, logger, port, }) => {
+const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, featureFlags, flags: denoFlags, formatExportTypeError, formatImportError, importMap: baseImportMap, logger, port, }) => {
     const processRef = {};
     const startServer = async (functions, env = {}, options = {}) => {
         if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
@@ -21,6 +21,21 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
             formatExportTypeError,
             formatImportError,
         });
+        const features = {};
+        const importMap = baseImportMap.clone();
+        if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_npm_modules) {
+            const vendor = await vendorNPMSpecifiers({
+                basePath,
+                directory: distDirectory,
+                functions: functions.map(({ path }) => path),
+                importMap,
+                logger,
+            });
+            if (vendor) {
+                features.npmModules = true;
+                importMap.add(vendor.importMap);
+            }
+        }
         try {
             // This command will print a JSON object with all the modules found in
             // the `stage2Path` file as well as all of their dependencies.
@@ -32,11 +47,12 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         catch {
             // no-op
         }
-        const bootstrapFlags = ['--port', port.toString()];
+        const extraDenoFlags = [`--import-map=${importMap.toDataURL()}`];
+        const applicationFlags = ['--port', port.toString()];
         // We set `extendEnv: false` to avoid polluting the edge function context
         // with variables from the user's system, since those will not be available
         // in the production environment.
-        await deno.runInBackground(['run', ...denoFlags, stage2Path, ...bootstrapFlags], processRef, {
+        await deno.runInBackground(['run', ...denoFlags, ...extraDenoFlags, stage2Path, ...applicationFlags], processRef, {
             pipeOutput: true,
             env,
             extendEnv: false,
@@ -45,8 +61,12 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         if (options.getFunctionsConfig) {
             functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, log: logger })));
         }
+        if (distImportMapPath) {
+            await importMap.writeToFile(distImportMapPath);
+        }
         const success = await waitForServer(port, processRef.ps);
         return {
+            features,
             functionsConfig,
             graph,
             success,
@@ -54,7 +74,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
     };
     return startServer;
 };
-const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
+export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, servePath, systemLogger, }) => {
     const logger = getLogger(systemLogger, debug);
     const deno = new DenoBridge({
         debug,
@@ -62,16 +82,11 @@ const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath,
         onAfterDownload,
         onBeforeDownload,
     });
-    // We need to generate a stage 2 file and write it somewhere. We use a
-    // temporary directory for that.
-    const distDirectory = await tmpName();
     // Wait for the binary to be downloaded if needed.
     await deno.getBinaryPath();
     // Downloading latest types if needed.
     await ensureLatestTypes(deno, logger);
-    const importMap = new ImportMap();
-    await importMap.addFiles(importMapPaths, logger);
-    const flags = ['--allow-all', `--import-map=${importMap.toDataURL()}`, '--no-config'];
+    const flags = ['--allow-all', '--no-config'];
     if (certificatePath) {
         flags.push(`--cert=${certificatePath}`);
     }
@@ -89,10 +104,15 @@ const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath,
             flags.push(inspectSettings.address ? `--inspect=${inspectSettings.address}` : '--inspect');
         }
     }
+    const importMap = new ImportMap();
+    await importMap.addFiles(importMapPaths, logger);
     const server = prepareServer({
+        basePath,
         bootstrapURL,
         deno,
-        distDirectory,
+        distDirectory: servePath,
+        distImportMapPath,
+        featureFlags,
         flags,
         formatExportTypeError,
         formatImportError,
@@ -100,9 +120,5 @@ const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath,
         logger,
         port,
     });
-    if (distImportMapPath) {
-        await importMap.writeToFile(distImportMapPath);
-    }
     return server;
 };
-export { serve };

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

@@ -1,6 +1,7 @@
 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';
@@ -13,10 +14,13 @@ 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 server = await serve({
+        basePath,
         bootstrapURL: 'https://edge.netlify.com/bootstrap/index-combined.ts',
         importMapPaths,
         port,
+        servePath,
     });
     const functions = [
         {
@@ -35,9 +39,10 @@ test('Starts a server and serves requests for edge functions', async () => {
     const options = {
         getFunctionsConfig: true,
     };
-    const { functionsConfig, graph, success } = await server(functions, {
+    const { features, functionsConfig, graph, success } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
+    expect(features).toEqual({});
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
     for (const key in functions) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.20.0",
+  "version": "9.1.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",