@netlify/edge-bundler 8.17.0 → 8.18.0

package/deno/config.ts

@@ -1,6 +1,9 @@
-const [functionURL, collectorURL, rawExitCodes] = Deno.args
+const [functionURL, collectorURL, bootstrapURL, rawExitCodes] = Deno.args
 const exitCodes = JSON.parse(rawExitCodes)
 
+const { Netlify } = await import(bootstrapURL)
+globalThis.Netlify = Netlify
+
 let func
 
 try {

package/dist/node/bundler.d.ts

@@ -14,8 +14,9 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
     internalSrcFolder?: string;
+    bootstrapURL?: 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<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, bootstrapURL, }?: BundleOptions) => Promise<{
     functions: import("./edge_function.js").EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -14,7 +14,7 @@ import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts', } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -63,8 +63,8 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     await createFinalBundles([functionBundle], distDirectory, buildID);
     // Retrieving a configuration object for each function.
     // 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)]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
     // Creating a hash of function names to configuration objects.
     const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
     const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));

package/dist/node/config.d.ts

@@ -17,4 +17,10 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: ({ func, importMap, deno, bootstrapURL, log, }: {
+    func: EdgeFunction;
+    importMap: ImportMap;
+    deno: DenoBridge;
+    bootstrapURL: string;
+    log: Logger;
+}) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -26,7 +26,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async (func, importMap, deno, log) => {
+export const getFunctionConfig = async ({ func, importMap, deno, bootstrapURL, log, }) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -50,6 +50,7 @@ export const getFunctionConfig = async (func, importMap, deno, log) => {
         extractorPath,
         pathToFileURL(func.path).href,
         pathToFileURL(collector.path).href,
+        bootstrapURL,
         JSON.stringify(ConfigExitCode),
     ], { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {

package/dist/node/config.test.js

@@ -9,6 +9,7 @@ import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
 import { ImportMap } from './import_map.js';
+const bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts';
 const importMapFile = {
     baseURL: new URL('file:///some/path/import-map.json'),
     imports: {
@@ -114,9 +115,15 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
         const path = join(tmpDir, `${func.name}.js`);
         await fs.writeFile(path, func.source);
         const funcCall = () => getFunctionConfig({
-            name: func.name,
-            path,
-        }, new ImportMap([importMapFile]), deno, logger);
+            func: {
+                name: func.name,
+                path,
+            },
+            importMap: new ImportMap([importMapFile]),
+            deno,
+            log: logger,
+            bootstrapURL,
+        });
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
         }
@@ -161,14 +168,49 @@ 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',
+    });
+    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/*',
+    });
     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',
+    });
     expect(Object.keys(functionConfig)).toHaveLength(1);
     expect(functionConfig['user-func5']).toEqual({
         excluded_patterns: ['^/user-func5/excluded/?$'],
@@ -194,9 +236,15 @@ test('Passes validation if default export exists and is a function', async () =>
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     await expect(getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    })).resolves.not.toThrow();
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not function', async () => {
@@ -218,9 +266,15 @@ test('Fails validation if default export is not function', async () => {
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     const config = getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger);
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
@@ -242,9 +296,15 @@ test('Fails validation if default export is not present', async () => {
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     const config = getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger);
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/declaration.js

@@ -66,7 +66,12 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 // Validates and normalizes a pattern so that it's a valid regular expression
 // in Go, which is the engine used by our edge nodes.
 export const parsePattern = (pattern) => {
-    const regexp = new RegExp(pattern);
+    let enclosedPattern = pattern;
+    if (!pattern.startsWith('^'))
+        enclosedPattern = `^${enclosedPattern}`;
+    if (!pattern.endsWith('$'))
+        enclosedPattern = `${enclosedPattern}$`;
+    const regexp = new RegExp(enclosedPattern);
     const newRegexp = regexpAST.transform(regexp, {
         Assertion(path) {
             // Lookaheads are not supported. If we find one, throw an error.

package/dist/node/declaration.test.js

@@ -126,3 +126,9 @@ test('Escapes front slashes in a regex pattern', () => {
     const actual = parsePattern(regexPattern);
     expect(actual).toEqual(expected);
 });
+test('Ensures pattern match on the whole path', () => {
+    const regexPattern = '/foo/.*/bar';
+    const expected = '^\\/foo\\/.*\\/bar$';
+    const actual = parsePattern(regexPattern);
+    expect(actual).toEqual(expected);
+});

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,6 +1,6 @@
 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';
