@netlify/edge-bundler 9.0.0 → 9.2.0

package/dist/node/bridge.js

@@ -18,7 +18,7 @@ class DenoBridge {
         this.cacheDirectory = (_a = options.cacheDirectory) !== null && _a !== void 0 ? _a : getPathInHome('deno-cli');
         this.debug = (_b = options.debug) !== null && _b !== void 0 ? _b : false;
         this.denoDir = options.denoDir;
-        this.logger = (_c = options.logger) !== null && _c !== void 0 ? _c : getLogger(undefined, options.debug);
+        this.logger = (_c = options.logger) !== null && _c !== void 0 ? _c : getLogger(undefined, undefined, options.debug);
         this.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
         this.useGlobal = (_d = options.useGlobal) !== null && _d !== void 0 ? _d : true;

package/dist/node/bundler.d.ts

@@ -16,9 +16,10 @@ export interface BundleOptions {
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
+    userLogger?: LogFunction;
     vendorDirectory?: string;
 }
-export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
+export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, userLogger, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -15,8 +15,8 @@ import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
-export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, systemLogger, vendorDirectory, } = {}) => {
-    const logger = getLogger(systemLogger, debug);
+export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, userLogger, systemLogger, vendorDirectory, } = {}) => {
+    const logger = getLogger(systemLogger, userLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
         debug,

package/dist/node/bundler.test.js

@@ -398,6 +398,7 @@ test('Handles imports with the `node:` prefix', async () => {
     await cleanup();
 });
 test('Loads npm modules from bare specifiers', async () => {
+    const systemLogger = vi.fn();
     const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
     const sourceDirectory = join(basePath, 'functions');
     const declarations = [
@@ -412,7 +413,9 @@ test('Loads npm modules from bare specifiers', async () => {
         featureFlags: { edge_functions_npm_modules: true },
         importMapPaths: [join(basePath, 'import_map.json')],
         vendorDirectory: vendorDirectory.path,
+        systemLogger,
     });
+    expect(systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:')).toBeUndefined();
     const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const bundlePath = join(distPath, manifest.bundles[0].asset);

package/dist/node/finder.js

@@ -3,7 +3,7 @@ import { basename, extname, join, parse } from 'path';
 import { nonNullable } from './utils/non_nullable.js';
 // the order of the allowed extensions is also the order we remove duplicates
 // with a lower index meaning a higher precedence over the others
-const ALLOWED_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
+const ALLOWED_EXTENSIONS = ['.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'];
 export const removeDuplicatesByExtension = (functions) => {
     const seen = new Map();
     return Object.values(functions.reduce((acc, path) => {

package/dist/node/logger.d.ts

@@ -3,6 +3,6 @@ interface Logger {
     system: LogFunction;
     user: LogFunction;
 }
-declare const getLogger: (systemLogger?: LogFunction, debug?: boolean) => Logger;
+declare const getLogger: (systemLogger?: LogFunction, userLogger?: LogFunction, debug?: boolean) => Logger;
 export { getLogger };
 export type { LogFunction, Logger };

package/dist/node/logger.js

@@ -1,14 +1,15 @@
 const noopLogger = () => {
     // no-op
 };
-const getLogger = (systemLogger, debug = false) => {
+const getLogger = (systemLogger, userLogger, debug = false) => {
     // If there is a system logger configured, we'll use that. If there isn't,
     // we'll pipe system logs to stdout if `debug` is enabled and swallow them
     // otherwise.
     const system = systemLogger !== null && systemLogger !== void 0 ? systemLogger : (debug ? console.log : noopLogger);
+    const user = userLogger !== null && userLogger !== void 0 ? userLogger : console.log;
     return {
         system,
-        user: console.log,
+        user,
     };
 };
 export { getLogger };

package/dist/node/logger.test.js

@@ -8,23 +8,30 @@ afterEach(() => {
     // Restoring global `console.log`.
     console.log = consoleLog;
 });
-test('Prints user logs to stdout', () => {
+test('Prints user logs to stdout if no user logger is provided', () => {
     const mockConsoleLog = vi.fn();
     console.log = mockConsoleLog;
-    const logger1 = getLogger(noopLogger, true);
-    const logger2 = getLogger(noopLogger, false);
+    const logger1 = getLogger(noopLogger, undefined, true);
+    const logger2 = getLogger(noopLogger, undefined, false);
     logger1.user('Hello with `debug: true`');
     logger2.user('Hello with `debug: false`');
     expect(mockConsoleLog).toHaveBeenCalledTimes(2);
     expect(mockConsoleLog).toHaveBeenNthCalledWith(1, 'Hello with `debug: true`');
     expect(mockConsoleLog).toHaveBeenNthCalledWith(2, 'Hello with `debug: false`');
 });
+test('Prints user logs to user logger provided', () => {
+    const userLogger = vi.fn();
+    const logger = getLogger(noopLogger, userLogger, true);
+    logger.user('Hello!');
+    expect(userLogger).toHaveBeenCalledTimes(1);
+    expect(userLogger).toHaveBeenNthCalledWith(1, 'Hello!');
+});
 test('Prints system logs to the system logger provided', () => {
     const mockSystemLog = vi.fn();
     const mockConsoleLog = vi.fn();
     console.log = mockSystemLog;
-    const logger1 = getLogger(mockSystemLog, true);
-    const logger2 = getLogger(mockSystemLog, false);
+    const logger1 = getLogger(mockSystemLog, undefined, true);
+    const logger2 = getLogger(mockSystemLog, undefined, false);
     logger1.system('Hello with `debug: true`');
     logger2.system('Hello with `debug: false`');
     expect(mockConsoleLog).toHaveBeenCalledTimes(0);
@@ -35,8 +42,8 @@ test('Prints system logs to the system logger provided', () => {
 test('Prints system logs to stdout if there is no system logger provided and `debug` is enabled', () => {
     const mockConsoleLog = vi.fn();
     console.log = mockConsoleLog;
-    const logger1 = getLogger(undefined, true);
-    const logger2 = getLogger(undefined, false);
+    const logger1 = getLogger(undefined, undefined, true);
+    const logger2 = getLogger(undefined, undefined, false);
     logger1.system('Hello with `debug: true`');
     logger2.system('Hello with `debug: false`');
     expect(mockConsoleLog).toHaveBeenCalledTimes(1);

package/dist/node/npm_dependencies.d.ts

@@ -15,7 +15,7 @@ export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, imp
     cleanup: () => Promise<void>;
     directory: string;
     importMap: {
-        baseURL: import("node:url").URL;
+        baseURL: import("url").URL;
         imports: Record<string, string>;
     };
 } | undefined>;

package/dist/node/npm_dependencies.js

@@ -49,7 +49,7 @@ export const getDependencyTrackerPlugin = (specifiers, importMap, baseURL) => ({
             if (specifier.startsWith(npmPrefix)) {
                 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;
@@ -105,6 +105,7 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
             platform: 'node',
             plugins: [getDependencyTrackerPlugin(specifiers, importMap.getContentsWithURLObjects(), pathToFileURL(basePath))],
             write: false,
+            format: 'esm',
         });
     }
     catch (error) {
@@ -115,7 +116,6 @@ 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, create a barrel 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.

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

@@ -6,6 +6,7 @@
 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';
 export type FormatFunction = (name: string) => string;
 interface StartServerOptions {
@@ -22,6 +23,7 @@ interface ServeOptions {
     certificatePath?: string;
     debug?: boolean;
     distImportMapPath?: string;
+    featureFlags?: FeatureFlags;
     inspectSettings?: InspectSettings;
     importMapPaths?: string[];
     onAfterDownload?: OnAfterDownloadHook;
@@ -30,9 +32,11 @@ interface ServeOptions {
     formatImportError?: FormatFunction;
     port: number;
     servePath: string;
+    userLogger?: LogFunction;
     systemLogger?: LogFunction;
 }
-export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, servePath, 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, userLogger, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+    features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
     graph: any;
     success: boolean;

package/dist/node/server/server.js

@@ -6,7 +6,7 @@ import { getLogger } from '../logger.js';
 import { vendorNPMSpecifiers } from '../npm_dependencies.js';
 import { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
-const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, importMap: baseImportMap, 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,16 +21,20 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             formatExportTypeError,
             formatImportError,
         });
+        const features = {};
         const importMap = baseImportMap.clone();
-        const vendor = await vendorNPMSpecifiers({
-            basePath,
-            directory: distDirectory,
-            functions: functions.map(({ path }) => path),
-            importMap,
-            logger,
-        });
-        if (vendor) {
-            importMap.add(vendor.importMap);
+        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
@@ -62,6 +66,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
         }
         const success = await waitForServer(port, processRef.ps);
         return {
+            features,
             functionsConfig,
             graph,
             success,
@@ -69,8 +74,8 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
     };
     return startServer;
 };
-export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, servePath, systemLogger, }) => {
-    const logger = getLogger(systemLogger, debug);
+export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, servePath, userLogger, systemLogger, }) => {
+    const logger = getLogger(systemLogger, userLogger, debug);
     const deno = new DenoBridge({
         debug,
         logger,
@@ -107,6 +112,7 @@ export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, di
         deno,
         distDirectory: servePath,
         distImportMapPath,
+        featureFlags,
         flags,
         formatExportTypeError,
         formatImportError,

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

@@ -39,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": "9.0.0",
+  "version": "9.2.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -79,7 +79,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.19.2",
+    "esbuild": "0.19.4",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",