@netlify/edge-bundler 8.12.3 → 8.13.1

package/dist/node/bundler.d.ts

@@ -1,6 +1,5 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from './bridge.js';
 import { Declaration } from './declaration.js';
-import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { LogFunction } from './logger.js';
 interface BundleOptions {
@@ -17,23 +16,8 @@ interface BundleOptions {
     internalSrcFolder?: string;
 }
 declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, }?: BundleOptions) => Promise<{
-    functions: EdgeFunction[];
+    functions: import("./edge_function.js").EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;
-export declare const addGeneratorFieldIfMissing: (declaration: Declaration, functions: EdgeFunction[], internalFunctionsPath?: string) => {
-    generator: string | undefined;
-    cache?: string | undefined;
-    function: string;
-    name?: string | undefined;
-    path: `/${string}`;
-    excludedPath?: `/${string}` | undefined;
-} | {
-    generator: string | undefined;
-    cache?: string | undefined;
-    function: string;
-    name?: string | undefined;
-    pattern: string;
-    excludedPattern?: string | undefined;
-};
 export { bundle };
 export type { BundleOptions };

package/dist/node/bundler.js

@@ -1,7 +1,6 @@
 import { promises as fs } from 'fs';
-import { join, resolve } from 'path';
+import { join } from 'path';
 import commonPathPrefix from 'common-path-prefix';
-import isPathInside from 'is-path-inside';
 import { v4 as uuidv4 } from 'uuid';
 import { importMapSpecifier } from '../shared/consts.js';
 import { DenoBridge } from './bridge.js';
@@ -25,7 +24,6 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         onAfterDownload,
         onBeforeDownload,
     };
-    const internalFunctionsPath = internalSrcFolder && resolve(internalSrcFolder);
     if (cacheDirectory !== undefined) {
         options.denoDir = join(cacheDirectory, 'deno_dir');
     }
@@ -42,9 +40,12 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     // Layers are marked as externals in the ESZIP, so that those specifiers are
     // not actually included in the bundle.
     const externals = deployConfig.layers.map((layer) => layer.name);
+    const userSourceDirectories = sourceDirectories.filter((dir) => dir !== internalSrcFolder);
     const importMap = new ImportMap();
     await importMap.addFiles([deployConfig === null || deployConfig === void 0 ? void 0 : deployConfig.importMap, ...importMapPaths], logger);
-    const functions = await findFunctions(sourceDirectories);
+    const userFunctions = userSourceDirectories.length === 0 ? [] : await findFunctions(userSourceDirectories);
+    const internalFunctions = internalSrcFolder ? await findFunctions([internalSrcFolder]) : [];
+    const functions = [...internalFunctions, ...userFunctions];
     const functionBundle = await bundleESZIP({
         basePath,
         buildID,
@@ -61,24 +62,27 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     // rename the bundles to their permanent names.
     await createFinalBundles([functionBundle], distDirectory, buildID);
     // Retrieving a configuration object for each function.
-    const functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger, featureFlags)));
+    // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger, featureFlags)]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger, featureFlags)]);
     // Creating a hash of function names to configuration objects.
-    const functionsWithConfig = functions.reduce((acc, func, index) => ({ ...acc, [func.name]: functionsConfig[index] }), {});
+    const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
+    const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
     // Creating a final declarations array by combining the TOML file with the
     // deploy configuration API and the in-source configuration.
-    const declarationsFromConfig = mergeDeclarations(tomlDeclarations, functionsWithConfig, deployConfig.declarations);
-    // If any declarations are autogenerated and are missing the generator field
-    // add a default string.
-    const declarations = internalFunctionsPath
-        ? declarationsFromConfig.map((declaration) => addGeneratorFieldIfMissing(declaration, functions, internalFunctionsPath))
-        : declarationsFromConfig;
+    const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
+    const internalFunctionConfig = createFunctionConfig({
+        internalFunctionsWithConfig,
+        declarations,
+    });
     const manifest = await writeManifest({
         bundles: [functionBundle],
         declarations,
         distDirectory,
         featureFlags,
         functions,
-        functionConfig: functionsWithConfig,
+        userFunctionConfig: userFunctionsWithConfig,
+        internalFunctionConfig,
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });
@@ -107,12 +111,26 @@ const getBasePath = (sourceDirectories, inputBasePath) => {
     }
     return commonPathPrefix(sourceDirectories);
 };
