@netlify/edge-bundler 15.1.0 → 16.0.0

package/dist/node/bundler.d.ts

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

package/dist/node/bundler.js

@@ -64,6 +64,79 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     if (vendor) {
         importMap.add(vendor.importMap);
     }
+    // Extracts the in-source configuration for each function and derives the
+    // manifest's function config and routes from it.
+    const computeManifestData = async (log) => {
+        const { internalFunctions: internalFunctionsWithConfig, userFunctions: userFunctionsWithConfig } = await getFunctionConfigs({
+            deno,
+            importMap,
+            internalFunctions,
+            log,
+            userFunctions,
+        });
+        // Creating a final declarations array by combining the TOML file with the
+        // deploy configuration API and the in-source configuration.
+        const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
+        const internalFunctionConfig = createFunctionConfig({
+            internalFunctionsWithConfig,
+            declarations,
+        });
+        const manifestFunctionConfig = generateManifestFunctionConfig({
+            functions,
+            internalFunctionConfig,
+            userFunctionConfig: userFunctionsWithConfig,
+        });
+        const manifestRoutes = generateManifestRoutes({
+            functions,
+            declarations,
+        });
+        return { manifestFunctionConfig, manifestRoutes };
+    };
+    const excludeUnroutedFunctions = Boolean(featureFlags.edge_bundler_exclude_unrouted_functions);
+    // Excluding unrouted functions is the only reason to extract the config
+    // before bundling - we need the routes to know what to leave out. When we're
+    // not, we keep extracting it after bundling, as we always have, so that the
+    // extra Deno subprocess never runs ahead of the bundle and can't change what
+    // a build failure looks like.
+    //
+    // Config extraction reports the underlying failure to the user before it
+    // throws. When it runs up front we may end up discarding that error in favour
+    // of a bundling error (see below), and printing the detail of an error we
+    // then discard is just noise - so on that path we hold those logs back and
+    // only flush them if we do surface the config error.
+    const heldUserLogs = [];
+    const configLogger = {
+        system: logger.system,
+        user: (...args) => {
+            heldUserLogs.push(args);
+        },
+    };
+    const manifestDataPromise = excludeUnroutedFunctions ? computeManifestData(configLogger) : undefined;
+    // A function with no route is never invoked, so bundling it only serves to
+    // eagerly load code that can never run - which can surface import-time
+    // failures. The manifest is still generated from the full set of functions,
+    // but its routes exclude unrouted functions by definition. If config
+    // extraction failed, we have no routes to go on, so we bundle everything and
+    // let bundling report the failure.
+    const routes = manifestDataPromise ? (await manifestDataPromise.catch(() => undefined))?.manifestRoutes : undefined;
+    const bundledFunctions = excludeUnroutedFunctions && routes
+        ? functions.filter(({ name }) => !routes.unroutedFunctions.includes(name))
+        : functions;
+    // With nothing to bundle there is no code that can ever be invoked, so we
+    // produce neither a bundle nor a manifest. The deploy pipeline treats a
+    // manifest that exists but carries no ESZIP bundle as the deprecated JS format
+    // and can reject the deploy, so a missing manifest - the same path as a site
+    // with no edge functions at all - is safer than an empty one.
+    if (bundledFunctions.length === 0) {
+        // Config extraction may have produced function output that we were holding
+        // back; surface it before returning.
+        heldUserLogs.forEach((args) => {
+            logger.user(...args);
+        });
+        logger.system('Skipping bundling because no edge function has a route.');
+        await vendor?.cleanup();
+        return { functions, manifest: undefined };
+    }
     const bundles = [];
     let tarballBundleDurationMs;
     let tarballDryRunError;
@@ -78,7 +151,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
                     debug,
                     deno,
                     distDirectory,
-                    functions,
+                    functions: bundledFunctions,
                     featureFlags,
                     importMap: importMap.clone(),
                     vendorDirectory: vendor?.directory,
