@netlify/edge-bundler 7.0.0 → 7.1.0

package/dist/node/bundler.test.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
 import process from 'process';
+import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect, vi } from 'vitest';
@@ -277,32 +278,46 @@ test('Loads declarations and import maps from the deploy configuration', async (
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles } = manifest;
+    const { bundles, routes } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    // respects excludedPath from deploy config
+    expect(routes[1].excluded_pattern).toEqual('^/func2/skip/?$');
     await cleanup();
 });
 test("Ignores entries in `importMapPaths` that don't point to an existing import map file", async () => {
     const systemLogger = vi.fn();
     const { basePath, cleanup, distPath } = await useFixture('with_import_maps');
-    const sourceDirectory = join(basePath, 'functions');
-    const importMapPath = join(distPath, 'some-file-that-does-not-exist.json');
-    const declarations = [
+    const sourceDirectory = join(basePath, 'user-functions');
+    // Creating import map file
+    const importMap = await tmp.file();
+    const importMapContents = {
+        imports: {
+            helper: pathToFileURL(join(basePath, 'helper.ts')).toString(),
+        },
+        scopes: {
+            [pathToFileURL(join(sourceDirectory, 'func3')).toString()]: {
+                helper: pathToFileURL(join(basePath, 'helper2.ts')).toString(),
+            },
+        },
+    };
+    await fs.writeFile(importMap.path, JSON.stringify(importMapContents));
+    const nonExistingImportMapPath = join(distPath, 'some-file-that-does-not-exist.json');
+    const result = await bundle([sourceDirectory], distPath, [
         {
             function: 'func1',
             path: '/func1',
         },
-    ];
-    const result = await bundle([sourceDirectory], distPath, declarations, {
+    ], {
         basePath,
-        configPath: join(sourceDirectory, 'config.json'),
-        importMapPaths: [importMapPath],
+        importMapPaths: [nonExistingImportMapPath, importMap.path],
         systemLogger,
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(1);
+    expect(result.functions.length).toBe(2);
     expect(generatedFiles.length).toBe(2);
-    expect(systemLogger).toHaveBeenCalledWith(`Did not find an import map file at '${importMapPath}'.`);
+    expect(systemLogger).toHaveBeenCalledWith(`Did not find an import map file at '${nonExistingImportMapPath}'.`);
     await cleanup();
+    await importMap.cleanup();
 });

package/dist/node/declaration.d.ts

@@ -7,9 +7,11 @@ interface BaseDeclaration {
 }
 type DeclarationWithPath = BaseDeclaration & {
     path: string;
+    excludedPath?: string;
 };
 type DeclarationWithPattern = BaseDeclaration & {
     pattern: string;
+    excludedPattern?: string;
 };
 type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const getDeclarationsFromConfig: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>, deployConfig: DeployConfig) => Declaration[];

package/dist/node/declaration.test.js

@@ -92,3 +92,10 @@ test('In-source config works if path property is an empty array with cache value
     const expectedDeclarations = [{ function: 'json', path: '/json-toml', cache: 'manual' }];
     expect(getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig)).toEqual(expectedDeclarations);
 });
+test('netlify.toml-defined excludedPath are respected', () => {
+    const tomlConfig = [{ function: 'geolocation', path: '/geo/*', excludedPath: '/geo/exclude' }];
+    const funcConfig = {};
+    const expectedDeclarations = [{ function: 'geolocation', path: '/geo/*', excludedPath: '/geo/exclude' }];
+    const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig);
+    expect(declarations).toEqual(expectedDeclarations);
+});

package/dist/node/import_map.js

