@netlify/edge-bundler 8.17.1 → 8.19.0

package/deno/lib/consts.ts

@@ -1,4 +1,5 @@
-export const PUBLIC_SPECIFIER = 'netlify:edge'
+export const LEGACY_PUBLIC_SPECIFIER = 'netlify:edge'
+export const PUBLIC_SPECIFIER = '@netlify/edge-functions'
 export const STAGE1_SPECIFIER = 'netlify:bootstrap-stage1'
 export const STAGE2_SPECIFIER = 'netlify:bootstrap-stage2'
 export const virtualRoot = 'file:///root/'

package/deno/lib/stage2.ts

@@ -4,7 +4,7 @@ import * as path from 'https://deno.land/std@0.177.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
 import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'
-import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
+import { LEGACY_PUBLIC_SPECIFIER, PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
 interface FunctionReference {
@@ -75,7 +75,12 @@ const stage2Loader = (basePath: string, functions: InputFunction[], externals: S
       return inlineModule(specifier, importMapData)
     }
 
-    if (specifier === PUBLIC_SPECIFIER || externals.has(specifier) || specifier.startsWith('node:')) {
+    if (
+      specifier === LEGACY_PUBLIC_SPECIFIER ||
+      specifier === PUBLIC_SPECIFIER ||
+      externals.has(specifier) ||
+      specifier.startsWith('node:')
+    ) {
       return {
         kind: 'external',
         specifier,

package/dist/node/config.d.ts

@@ -6,6 +6,7 @@ export declare const enum Cache {
     Off = "off",
     Manual = "manual"
 }
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
 export type Path = `/${string}`;
 export type OnError = 'fail' | 'bypass' | Path;
 export declare const isValidOnError: (value: unknown) => value is OnError;
@@ -16,6 +17,7 @@ export interface FunctionConfig {
     onError?: OnError;
     name?: string;
     generator?: string;
+    method?: HTTPMethod | HTTPMethod[];
 }
 export declare const getFunctionConfig: ({ func, importMap, deno, bootstrapURL, log, }: {
     func: EdgeFunction;

package/dist/node/config.test.js

@@ -151,12 +151,12 @@ test('Loads function paths from the in-source `config` function', async () => {
         {
             function: 'user-func2',
             path: '/user-func2',
+            method: ['PATCH'],
         },
     ];
     const result = await bundle([internalDirectory, userDirectory], distPath, declarations, {
         basePath,
         configPath: join(internalDirectory, 'config.json'),
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(7);
@@ -168,14 +168,52 @@ test('Loads function paths from the in-source `config` function', async () => {
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     expect(routes.length).toBe(6);
-    expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$', excluded_patterns: [] });
-    expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$', excluded_patterns: [] });
-    expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$', excluded_patterns: [] });
-    expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$', excluded_patterns: [] });
-    expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$', excluded_patterns: [] });
-    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5(?:/(.*))/?$', excluded_patterns: [] });
+    expect(routes[0]).toEqual({
+        function: 'framework-func2',
+        pattern: '^/framework-func2/?$',
+        excluded_patterns: [],
+        path: '/framework-func2',
+    });
+    expect(routes[1]).toEqual({
+        function: 'user-func2',
+        pattern: '^/user-func2/?$',
+        excluded_patterns: [],
+        path: '/user-func2',
+        methods: ['PATCH'],
+    });
+    expect(routes[2]).toEqual({
+        function: 'framework-func1',
+        pattern: '^/framework-func1/?$',
+        excluded_patterns: [],
+        path: '/framework-func1',
+    });
+    expect(routes[3]).toEqual({
+        function: 'user-func1',
+        pattern: '^/user-func1/?$',
+        excluded_patterns: [],
+        path: '/user-func1',
+    });
+    expect(routes[4]).toEqual({
+        function: 'user-func3',
+        pattern: '^/user-func3/?$',
+        excluded_patterns: [],
+        path: '/user-func3',
+    });
+    expect(routes[5]).toEqual({
+        function: 'user-func5',
+        pattern: '^/user-func5(?:/(.*))/?$',
+        excluded_patterns: [],
+        path: '/user-func5/*',
+        methods: ['GET'],
+    });
     expect(postCacheRoutes.length).toBe(1);
-    expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$', excluded_patterns: [] });
+    expect(postCacheRoutes[0]).toEqual({
+        function: 'user-func4',
+        pattern: '^/user-func4/?$',
+        excluded_patterns: [],
+        path: '/user-func4',
+        methods: ['POST', 'PUT'],
+    });
     expect(Object.keys(functionConfig)).toHaveLength(1);
     expect(functionConfig['user-func5']).toEqual({
         excluded_patterns: ['^/user-func5/excluded/?$'],

package/dist/node/declaration.d.ts

@@ -1,8 +1,9 @@
-import { FunctionConfig, Path } from './config.js';
+import { FunctionConfig, HTTPMethod, Path } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
 interface BaseDeclaration {
     cache?: string;
     function: string;
+    method?: HTTPMethod | HTTPMethod[];
     name?: string;
     generator?: string;
 }

package/dist/node/declaration.js

@@ -48,7 +48,7 @@ const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsV
 const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited) => {
     const declarations = [];
     for (const name in functionConfigs) {
-        const { cache, path } = functionConfigs[name];
+        const { cache, path, method } = 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];
@@ -57,6 +57,9 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
                 if (cache) {
                     declaration.cache = cache;
                 }
+                if (method) {
+                    declaration.method = method;
+                }
                 declarations.push(declaration);
             });
         }

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

package/dist/node/formats/eszip.js

@@ -1,4 +1,5 @@
 import { join } from 'path';
+import { pathToFileURL } from 'url';
 import { virtualRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
@@ -9,13 +10,17 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
-    const importMapData = JSON.stringify(importMap.getContents(basePath, virtualRoot));
+    // Transforming all paths under `basePath` to use the virtual root prefix.
+    const importMapPrefixes = {
+        [`${pathToFileURL(basePath)}/`]: virtualRoot,
+    };
+    const importMapData = importMap.getContents(importMapPrefixes);
     const payload = {
         basePath,
         destPath,
         externals,
         functions,
-        importMapData,
+        importMapData: JSON.stringify(importMapData),
     };
     const flags = ['--allow-all', '--no-config', `--import-map=${bundlerImportMap}`];
     if (!debug) {

package/dist/node/import_map.d.ts

@@ -1,29 +1,32 @@
+import { ParsedImportMap } from '@import-maps/resolve';
 import { Logger } from './logger.js';
 type Imports = Record<string, string>;
-interface ImportMapSource {
+export interface ImportMapFile {
     baseURL: URL;
     imports: Imports;
     scopes?: Record<string, Imports>;
 }
-declare class ImportMap {
-    sources: ImportMapSource[];
-    constructor(sources?: ImportMapSource[]);
-    static resolve(source: ImportMapSource, basePath?: string, prefix?: string): {
-        imports: Record<string, string>;
-        scopes: Record<string, Imports>;
-    };
-    static resolveImports(imports: Record<string, URL | null>, basePath?: string, prefix?: string): Record<string, string>;
-    static resolvePath(url: URL, basePath?: string, prefix?: string): string;
-    add(source: ImportMapSource): void;
+export declare class ImportMap {
+    rootPath: string | null;
+    sources: ImportMapFile[];
+    constructor(sources?: ImportMapFile[], rootURL?: string | null);
+    add(source: ImportMapFile): void;
     addFile(path: string, logger: Logger): Promise<void>;
     addFiles(paths: (string | undefined)[], logger: Logger): Promise<void>;
-    getContents(basePath?: string, prefix?: string): {
+    static applyPrefixesToImports(imports: Imports, prefixes: Record<string, string>): Imports;
+    static applyPrefixesToPath(path: string, prefixes: Record<string, string>): string;
+    filterImports(imports?: Record<string, URL | null>): Record<string, string>;
+    filterScopes(scopes?: ParsedImportMap['scopes']): Record<string, Imports>;
+    getContents(prefixes?: Record<string, string>): {
         imports: Imports;
+        scopes: {};
+    };
+    static readFile(path: string, logger: Logger): Promise<ImportMapFile>;
+    resolve(source: ImportMapFile): {
+        imports: Record<string, string>;
         scopes: Record<string, Imports>;
     };
     toDataURL(): string;
     writeToFile(path: string): Promise<void>;
 }
-declare const readFile: (path: string, logger: Logger) => Promise<ImportMapSource>;
-export { ImportMap, readFile };
-export type { ImportMapSource as ImportMapFile };
+export {};

package/dist/node/import_map.js

@@ -1,82 +1,28 @@
 import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
-import { dirname, posix, relative, sep } from 'path';
+import { dirname, relative } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { parse } from '@import-maps/resolve';
 import { isFileNotFoundError } from './utils/error.js';
 const INTERNAL_IMPORTS = {
+    '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
     'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
 };
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.
-class ImportMap {
-    constructor(sources = []) {
+export class ImportMap {
+    constructor(sources = [], rootURL = null) {
+        this.rootPath = rootURL ? fileURLToPath(rootURL) : null;
         this.sources = [];
         sources.forEach((file) => {
             this.add(file);
         });
     }
-    // Transforms an import map by making any relative paths use a different path
-    // as a base.
-    static resolve(source, basePath, prefix = 'file://') {
-        const { baseURL, ...importMap } = source;
-        const parsedImportMap = parse(importMap, baseURL);
-        const { imports = {}, scopes = {} } = parsedImportMap;
-        const resolvedImports = ImportMap.resolveImports(imports, basePath, prefix);
-        const resolvedScopes = {};
-        Object.keys(scopes).forEach((path) => {
-            const resolvedPath = ImportMap.resolvePath(new URL(path), basePath, prefix);
-            resolvedScopes[resolvedPath] = ImportMap.resolveImports(scopes[path], basePath, prefix);
-        });
-        return { ...parsedImportMap, imports: resolvedImports, scopes: resolvedScopes };
-    }
-    // Takes an imports object and resolves relative specifiers with a given base
-    // path and URL prefix.
-    static resolveImports(imports, basePath, prefix) {
-        const resolvedImports = {};
-        Object.keys(imports).forEach((specifier) => {
-            const url = imports[specifier];
-            // If there's no URL, don't even add the specifier to the final imports.
-            if (url === null) {
-                return;
-            }
-            // If this is a file URL, we might want to transform it to use another
-            // base path.
-            if (url.protocol === 'file:') {
-                resolvedImports[specifier] = ImportMap.resolvePath(url, basePath, prefix);
-                return;
-            }
-            resolvedImports[specifier] = url.toString();
-        });
-        return resolvedImports;
-    }
-    // Takes a URL, turns it into a path relative to the given base, and prepends
-    // a prefix (such as the virtual root prefix).
-    static resolvePath(url, basePath, prefix) {
-        if (basePath === undefined) {
-            return url.toString();
-        }
-        const path = fileURLToPath(url);
-        const relativePath = relative(basePath, path);
-        if (relativePath.startsWith('..')) {
-            throw new Error(`Import map cannot reference '${path}' as it's outside of the base directory '${basePath}'`);
-        }
-        // We want to use POSIX paths for the import map regardless of the OS
-        // we're building in.
-        let normalizedPath = relativePath.split(sep).join(posix.sep);
-        // If the original URL had a trailing slash, ensure the normalized path
-        // has one too.
-        if (normalizedPath !== '' && url.pathname.endsWith(posix.sep) && !normalizedPath.endsWith(posix.sep)) {
-            normalizedPath += posix.sep;
-        }
-        const newURL = new URL(normalizedPath, prefix);
-        return newURL.toString();
-    }
     add(source) {
         this.sources.push(source);
     }
     async addFile(path, logger) {
-        const source = await readFile(path, logger);
+        const source = await ImportMap.readFile(path, logger);
         if (Object.keys(source.imports).length === 0) {
             return;
         }
@@ -90,11 +36,73 @@ class ImportMap {
             await this.addFile(path, logger);
         }
     }
-    getContents(basePath, prefix) {
+    // Applies a list of prefixes to an `imports` block, by transforming values
+    // with the `applyPrefixesToPath` method.
+    static applyPrefixesToImports(imports, prefixes) {
+        return Object.entries(imports).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: ImportMap.applyPrefixesToPath(value, prefixes),
+        }), {});
+    }
+    // Applies a list of prefixes to a given path, returning the replaced path.
+    // For example, given a `path` of `file:///foo/bar/baz.js` and a `prefixes`
+    // object with `{"file:///foo/": "file:///hello/"}`, this method will return
+    // `file:///hello/bar/baz.js`. If no matching prefix is found, the original
+    // path is returned.
+    static applyPrefixesToPath(path, prefixes) {
+        for (const prefix in prefixes) {
+            if (path.startsWith(prefix)) {
+                return path.replace(prefix, prefixes[prefix]);
+            }
+        }
+        return path;
+    }
+    // Takes an `imports` object and filters out any entries without a URL. Also,
+    // it checks whether the import map is referencing a path outside `rootPath`,
+    // if one is set.
+    filterImports(imports = {}) {
+        const filteredImports = {};
+        Object.keys(imports).forEach((specifier) => {
+            const url = imports[specifier];
+            // If there's no URL, don't even add the specifier to the final imports.
+            if (url === null) {
+                return;
+            }
+            if (this.rootPath !== null) {
+                const path = fileURLToPath(url);
+                const relativePath = relative(this.rootPath, path);
+                if (relativePath.startsWith('..')) {
+                    throw new Error(`Import map cannot reference '${path}' as it's outside of the base directory '${this.rootPath}'`);
+                }
+            }
+            filteredImports[specifier] = url.toString();
+        });
+        return filteredImports;
+    }
+    // Takes a `scopes` object and runs all imports through `filterImports`,
+    // omitting any scopes for which there are no imports.
+    filterScopes(scopes) {
+        const filteredScopes = {};
+        if (scopes !== undefined) {
+            Object.keys(scopes).forEach((url) => {
+                const imports = this.filterImports(scopes[url]);
+                if (Object.keys(imports).length === 0) {
+                    return;
+                }
+                filteredScopes[url] = imports;
+            });
+        }
+        return filteredScopes;
+    }
+    // Returns the import map as a plain object, with any relative paths resolved
+    // to full URLs. It takes an optional `prefixes` object that specifies a list
+    // of prefixes to replace path prefixes (see `applyPrefixesToPath`). Prefixes
+    // will be applied on both `imports` and `scopes`.
+    getContents(prefixes = {}) {
         let imports = {};
         let scopes = {};
         this.sources.forEach((file) => {
-            const importMap = ImportMap.resolve(file, basePath, prefix);
+            const importMap = this.resolve(file);
             imports = { ...imports, ...importMap.imports };
             scopes = { ...scopes, ...importMap.scopes };
         });
@@ -104,11 +112,49 @@ class ImportMap {
             const [specifier, url] = internalImport;
             imports[specifier] = url;
         });
+        const transformedImports = ImportMap.applyPrefixesToImports(imports, prefixes);
+        const transformedScopes = Object.entries(scopes).reduce((acc, [key, value]) => ({
+            ...acc,
+            [ImportMap.applyPrefixesToPath(key, prefixes)]: ImportMap.applyPrefixesToImports(value, prefixes),
+        }), {});
+        return {
+            imports: transformedImports,
+            scopes: transformedScopes,
+        };
+    }
+    static async readFile(path, logger) {
+        const baseURL = pathToFileURL(path);
+        try {
+            const data = await fs.readFile(path, 'utf8');
+            const importMap = JSON.parse(data);
+            return {
+                ...importMap,
+                baseURL,
+            };
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                logger.system(`Did not find an import map file at '${path}'.`);
+            }
+            else {
+                logger.user(`Error while loading import map at '${path}':`, error);
+            }
+        }
         return {
-            imports,
-            scopes,
+            baseURL,
+            imports: {},
         };
     }
+    // Resolves an import map file by transforming all relative paths into full
+    // URLs. The `baseURL` property of each file is used to resolve all relative
+    // paths against.
+    resolve(source) {
+        const { baseURL, ...importMap } = source;
+        const parsedImportMap = parse(importMap, baseURL);
+        const imports = this.filterImports(parsedImportMap.imports);
+        const scopes = this.filterScopes(parsedImportMap.scopes);
+        return { ...parsedImportMap, imports, scopes };
+    }
     toDataURL() {
         const data = JSON.stringify(this.getContents());
         const encodedImportMap = Buffer.from(data).toString('base64');
@@ -121,27 +167,3 @@ class ImportMap {
         await fs.writeFile(path, JSON.stringify(contents));
     }
 }
-const readFile = async (path, logger) => {
-    const baseURL = pathToFileURL(path);
-    try {
-        const data = await fs.readFile(path, 'utf8');
-        const importMap = JSON.parse(data);
-        return {
-            ...importMap,
-            baseURL,
-        };
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            logger.system(`Did not find an import map file at '${path}'.`);
-        }
-        else {
-            logger.user(`Error while loading import map at '${path}':`, error);
-        }
-    }
-    return {
-        baseURL,
-        imports: {},
-    };
-};
-export { ImportMap, readFile };

package/dist/node/import_map.test.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { cwd } from 'process';
 import { pathToFileURL } from 'url';
 import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
+import { describe, test, expect } from 'vitest';
 import { ImportMap } from './import_map.js';
 test('Handles import maps with full URLs without specifying a base URL', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
@@ -39,35 +39,79 @@ test('Resolves relative paths to absolute paths if a base path is not provided',
     expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
 });
-test('Transforms relative paths so that they become relative to the base path', () => {
-    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
+describe('Returns the fully resolved import map', () => {
     const inputFile1 = {
-        baseURL: pathToFileURL(basePath),
+        baseURL: new URL('file:///some/full/path/import-map.json'),
         imports: {
-            'alias:pets': './heart/pets/',
+            specifier1: 'file:///some/full/path/file.js',
+            specifier2: './file2.js',
+            specifier3: 'file:///different/full/path/file3.js',
         },
     };
-    // Without a prefix.
-    const map1 = new ImportMap([inputFile1]);
-    const { imports: imports1 } = map1.getContents(cwd());
-    expect(imports1['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports1['alias:pets']).toBe('file:///my-cool-site/heart/pets/');
-    // With a prefix.
-    const map2 = new ImportMap([inputFile1]);
-    const { imports: imports2 } = map2.getContents(cwd(), 'file:///root/');
-    expect(imports2['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports2['alias:pets']).toBe('file:///root/my-cool-site/heart/pets/');
+    const inputFile2 = {
+        baseURL: new URL('file:///some/cool/path/import-map.json'),
+        imports: {
+            'lib/*': './library/',
+        },
+        scopes: {
+            'with/scopes/': {
+                'lib/*': 'https://external.netlify/lib/',
+                foo: './foo-alias',
+                bar: 'file:///different/full/path/bar.js',
+            },
+        },
+    };
+    test('Without prefixes', () => {
+        const map = new ImportMap([inputFile1, inputFile2]);
+        const { imports, scopes } = map.getContents();
+        expect(imports).toStrictEqual({
+            'lib/*': 'file:///some/cool/path/library/',
+            specifier3: 'file:///different/full/path/file3.js',
+            specifier2: 'file:///some/full/path/file2.js',
+            specifier1: 'file:///some/full/path/file.js',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+        });
+        expect(scopes).toStrictEqual({
+            'file:///some/cool/path/with/scopes/': {
+                'lib/*': 'https://external.netlify/lib/',
+                foo: 'file:///some/cool/path/foo-alias',
+                bar: 'file:///different/full/path/bar.js',
+            },
+        });
+    });
+    test('With prefixes', () => {
+        const map = new ImportMap([inputFile1, inputFile2]);
+        const { imports, scopes } = map.getContents({
+            'file:///some/': 'file:///root/',
+            'file:///different/': 'file:///vendor/',
+        });
+        expect(imports).toStrictEqual({
+            'lib/*': 'file:///root/cool/path/library/',
+            specifier3: 'file:///vendor/full/path/file3.js',
+            specifier2: 'file:///root/full/path/file2.js',
+            specifier1: 'file:///root/full/path/file.js',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+        });
+        expect(scopes).toStrictEqual({
+            'file:///root/cool/path/with/scopes/': {
+                'lib/*': 'https://external.netlify/lib/',
+                foo: 'file:///root/cool/path/foo-alias',
+                bar: 'file:///vendor/full/path/bar.js',
+            },
+        });
+    });
 });
 test('Throws when an import map uses a relative path to reference a file outside of the base path', () => {
-    const basePath = join(cwd(), 'my-cool-site');
     const inputFile1 = {
-        baseURL: pathToFileURL(join(basePath, 'import_map.json')),
+        baseURL: pathToFileURL(join(cwd(), 'import-map.json')),
         imports: {
             'alias:file': '../file.js',
         },
     };
-    const map = new ImportMap([inputFile1]);
-    expect(() => map.getContents(basePath)).toThrowError(`Import map cannot reference '${join(cwd(), 'file.js')}' as it's outside of the base directory '${basePath}'`);
+    const map = new ImportMap([inputFile1], pathToFileURL(cwd()).toString());
+    expect(() => map.getContents()).toThrowError(`Import map cannot reference '${join(cwd(), '..', 'file.js')}' as it's outside of the base directory '${cwd()}'`);
 });
 test('Writes import map file to disk', async () => {
     const file = await tmp.file();

package/dist/node/manifest.d.ts

@@ -8,6 +8,8 @@ interface Route {
     function: string;
     pattern: string;
     excluded_patterns: string[];
+    path?: string;
+    methods?: string[];
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];

package/dist/node/manifest.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
-import globToRegExp from 'glob-to-regexp';
+import { wrapBundleError } from './bundle_error.js';
 import { parsePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
@@ -26,13 +26,26 @@ const sanitizeEdgeFunctionConfig = (config) => {
     }
     return newConfig;
 };
-const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath, featureFlags) => {
+const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath) => {
     if (excludedPath) {
         const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
-        const excludedPatterns = paths.map((path) => pathToRegularExpression(path, featureFlags)).map(serializePattern);
+        const excludedPatterns = paths.map((path) => pathToRegularExpression(path)).map(serializePattern);
         manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
     }
 };
+/**
+ * Normalizes method names into arrays of uppercase strings.
+ * (e.g. "get" becomes ["GET"])
+ */
+const normalizeMethods = (method, name) => {
+    const methods = Array.isArray(method) ? method : [method];
+    return methods.map((method) => {
+        if (typeof method !== 'string') {
+            throw new TypeError(`Could not parse method declaration of function '${name}'. Expecting HTTP Method, got ${method}`);
+        }
+        return method.toUpperCase();
+    });
+};
 const generateManifest = ({ bundles = [], declarations = [], featureFlags, functions, userFunctionConfig = {}, internalFunctionConfig = {}, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
@@ -42,7 +55,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath, featureFlags);
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
         manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
     }
     for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
@@ -50,7 +63,7 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
-        addExcludedPatterns(name, manifestFunctionConfig, excludedPath, featureFlags);
+        addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
         manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
     }
     declarations.forEach((declaration) => {
@@ -65,6 +78,12 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             pattern: serializePattern(pattern),
             excluded_patterns: excludedPattern.map(serializePattern),
         };
+        if ('method' in declaration) {
+            route.methods = normalizeMethods(declaration.method, func.name);
+        }
+        if ('path' in declaration) {
+            route.path = declaration.path;
+        }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
         }
@@ -87,8 +106,8 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
     };
     return manifest;
 };
-const pathToRegularExpression = (path, featureFlags) => {
-    if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_path_urlpattern) {
+const pathToRegularExpression = (path) => {
+    try {
         const pattern = new ExtendedURLPattern({ pathname: path });
         // Removing the `^` and `$` delimiters because we'll need to modify what's
         // between them.
@@ -99,14 +118,9 @@ const pathToRegularExpression = (path, featureFlags) => {
         const normalizedSource = `^${source}\\/?$`;
         return normalizedSource;
     }
-    // We use the global flag so that `globToRegExp` will not wrap the expression
-    // with `^` and `$`. We'll do that ourselves.
-    const regularExpression = globToRegExp(path, { flags: 'g' });
-    // Wrapping the expression source with `^` and `$`. Also, adding an optional
-    // trailing slash, so that a declaration of `path: "/foo"` matches requests
-    // for both `/foo` and `/foo/`.
-    const normalizedSource = `^${regularExpression.source}\\/?$`;
-    return normalizedSource;
+    catch (error) {
+        throw wrapBundleError(error);
+    }
 };
 const getRegularExpression = (declaration, featureFlags) => {
     if ('pattern' in declaration) {
@@ -122,7 +136,7 @@ const getRegularExpression = (declaration, featureFlags) => {
             return declaration.pattern;
         }
     }
-    return pathToRegularExpression(declaration.path, featureFlags);
+    return pathToRegularExpression(declaration.path);
 };
 const getExcludedRegularExpressions = (declaration, featureFlags) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
@@ -144,7 +158,7 @@ const getExcludedRegularExpressions = (declaration, featureFlags) => {
     }
     if ('path' in declaration && declaration.excludedPath) {
         const paths = Array.isArray(declaration.excludedPath) ? declaration.excludedPath : [declaration.excludedPath];
-        return paths.map((path) => pathToRegularExpression(path, featureFlags));
+        return paths.map((path) => pathToRegularExpression(path));
     }
     return [];
 };

package/dist/node/manifest.test.js

@@ -2,6 +2,7 @@ import { env } from 'process';
 import { test, expect, vi } from 'vitest';
 import { getRouteMatcher } from '../test/util.js';
 import { BundleFormat } from './bundle.js';
+import { BundleError } from './bundle_error.js';
 import { generateManifest } from './manifest.js';
 test('Generates a manifest with different bundles', () => {
     const bundle1 = {
@@ -21,7 +22,7 @@ test('Generates a manifest with different bundles', () => {
         { asset: bundle1.hash + bundle1.extension, format: bundle1.format },
         { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
     ];
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
@@ -39,9 +40,8 @@ test('Generates a manifest with display names', () => {
         declarations,
         functions,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
     expect(manifest.function_config).toEqual({
         'func-1': { name: 'Display Name' },
     });
@@ -61,9 +61,8 @@ test('Generates a manifest with a generator field', () => {
         declarations,
         functions,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
     const expectedFunctionConfig = { 'func-1': { generator: '@netlify/fake-plugin@1.0.0' } };
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual(expectedFunctionConfig);
@@ -84,15 +83,19 @@ test('Generates a manifest with excluded paths and patterns', () => {
         bundles: [],
         declarations,
         functions,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: ['^/f1/exclude/?$'] },
-        { function: 'func-2', pattern: '^/f2(?:/(.*))/?$', excluded_patterns: ['^/f2/exclude$', '^/f2/exclude-as-well$'] },
+        { function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: ['^/f1/exclude/?$'], path: '/f1/*' },
+        {
+            function: 'func-2',
+            pattern: '^/f2(?:/(.*))/?$',
+            excluded_patterns: ['^/f2/exclude$', '^/f2/exclude-as-well$'],
+        },
         {
             function: 'func-3',
             pattern: '^(?:/(.*))/?$',
             excluded_patterns: ['^(?:/((?:.*)(?:/(?:.*))*))?(?:/(.*))\\.html/?$'],
+            path: '/*',
         },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
@@ -113,9 +116,8 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
         declarations,
         functions,
         userFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual({
         'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
@@ -190,18 +192,19 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
         functions,
         userFunctionConfig,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     expect(manifest.routes).toEqual([
         {
             function: 'customisation',
             pattern: '^/showcases(?:/(.*))/?$',
             excluded_patterns: [],
+            path: '/showcases/*',
         },
         {
             function: 'customisation',
             pattern: '^/checkout(?:/(.*))/?$',
             excluded_patterns: ['^(?:/(.*))/terms-and-conditions/?$'],
+            path: '/checkout/*',
         },
     ]);
     expect(manifest.function_config).toEqual({
@@ -216,6 +219,42 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
     expect(matcher('/checkout/scrooge-mc-duck-animation.css')).toBeUndefined();
     expect(matcher('/showcases/boho-style/expensive-chair.jpg')).toBeUndefined();
 });
+test('URLPattern named groups are supported', () => {
+    const functions = [{ name: 'customisation', path: '/path/to/customisation.ts' }];
+    const declarations = [{ function: 'customisation', path: '/products/:productId' }];
+    const userFunctionConfig = {};
+    const internalFunctionConfig = {};
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+        internalFunctionConfig,
+    });
+    expect(manifest.routes).toEqual([
+        {
+            function: 'customisation',
+            pattern: '^/products(?:/([^/]+?))/?$',
+            excluded_patterns: [],
+            path: '/products/:productId',
+        },
+    ]);
+    const matcher = getRouteMatcher(manifest);
+    expect(matcher('/products/jigsaw-doweling-jig')).toBeDefined();
+});
+test('Invalid Path patterns throw bundling errors', () => {
+    const functions = [{ name: 'customisation', path: '/path/to/customisation.ts' }];
+    const declarations = [{ function: 'customisation', path: '/https://foo.netlify.app/' }];
+    const userFunctionConfig = {};
+    const internalFunctionConfig = {};
+    expect(() => generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+        internalFunctionConfig,
+    })).toThrowError(BundleError);
+});
 test('Includes failure modes in manifest', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
@@ -247,7 +286,7 @@ test('Excludes functions for which there are function files but no matching conf
     ];
     const declarations = [{ function: 'func-1', path: '/f1' }];
     const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
 test('Excludes functions for which there are config declarations but no matching function files', () => {
@@ -262,14 +301,14 @@ test('Excludes functions for which there are config declarations but no matching
         { function: 'func-2', path: '/f2' },
     ];
     const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
-    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$', excluded_patterns: [], path: '/f2' }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
 test('Generates a manifest without bundles', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', path: '/f1' }];
     const manifest = generateManifest({ bundles: [], declarations, functions });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.bundles).toEqual([]);
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
@@ -301,10 +340,12 @@ test('Generates a manifest with pre and post-cache routes', () => {
         { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
     ];
     const expectedPreCacheRoutes = [
-        { function: 'func-1', name: undefined, pattern: '^/f1/?$', excluded_patterns: [] },
-        { function: 'func-2', name: undefined, pattern: '^/f2/?$', excluded_patterns: [] },
+        { function: 'func-1', name: undefined, pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' },
+        { function: 'func-2', name: undefined, pattern: '^/f2/?$', excluded_patterns: [], path: '/f2' },
+    ];
+    const expectedPostCacheRoutes = [
+        { function: 'func-3', name: undefined, pattern: '^/f3/?$', excluded_patterns: [], path: '/f3' },
     ];
-    const expectedPostCacheRoutes = [{ function: 'func-3', name: undefined, pattern: '^/f3/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedPreCacheRoutes);
     expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
@@ -320,8 +361,8 @@ test('Generates a manifest with layers', () => {
         { function: 'func-2', path: '/f2/*' },
     ];
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [] },
-        { function: 'func-2', pattern: '^/f2(?:/(.*))/?$', excluded_patterns: [] },
+        { function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' },
+        { function: 'func-2', pattern: '^/f2(?:/(.*))/?$', excluded_patterns: [], path: '/f2/*' },
     ];
     const layers = [
         {
@@ -333,14 +374,12 @@ test('Generates a manifest with layers', () => {
         bundles: [],
         declarations,
         functions,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     const manifest2 = generateManifest({
         bundles: [],
         declarations,
         functions,
         layers,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     expect(manifest1.routes).toEqual(expectedRoutes);
     expect(manifest1.layers).toEqual([]);

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

@@ -47,6 +47,16 @@ declare const edgeManifestSchema: {
                     generator: {
                         type: string;
                     };
+                    path: {
+                        type: string;
+                    };
+                    methods: {
+                        type: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -79,6 +89,16 @@ declare const edgeManifestSchema: {
                     generator: {
                         type: string;
                     };
+                    path: {
+                        type: string;
+                    };
+                    methods: {
+                        type: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };

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

@@ -28,6 +28,11 @@ const routesSchema = {
         },
         excluded_patterns: excludedPatternsSchema,
         generator: { type: 'string' },
+        path: { type: 'string' },
+        methods: {
+            type: 'array',
+            items: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'] },
+        },
     },
     additionalProperties: false,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.17.1",
+  "version": "8.19.0",
   "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-v8": "^0.33.0",
+    "@vitest/coverage-v8": "^0.34.0",
     "archiver": "^5.3.1",
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
@@ -67,7 +67,7 @@
     "nock": "^13.2.4",
     "tar": "^6.1.11",
     "typescript": "^5.0.0",
-    "vitest": "^0.33.0"
+    "vitest": "^0.34.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
@@ -82,7 +82,6 @@
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",
-    "glob-to-regexp": "^0.4.1",
     "is-path-inside": "^4.0.0",
     "jsonc-parser": "^3.2.0",
     "node-fetch": "^3.1.1",