@@ -9,74 +9,19 @@ const INTERNAL_IMPORTS = {
 };
 // 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 +35,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 +111,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 +166,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,77 @@ 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': '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': '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,7 @@ interface Route {
     function: string;
     pattern: string;
     excluded_patterns: string[];
+    path?: string;
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];

package/dist/node/manifest.js

@@ -1,6 +1,7 @@
 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';
@@ -65,6 +66,9 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             pattern: serializePattern(pattern),
             excluded_patterns: excludedPattern.map(serializePattern),
         };
+        if ('path' in declaration) {
+            route.path = declaration.path;
+        }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
         }
@@ -89,15 +93,20 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
 };
 const pathToRegularExpression = (path, featureFlags) => {
     if (featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_path_urlpattern) {
-        const pattern = new ExtendedURLPattern({ pathname: path });
-        // Removing the `^` and `$` delimiters because we'll need to modify what's
-        // between them.
-        const source = pattern.regexp.pathname.source.slice(1, -1);
-        // 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 = `^${source}\\/?$`;
-        return normalizedSource;
+        try {
+            const pattern = new ExtendedURLPattern({ pathname: path });
+            // Removing the `^` and `$` delimiters because we'll need to modify what's
+            // between them.
+            const source = pattern.regexp.pathname.source.slice(1, -1);
+            // 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 = `^${source}\\/?$`;
+            return normalizedSource;
+        }
+        catch (error) {
+            throw wrapBundleError(error);
+        }
     }
     // We use the global flag so that `globToRegExp` will not wrap the expression
     // with `^` and `$`. We'll do that ourselves.

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);
@@ -41,7 +42,7 @@ test('Generates a manifest with display names', () => {
         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' },
     });
@@ -63,7 +64,7 @@ test('Generates a manifest with a generator field', () => {
         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);
@@ -87,12 +88,17 @@ test('Generates a manifest with excluded paths and patterns', () => {
         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);
@@ -115,7 +121,7 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
         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/?$'] },
@@ -197,11 +203,13 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
             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 +224,44 @@ 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,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    });
+    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,
+        featureFlags: { edge_functions_path_urlpattern: true },
+    })).toThrowError(BundleError);
+});
 test('Includes failure modes in manifest', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
@@ -247,7 +293,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 +308,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 +347,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 +368,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 = [
         {

package/dist/node/server/server.js

@@ -43,7 +43,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger)));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, bootstrapURL, log: logger })));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/dist/node/server/server.test.js

@@ -27,6 +27,10 @@ test('Starts a server and serves requests for edge functions', async () => {
             name: 'greet',
             path: join(paths.internal, 'greet.ts'),
         },
+        {
+            name: 'global_netlify',
+            path: join(paths.user, 'global_netlify.ts'),
+        },
     ];
     const options = {
         getFunctionsConfig: true,
@@ -35,7 +39,7 @@ test('Starts a server and serves requests for edge functions', async () => {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(success).toBe(true);
-    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}]);
+    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
     for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
         // @ts-expect-error TODO: Module graph is currently not typed
@@ -60,4 +64,15 @@ test('Starts a server and serves requests for edge functions', async () => {
     });
     expect(response2.status).toBe(200);
     expect(await response2.text()).toBe('HELLO!');
+    const response3 = await fetch(`http://0.0.0.0:${port}/global-netlify`, {
+        headers: {
+            'x-nf-edge-functions': 'global_netlify',
+            'x-ef-passthrough': 'passthrough',
+            'X-NF-Request-ID': uuidv4(),
+        },
+    });
+    expect(await response3.json()).toEqual({
+        global: 'i love netlify',
+        local: 'i love netlify',
+    });
 });

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

@@ -47,6 +47,9 @@ declare const edgeManifestSchema: {
                     generator: {
                         type: string;
                     };
+                    path: {
+                        type: string;
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -79,6 +82,9 @@ declare const edgeManifestSchema: {
                     generator: {
                         type: string;
                     };
+                    path: {
+                        type: string;
+                    };
                 };
                 additionalProperties: boolean;
             };

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

@@ -28,6 +28,7 @@ const routesSchema = {
         },
         excluded_patterns: excludedPatternsSchema,
         generator: { type: 'string' },
+        path: { type: 'string' },
     },
     additionalProperties: false,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.17.0",
+  "version": "8.18.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"