@netlify/edge-bundler 9.1.0 → 9.2.1

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

@@ -116,7 +116,10 @@ test('Prints a nice error message when user tries importing an npm module and np
         },
     ];
     try {
-        await bundle([sourceDirectory], distPath, declarations, { basePath });
+        await bundle([sourceDirectory], distPath, declarations, {
+            basePath,
+            importMapPaths: [join(basePath, 'import_map.json')],
+        });
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
@@ -398,6 +401,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 +416,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.js

@@ -37,6 +37,9 @@ export const getDependencyTrackerPlugin = (specifiers, importMap, baseURL) => ({
             // If it does, the resolved import is the specifier we'll evaluate going
             // forward.
             if (matched) {
+                if (resolvedImport.protocol !== 'file:') {
+                    return { external: true };
+                }
                 specifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
                 result.path = specifier;
             }
@@ -95,21 +98,28 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // loaded as npm dependencies, because they either use the `npm:` prefix or
     // they are bare specifiers. We'll collect them in `specifiers`.
     try {
-        await build({
+        const { errors, warnings } = await build({
             banner,
             bundle: true,
             entryPoints: functions,
-            logLevel: 'error',
+            logLevel: 'silent',
             nodePaths,
             outdir: temporaryDirectory.path,
             platform: 'node',
             plugins: [getDependencyTrackerPlugin(specifiers, importMap.getContentsWithURLObjects(), pathToFileURL(basePath))],
             write: false,
+            format: 'esm',
         });
+        if (errors.length !== 0) {
+            logger.system('ESBuild errored while tracking dependencies in edge function:', errors);
+        }
+        if (warnings.length !== 0) {
+            logger.system('ESBuild warned while tracking dependencies in edge function:', warnings);
+        }
     }
     catch (error) {
         logger.system('Could not track dependencies in edge function:', error);
-        logger.user('An error occurred when trying to scan your edge functions for npm modules, which is an experimental feature. If you are loading npm modules, please share the errors above in https://ntl.fyi/edge-functions-npm. If you are not loading npm modules, you can ignore this message.');
+        logger.user('An error occurred when trying to scan your edge functions for npm modules, which is an experimental feature. If you are loading npm modules, please share the link to this deploy in https://ntl.fyi/edge-functions-npm. If you are not loading npm modules, you can ignore this message.');
     }
     // If we found no specifiers, there's nothing left to do here.
     if (specifiers.size === 0) {

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

@@ -32,9 +32,10 @@ interface ServeOptions {
     formatImportError?: FormatFunction;
     port: number;
     servePath: string;
+    userLogger?: LogFunction;
     systemLogger?: LogFunction;
 }
-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<{
+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;

package/dist/node/server/server.js

@@ -74,8 +74,8 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
     };
     return startServer;
 };
-export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, 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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "9.1.0",
+  "version": "9.2.1",
   "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",