-export const addGeneratorFieldIfMissing = (declaration, functions, internalFunctionsPath) => {
-    var _a;
-    const fullFuncPath = (_a = functions === null || functions === void 0 ? void 0 : functions.find((func) => func.name === declaration.function)) === null || _a === void 0 ? void 0 : _a.path;
-    // If function path is in the internalFunctionsPath, we assume it is autogenerated.
-    const isInternal = Boolean(internalFunctionsPath && fullFuncPath && isPathInside(fullFuncPath, internalFunctionsPath));
-    const generatorFallback = isInternal ? 'internalFunc' : undefined;
-    return { ...declaration, generator: declaration.generator || generatorFallback };
+// We used to allow the `name` and `generator` fields to be defined at the
+// 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 === null || declarations === void 0 ? void 0 : declarations.find((decl) => decl.function === functionName);
+    return {
+        ...config,
+        name: (declaration === null || declaration === void 0 ? void 0 : declaration.name) || config.name,
+        generator: (declaration === null || declaration === void 0 ? void 0 : declaration.generator) || config.generator,
+    };
 };
+const addGeneratorFallback = (config) => ({
+    ...config,
+    generator: config.generator || 'internalFunc',
+});
+const createFunctionConfig = ({ internalFunctionsWithConfig, declarations }) => Object.entries(internalFunctionsWithConfig).reduce((acc, [functionName, config]) => {
+    const mergedConfigFields = mergeWithDeclarationConfig({ functionName, config, declarations });
+    return {
+        ...acc,
+        [functionName]: addGeneratorFallback(mergedConfigFields),
+    };
+}, {});
 export { bundle };

package/dist/node/bundler.test.js

@@ -264,7 +264,7 @@ test('Processes a function that imports a custom layer', async () => {
     expect(layers).toEqual([layer]);
     await cleanup();
 });
