@netlify/edge-bundler 11.3.0 → 11.4.1

package/README.md

@@ -1,51 +1,4 @@
-[![Build](https://github.com/netlify/edge-bundler/workflows/Build/badge.svg)](https://github.com/netlify/edge-bundler/actions)
-[![Node](https://img.shields.io/node/v/@netlify/edge-bundler.svg?logo=node.js)](https://www.npmjs.com/package/@netlify/edge-bundler)
-
 # Edge Bundler
 
-Intelligently prepare Netlify Edge Functions for deployment.
-
-## Usage
-
-1. Install this module as a dependency in your project
-
-   ```
-   npm install @netlify/edge-bundler --save
-   ```
-
-2. Import it and create a bundle from a directory of Edge Functions and a list of declarations.
-
-   ```js
-   import { bundle } from '@netlify/edge-bundler'
-
-   // List of directories to search for Edge Functions.
-   const sourceDirectories = ['/repo/netlify/edge-functions', '/repo/.netlify/edge-functions']
-
-   // Directory where bundle should be placed.
-   const distDirectory = '/repo/.netlify/edge-functions-dist'
-
-   // List of Edge Functions declarations.
-   const declarations = [
-     { function: 'user-1', path: '/blog/*' },
-     { function: 'internal-2', path: '/' },
-   ]
-
-   await bundle(sourceDirectories, distDirectory, declarations)
-   ```
-
-## Vendored modules
-
-To avoid pulling in additional dependencies at runtime, this package vendors some Deno modules in the `deno/vendor`
-directory.
-
-You can recreate this directory by running `npm run vendor`.
-
-> [!WARNING]  
-> At the time of writing, the underlying Deno CLI command doesn't correctly pull the WASM binary required by the ESZIP
-> module. If you run the command to update the list of vendores modules, please ensure you're not deleting
-> `eszip_wasm_bg.wasm`.
-
-## Contributors
-
-Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for instructions on how to set up and work on this repository. Thanks
-for contributing!
+> [!IMPORTANT]  
+> This project was moved into the [Netlify Build monorepo](https://github.com/netlify/build/tree/main/packages/edge-bundler).

package/dist/node/bridge.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { type WriteStream } from 'fs';
 import { ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';

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/npm_dependencies.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
 interface VendorNPMSpecifiersOptions {

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/dist/node/server/server.d.ts

@@ -1,9 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { WriteStream } from 'fs';
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';

package/dist/node/utils/error.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 export declare const isNodeError: (error: any) => error is NodeJS.ErrnoException;
 export declare const isFileNotFoundError: (error: any) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "11.3.0",
+  "version": "11.4.1",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -75,13 +75,13 @@
   },
   "dependencies": {
     "@import-maps/resolve": "^1.0.1",
-    "@vercel/nft": "^0.26.0",
+    "@vercel/nft": "^0.29.0",
     "ajv": "^8.11.2",
     "ajv-errors": "^3.0.0",
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.20.0",
+    "esbuild": "0.25.1",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-package-name": "^2.2.0",