@netlify/edge-bundler 8.13.0 → 8.13.1

package/dist/node/bundler.js

@@ -70,7 +70,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     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 declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations);
+    const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
     const internalFunctionConfig = createFunctionConfig({
         internalFunctionsWithConfig,
         declarations,

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[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: 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, userFunctionsConfig, internalFunctionsConfig, 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 = userFunctionsConfig[declaration.function] || internalFunctionsConfig[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,10 +53,12 @@ export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, interna
         }
         functionsVisited.add(declaration.function);
     }
-    // Finally, we must create declarations for functions that are not declared
-    // in the TOML at all.
-    for (const name in { ...internalFunctionsConfig, ...userFunctionsConfig }) {
-        const { cache, path } = internalFunctionsConfig[name] || userFunctionsConfig[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];

package/dist/node/declaration.test.js

@@ -1,22 +1,47 @@
 import { test, expect } from 'vitest';
 import { mergeDeclarations } from './declaration.js';
 const deployConfigDeclarations = [];
-test('Deploy config takes precedence over user config', () => {
+test('Ensure the order of edge functions with FF', () => {
     const deployConfigDeclarations = [
-        { function: 'framework-a', path: '/path1' },
-        { function: 'framework-b', path: '/path2' },
+        { function: 'framework-manifest-a', path: '/path1' },
+        { function: 'framework-manifest-c', path: '/path3' },
+        { function: 'framework-manifest-b', path: '/path2' },
     ];
     const tomlConfig = [
-        { function: 'user-a', path: '/path1' },
-        { function: 'user-b', path: '/path2' },
+        { function: 'user-toml-a', path: '/path1' },
+        { function: 'user-toml-c', path: '/path3' },
+        { function: 'user-toml-b', path: '/path2' },
     ];
     const userFuncConfig = {
-        'user-c': { path: ['/path1', '/path2'] },
+        'user-isc-c': { path: ['/path1', '/path2'] },
     };
     const internalFuncConfig = {
-        'framework-c': { path: ['/path1', '/path2'] },
+        'framework-isc-c': { path: ['/path1', '/path2'] },
     };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations)).toMatchSnapshot();
+    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 = [

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/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.13.0",
+  "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.7",
+    "@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.7"
+    "typescript": "^5.0.0",
+    "vitest": "^0.30.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"