@netlify/edge-bundler 11.3.0 → 11.4.0

package/dist/node/config.d.ts

@@ -2,6 +2,7 @@ import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
+import { RateLimit } from './rate_limit.js';
 export declare const enum Cache {
     Off = "off",
     Manual = "manual"
@@ -18,6 +19,7 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
     method?: HTTPMethod | HTTPMethod[];
+    rateLimit?: RateLimit;
 }
 export declare const getFunctionConfig: ({ func, importMap, deno, log, }: {
     func: EdgeFunction;

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';
+import { RateLimitAction, RateLimitAggregator } from './rate_limit.js';
 const importMapFile = {
     baseURL: new URL('file:///some/path/import-map.json'),
     imports: {
@@ -64,7 +65,7 @@ const functions = [
     },
     {
         testName: 'config with wrong onError',
-        name: 'func7',
+        name: 'func6',
         source: `
       export default async () => new Response("Hello from function two")
       export const config = { onError: "foo" }
@@ -74,7 +75,7 @@ const functions = [
     {
         testName: 'config with `path`',
         expectedConfig: { path: '/home' },
-        name: 'func6',
+        name: 'func7',
         source: `
         export default async () => new Response("Hello from function three")
 
@@ -89,17 +90,74 @@ const functions = [
             name: 'a displayName',
             onError: 'bypass',
         },
-        name: 'func6',
+        name: 'func8',
         source: `
         export default async () => new Response("Hello from function three")
 
-        export const config = { path: "/home",
+        export const config = {
+          path: "/home",
           generator: '@netlify/fake-plugin@1.0.0',
           name: 'a displayName',
           onError: 'bypass',
         }
       `,
     },
+    {
+        testName: 'config with ratelimit',
+        expectedConfig: {
+            path: '/ratelimit',
+            name: 'a limit rate',
+            rateLimit: {
+                windowSize: 10,
+                windowLimit: 100,
+                aggregateBy: [RateLimitAggregator.IP, RateLimitAggregator.Domain],
+            },
+        },
+        name: 'func9',
+        source: `
+        export default async () => new Response("Rate my limits")
+
+        export const config = {
+          path: "/ratelimit",
+          rateLimit: {
+            windowSize: 10,
+            windowLimit: 100,
+            aggregateBy: ["ip", "domain"],
+          },
+          name: 'a limit rate',
+        }
+      `,
+    },
+    {
+        testName: 'config with rewrite',
+        expectedConfig: {
+            path: '/rewrite',
+            name: 'a limit rewrite',
+            rateLimit: {
+                action: RateLimitAction.Rewrite,
+                to: '/rewritten',
+                windowSize: 20,
+                windowLimit: 200,
+                aggregateBy: [RateLimitAggregator.IP, RateLimitAggregator.Domain],
+            },
+        },
+        name: 'func9',
+        source: `
+        export default async () => new Response("Rate my limits")
+
+        export const config = {
+          path: "/rewrite",
+          rateLimit: {
+            action: "rewrite",
+            to: "/rewritten",
+            windowSize: 20,
+            windowLimit: 200,
+            aggregateBy: ["ip", "domain"],
+          },
+          name: 'a limit rewrite',
+        }
+      `,
+    },
 ];
 describe('`getFunctionConfig` extracts configuration properties from function file', () => {
     test.each(functions)('$testName', async (func) => {

package/dist/node/manifest.d.ts

@@ -11,11 +11,30 @@ interface Route {
     path?: string;
     methods?: string[];
 }
+interface TrafficRules {
+    action: {
+        type: string;
+        config: {
+            rate_limit_config: {
+                algorithm: string;
+                window_size: number;
+                window_limit: number;
+            };
+            aggregate: {
+                keys: {
+                    type: string;
+                }[];
+            };
+            to?: string;
+        };
+    };
+}
 export interface EdgeFunctionConfig {
     excluded_patterns: string[];
     on_error?: string;
     generator?: string;
     name?: string;
+    traffic_rules?: TrafficRules;
 }
 interface Manifest {
     bundler_version: string;

package/dist/node/manifest.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import { wrapBundleError } from './bundle_error.js';
 import { normalizePattern } from './declaration.js';
 import { getPackageVersion } from './package_json.js';
+import { RateLimitAction, RateLimitAlgorithm, RateLimitAggregator } from './rate_limit.js';
 import { nonNullable } from './utils/non_nullable.js';
 import { ExtendedURLPattern } from './utils/urlpattern.js';
 const removeEmptyConfigValues = (functionConfig) => Object.entries(functionConfig).reduce((acc, [key, value]) => {
@@ -52,21 +53,30 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
     const routedFunctions = new Set();
     const declarationsWithoutFunction = new Set();
-    for (const [name, { excludedPath, onError }] of Object.entries(userFunctionConfig)) {
+    for (const [name, { excludedPath, onError, rateLimit }] of Object.entries(userFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
         addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
-        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError };
+        manifestFunctionConfig[name] = {
+            ...manifestFunctionConfig[name],
+            on_error: onError,
+            traffic_rules: getTrafficRulesConfig(rateLimit),
+        };
     }
-    for (const [name, { excludedPath, path, onError, ...rest }] of Object.entries(internalFunctionConfig)) {
+    for (const [name, { excludedPath, path, onError, rateLimit, ...rest }] of Object.entries(internalFunctionConfig)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
             continue;
         }
         addExcludedPatterns(name, manifestFunctionConfig, excludedPath);
-        manifestFunctionConfig[name] = { ...manifestFunctionConfig[name], on_error: onError, ...rest };
+        manifestFunctionConfig[name] = {
+            ...manifestFunctionConfig[name],
+            on_error: onError,
+            traffic_rules: getTrafficRulesConfig(rateLimit),
+            ...rest,
+        };
     }
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
@@ -116,6 +126,29 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     const unroutedFunctions = functions.filter(({ name }) => !routedFunctions.has(name)).map(({ name }) => name);
     return { declarationsWithoutFunction: [...declarationsWithoutFunction], manifest, unroutedFunctions };
 };
+const getTrafficRulesConfig = (rl) => {
+    if (rl === undefined) {
+        return;
+    }
+    const rateLimitAgg = Array.isArray(rl.aggregateBy) ? rl.aggregateBy : [RateLimitAggregator.Domain];
+    const rewriteConfig = 'to' in rl && typeof rl.to === 'string' ? { to: rl.to } : undefined;
+    return {
+        action: {
+            type: rl.action || RateLimitAction.Limit,
+            config: {
+                ...rewriteConfig,
+                rate_limit_config: {
+                    window_limit: rl.windowLimit,
+                    window_size: rl.windowSize,
+                    algorithm: RateLimitAlgorithm.SlidingWindow,
+                },
+                aggregate: {
+                    keys: rateLimitAgg.map((agg) => ({ type: agg })),
+                },
+            },
+        },
+    };
+};
 const pathToRegularExpression = (path) => {
     if (!path) {
         return null;

package/dist/node/manifest.test.js

@@ -4,6 +4,7 @@ import { getRouteMatcher } from '../test/util.js';
 import { BundleFormat } from './bundle.js';
 import { BundleError } from './bundle_error.js';
 import { generateManifest } from './manifest.js';
+import { RateLimitAction, RateLimitAggregator } from './rate_limit.js';
 test('Generates a manifest with different bundles', () => {
     const bundle1 = {
         extension: '.ext1',
@@ -433,3 +434,82 @@ test('Returns functions without a declaration and unrouted functions', () => {
     expect(declarationsWithoutFunction).toEqual(['func-3']);
     expect(unroutedFunctions).toEqual(['func-2', 'func-4']);
 });
+test('Generates a manifest with rate limit config', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': { rateLimit: { windowLimit: 100, windowSize: 60 } },
+    };
+    const { manifest } = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
+    const expectedFunctionConfig = {
+        'func-1': {
+            traffic_rules: {
+                action: {
+                    type: 'rate_limit',
+                    config: {
+                        rate_limit_config: {
+                            window_limit: 100,
+                            window_size: 60,
+                            algorithm: 'sliding_window',
+                        },
+                        aggregate: {
+                            keys: [{ type: 'domain' }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});
+test('Generates a manifest with rewrite config', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1/*' }];
+    const userFunctionConfig = {
+        'func-1': {
+            rateLimit: {
+                action: RateLimitAction.Rewrite,
+                to: '/new_path',
+                windowLimit: 100,
+                windowSize: 60,
+                aggregateBy: [RateLimitAggregator.Domain, RateLimitAggregator.IP],
+            },
+        },
+    };
+    const { manifest } = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1(?:/(.*))/?$', excluded_patterns: [], path: '/f1/*' }];
+    const expectedFunctionConfig = {
+        'func-1': {
+            traffic_rules: {
+                action: {
+                    type: 'rewrite',
+                    config: {
+                        to: '/new_path',
+                        rate_limit_config: {
+                            window_limit: 100,
+                            window_size: 60,
+                            algorithm: 'sliding_window',
+                        },
+                        aggregate: {
+                            keys: [{ type: 'domain' }, { type: 'ip' }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.function_config).toEqual(expectedFunctionConfig);
+});

package/dist/node/rate_limit.d.ts

@@ -0,0 +1,25 @@
+export declare enum RateLimitAlgorithm {
+    SlidingWindow = "sliding_window"
+}
+export declare enum RateLimitAggregator {
+    Domain = "domain",
+    IP = "ip"
+}
+export declare enum RateLimitAction {
+    Limit = "rate_limit",
+    Rewrite = "rewrite"
+}
+interface SlidingWindow {
+    windowLimit: number;
+    windowSize: number;
+}
+export type RewriteActionConfig = SlidingWindow & {
+    to: string;
+};
+interface RateLimitConfig {
+    action?: RateLimitAction;
+    aggregateBy?: RateLimitAggregator | RateLimitAggregator[];
+    algorithm?: RateLimitAlgorithm;
+}
+export type RateLimit = RateLimitConfig & (SlidingWindow | RewriteActionConfig);
+export {};

package/dist/node/rate_limit.js

@@ -0,0 +1,14 @@
+export var RateLimitAlgorithm;
+(function (RateLimitAlgorithm) {
+    RateLimitAlgorithm["SlidingWindow"] = "sliding_window";
+})(RateLimitAlgorithm || (RateLimitAlgorithm = {}));
+export var RateLimitAggregator;
+(function (RateLimitAggregator) {
+    RateLimitAggregator["Domain"] = "domain";
+    RateLimitAggregator["IP"] = "ip";
+})(RateLimitAggregator || (RateLimitAggregator = {}));
+export var RateLimitAction;
+(function (RateLimitAction) {
+    RateLimitAction["Limit"] = "rate_limit";
+    RateLimitAction["Rewrite"] = "rewrite";
+})(RateLimitAction || (RateLimitAction = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -81,7 +81,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.20.0",
+    "esbuild": "0.20.2",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-package-name": "^2.2.0",