@netlify/edge-bundler 8.18.0 → 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);
@@ -179,6 +179,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func2/?$',
         excluded_patterns: [],
         path: '/user-func2',
+        methods: ['PATCH'],
     });
     expect(routes[2]).toEqual({
         function: 'framework-func1',
@@ -203,6 +204,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func5(?:/(.*))/?$',
         excluded_patterns: [],
         path: '/user-func5/*',
+        methods: ['GET'],
     });
     expect(postCacheRoutes.length).toBe(1);
     expect(postCacheRoutes[0]).toEqual({
@@ -210,6 +212,7 @@ test('Loads function paths from the in-source `config` function', async () => {
         pattern: '^/user-func4/?$',
         excluded_patterns: [],
         path: '/user-func4',
+        methods: ['POST', 'PUT'],
     });
     expect(Object.keys(functionConfig)).toHaveLength(1);
     expect(functionConfig['user-func5']).toEqual({

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/import_map.js

@@ -5,6 +5,7 @@ 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

package/dist/node/import_map.test.js

@@ -69,6 +69,7 @@ describe('Returns the fully resolved import map', () => {
             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({
@@ -90,6 +91,7 @@ describe('Returns the fully resolved import map', () => {
             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({

package/dist/node/manifest.d.ts

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

package/dist/node/manifest.js

@@ -1,6 +1,5 @@
 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';
@@ -27,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 = [];
@@ -43,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)) {
@@ -51,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) => {
@@ -66,6 +78,9 @@ 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;
         }
@@ -91,31 +106,21 @@ 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) {
-        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);
-        }
+const pathToRegularExpression = (path) => {
+    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.
-    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;
 };
 const getRegularExpression = (declaration, featureFlags) => {
     if ('pattern' in declaration) {
@@ -131,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) {
@@ -153,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

@@ -40,7 +40,6 @@ 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: [], path: '/f1/*' }];
     expect(manifest.function_config).toEqual({
@@ -62,7 +61,6 @@ 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: [], path: '/f1/*' }];
     const expectedFunctionConfig = { 'func-1': { generator: '@netlify/fake-plugin@1.0.0' } };
@@ -85,7 +83,6 @@ 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/?$'], path: '/f1/*' },
@@ -119,7 +116,6 @@ 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: [], path: '/f1/*' }];
     expect(manifest.routes).toEqual(expectedRoutes);
@@ -196,7 +192,6 @@ 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([
         {
@@ -235,7 +230,6 @@ test('URLPattern named groups are supported', () => {
         functions,
         userFunctionConfig,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     });
     expect(manifest.routes).toEqual([
         {
@@ -259,7 +253,6 @@ test('Invalid Path patterns throw bundling errors', () => {
         functions,
         userFunctionConfig,
         internalFunctionConfig,
-        featureFlags: { edge_functions_path_urlpattern: true },
     })).toThrowError(BundleError);
 });
 test('Includes failure modes in manifest', () => {
@@ -381,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

@@ -50,6 +50,13 @@ declare const edgeManifestSchema: {
                     path: {
                         type: string;
                     };
+                    methods: {
+                        type: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -85,6 +92,13 @@ declare const edgeManifestSchema: {
                     path: {
                         type: string;
                     };
+                    methods: {
+                        type: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };

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

@@ -29,6 +29,10 @@ 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.18.0",
+  "version": "8.19.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -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",