@netlify/edge-bundler 14.9.19 → 14.10.1

package/dist/node/bundler.js

@@ -13,7 +13,7 @@ import { bundle as bundleESZIP } from './formats/eszip.js';
 import { bundle as bundleTarball } from './formats/tarball.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
-import { writeManifest } from './manifest.js';
+import { generateManifestFunctionConfig, generateManifestRoutes, writeManifest } from './manifest.js';
 import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
 import { nonNullable } from './utils/non_nullable.js';
@@ -66,9 +66,10 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     }
     const bundles = [];
     let tarballBundleDurationMs;
-    let tarballLogMsg;
+    let tarballDryRunError;
+    let finalizeTarballBundle;
     if (featureFlags.edge_bundler_generate_tarball || featureFlags.edge_bundler_dry_run_generate_tarball) {
-        const tarballPromise = (async () => {
+        const tarballInitialPromise = (async () => {
             const start = Date.now();
             try {
                 return await bundleTarball({
@@ -90,21 +91,15 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         let tarballPromiseResolved = false;
         if (featureFlags.edge_bundler_dry_run_generate_tarball) {
             try {
-                await tarballPromise;
-                tarballLogMsg = 'Dry run: Eszip and tarball bundle generated successfully.';
+                await tarballInitialPromise;
                 tarballPromiseResolved = true;
             }
             catch (error) {
-                if (error instanceof Error) {
-                    tarballLogMsg = `Dry run: Eszip successful, tarball bundle generation failed: ${error.message}`;
-                }
-                else {
-                    tarballLogMsg = `Dry run: Eszip successful, tarball bundle generation failed: ${String(error)}`;
-                }
+                tarballDryRunError = error ?? new Error('Unknown error during tarball bundle generation');
             }
         }
         if (featureFlags.edge_bundler_generate_tarball || tarballPromiseResolved) {
-            bundles.push(await tarballPromise);
+            finalizeTarballBundle = await tarballInitialPromise;
         }
     }
     bundles.push(await bundleESZIP({
@@ -119,16 +114,6 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         importMap,
         vendorDirectory: vendor?.directory,
     }));
-    // Log tarball generation status after eszip bundling succeeds (only set during dry runs).
-    if (tarballLogMsg) {
-        // Reported errors might be multiple lines, so we replace newlines with the literal string '\n' to get a single log line,
-        // while still ensuring it could be expanded into the original multi-line message if needed.
-        logger.system(tarballLogMsg.replaceAll('\n', '\\n'));
-    }
-    // The final file name of the bundles contains a SHA256 hash of the contents,
-    // which we can only compute now that the files have been generated. So let's
-    // rename the bundles to their permanent names.
-    await createFinalBundles(bundles, distDirectory, buildID);
     const { internalFunctions: internalFunctionsWithConfig, userFunctions: userFunctionsWithConfig } = await getFunctionConfigs({
         deno,
         importMap,
@@ -143,14 +128,59 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         internalFunctionsWithConfig,
         declarations,
     });
+    const manifestFunctionConfig = generateManifestFunctionConfig({
+        functions,
+        internalFunctionConfig,
+        userFunctionConfig: userFunctionsWithConfig,
+    });
+    const manifestRoutes = generateManifestRoutes({
+        functions,
+        declarations,
+    });
+    if (!tarballDryRunError && finalizeTarballBundle) {
+        try {
+            bundles.unshift(await finalizeTarballBundle({ manifestFunctionConfig, manifestRoutes }));
+        }
+        catch (error) {
+            if (featureFlags.edge_bundler_dry_run_generate_tarball) {
+                tarballDryRunError = error ?? new Error('Unknown error during tarball bundle finalization');
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    if (featureFlags.edge_bundler_dry_run_generate_tarball) {
+        let tarballLogMsg;
+        if (tarballDryRunError) {
+            if (tarballDryRunError instanceof Error) {
+                tarballLogMsg = `Dry run: Eszip successful, tarball bundle generation failed: ${tarballDryRunError.message}`;
+            }
+            else {
+                tarballLogMsg = `Dry run: Eszip successful, tarball bundle generation failed: ${String(tarballDryRunError)}`;
+            }
+        }
+        else {
+            tarballLogMsg = 'Dry run: Eszip and tarball bundle generated successfully.';
+        }
+        if (tarballLogMsg) {
+            // Log tarball generation status after eszip bundling succeeds (only set during dry runs).
+            // Reported errors might be multiple lines, so we replace newlines with the literal string '\n' to get a single log line,
+            // while still ensuring it could be expanded into the original multi-line message if needed.
+            logger.system(tarballLogMsg.replaceAll('\n', '\\n'));
+        }
+    }
+    // The final file name of the bundles contains a SHA256 hash of the contents,
+    // which we can only compute now that the files have been generated. So let's
+    // rename the bundles to their permanent names.
+    await createFinalBundles(bundles, distDirectory, buildID);
     const manifest = await writeManifest({
         bundles,
-        declarations,
         distDirectory,
         featureFlags,
         functions,
-        userFunctionConfig: userFunctionsWithConfig,
-        internalFunctionConfig,
+        manifestFunctionConfig,
+        manifestRoutes,
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
         bundlingTiming: tarballBundleDurationMs === undefined ? undefined : { tarball_ms: tarballBundleDurationMs },

package/dist/node/config.d.ts

@@ -6,7 +6,7 @@ export declare const enum Cache {
     Off = "off",
     Manual = "manual"
 }
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+export type HTTPMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
 export type Path = `/${string}`;
 export type OnError = 'fail' | 'bypass' | Path;
 export declare const isValidOnError: (value: unknown) => value is OnError;

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

@@ -3,6 +3,8 @@ import { Bundle } from '../bundle.js';
 import { EdgeFunction } from '../edge_function.js';
 import { FeatureFlags } from '../feature_flags.js';
 import { ImportMap } from '../import_map.js';
+import { EdgeFunctionConfig } from '../index.js';
+import { generateManifestRoutes } from '../manifest.js';
 interface BundleTarballOptions {
     basePath: string;
     buildID: string;
@@ -14,7 +16,11 @@ interface BundleTarballOptions {
     importMap: ImportMap;
     vendorDirectory?: string;
 }
-export declare const bundle: ({ buildID, deno, distDirectory, functions, importMap, vendorDirectory, }: BundleTarballOptions) => Promise<Bundle>;
+interface FinalizeTarballBundleOptions {
+    manifestFunctionConfig: Record<string, EdgeFunctionConfig>;
+    manifestRoutes: ReturnType<typeof generateManifestRoutes>;
+}
+export declare const bundle: ({ buildID, deno, distDirectory, functions, importMap, vendorDirectory, }: BundleTarballOptions) => Promise<(arg: FinalizeTarballBundleOptions) => Promise<Bundle>>;
 /**
  * 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

@@ -13,9 +13,9 @@ const getUnixPath = (input) => input.split(path.sep).join('/');
 export const bundle = async ({ buildID, deno, distDirectory, functions, importMap, vendorDirectory, }) => {
     const bundleDir = await tmp.dir({ unsafeCleanup: true });
     const cleanup = [bundleDir.cleanup];
-    const manifest = {
+    const initialManifest = {
         functions: {},
-        version: 1,
+        version: 2,
     };
     const entryPoints = functions.map((func) => func.path);
     // Use deno info to get the module graph and identify which local files are actually needed.
@@ -52,7 +52,7 @@ export const bundle = async ({ buildID, deno, distDirectory, functions, importMa
     // Build the manifest mapping function names to their relative paths
     for (const func of functions) {
         const relativePath = path.relative(commonPath, func.path);
-        manifest.functions[func.name] = getUnixPath(relativePath);
+        initialManifest.functions[func.name] = getUnixPath(relativePath);
     }
     for (const sourceFile of sourceFilesSet) {
         let relativePath = path.relative(commonPath, sourceFile);
@@ -87,7 +87,7 @@ export const bundle = async ({ buildID, deno, distDirectory, functions, importMa
         '--node-modules-dir=manual',
         '--vendor',
         '--entrypoint',
-        ...Object.values(manifest.functions),
+        ...Object.values(initialManifest.functions),
     ], {
         cwd: bundleDir.path,
     });
@@ -99,37 +99,49 @@ export const bundle = async ({ buildID, deno, distDirectory, functions, importMa
             await rewriteImportAssertions(denoVendorFile, denoVendorFile);
         }
     }
-    const manifestPath = path.join(bundleDir.path, '___netlify-edge-functions.json');
-    const manifestContents = JSON.stringify(manifest);
-    await fs.writeFile(manifestPath, manifestContents);
-    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.
-    // Using absolute paths here leads to platform-specific quirks (notably on Windows),
-    // where entries can include drive letters and break extraction/imports.
-    // The './' prefix is required to prevent node-tar from interpreting entries
-    // starting with '@' as GNU tar archive-include directives, which would cause
-    // it to strip the '@' and stat a non-existent path (ENOENT).
-    const files = (await listRecursively(bundleDir.path))
-        .map((p) => path.relative(bundleDir.path, p))
-        .map((p) => './' + getUnixPath(p))
-        .sort();
-    await tar.create({
-        cwd: bundleDir.path,
-        file: tarballPath,
-        gzip: true,
-        noDirRecurse: true,
-        // Ensure forward slashes inside the tarball for cross-platform consistency.
-        onWriteEntry(entry) {
-            entry.path = getUnixPath(entry.path);
-        },
-    }, files);
-    const hash = await getFileHash(tarballPath);
-    await Promise.allSettled(cleanup);
-    return {
-        extension: TARBALL_EXTENSION,
-        format: BundleFormat.TARBALL,
-        hash,
+    // First stage of bundling is now done. To finalize bundling we require functionConfig, routes and postCacheRoutes
+    // so we could inject those into bundle manifest. Tarball bundling is done in 2-step process process to preserve ordering
+    // and potential errors messages that could be thrown to make sure we don't impact behaviors. Otherwise we would throw different
+    // kind of errors than we used to and introduce confusion for users.
+    return async function finalizeBundle({ manifestFunctionConfig, manifestRoutes }) {
+        const manifest = {
+            ...initialManifest,
+            function_config: manifestFunctionConfig,
+            routes: manifestRoutes.preCacheRoutes,
+            post_cache_routes: manifestRoutes.postCacheRoutes,
+        };
+        const manifestPath = path.join(bundleDir.path, '___netlify-edge-functions.json');
+        const manifestContents = JSON.stringify(manifest);
+        await fs.writeFile(manifestPath, manifestContents);
+        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.
+        // Using absolute paths here leads to platform-specific quirks (notably on Windows),
+        // where entries can include drive letters and break extraction/imports.
+        // The './' prefix is required to prevent node-tar from interpreting entries
+        // starting with '@' as GNU tar archive-include directives, which would cause
+        // it to strip the '@' and stat a non-existent path (ENOENT).
+        const files = (await listRecursively(bundleDir.path))
+            .map((p) => path.relative(bundleDir.path, p))
+            .map((p) => './' + getUnixPath(p))
+            .sort();
+        await tar.create({
+            cwd: bundleDir.path,
+            file: tarballPath,
+            gzip: true,
+            noDirRecurse: true,
+            // Ensure forward slashes inside the tarball for cross-platform consistency.
+            onWriteEntry(entry) {
+                entry.path = getUnixPath(entry.path);
+            },
+        }, files);
+        const hash = await getFileHash(tarballPath);
+        await Promise.allSettled(cleanup);
+        return {
+            extension: TARBALL_EXTENSION,
+            format: BundleFormat.TARBALL,
+            hash,
+        };
     };
 };
 // Source file extensions that may contain import statements.

package/dist/node/manifest.d.ts

@@ -56,24 +56,42 @@ interface Manifest {
     post_cache_routes: Route[];
     function_config: Record<string, EdgeFunctionConfig>;
 }
-interface GenerateManifestOptions {
-    bundles?: Bundle[];
+interface GenerateManifestFunctionConfigOptions {
+    functions: EdgeFunction[];
+    internalFunctionConfig?: Record<string, FunctionConfig>;
+    userFunctionConfig?: Record<string, FunctionConfig>;
+}
+interface GenerateManifestRoutesOptions {
+    functions: EdgeFunction[];
     declarations?: Declaration[];
+}
+interface GenerateManifestOptionsBase {
+    bundles?: Bundle[];
     featureFlags?: FeatureFlags;
-    functions: EdgeFunction[];
     importMap?: string;
-    internalFunctionConfig?: Record<string, FunctionConfig>;
     layers?: Layer[];
-    userFunctionConfig?: Record<string, FunctionConfig>;
     bundlingTiming?: BundlingTiming;
+    functions: EdgeFunction[];
 }
-declare const generateManifest: ({ bundles, declarations, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, bundlingTiming, }: GenerateManifestOptions) => {
+export declare const generateManifestFunctionConfig: ({ functions, userFunctionConfig, internalFunctionConfig, }: GenerateManifestFunctionConfigOptions) => Record<string, EdgeFunctionConfig>;
+export declare const generateManifestRoutes: ({ functions, declarations }: GenerateManifestRoutesOptions) => {
+    preCacheRoutes: Route[];
+    postCacheRoutes: Route[];
+    unroutedFunctions: string[];
+    declarationsWithoutFunction: Set<string>;
+};
+type GenerateManifestOptions = GenerateManifestOptionsBase & (GenerateManifestFunctionConfigOptions | {
+    manifestFunctionConfig: ReturnType<typeof generateManifestFunctionConfig>;
+}) & (GenerateManifestRoutesOptions | {
+    manifestRoutes: ReturnType<typeof generateManifestRoutes>;
+});
+declare const generateManifest: ({ bundles, importMap, layers, bundlingTiming, functions, ...rest }: GenerateManifestOptions) => {
     declarationsWithoutFunction: string[];
     manifest: Manifest;
     unroutedFunctions: string[];
 };
-interface WriteManifestOptions extends GenerateManifestOptions {
+type WriteManifestOptions = GenerateManifestOptions & {
     distDirectory: string;
-}
+};
 declare const writeManifest: ({ distDirectory, ...rest }: WriteManifestOptions) => Promise<Manifest>;
 export { generateManifest, Manifest, Route, writeManifest };

package/dist/node/manifest.js

@@ -54,12 +54,8 @@ const normalizeMethods = (method, name) => {
         return method.toUpperCase();
     });
 };
-const generateManifest = ({ bundles = [], declarations = [], functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], bundlingTiming, }) => {
-    const preCacheRoutes = [];
-    const postCacheRoutes = [];
+export const generateManifestFunctionConfig = ({ functions, userFunctionConfig = {}, internalFunctionConfig = {}, }) => {
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
-    const routedFunctions = new Set();
-    const declarationsWithoutFunction = new Set();
     for (const [name, singleUserFunctionConfig] of Object.entries(userFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
@@ -97,6 +93,13 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
             ...rest,
         };
     }
+    return sanitizeEdgeFunctionConfig(manifestFunctionConfig);
+};
+export const generateManifestRoutes = ({ functions, declarations = [] }) => {
+    const preCacheRoutes = [];
+    const postCacheRoutes = [];
+    const routedFunctions = new Set();
+    const declarationsWithoutFunction = new Set();
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
         if (func === undefined) {
@@ -132,14 +135,32 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
             preCacheRoutes.push(route);
         }
     });
+    const unroutedFunctions = functions.filter(({ name }) => !routedFunctions.has(name)).map(({ name }) => name);
+    return {
+        preCacheRoutes: preCacheRoutes.filter(nonNullable),
+        postCacheRoutes: postCacheRoutes.filter(nonNullable),
+        unroutedFunctions,
+        declarationsWithoutFunction,
+    };
+};
+const generateManifest = ({ bundles = [], importMap, layers = [], bundlingTiming, functions, ...rest }) => {
+    const manifestFunctionConfig = 'manifestFunctionConfig' in rest
+        ? rest.manifestFunctionConfig
+        : generateManifestFunctionConfig({ functions, ...rest });
+    const { preCacheRoutes, postCacheRoutes, unroutedFunctions, declarationsWithoutFunction } = 'manifestRoutes' in rest
+        ? rest.manifestRoutes
+        : generateManifestRoutes({
+            functions,
+            ...rest,
+        });
     const manifestBundles = bundles.map(({ extension, format, hash }) => ({
         asset: hash + extension,
         format,
     }));
     const manifest = {
         bundles: manifestBundles,
-        routes: preCacheRoutes.filter(nonNullable),
-        post_cache_routes: postCacheRoutes.filter(nonNullable),
+        routes: preCacheRoutes,
+        post_cache_routes: postCacheRoutes,
         bundler_version: getPackageVersion(),
         layers,
         import_map: importMap,
@@ -148,7 +169,6 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
             ? { bundling_timing: bundlingTiming }
             : {}),
     };
-    const unroutedFunctions = functions.filter(({ name }) => !routedFunctions.has(name)).map(({ name }) => name);
     return { declarationsWithoutFunction: [...declarationsWithoutFunction], manifest, unroutedFunctions };
 };
 const getTrafficRulesConfig = (rl) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.9.19",
+  "version": "14.10.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -81,5 +81,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "3694352be4959c56e96a6c15dd04ed4d7aa31344"
+  "gitHead": "d17373f5f6ab58289a5bc78d90bd0b520c9c652f"
 }