-test('Loads declarations and import maps from the deploy configuration', async () => {
+test('Loads declarations and import maps from the deploy configuration and in-source config', async () => {
     const { basePath, cleanup, distPath } = await useFixture('with_deploy_config');
     const declarations = [
         {
@@ -283,16 +283,22 @@ test('Loads declarations and import maps from the deploy configuration', async (
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { routes, bundles, function_config: functionConfig } = manifest;
+    const { bundles, function_config: functionConfig } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(routes[0].generator).toBeUndefined();
-    expect(routes[1].name).toBe('Function two');
-    expect(routes[1].generator).toBe('@netlify/fake-plugin@1.0.0');
-    expect(routes[2].generator).toBe('internalFunc');
     // respects excludedPath from deploy config
-    expect(functionConfig.func2).toEqual({ excluded_patterns: ['^/func2/skip/?$'] });
+    expect(functionConfig.func2).toEqual({
+        excluded_patterns: ['^/func2/skip/?$'],
+        name: 'Function two',
+        generator: '@netlify/fake-plugin@1.0.0',
+    });
+    // respects in-source config
+    expect(functionConfig.func3).toEqual({
+        name: 'in-config-function',
+        on_error: 'bypass',
+        generator: 'internalFunc',
+    });
     await cleanup();
 });
 test("Ignores entries in `importMapPaths` that don't point to an existing import map file", async () => {

package/dist/node/config.d.ts

@@ -8,12 +8,14 @@ export declare const enum Cache {
     Manual = "manual"
 }
 export type Path = `/${string}`;
-export type OnError = 'fail' | 'bypass' | `/${string}`;
+export type OnError = 'fail' | 'bypass' | Path;
 export declare const isValidOnError: (value: unknown) => value is OnError;
 export interface FunctionConfig {
     cache?: Cache;
     path?: Path | Path[];
     excludedPath?: Path | Path[];
     onError?: OnError;
+    name?: string;
+    generator?: string;
 }
 export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger, featureFlags: FeatureFlags) => Promise<FunctionConfig>;

package/dist/node/config.test.js

@@ -117,6 +117,25 @@ const functions = [
         export const config = { path: "/home" }
       `,
     },
+    {
+        testName: 'config with path, generator, name and onError`',
+        expectedConfig: {
+            path: '/home',
+            generator: '@netlify/fake-plugin@1.0.0',
+            name: 'a displayName',
+            onError: 'bypass',
+        },
+        name: 'func6',
+        source: `
+        export default async () => new Response("Hello from function three")
+
+        export const config = { path: "/home",
+          generator: '@netlify/fake-plugin@1.0.0',
+          name: 'a displayName',
+          onError: 'bypass',
+        }
+      `,
+    },
 ];
 describe('`getFunctionConfig` extracts configuration properties from function file', () => {
     test.each(functions)('$testName', async (func) => {

package/dist/node/declaration.d.ts

@@ -1,4 +1,5 @@
 import { FunctionConfig, Path } from './config.js';
+import { FeatureFlags } from './feature_flags.js';
 interface BaseDeclaration {
     cache?: string;
     function: string;
@@ -14,6 +15,6 @@ type DeclarationWithPattern = BaseDeclaration & {
     excludedPattern?: string;
 };
 export type Declaration = DeclarationWithPath | DeclarationWithPattern;
-export declare const mergeDeclarations: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[]) => Declaration[];
+export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], featureFlags?: FeatureFlags) => Declaration[];
 export declare const parsePattern: (pattern: string) => string;
 export {};

package/dist/node/declaration.js

@@ -1,14 +1,39 @@
 import regexpAST from 'regexp-tree';
-export const mergeDeclarations = (tomlDeclarations, functionsConfig, deployConfigDeclarations) => {
+export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, featureFlags = {}) => {
+    const functionsVisited = new Set();
+    let declarations = getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited);
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (featureFlags.edge_functions_correct_order) {
+        declarations = [
+            // INTEGRATIONS
+            // 1. Declarations from the integrations deploy config
+            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
+            // 2. Declarations from the integrations ISC
+            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
+            // USER
+            // 3. Declarations from the users toml config
+            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
+            // 4. Declarations from the users ISC
+            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
+        ];
+    }
+    else {
+        declarations = [
+            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
+            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
+            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
+            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
+        ];
+    }
+    return declarations;
+};
+const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsVisited) => {
     var _a;
     const declarations = [];
-    const functionsVisited = new Set();
-    // We start by iterating over all the declarations in the TOML file and in
-    // the deploy configuration file. For any declaration for which we also have
-    // a function configuration object, we replace the path because that object
-    // takes precedence.
-    for (const declaration of [...tomlDeclarations, ...deployConfigDeclarations]) {
-        const config = functionsConfig[declaration.function];
+    // For any declaration for which we also have a function configuration object,
+    // we replace the path because that object takes precedence.
+    for (const declaration of inputDeclarations) {
+        const config = functionConfigs[declaration.function];
         if (!config) {
             // If no config is found, add the declaration as is.
             declarations.push(declaration);
@@ -28,15 +53,21 @@ export const mergeDeclarations = (tomlDeclarations, functionsConfig, deployConfi
         }
         functionsVisited.add(declaration.function);
     }
-    // Finally, we must create declarations for functions that are not declared
-    // in the TOML at all.
-    for (const name in functionsConfig) {
-        const { cache, path } = functionsConfig[name];
+    return declarations;
+};
+const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited) => {
+    const declarations = [];
+    for (const name in functionConfigs) {
+        const { cache, path } = functionConfigs[name];
         // If we have a path specified, create a declaration for each path.
         if (!functionsVisited.has(name) && path) {
             const paths = Array.isArray(path) ? path : [path];
             paths.forEach((singlePath) => {
-                declarations.push({ cache, function: name, path: singlePath });
+                const declaration = { function: name, path: singlePath };
+                if (cache) {
+                    declaration.cache = cache;
+                }
+                declarations.push(declaration);
             });
         }
     }

package/dist/node/declaration.test.js

@@ -1,13 +1,54 @@
 import { test, expect } from 'vitest';
 import { mergeDeclarations } from './declaration.js';
-// TODO: Add tests with the deploy config.
 const deployConfigDeclarations = [];
+test('Ensure the order of edge functions with FF', () => {
+    const deployConfigDeclarations = [
+        { function: 'framework-manifest-a', path: '/path1' },
+        { function: 'framework-manifest-c', path: '/path3' },
+        { function: 'framework-manifest-b', path: '/path2' },
+    ];
+    const tomlConfig = [
+        { function: 'user-toml-a', path: '/path1' },
+        { function: 'user-toml-c', path: '/path3' },
+        { function: 'user-toml-b', path: '/path2' },
+    ];
+    const userFuncConfig = {
+        'user-isc-c': { path: ['/path1', '/path2'] },
+    };
+    const internalFuncConfig = {
+        'framework-isc-c': { path: ['/path1', '/path2'] },
+    };
+    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
+        edge_functions_correct_order: true,
+    })).toMatchSnapshot();
+});
+test('Ensure the order of edge functions without FF', () => {
+    const deployConfigDeclarations = [
+        { function: 'framework-manifest-a', path: '/path1' },
+        { function: 'framework-manifest-c', path: '/path3' },
+        { function: 'framework-manifest-b', path: '/path2' },
+    ];
+    const tomlConfig = [
+        { function: 'user-toml-a', path: '/path1' },
+        { function: 'user-toml-c', path: '/path3' },
+        { function: 'user-toml-b', path: '/path2' },
+    ];
+    const userFuncConfig = {
+        'user-isc-c': { path: ['/path1', '/path2'] },
+    };
+    const internalFuncConfig = {
+        'framework-isc-c': { path: ['/path1', '/path2'] },
+    };
+    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
+        edge_functions_correct_order: false,
+    })).toMatchSnapshot();
+});
 test('In-source config takes precedence over netlify.toml config', () => {
     const tomlConfig = [
         { function: 'geolocation', path: '/geo', cache: 'off' },
         { function: 'json', path: '/json', cache: 'manual' },
     ];
-    const funcConfig = {
+    const userFuncConfig = {
         geolocation: { path: ['/geo-isc', '/*'], cache: 'manual' },
         json: { path: '/json', cache: 'off' },
     };
@@ -16,7 +57,7 @@ test('In-source config takes precedence over netlify.toml config', () => {
         { function: 'geolocation', path: '/*', cache: 'manual' },
         { function: 'json', path: '/json', cache: 'off' },
     ];
-    const declarations = mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations);
+    const declarations = mergeDeclarations(tomlConfig, userFuncConfig, {}, deployConfigDeclarations);
     expect(declarations).toEqual(expectedDeclarations);
 });
 test("Declarations don't break if no in-source config is provided", () => {
@@ -24,7 +65,7 @@ test("Declarations don't break if no in-source config is provided", () => {
         { function: 'geolocation', path: '/geo', cache: 'off' },
         { function: 'json', path: '/json', cache: 'manual' },
     ];
-    const funcConfig = {
+    const userFuncConfig = {
         geolocation: { path: ['/geo-isc'], cache: 'manual' },
         json: {},
     };
@@ -32,7 +73,7 @@ test("Declarations don't break if no in-source config is provided", () => {
         { function: 'geolocation', path: '/geo-isc', cache: 'manual' },
         { function: 'json', path: '/json', cache: 'manual' },
     ];
-    const declarations = mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations);
+    const declarations = mergeDeclarations(tomlConfig, userFuncConfig, {}, deployConfigDeclarations);
     expect(declarations).toEqual(expectedDeclarations);
 });
 test('In-source config works independent of the netlify.toml file if a path is defined and otherwise if no path is set', () => {
@@ -49,9 +90,9 @@ test('In-source config works independent of the netlify.toml file if a path is d
         { function: 'json', path: '/json-isc', cache: 'off' },
     ];
     const expectedDeclarationsWithoutISCPath = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
-    const declarationsWithISCPath = mergeDeclarations(tomlConfig, funcConfigWithPath, deployConfigDeclarations);
+    const declarationsWithISCPath = mergeDeclarations(tomlConfig, funcConfigWithPath, {}, deployConfigDeclarations);
     expect(declarationsWithISCPath).toEqual(expectedDeclarationsWithISCPath);
-    const declarationsWithoutISCPath = mergeDeclarations(tomlConfig, funcConfigWithoutPath, deployConfigDeclarations);
+    const declarationsWithoutISCPath = mergeDeclarations(tomlConfig, funcConfigWithoutPath, {}, deployConfigDeclarations);
     expect(declarationsWithoutISCPath).toEqual(expectedDeclarationsWithoutISCPath);
 });
 test('In-source config works if only the cache config property is set', () => {
@@ -60,7 +101,7 @@ test('In-source config works if only the cache config property is set', () => {
         geolocation: { cache: 'manual' },
     };
     const expectedDeclarations = [{ function: 'geolocation', path: '/geo', cache: 'manual' }];
-    expect(mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations)).toEqual(expectedDeclarations);
+    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
 });
 test("In-source config path property works if it's not an array", () => {
     const tomlConfig = [{ function: 'json', path: '/json-toml', cache: 'off' }];
@@ -68,7 +109,7 @@ test("In-source config path property works if it's not an array", () => {
         json: { path: '/json', cache: 'manual' },
     };
     const expectedDeclarations = [{ function: 'json', path: '/json', cache: 'manual' }];
-    expect(mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations)).toEqual(expectedDeclarations);
+    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
 });
 test("In-source config path property works if it's not an array and it's not present in toml or deploy config", () => {
     const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
@@ -79,7 +120,7 @@ test("In-source config path property works if it's not an array and it's not pre
         { function: 'geolocation', path: '/geo', cache: 'off' },
         { function: 'json', path: '/json-isc', cache: 'manual' },
     ];
-    expect(mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations)).toEqual(expectedDeclarations);
+    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
 });
 test('In-source config works if path property is an empty array with cache value specified', () => {
     const tomlConfig = [{ function: 'json', path: '/json-toml', cache: 'off' }];
@@ -87,12 +128,12 @@ test('In-source config works if path property is an empty array with cache value
         json: { path: [], cache: 'manual' },
     };
     const expectedDeclarations = [{ function: 'json', path: '/json-toml', cache: 'manual' }];
-    expect(mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations)).toEqual(expectedDeclarations);
+    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
 });
 test('netlify.toml-defined excludedPath are respected', () => {
     const tomlConfig = [{ function: 'geolocation', path: '/geo/*', excludedPath: '/geo/exclude' }];
     const funcConfig = {};
     const expectedDeclarations = [{ function: 'geolocation', path: '/geo/*', excludedPath: '/geo/exclude' }];
-    const declarations = mergeDeclarations(tomlConfig, funcConfig, deployConfigDeclarations);
+    const declarations = mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations);
     expect(declarations).toEqual(expectedDeclarations);
 });

package/dist/node/downloader.test.js

@@ -4,10 +4,20 @@ import { PassThrough } from 'stream';
 import { execa } from 'execa';
 import nock from 'nock';
 import tmp from 'tmp-promise';
-import { beforeEach, afterEach, test, expect } from 'vitest';
+import { beforeEach, afterEach, test, expect, vi } from 'vitest';
 import { fixturesDir, testLogger } from '../test/util.js';
 import { download } from './downloader.js';
 import { getPlatformTarget } from './platform.js';
+// This changes the defaults for p-retry
+// minTimeout 1000 -> 10
+// factor 2 -> 1
+// This reduces the wait time in the tests from `2s, 4s, 8s` to `10ms, 10ms, 10ms` for 3 retries
+vi.mock('p-retry', async (importOriginal) => {
+    const pRetry = (await importOriginal());
+    return {
+        default: (func, options) => pRetry.default(func, { minTimeout: 10, factor: 1, ...options }),
+    };
+});
 const streamError = () => {
     const stream = new PassThrough();
     setTimeout(() => stream.emit('data', 'zipcontent'), 100);

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

@@ -1,7 +1,7 @@
 const defaultFlags = {
+    edge_functions_correct_order: false,
     edge_functions_fail_unsupported_regex: false,
     edge_functions_invalid_config_throw: false,
-    edge_functions_manifest_validate_slash: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/finder.d.ts

@@ -1,3 +1,4 @@
 import { EdgeFunction } from './edge_function.js';
+export declare const removeDuplicatesByExtension: (functions: string[]) => string[];
 declare const findFunctions: (directories: string[]) => Promise<EdgeFunction[]>;
 export { findFunctions };

package/dist/node/finder.js

@@ -1,12 +1,24 @@
 import { promises as fs } from 'fs';
-import { basename, extname, join } from 'path';
+import { basename, extname, join, parse } from 'path';
 import { nonNullable } from './utils/non_nullable.js';
-const ALLOWED_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx']);
+// 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'];
+export const removeDuplicatesByExtension = (functions) => {
+    const seen = new Map();
+    return Object.values(functions.reduce((acc, path) => {
+        const { ext, name } = parse(path);
+        const extIndex = ALLOWED_EXTENSIONS.indexOf(ext);
+        if (!seen.has(name) || seen.get(name) > extIndex) {
+            seen.set(name, extIndex);
+            return { ...acc, [name]: path };
+        }
+        return acc;
+    }, {}));
+};
 const findFunctionInDirectory = async (directory) => {
     const name = basename(directory);
-    const candidatePaths = [...ALLOWED_EXTENSIONS]
-        .flatMap((extension) => [`${name}${extension}`, `index${extension}`])
-        .map((filename) => join(directory, filename));
+    const candidatePaths = ALLOWED_EXTENSIONS.flatMap((extension) => [`${name}${extension}`, `index${extension}`]).map((filename) => join(directory, filename));
     let functionPath;
     for (const candidatePath of candidatePaths) {
         try {
@@ -35,14 +47,14 @@ const findFunctionInPath = async (path) => {
         return findFunctionInDirectory(path);
     }
     const extension = extname(path);
-    if (ALLOWED_EXTENSIONS.has(extension)) {
+    if (ALLOWED_EXTENSIONS.includes(extension)) {
         return { name: basename(path, extension), path };
     }
 };
 const findFunctionsInDirectory = async (baseDirectory) => {
     let items = [];
     try {
-        items = await fs.readdir(baseDirectory);
+        items = await fs.readdir(baseDirectory).then(removeDuplicatesByExtension);
     }
     catch {
         // no-op

package/dist/node/finder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/finder.test.js

@@ -0,0 +1,17 @@
+import { test, expect } from 'vitest';
+import { removeDuplicatesByExtension } from './finder.js';
+test('filters out any duplicate files based on the extension', () => {
+    const functions = [
+        'file1.js',
+        'file1.ts',
+        'file2.tsx',
+        'file2.jsx',
+        'file3.tsx',
+        'file3.js',
+        'file4.ts',
+        'file5.ts',
+        'file5.tsx',
+    ];
+    const expected = ['file1.js', 'file2.jsx', 'file3.js', 'file4.ts', 'file5.ts'];
+    expect(removeDuplicatesByExtension(functions)).toStrictEqual(expected);
+});

package/dist/node/manifest.d.ts

@@ -6,13 +6,13 @@ import { FeatureFlags } from './feature_flags.js';
 import { Layer } from './layer.js';
 interface Route {
     function: string;
-    name?: string;
     pattern: string;
-    generator?: string;
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];
     on_error?: string;
+    generator?: string;
+    name?: string;
 }
 interface Manifest {
     bundler_version: string;
@@ -34,11 +34,12 @@ interface GenerateManifestOptions {
     declarations?: Declaration[];
     featureFlags?: FeatureFlags;
     functions: EdgeFunction[];
-    functionConfig?: Record<string, FunctionConfig>;
     importMap?: string;
+    internalFunctionConfig?: Record<string, FunctionConfig>;
     layers?: Layer[];
+    userFunctionConfig?: Record<string, FunctionConfig>;
 }
-declare const generateManifest: ({ bundles, declarations, featureFlags, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, featureFlags, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
 }

package/dist/node/manifest.js

@@ -4,6 +4,12 @@ import globToRegExp from 'glob-to-regexp';
 import { parsePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
+const removeEmptyConfigValues = (functionConfig) => Object.entries(functionConfig).reduce((acc, [key, value]) => {
+    if (value && !(Array.isArray(value) && value.length === 0)) {
+        return { ...acc, [key]: value };
+    }
+    return acc;
+}, {});
 // JavaScript regular expressions are converted to strings with leading and
 // trailing slashes, so any slashes inside the expression itself are escaped
 // as `//`. This function deserializes that back into a single slash, which
@@ -12,29 +18,39 @@ const serializePattern = (pattern) => pattern.replace(/\\\//g, '/');
 const sanitizeEdgeFunctionConfig = (config) => {
     const newConfig = {};
     for (const [name, functionConfig] of Object.entries(config)) {
-        if (functionConfig.excluded_patterns.length !== 0 || functionConfig.on_error) {
-            newConfig[name] = functionConfig;
+        const newFunctionConfig = removeEmptyConfigValues(functionConfig);
+        if (Object.keys(newFunctionConfig).length !== 0) {
+            newConfig[name] = newFunctionConfig;
         }
     }
     return newConfig;
 };
-const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, functionConfig = {}, importMap, layers = [], }) => {
+const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath) => {
+    if (excludedPath) {
+        const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
+        const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);
+        manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
+    }
+};
+const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
-    for (const [name, { excludedPath, onError }] of Object.entries(functionConfig)) {
+    for (const [name, { excludedPath, onError }] of Object.entries(userFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        if (excludedPath) {
-            const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
-            const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);
-            manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
-        }
-        if (onError) {
-            manifestFunctionConfig[name].on_error = onError;
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
+        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
+    }
+    for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
+        // If the config block is for a function that is not defined, discard it.
+        if (manifestFunctionConfig[name] === undefined) {
+            continue;
         }
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
+        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
     }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
@@ -44,9 +60,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         const pattern = getRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         const route = {
             function: func.name,
-            name: declaration.name,
             pattern: serializePattern(pattern),
-            generator: declaration.generator,
         };
         const excludedPattern = getExcludedRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         if (excludedPattern) {

package/dist/node/manifest.test.js

@@ -26,63 +26,105 @@ test('Generates a manifest with different bundles', () => {
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
 test('Generates a manifest with display names', () => {
-    const functions = [
-        { name: 'func-1', path: '/path/to/func-1.ts' },
-        { name: 'func-2', path: '/path/to/func-2.ts' },
-    ];
-    const declarations = [
-        { function: 'func-1', name: 'Display Name', path: '/f1/*' },
-        { function: 'func-2', path: '/f2/*' },
-    ];
-    const manifest = generateManifest({ bundles: [], declarations, functions });
-    const expectedRoutes = [
-        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
-    ];
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const internalFunctionConfig = {
+        'func-1': {
+            name: 'Display Name',
+        },
+    };
+    const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    expect(manifest.function_config).toEqual({
+        'func-1': { name: 'Display Name' },
+    });
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
 test('Generates a manifest with a generator field', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const internalFunctionConfig = {
+        'func-1': {
+            generator: '@netlify/fake-plugin@1.0.0',
+        },
+    };
+    const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedFunctionConfig = { 'func-1': { generator: '@netlify/fake-plugin@1.0.0' } };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});
+test('Generates a manifest with excluded paths and patterns', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
         { name: 'func-2', path: '/path/to/func-2.ts' },
-        { name: 'func-3', path: '/path/to/func-3.ts' },
     ];
     const declarations = [
-        { function: 'func-1', generator: '@netlify/fake-plugin@1.0.0', path: '/f1/*' },
-        { function: 'func-2', path: '/f2/*' },
-        { function: 'func-3', generator: '@netlify/fake-plugin@1.0.0', cache: 'manual', path: '/f3' },
+        { function: 'func-1', path: '/f1/*', excludedPath: '/f1/exclude' },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
-        { function: 'func-1', generator: '@netlify/fake-plugin@1.0.0', pattern: '^/f1/.*/?$' },
+        { function: 'func-1', pattern: '^/f1/.*/?$' },
         { function: 'func-2', pattern: '^/f2/.*/?$' },
     ];
-    const expectedPostCacheRoutes = [{ function: 'func-3', generator: '@netlify/fake-plugin@1.0.0', pattern: '^/f3/?$' }];
     expect(manifest.routes).toEqual(expectedRoutes);
-    expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
+    expect(manifest.function_config).toEqual({
+        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
+        'func-2': { excluded_patterns: ['^/f2/exclude$'] },
+    });
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
-test('Generates a manifest with excluded paths and patterns', () => {
+test('Filters out internal in-source configurations in user created functions', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
         { name: 'func-2', path: '/path/to/func-2.ts' },
     ];
     const declarations = [
-        { function: 'func-1', name: 'Display Name', path: '/f1/*', excludedPath: '/f1/exclude' },
-        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
-    ];
-    const manifest = generateManifest({ bundles: [], declarations, functions });
-    const expectedRoutes = [
-        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$' },
+        { function: 'func-1', path: '/f1/*' },
         { function: 'func-2', pattern: '^/f2/.*/?$' },
     ];
-    expect(manifest.routes).toEqual(expectedRoutes);
+    const userFunctionConfig = {
+        'func-1': {
+            onError: '/custom-error',
+            cache: "manual" /* Cache.Manual */,
+            excludedPath: '/f1/exclude',
+            path: '/path/to/func-1.ts',
+            name: 'User function',
+            generator: 'fake-generator',
+        },
+    };
+    const internalFunctionConfig = {
+        'func-2': {
+            onError: 'bypass',
+            cache: "off" /* Cache.Off */,
+            excludedPath: '/f2/exclude',
+            path: '/path/to/func-2.ts',
+            name: 'Internal function',
+            generator: 'internal-generator',
+        },
+    };
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+        internalFunctionConfig,
+    });
     expect(manifest.function_config).toEqual({
-        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
-        'func-2': { excluded_patterns: ['^/f2/exclude$'] },
+        'func-1': {
+            on_error: '/custom-error',
+            excluded_patterns: ['^/f1/exclude/?$'],
+        },
+        'func-2': {
+            on_error: 'bypass',
+            cache: "off" /* Cache.Off */,
+            name: 'Internal function',
+            generator: 'internal-generator',
+            excluded_patterns: ['^/f2/exclude/?$'],
+        },
     });
-    expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
 test('Includes failure modes in manifest', () => {
     const functions = [
@@ -90,17 +132,17 @@ test('Includes failure modes in manifest', () => {
         { name: 'func-2', path: '/path/to/func-2.ts' },
     ];
     const declarations = [
-        { function: 'func-1', name: 'Display Name', path: '/f1/*' },
+        { function: 'func-1', path: '/f1/*' },
         { function: 'func-2', pattern: '^/f2/.*/?$' },
     ];
-    const functionConfig = {
+    const userFunctionConfig = {
         'func-1': {
             onError: '/custom-error',
         },
     };
-    const manifest = generateManifest({ bundles: [], declarations, functions, functionConfig });
+    const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
     expect(manifest.function_config).toEqual({
-        'func-1': { excluded_patterns: [], on_error: '/custom-error' },
+        'func-1': { on_error: '/custom-error' },
     });
 });
 test('Excludes functions for which there are function files but no matching config declarations', () => {

package/dist/node/validation/manifest/index.d.ts

@@ -1,4 +1,4 @@
 import { FeatureFlags } from '../../feature_flags.js';
 import ManifestValidationError from './error.js';
-export declare const validateManifest: (manifestData: unknown, featureFlags?: FeatureFlags) => void;
+export declare const validateManifest: (manifestData: unknown, _featureFlags?: FeatureFlags) => void;
 export { ManifestValidationError };

package/dist/node/validation/manifest/index.js

@@ -4,13 +4,13 @@ import betterAjvErrors from 'better-ajv-errors';
 import ManifestValidationError from './error.js';
 import edgeManifestSchema from './schema.js';
 let manifestValidator;
-const initializeValidator = (featureFlags) => {
+const initializeValidator = () => {
     if (manifestValidator === undefined) {
         const ajv = new Ajv({ allErrors: true });
         ajvErrors(ajv);
         // regex pattern for manifest route pattern
         // checks if the pattern string starts with ^ and ends with $
-        const normalizedPatternRegex = featureFlags.edge_functions_manifest_validate_slash ? /^\^\/.*\$$/ : /^\^.*\$$/;
+        const normalizedPatternRegex = /^\^.*\$$/;
         ajv.addFormat('regexPattern', {
             validate: (data) => normalizedPatternRegex.test(data),
         });
@@ -19,8 +19,9 @@ const initializeValidator = (featureFlags) => {
     return manifestValidator;
 };
 // throws on validation error
-export const validateManifest = (manifestData, featureFlags = {}) => {
-    const validate = initializeValidator(featureFlags);
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const validateManifest = (manifestData, _featureFlags = {}) => {
+    const validate = initializeValidator();
     const valid = validate(manifestData);
     if (!valid) {
         let errorOutput;

package/dist/node/validation/manifest/index.test.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { test, expect, describe, beforeEach, vi } from 'vitest';
+import { test, expect, describe } from 'vitest';
 import { validateManifest, ManifestValidationError } from './index.js';
 // We need to disable all color outputs for the tests as they are different on different platforms, CI, etc.
 // This only works if this is the same instance of chalk that better-ajv-errors uses
@@ -92,42 +92,25 @@ describe('bundle', () => {
     });
 });
 describe('route', () => {
-    let freshValidateManifest;
-    beforeEach(async () => {
-        // reset all modules, to get a fresh AJV validator for FF changes
-        vi.resetModules();
-        const indexImport = await import('./index.js');
-        freshValidateManifest = indexImport.validateManifest;
-    });
     test('should throw on additional property', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].foo = 'bar';
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on invalid pattern', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].pattern = '/^/hello/?$/';
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should not throw on missing beginning slash without FF', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].pattern = '^hello/?$';
-        expect(() => freshValidateManifest(manifest, { edge_functions_manifest_validate_slash: false })).not.toThrowError();
-    });
-    test('should throw on missing beginning slash with FF', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].pattern = '^hello/?$';
-        expect(() => freshValidateManifest(manifest, { edge_functions_manifest_validate_slash: true })).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on missing function', () => {
         const manifest = getBaseManifest();
         delete manifest.routes[0].function;
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on missing pattern', () => {
         const manifest = getBaseManifest();
         delete manifest.routes[0].pattern;
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
 });
 // No tests for post_cache_routes as schema shared with routes

package/dist/node/validation/manifest/schema.js

@@ -16,7 +16,7 @@ const routesSchema = {
         pattern: {
             type: 'string',
             format: 'regexPattern',
-            errorMessage: 'pattern needs to be a regex that starts with ^ followed by / and ends with $ without any additional slashes before and afterwards',
+            errorMessage: 'pattern must be a regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
         },
         generator: { type: 'string' },
     },
@@ -31,7 +31,7 @@ const functionConfigSchema = {
             items: {
                 type: 'string',
                 format: 'regexPattern',
-                errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ followed by / and ends with $ without any additional slashes before and afterwards',
+                errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
             },
         },
         on_error: { type: 'string' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.12.3",
+  "version": "8.13.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -58,7 +58,7 @@
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^9.0.0",
-    "@vitest/coverage-c8": "^0.29.2",
+    "@vitest/coverage-c8": "^0.30.0",
     "archiver": "^5.3.1",
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
@@ -66,8 +66,8 @@
     "husky": "^8.0.0",
     "nock": "^13.2.4",
     "tar": "^6.1.11",
-    "typescript": "^4.5.4",
-    "vitest": "^0.29.2"
+    "typescript": "^5.0.0",
+    "vitest": "^0.30.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"