@netlify/edge-bundler 7.1.0 → 8.1.0

package/deno/config.ts

@@ -19,22 +19,12 @@ if (func.config === undefined) {
   Deno.exit(exitCodes.NoConfig)
 }
 
-if (typeof func.config !== 'function') {
+if (typeof func.config !== 'object') {
   Deno.exit(exitCodes.InvalidExport)
 }
 
-let config
-
-try {
-  config = await func.config()
-} catch (error) {
-  console.error(error)
-
-  Deno.exit(exitCodes.RuntimeError)
-}
-
 try {
-  const result = JSON.stringify(config)
+  const result = JSON.stringify(func.config)
 
   await Deno.writeTextFile(new URL(collectorURL), result)
 } catch (error) {

package/dist/node/bundler.js

@@ -75,6 +75,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         declarations,
         distDirectory,
         functions,
+        functionConfig: functionsWithConfig,
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });

package/dist/node/bundler.test.js

@@ -110,7 +110,28 @@ test('Prints a nice error message when user tries importing NPM module', async (
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
-        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported in Deno via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
+        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
+    }
+    finally {
+        await cleanup();
+    }
+});
+test('Prints a nice error message when user tries importing NPM module with npm: scheme', async () => {
+    expect.assertions(2);
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_scheme');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    try {
+        await bundle([sourceDirectory], distPath, declarations, { basePath });
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(BundleError);
+        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
     }
     finally {
         await cleanup();
@@ -278,12 +299,12 @@ 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 { bundles, routes } = 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);
     // respects excludedPath from deploy config
-    expect(routes[1].excluded_pattern).toEqual('^/func2/skip/?$');
+    expect(functionConfig.func2).toEqual({ excluded_patterns: ['^/func2/skip/?$'] });
     await cleanup();
 });
 test("Ignores entries in `importMapPaths` that don't point to an existing import map file", async () => {

package/dist/node/config.d.ts

@@ -9,5 +9,6 @@ export declare const enum Cache {
 export interface FunctionConfig {
     cache?: Cache;
     path?: string | string[];
+    excludedPath?: string | string[];
 }
 export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -11,9 +11,8 @@ var ConfigExitCode;
     ConfigExitCode[ConfigExitCode["ImportError"] = 2] = "ImportError";
     ConfigExitCode[ConfigExitCode["NoConfig"] = 3] = "NoConfig";
     ConfigExitCode[ConfigExitCode["InvalidExport"] = 4] = "InvalidExport";
-    ConfigExitCode[ConfigExitCode["RuntimeError"] = 5] = "RuntimeError";
-    ConfigExitCode[ConfigExitCode["SerializationError"] = 6] = "SerializationError";
-    ConfigExitCode[ConfigExitCode["InvalidDefaultExport"] = 7] = "InvalidDefaultExport";
+    ConfigExitCode[ConfigExitCode["SerializationError"] = 5] = "SerializationError";
+    ConfigExitCode[ConfigExitCode["InvalidDefaultExport"] = 6] = "InvalidDefaultExport";
 })(ConfigExitCode || (ConfigExitCode = {}));
 const getConfigExtractor = () => {
     const packagePath = getPackagePath();
@@ -75,14 +74,10 @@ const logConfigError = (func, exitCode, stderr, log) => {
             log.system(`No in-source config found for edge function at '${func.path}'`);
             break;
         case ConfigExitCode.InvalidExport:
-            log.user(`'config' export in edge function at '${func.path}' must be a function`);
-            break;
-        case ConfigExitCode.RuntimeError:
-            log.user(`Error while running 'config' function in edge function at '${func.path}'`);
-            log.user(stderr);
+            log.user(`'config' export in edge function at '${func.path}' must be an object`);
             break;
         case ConfigExitCode.SerializationError:
-            log.user(`'config' function in edge function at '${func.path}' must return an object with primitive values only`);
+            log.user(`'config' object in edge function at '${func.path}' must contain primitive values only`);
             break;
         case ConfigExitCode.InvalidDefaultExport:
             throw new BundleError(new Error(`Default export in '${func.path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`));

package/dist/node/config.test.js

@@ -35,7 +35,7 @@ test('`getFunctionConfig` extracts configuration properties from function file',
             source: `
         export default async () => new Response("Hello from function two")
 
-        export const config = () => ({})
+        export const config = {}
       `,
         },
         // Config with the wrong type
@@ -45,9 +45,9 @@ test('`getFunctionConfig` extracts configuration properties from function file',
             source: `
       export default async () => new Response("Hello from function two")
 
-      export const config = {}
+      export const config = () => ({})
     `,
-            userLog: /^'config' export in edge function at '(.*)' must be a function$/,
+            userLog: /^'config' export in edge function at '(.*)' must be an object$/,
         },
         // Config with a syntax error
         {
@@ -60,19 +60,6 @@ test('`getFunctionConfig` extracts configuration properties from function file',
     `,
             userLog: /^Could not load edge function at '(.*)'$/,
         },
-        // Config that throws
-        {
-            expectedConfig: {},
-            name: 'func5',
-            source: `
-          export default async () => new Response("Hello from function two")
-
-          export const config = () => {
-            throw new Error('uh-oh')
-          }
-        `,
-            userLog: /^Error while running 'config' function in edge function at '(.*)'$/,
-        },
         // Config with `path`
         {
             expectedConfig: { path: '/home' },
@@ -80,24 +67,9 @@ test('`getFunctionConfig` extracts configuration properties from function file',
             source: `
         export default async () => new Response("Hello from function three")
 
-        export const config = () => ({ path: "/home" })
+        export const config = { path: "/home" }
       `,
         },
-        // Config that prints to stdout
-        {
-            expectedConfig: { path: '/home' },
-            name: 'func7',
-            source: `
-        export default async () => new Response("Hello from function three")
-
-        export const config = () => {
-          console.log("Hello from config!")
-
-          return { path: "/home" }
-        }
-      `,
-            userLog: /^Hello from config!$/,
-        },
     ];
     for (const func of functions) {
         const logger = {
@@ -130,7 +102,7 @@ test('Ignores function paths from the in-source `config` function if the feature
         configPath: join(internalDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(6);
+    expect(result.functions.length).toBe(7);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
@@ -163,22 +135,27 @@ test('Loads function paths from the in-source `config` function', async () => {
         },
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(6);
+    expect(result.functions.length).toBe(7);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles, routes, post_cache_routes: postCacheRoutes } = manifest;
+    const { bundles, routes, post_cache_routes: postCacheRoutes, 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.length).toBe(5);
+    expect(routes.length).toBe(6);
     expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$' });
     expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$' });
     expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$' });
     expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$' });
     expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$' });
+    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5/.*/?$' });
     expect(postCacheRoutes.length).toBe(1);
     expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
+    expect(Object.keys(functionConfig)).toHaveLength(1);
+    expect(functionConfig['user-func5']).toEqual({
+        excluded_patterns: ['^/user-func5/excluded/?$'],
+    });
     await cleanup();
 });
 test('Passes validation if default export exists and is a function', async () => {

package/dist/node/declaration.js

@@ -17,13 +17,13 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, dep
         else if ((_a = config.path) === null || _a === void 0 ? void 0 : _a.length) {
             const paths = Array.isArray(config.path) ? config.path : [config.path];
             paths.forEach((path) => {
-                declarations.push({ ...declaration, ...config, path });
+                declarations.push({ ...declaration, cache: config.cache, path });
             });
             // With an in-source config without a path, add the config to the declaration
         }
         else {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { path, ...rest } = config;
+            const { path, excludedPath, ...rest } = config;
             declarations.push({ ...declaration, ...rest });
         }
         functionsVisited.add(declaration.function);
@@ -31,13 +31,12 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, dep
     // Finally, we must create declarations for functions that are not declared
     // in the TOML at all.
     for (const name in functionsConfig) {
-        const { ...config } = functionsConfig[name];
-        const { path } = functionsConfig[name];
+        const { cache, path } = functionsConfig[name];
         // If we have 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({ ...config, function: name, path: singlePath });
+                declarations.push({ cache, function: name, path: singlePath });
             });
         }
     }

package/dist/node/manifest.d.ts

@@ -1,19 +1,15 @@
 import type { Bundle } from './bundle.js';
+import { FunctionConfig } from './config.js';
 import type { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
 import { Layer } from './layer.js';
-interface GenerateManifestOptions {
-    bundles?: Bundle[];
-    declarations?: Declaration[];
-    functions: EdgeFunction[];
-    importMap?: string;
-    layers?: Layer[];
-}
 interface Route {
     function: string;
     name?: string;
     pattern: string;
-    excluded_pattern?: string;
+}
+interface EdgeFunctionConfig {
+    excluded_patterns: string[];
 }
 interface Manifest {
     bundler_version: string;
@@ -28,20 +24,24 @@ interface Manifest {
     }[];
     routes: Route[];
     post_cache_routes: Route[];
+    function_config: Record<string, EdgeFunctionConfig>;
+}
+interface GenerateManifestOptions {
+    bundles?: Bundle[];
+    declarations?: Declaration[];
+    functions: EdgeFunction[];
+    functionConfig?: Record<string, FunctionConfig>;
+    importMap?: string;
+    layers?: Layer[];
 }
 interface Route {
     function: string;
     name?: string;
     pattern: string;
 }
-declare const generateManifest: ({ bundles, declarations, functions, importMap, layers, }: GenerateManifestOptions) => Manifest;
-interface WriteManifestOptions {
-    bundles: Bundle[];
-    declarations: Declaration[];
+declare const generateManifest: ({ bundles, declarations, functions, functionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
+interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
-    functions: EdgeFunction[];
-    importMap?: string;
-    layers?: Layer[];
 }
-declare const writeManifest: ({ bundles, declarations, distDirectory, functions, importMap, layers, }: WriteManifestOptions) => Promise<Manifest>;
+declare const writeManifest: ({ distDirectory, ...rest }: WriteManifestOptions) => Promise<Manifest>;
 export { generateManifest, Manifest, writeManifest };

package/dist/node/manifest.js

@@ -4,9 +4,26 @@ import globToRegExp from 'glob-to-regexp';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
 const serializePattern = (regex) => regex.source.replace(/\\\//g, '/');
-const generateManifest = ({ bundles = [], declarations = [], functions, importMap, layers = [], }) => {
+const sanitizeEdgeFunctionConfig = (config) => {
+    const newConfig = {};
+    for (const [name, functionConfig] of Object.entries(config)) {
+        if (functionConfig.excluded_patterns.length !== 0) {
+            newConfig[name] = functionConfig;
+        }
+    }
+    return newConfig;
+};
+const generateManifest = ({ bundles = [], declarations = [], functions, functionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
+    const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
+    for (const [name, { excludedPath }] of Object.entries(functionConfig)) {
+        if (excludedPath) {
+            const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
+            const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);
+            manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
+        }
+    }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
         if (func === undefined) {
@@ -20,7 +37,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
         };
         const excludedPattern = getExcludedRegularExpression(declaration);
         if (excludedPattern) {
-            route.excluded_pattern = serializePattern(excludedPattern);
+            manifestFunctionConfig[func.name].excluded_patterns.push(serializePattern(excludedPattern));
         }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
@@ -40,6 +57,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
         bundler_version: getPackageVersion(),
         layers,
         import_map: importMap,
+        function_config: sanitizeEdgeFunctionConfig(manifestFunctionConfig),
     };
     return manifest;
 };
@@ -67,8 +85,8 @@ const getExcludedRegularExpression = (declaration) => {
         return pathToRegularExpression(declaration.excludedPath);
     }
 };
-const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, importMap, layers, }) => {
-    const manifest = generateManifest({ bundles, declarations, functions, importMap, layers });
+const writeManifest = async ({ distDirectory, ...rest }) => {
+    const manifest = generateManifest(rest);
     const manifestPath = join(distDirectory, 'manifest.json');
     await fs.writeFile(manifestPath, JSON.stringify(manifest));
     return manifest;

package/dist/node/manifest.test.js

@@ -53,10 +53,14 @@ test('Generates a manifest with excluded paths and patterns', () => {
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
-        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$', excluded_pattern: '^/f1/exclude/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_pattern: '^/f2/exclude$' },
+        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$' },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
+    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('Excludes functions for which there are function files but no matching config declarations', () => {

package/dist/node/npm_import_error.js

@@ -1,6 +1,6 @@
 class NPMImportError extends Error {
     constructor(originalError, moduleName) {
-        super(`It seems like you're trying to import an npm module. This is only supported in Deno via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/${moduleName}"'?`);
+        super(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/${moduleName}"'?`);
         this.name = 'NPMImportError';
         this.stack = originalError.stack;
         // https://github.com/microsoft/TypeScript-wiki/blob/8a66ecaf77118de456f7cd9c56848a40fe29b9b4/Breaking-Changes.md#implicit-any-error-raised-for-un-annotated-callback-arguments-with-no-matching-overload-arguments
@@ -14,6 +14,11 @@ const wrapNpmImportError = (input) => {
             const [, moduleName] = match;
             return new NPMImportError(input, moduleName);
         }
+        const schemeMatch = input.message.match(/Error: Module not found "npm:(.*)"/);
+        if (schemeMatch !== null) {
+            const [, moduleName] = schemeMatch;
+            return new NPMImportError(input, moduleName);
+        }
     }
     return input;
 };

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

@@ -86,6 +86,23 @@ declare const edgeManifestSchema: {
         bundler_version: {
             type: string;
         };
+        function_config: {
+            type: string;
+            items: {
+                type: string;
+                required: never[];
+                properties: {
+                    excluded_patterns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            format: string;
+                            errorMessage: string;
+                        };
+                    };
+                };
+            };
+        };
     };
     additionalProperties: boolean;
 };

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

@@ -21,6 +21,20 @@ const routesSchema = {
     },
     additionalProperties: false,
 };
+const functionConfigSchema = {
+    type: 'object',
+    required: [],
+    properties: {
+        excluded_patterns: {
+            type: 'array',
+            items: {
+                type: 'string',
+                format: 'regexPattern',
+                errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ and ends with $ without any additional slashes before and afterwards',
+            },
+        },
+    },
+};
 const layersSchema = {
     type: 'object',
     required: ['flag', 'name'],
@@ -53,6 +67,7 @@ const edgeManifestSchema = {
         },
         import_map: { type: 'string' },
         bundler_version: { type: 'string' },
+        function_config: { type: 'object', items: functionConfigSchema },
     },
     additionalProperties: false,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "7.1.0",
+  "version": "8.1.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",