@@ -109,34 +182,28 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         deno,
         distDirectory,
         externals,
-        functions,
+        functions: bundledFunctions,
         featureFlags,
         importMap,
         vendorDirectory: vendor?.directory,
     }));
-    const { internalFunctions: internalFunctionsWithConfig, userFunctions: userFunctionsWithConfig } = await getFunctionConfigs({
-        deno,
-        importMap,
-        internalFunctions,
-        log: logger,
-        userFunctions,
-    });
-    // Creating a final declarations array by combining the TOML file with the
-    // deploy configuration API and the in-source configuration.
-    const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
-    const internalFunctionConfig = createFunctionConfig({
-        internalFunctionsWithConfig,
-        declarations,
-    });
-    const manifestFunctionConfig = generateManifestFunctionConfig({
-        functions,
-        internalFunctionConfig,
-        userFunctionConfig: userFunctionsWithConfig,
-    });
-    const manifestRoutes = generateManifestRoutes({
-        functions,
-        declarations,
-    });
+    // When we extracted the config up front, bundling didn't fail, so no more
+    // precise error is coming - re-awaiting surfaces the config extraction error
+    // if there was one. When we didn't, we extract it now, after bundling, as we
+    // always have. Either way, we reach this point only once bundling has had its
+    // chance to throw, so any logs we held back are no longer masking a bundling
+    // error and should reach the user: on success they are the function's own
+    // output, on failure the detail of the error we are about to surface.
+    let manifestData;
+    try {
+        manifestData = await (manifestDataPromise ?? computeManifestData(logger));
+    }
+    finally {
+        heldUserLogs.forEach((args) => {
+            logger.user(...args);
+        });
+    }
+    const { manifestFunctionConfig, manifestRoutes } = manifestData;
     if (!tarballDryRunError && finalizeTarballBundle) {
         try {
             bundles.unshift(await finalizeTarballBundle({ manifestFunctionConfig, manifestRoutes }));
@@ -255,11 +322,16 @@ const getBasePath = (sourceDirectories, inputBasePath) => {
 // declaration level. We want these properties to live at the function level
 // in their config object, so we translate that for backwards-compatibility.
 const mergeWithDeclarationConfig = ({ functionName, config, declarations }) => {
-    const declaration = declarations?.find((decl) => decl.function === functionName);
+    // A function may have several declarations — for example, one synthesized
+    // from its in-source config and one coming from `netlify.toml` or the
+    // Frameworks API. Only the latter can carry `name` and `generator`, so we
+    // look for each field across all of the function's declarations rather than
+    // just the first one, which may well be the in-source one.
+    const functionDeclarations = declarations?.filter((decl) => decl.function === functionName) ?? [];
     return {
         ...config,
-        name: declaration?.name || config.name,
-        generator: declaration?.generator || config.generator,
+        name: functionDeclarations.find((decl) => decl.name)?.name || config.name,
+        generator: functionDeclarations.find((decl) => decl.generator)?.generator || config.generator,
     };
 };
 const addGeneratorFallback = (config) => ({

package/dist/node/config.d.ts

@@ -2,6 +2,15 @@ import { DenoBridge } from './bridge.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
 import { RateLimit } from './rate_limit.js';
+export declare enum ConfigExitCode {
+    Success = 0,
+    UnhandledError = 1,
+    ImportError = 2,
+    NoConfig = 3,
+    InvalidExport = 4,
+    SerializationError = 5,
+    InvalidDefaultExport = 6
+}
 export declare const enum Cache {
     Off = "off",
     Manual = "manual"

package/dist/node/config.js

@@ -1,11 +1,13 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
+import pRetry from 'p-retry';
 import { SemVer } from 'semver';
 import tmp from 'tmp-promise';
 import { BundleError } from './bundle_error.js';
 import { getPackagePath } from './package_json.js';
-var ConfigExitCode;
+import { DENO_RETRIES, isTransientDenoError } from './utils/transient_error.js';
+export var ConfigExitCode;
 (function (ConfigExitCode) {
     ConfigExitCode[ConfigExitCode["Success"] = 0] = "Success";
     ConfigExitCode[ConfigExitCode["UnhandledError"] = 1] = "UnhandledError";
@@ -43,7 +45,7 @@ export const getFunctionConfig = async ({ deno, functionPath, importMap, log, })
     // The extractor will use its exit code to signal different error scenarios,
     // based on the list of exit codes we send as an argument. We then capture
     // the exit code to know exactly what happened and guide people accordingly.
-    const { exitCode, stderr, stdout } = await deno.run([
+    const runExtractor = () => deno.run([
         'run',
         '--allow-env',
         version.major >= 2 ? '--allow-import' : '',
@@ -59,6 +61,32 @@ export const getFunctionConfig = async ({ deno, functionPath, importMap, log, })
         pathToFileURL(collector.path).href,
         JSON.stringify(ConfigExitCode),
     ].filter(Boolean), { rejectOnExitCode: false });
+    // The extractor imports the function, so a dropped connection while fetching a remote module
+    // looks exactly like an import error. Because we're not rejecting on the exit code, we have to
+    // read the transient failure out of `stderr` ourselves and throw so that `pRetry` has another go.
+    // If every attempt fails we fall through with the last result, leaving the error handling below
+    // to report it as it would have without any retries.
+    let lastResult;
+    const { exitCode, stderr, stdout } = await pRetry(async () => {
+        lastResult = await runExtractor();
+        if (lastResult.exitCode !== ConfigExitCode.Success && isTransientDenoError(lastResult.stderr)) {
+            throw new Error(lastResult.stderr);
+        }
+        return lastResult;
+    }, {
+        retries: DENO_RETRIES,
+        onFailedAttempt: (error) => {
+            log.system(`Config extraction for '${functionPath}' hit a transient error, retrying: ${error.message}`);
+        },
+    }).catch((error) => {
+        // If we never captured a result, the extractor rejected outright rather than resolving with a
+        // non-zero exit code (e.g. the binary failed to spawn). Surface that error instead of falling
+        // through to destructure `undefined`.
+        if (lastResult === undefined) {
+            throw error;
+        }
+        return lastResult;
+    });
     if (exitCode !== ConfigExitCode.Success) {
         handleConfigError(functionPath, exitCode, stderr, log);
         return {};

package/dist/node/feature_flags.d.ts

@@ -1,12 +1,14 @@
 declare const defaultFlags: {
     edge_bundler_generate_tarball: boolean;
     edge_bundler_dry_run_generate_tarball: boolean;
+    edge_bundler_exclude_unrouted_functions: boolean;
 };
 type FeatureFlag = keyof typeof defaultFlags;
 type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
 declare const getFlags: (input?: Record<string, boolean>, flags?: {
     edge_bundler_generate_tarball: boolean;
     edge_bundler_dry_run_generate_tarball: boolean;
+    edge_bundler_exclude_unrouted_functions: boolean;
 }) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

package/dist/node/feature_flags.js

@@ -1,6 +1,7 @@
 const defaultFlags = {
     edge_bundler_generate_tarball: false,
     edge_bundler_dry_run_generate_tarball: false,
+    edge_bundler_exclude_unrouted_functions: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

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

@@ -21,6 +21,12 @@ interface FinalizeTarballBundleOptions {
     manifestRoutes: ReturnType<typeof generateManifestRoutes>;
 }
 export declare const bundle: ({ buildID, deno, distDirectory, functions, importMap, vendorDirectory, }: BundleTarballOptions) => Promise<(arg: FinalizeTarballBundleOptions) => Promise<Bundle>>;
+/**
+ * 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.
+ */
+export declare function getRequiredSourceFiles(deno: DenoBridge, entryPoints: string[], importMap: ImportMap): Promise<Set<string>>;
 /**
  * Rewrites import assert into import with in the bundle directory
  * Defaults to copying the file in its current form

package/dist/node/formats/tarball.js

@@ -2,11 +2,13 @@ import { promises as fs, existsSync } from 'fs';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import commonPathPrefix from 'common-path-prefix';
+import pRetry, { AbortError } from 'p-retry';
 import * as tar from 'tar';
 import tmp from 'tmp-promise';
 import { BundleFormat } from '../bundle.js';
 import { listRecursively } from '../utils/fs.js';
 import { getFileHash } from '../utils/sha256.js';
+import { DENO_RETRIES, isTransientDenoErrorObject } from '../utils/transient_error.js';
 import { rewriteSourceImportAssertions } from '../utils/import_attributes.js';
 const TARBALL_EXTENSION = '.tar.gz';
 const getUnixPath = (input) => input.split(path.sep).join('/');
@@ -154,19 +156,35 @@ const REWRITABLE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.m
  * 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.
  */
-async function getRequiredSourceFiles(deno, entryPoints, importMap) {
+export 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) {
-        const { stdout } = await deno.run([
-            'info',
-            '--json',
-            '--no-config',
-            '--import-map',
-            importMapDataUrl,
-            pathToFileURL(entryPoint).href,
-        ]);
+        const { stdout } = await pRetry(async () => {
+            try {
+                return await deno.run([
+                    'info',
+                    '--json',
+                    '--no-config',
+                    '--import-map',
+                    importMapDataUrl,
+                    pathToFileURL(entryPoint).href,
+                ]);
+            }
+            catch (error) {
+                if (isTransientDenoErrorObject(error)) {
+                    throw error;
+                }
+                // `AbortError` stops the retry loop and rethrows the error we pass it, unchanged.
+                throw new AbortError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }, {
+            retries: DENO_RETRIES,
+            onFailedAttempt: (error) => {
+                deno.logger.system(`\`deno info\` failed with a transient error, retrying: ${error.message}`);
+            },
+        });
         const graph = JSON.parse(stdout);
         // Collect the specifiers of every module reachable through a *code* (runtime)
         // import edge. Deno's module graph classifies each dependency as either a `code`

package/dist/node/utils/transient_error.d.ts

@@ -0,0 +1,3 @@
+export declare const isTransientDenoError: (output: string) => boolean;
+export declare const isTransientDenoErrorObject: (error: unknown) => boolean;
+export declare const DENO_RETRIES = 3;

package/dist/node/utils/transient_error.js

@@ -0,0 +1,20 @@
+// Deno subprocesses fetch remote modules and npm registry metadata, so they can fail for reasons
+// that have nothing to do with the user's code: a dropped connection, a DNS blip, a registry
+// timeout. These are the messages Deno surfaces for those failures. Anything else (a syntax error,
+// an unresolvable import) is deterministic, and retrying it just delays the real error.
+const TRANSIENT_DENO_ERRORS = [
+    'error sending request',
+    'error reading a body from connection',
+    'connection closed before message completed',
+    'connection reset',
+    'operation timed out',
+    'tcp connect error',
+    'dns error',
+];
+export const isTransientDenoError = (output) => {
+    const haystack = output.toLowerCase();
+    return TRANSIENT_DENO_ERRORS.some((pattern) => haystack.includes(pattern));
+};
+// execa folds stderr into `message`, which is where Deno writes the `Caused by:` detail.
+export const isTransientDenoErrorObject = (error) => error instanceof Error && isTransientDenoError(error.message);
+export const DENO_RETRIES = 3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "15.1.0",
+  "version": "16.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -80,5 +80,5 @@
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2"
   },
-  "gitHead": "0a4aa4be3f9abbb49ebe00e82c64898148986715"
+  "gitHead": "af94ccf9fe17c7b2c653eaad23cc413283548d1a"
 }