@@ -85,7 +85,7 @@ class ImportMap {
     async addFiles(paths, logger) {
         for (const path of paths) {
             if (path === undefined) {
-                return;
+                continue;
             }
             await this.addFile(path, logger);
         }

package/dist/node/manifest.d.ts

@@ -9,6 +9,12 @@ interface GenerateManifestOptions {
     importMap?: string;
     layers?: Layer[];
 }
+interface Route {
+    function: string;
+    name?: string;
+    pattern: string;
+    excluded_pattern?: string;
+}
 interface Manifest {
     bundler_version: string;
     bundles: {
@@ -20,16 +26,13 @@ interface Manifest {
         name: string;
         flag: string;
     }[];
-    routes: {
-        function: string;
-        name?: string;
-        pattern: string;
-    }[];
-    post_cache_routes: {
-        function: string;
-        name?: string;
-        pattern: string;
-    }[];
+    routes: Route[];
+    post_cache_routes: Route[];
+}
+interface Route {
+    function: string;
+    name?: string;
+    pattern: string;
 }
 declare const generateManifest: ({ bundles, declarations, functions, importMap, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions {

package/dist/node/manifest.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import globToRegExp from 'glob-to-regexp';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
+const serializePattern = (regex) => regex.source.replace(/\\\//g, '/');
 const generateManifest = ({ bundles = [], declarations = [], functions, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
@@ -12,12 +13,15 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
             return;
         }
         const pattern = getRegularExpression(declaration);
-        const serializablePattern = pattern.source.replace(/\\\//g, '/');
         const route = {
             function: func.name,
             name: declaration.name,
-            pattern: serializablePattern,
+            pattern: serializePattern(pattern),
         };
+        const excludedPattern = getExcludedRegularExpression(declaration);
+        if (excludedPattern) {
+            route.excluded_pattern = serializePattern(excludedPattern);
+        }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
         }
@@ -39,19 +43,30 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
     };
     return manifest;
 };
-const getRegularExpression = (declaration) => {
-    if ('pattern' in declaration) {
-        return new RegExp(declaration.pattern);
-    }
+const pathToRegularExpression = (path) => {
     // We use the global flag so that `globToRegExp` will not wrap the expression
     // with `^` and `$`. We'll do that ourselves.
-    const regularExpression = globToRegExp(declaration.path, { flags: 'g' });
+    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 new RegExp(normalizedSource);
 };
+const getRegularExpression = (declaration) => {
+    if ('pattern' in declaration) {
+        return new RegExp(declaration.pattern);
+    }
+    return pathToRegularExpression(declaration.path);
+};
+const getExcludedRegularExpression = (declaration) => {
+    if ('pattern' in declaration && declaration.excludedPattern) {
+        return new RegExp(declaration.excludedPattern);
+    }
+    if ('path' in declaration && declaration.excludedPath) {
+        return pathToRegularExpression(declaration.excludedPath);
+    }
+};
 const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, importMap, layers, }) => {
     const manifest = generateManifest({ bundles, declarations, functions, importMap, layers });
     const manifestPath = join(distDirectory, 'manifest.json');

package/dist/node/manifest.test.js

@@ -42,6 +42,23 @@ test('Generates a manifest with display names', () => {
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
+test('Generates a manifest with excluded paths and patterns', () => {
+    const functions = [
+        { name: 'func-1', path: '/path/to/func-1.ts' },
+        { name: 'func-2', path: '/path/to/func-2.ts' },
+    ];
+    const declarations = [
+        { function: 'func-1', name: 'Display Name', path: '/f1/*', excludedPath: '/f1/exclude' },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
+    ];
+    const manifest = generateManifest({ bundles: [], declarations, functions });
+    const expectedRoutes = [
+        { function: 'func-1', name: 'Display Name', pattern: '^/f1/.*/?$', excluded_pattern: '^/f1/exclude/?$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_pattern: '^/f2/exclude$' },
+    ];
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.bundler_version).toBe(env.npm_package_version);
+});
 test('Excludes functions for which there are function files but no matching config declarations', () => {
     const bundle1 = {
         extension: '.ext2',

package/dist/test/util.js

@@ -12,13 +12,12 @@ const url = new URL(import.meta.url);
 const dirname = fileURLToPath(url);
 const fixturesDir = resolve(dirname, '..', 'fixtures');
 const useFixture = async (fixtureName) => {
-    const tmpDir = await tmp.dir();
-    const cleanup = () => fs.rmdir(tmpDir.path, { recursive: true });
+    const tmpDir = await tmp.dir({ unsafeCleanup: true });
     const fixtureDir = resolve(fixturesDir, fixtureName);
     const distPath = join(tmpDir.path, '.netlify', 'edge-functions-dist');
     return {
         basePath: fixtureDir,
-        cleanup,
+        cleanup: tmpDir.cleanup,
         distPath,
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",