@netlify/edge-bundler 14.8.2 → 14.8.4

package/dist/node/config.test.js

@@ -1,408 +0,0 @@
-import { promises as fs } from 'fs';
-import { rm } from 'fs/promises';
-import { join, resolve } from 'path';
-import { pathToFileURL } from 'url';
-import tmp from 'tmp-promise';
-import { test, expect, vi, describe } from 'vitest';
-import { fixturesDir, useFixture } from '../test/util.js';
-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: {
-        'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
-    },
-};
-const invalidDefaultExportErr = (path) => `Default export in '${path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`;
-const functions = [
-    {
-        testName: 'no config',
-        expectedConfig: {},
-        name: 'func1',
-        source: `export default async () => new Response("Hello from function one")`,
-    },
-    {
-        testName: 'empty config',
-        expectedConfig: {},
-        name: 'func2',
-        source: `
-        export default async () => new Response("Hello from function two")
-
-        export const config = {}
-      `,
-    },
-    {
-        testName: 'config with wrong type',
-        name: 'func3',
-        source: `
-      export default async () => new Response("Hello from function two")
-
-      export const config = () => ({})
-    `,
-        error: /^The 'config' export in edge function at '(.*)' must be an object\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
-    },
-    {
-        testName: 'config with syntax error',
-        name: 'func4',
-        source: `
-      export default async () => new Response("Hello from function two")
-
-      export const config
-    `,
-        error: /^Could not load edge function at '(.*)'\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
-    },
-    {
-        testName: 'config with correct onError',
-        expectedConfig: { onError: 'bypass' },
-        name: 'func5',
-        source: `
-      export default async () => new Response("Hello from function two")
-      export const config = { onError: "bypass" }
-    `,
-    },
-    {
-        testName: 'config with wrong onError',
-        name: 'func6',
-        source: `
-      export default async () => new Response("Hello from function two")
-      export const config = { onError: "foo" }
-    `,
-        error: /The 'onError' configuration property in edge function at .*/,
-    },
-    {
-        testName: 'config with `path`',
-        expectedConfig: { path: '/home' },
-        name: 'func7',
-        source: `
-        export default async () => new Response("Hello from function three")
-
-        export const config = { path: "/home" }
-      `,
-    },
-    {
-        testName: 'config with path, generator, name and onError`',
-        expectedConfig: {
-            path: '/home',
-            generator: '@netlify/fake-plugin@1.0.0',
-            name: 'a displayName',
-            onError: 'bypass',
-        },
-        name: 'func8',
-        source: `
-        export default async () => new Response("Hello from function three")
-
-        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) => {
-        const { path: tmpDir } = await tmp.dir();
-        const deno = new DenoBridge({
-            cacheDirectory: tmpDir,
-        });
-        const logger = {
-            user: vi.fn().mockResolvedValue(null),
-            system: vi.fn().mockResolvedValue(null),
-        };
-        const path = join(tmpDir, `${func.name}.js`);
-        await fs.writeFile(path, func.source);
-        const funcCall = () => getFunctionConfig({
-            functionPath: path,
-            importMap: new ImportMap([importMapFile]),
-            deno,
-            log: logger,
-        });
-        if (func.error) {
-            await expect(funcCall()).rejects.toThrowError(func.error);
-        }
-        else if (func.userLog) {
-            await expect(funcCall()).resolves.not.toThrowError();
-            expect(logger.user).toHaveBeenCalledWith(expect.stringMatching(func.userLog));
-        }
-        else {
-            const config = await funcCall();
-            expect(config).toEqual(func.expectedConfig);
-            expect(logger.user).not.toHaveBeenCalled();
-        }
-        await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
-    });
-});
-test('Loads function paths from the in-source `config` function', async () => {
-    const { basePath, cleanup, distPath } = await useFixture('with_config');
-    const userDirectory = resolve(basePath, 'netlify', 'edge-functions');
-    const internalDirectory = resolve(basePath, '.netlify', 'edge-functions');
-    const declarations = [
-        {
-            function: 'framework-func2',
-            path: '/framework-func2',
-        },
-        {
-            function: 'user-func2',
-            path: '/user-func2',
-            method: ['PATCH'],
-        },
-    ];
-    const result = await bundle([internalDirectory, userDirectory], distPath, declarations, {
-        basePath,
-        configPath: join(internalDirectory, 'config.json'),
-    });
-    const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(11);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
-    const manifest = JSON.parse(manifestFile);
-    const { bundles, routes, post_cache_routes: postCacheRoutes, function_config: functionConfig } = manifest;
-    expect(bundles.length).toBe(1);
-    expect(bundles[0].format).toBe('eszip2');
-    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(routes.length).toBe(12);
-    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',
-        methods: ['PATCH'],
-    });
-    expect(routes[2]).toEqual({
-        function: 'framework-func1',
-        pattern: '^/framework-func1/?$',
-        excluded_patterns: [],
-        path: '/framework-func1',
-    });
-    expect(routes[3]).toEqual({
-        function: 'framework-func3',
-        pattern: '^/framework-func3(/.*)?$',
-        excluded_patterns: ['^/framework-func3/excluded$'],
-    });
-    expect(routes[4]).toEqual({
-        function: 'framework-func4',
-        pattern: '^/framework-func4(/.*)?$',
-        excluded_patterns: ['^/framework-func4/excluded$', '^/framework-func4-alt/excluded$'],
-    });
-    expect(routes[5]).toEqual({
-        function: 'framework-func4',
-        pattern: '^/framework-func4-alt(/.*)?$',
-        excluded_patterns: ['^/framework-func4/excluded$', '^/framework-func4-alt/excluded$'],
-    });
-    expect(routes[6]).toEqual({
-        function: 'user-func1',
-        pattern: '^/user-func1/?$',
-        excluded_patterns: [],
-        path: '/user-func1',
-        headers: {
-            'x-must-be-there': {
-                matcher: 'exists',
-            },
-            'x-must-match': {
-                pattern: '^(foo|bar)$',
-                matcher: 'regex',
-            },
-            'x-must-not-be-there': {
-                matcher: 'missing',
-            },
-        },
-    });
-    expect(routes[7]).toEqual({
-        function: 'user-func3',
-        pattern: '^/user-func3/?$',
-        excluded_patterns: [],
-        path: '/user-func3',
-    });
-    expect(routes[8]).toEqual({
-        function: 'user-func5',
-        pattern: '^/user-func5(?:/(.*))/?$',
-        excluded_patterns: ['^/user-func5/excluded/?$'],
-        path: '/user-func5/*',
-        methods: ['GET'],
-    });
-    expect(routes[9]).toEqual({
-        function: 'user-func6',
-        pattern: '^/user-func6(/.*)?$',
-        excluded_patterns: ['^/user-func6/excluded$'],
-    });
-    expect(routes[10]).toEqual({
-        function: 'user-func7',
-        pattern: '^/user-func7(/.*)?$',
-        excluded_patterns: ['^/user-func7/excluded$', '^/user-func7-alt/excluded$'],
-    });
-    expect(routes[11]).toEqual({
-        function: 'user-func7',
-        pattern: '^/user-func7-alt(/.*)?$',
-        excluded_patterns: ['^/user-func7/excluded$', '^/user-func7-alt/excluded$'],
-    });
-    expect(postCacheRoutes.length).toBe(1);
-    expect(postCacheRoutes[0]).toEqual({
-        function: 'user-func4',
-        pattern: '^/user-func4/?$',
-        excluded_patterns: [],
-        path: '/user-func4',
-        methods: ['POST', 'PUT'],
-    });
-    expect(Object.keys(functionConfig)).toHaveLength(5);
-    expect(functionConfig['user-func5']).toEqual({
-        excluded_patterns: ['^/user-func5/excluded/?$'],
-    });
-    expect(functionConfig['user-func6']).toEqual({
-        excluded_patterns: ['^/user-func6/excluded$'],
-    });
-    expect(functionConfig['user-func7']).toEqual({
-        excluded_patterns: ['^/user-func7/excluded$', '^/user-func7-alt/excluded$'],
-    });
-    expect(functionConfig['framework-func3']).toEqual({
-        excluded_patterns: ['^/framework-func3/excluded$'],
-    });
-    expect(functionConfig['framework-func4']).toEqual({
-        excluded_patterns: ['^/framework-func4/excluded$', '^/framework-func4-alt/excluded$'],
-    });
-    await cleanup();
-});
-test('Passes validation if default export exists and is a function', async () => {
-    const { path: tmpDir } = await tmp.dir();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir,
-    });
-    const func = {
-        name: 'func1',
-        source: `
-        const func = () => new Response("Hello world!")
-        export default func
-      `,
-    };
-    const logger = {
-        user: vi.fn().mockResolvedValue(null),
-        system: vi.fn().mockResolvedValue(null),
-    };
-    const path = join(tmpDir, `${func.name}.ts`);
-    await fs.writeFile(path, func.source);
-    await expect(getFunctionConfig({
-        functionPath: path,
-        importMap: new ImportMap([importMapFile]),
-        deno,
-        log: logger,
-    })).resolves.not.toThrow();
-    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
-});
-test('Fails validation if default export is not function', async () => {
-    const { path: tmpDir } = await tmp.dir();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir,
-    });
-    const func = {
-        name: 'func2',
-        source: `
-        const func = new Response("Hello world!")
-        export default func
-      `,
-    };
-    const logger = {
-        user: vi.fn().mockResolvedValue(null),
-        system: vi.fn().mockResolvedValue(null),
-    };
-    const path = join(tmpDir, `${func.name}.ts`);
-    await fs.writeFile(path, func.source);
-    const config = getFunctionConfig({
-        functionPath: path,
-        importMap: new ImportMap([importMapFile]),
-        deno,
-        log: logger,
-    });
-    await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
-    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
-});
-test('Fails validation if default export is not present', async () => {
-    const { path: tmpDir } = await tmp.dir();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir,
-    });
-    const func = {
-        name: 'func3',
-        source: `
-        export const func = () => new Response("Hello world!")
-      `,
-    };
-    const logger = {
-        user: vi.fn().mockResolvedValue(null),
-        system: vi.fn().mockResolvedValue(null),
-    };
-    const path = join(tmpDir, `${func.name}.ts`);
-    await fs.writeFile(path, func.source);
-    const config = getFunctionConfig({
-        functionPath: path,
-        importMap: new ImportMap([importMapFile]),
-        deno,
-        log: logger,
-    });
-    await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
-    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
-});

package/dist/node/declaration.test.js

@@ -1,131 +0,0 @@
-import { test, expect } from 'vitest';
-import { mergeDeclarations, normalizePattern } from './declaration.js';
-const deployConfigDeclarations = [];
-test('Ensure the order of edge functions with FF', () => {
-    const deployConfigDeclarations = [
-        { function: 'framework-manifest-a', path: '/path1' },
-        { function: 'framework-manifest-c', path: '/path3' },
-        { function: 'framework-manifest-b', path: '/path2' },
-    ];
-    const tomlConfig = [
-        { function: 'user-toml-a', path: '/path1' },
-        { function: 'user-toml-c', path: '/path3' },
-        { function: 'user-toml-b', path: '/path2' },
-    ];
-    const userFuncConfig = {
-        'user-isc-c': { path: ['/path1', '/path2'] },
-    };
-    const internalFuncConfig = {
-        'framework-isc-c': { path: ['/path1', '/path2'] },
-    };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations)).toMatchSnapshot();
-});
-test('In-source config takes precedence over netlify.toml config', () => {
-    const tomlConfig = [
-        { function: 'geolocation', path: '/geo', cache: 'off' },
-        { function: 'json', path: '/json', cache: 'manual' },
-    ];
-    const userFuncConfig = {
-        geolocation: { path: ['/geo-isc', '/*'], cache: 'manual' },
-        json: { path: '/json', cache: 'off' },
-    };
-    const expectedDeclarations = [
-        { function: 'geolocation', path: '/geo-isc', cache: 'manual' },
-        { function: 'geolocation', path: '/*', cache: 'manual' },
-        { function: 'json', path: '/json', cache: 'off' },
-    ];
-    const declarations = mergeDeclarations(tomlConfig, userFuncConfig, {}, deployConfigDeclarations);
-    expect(declarations).toEqual(expectedDeclarations);
-});
-test("Declarations don't break if no in-source config is provided", () => {
-    const tomlConfig = [
-        { function: 'geolocation', path: '/geo', cache: 'off' },
-        { function: 'json', path: '/json', cache: 'manual' },
-    ];
-    const userFuncConfig = {
-        geolocation: { path: ['/geo-isc'], cache: 'manual' },
-        json: {},
-    };
-    const expectedDeclarations = [
-        { function: 'geolocation', path: '/geo-isc', cache: 'manual' },
-        { function: 'json', path: '/json', cache: 'manual' },
-    ];
-    const declarations = mergeDeclarations(tomlConfig, userFuncConfig, {}, deployConfigDeclarations);
-    expect(declarations).toEqual(expectedDeclarations);
-});
-test('In-source config works independent of the netlify.toml file if a path is defined and otherwise if no path is set', () => {
-    const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
-    const funcConfigWithPath = {
-        json: { path: ['/json', '/json-isc'], cache: 'off' },
-    };
-    const funcConfigWithoutPath = {
-        json: { cache: 'off' },
-    };
-    const expectedDeclarationsWithISCPath = [
-        { function: 'geolocation', path: '/geo', cache: 'off' },
-        { function: 'json', path: '/json', cache: 'off' },
-        { function: 'json', path: '/json-isc', cache: 'off' },
-    ];
-    const expectedDeclarationsWithoutISCPath = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
-    const declarationsWithISCPath = mergeDeclarations(tomlConfig, funcConfigWithPath, {}, deployConfigDeclarations);
-    expect(declarationsWithISCPath).toEqual(expectedDeclarationsWithISCPath);
-    const declarationsWithoutISCPath = mergeDeclarations(tomlConfig, funcConfigWithoutPath, {}, deployConfigDeclarations);
-    expect(declarationsWithoutISCPath).toEqual(expectedDeclarationsWithoutISCPath);
-});
-test('In-source config works if only the cache config property is set', () => {
-    const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
-    const funcConfig = {
-        geolocation: { cache: 'manual' },
-    };
-    const expectedDeclarations = [{ function: 'geolocation', path: '/geo', cache: 'manual' }];
-    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
-});
-test("In-source config path property works if it's not an array", () => {
-    const tomlConfig = [{ function: 'json', path: '/json-toml', cache: 'off' }];
-    const funcConfig = {
-        json: { path: '/json', cache: 'manual' },
-    };
-    const expectedDeclarations = [{ function: 'json', path: '/json', cache: 'manual' }];
-    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
-});
-test("In-source config path property works if it's not an array and it's not present in toml or deploy config", () => {
-    const tomlConfig = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
-    const funcConfig = {
-        json: { path: '/json-isc', cache: 'manual' },
-    };
-    const expectedDeclarations = [
-        { function: 'geolocation', path: '/geo', cache: 'off' },
-        { function: 'json', path: '/json-isc', cache: 'manual' },
-    ];
-    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).toEqual(expectedDeclarations);
-});
-test('In-source config works if path property is an empty array with cache value specified', () => {
-    const tomlConfig = [{ function: 'json', path: '/json-toml', cache: 'off' }];
-    const funcConfig = {
-        json: { path: [], cache: 'manual' },
-    };
-    const expectedDeclarations = [{ function: 'json', path: '/json-toml', cache: 'manual' }];
-    expect(mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations)).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 = mergeDeclarations(tomlConfig, funcConfig, {}, deployConfigDeclarations);
-    expect(declarations).toEqual(expectedDeclarations);
-});
-test('Does not escape front slashes in a regex pattern if they are already escaped', () => {
-    const regexPattern = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[\\/#\\?]?$';
-    const expected = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[\\/#\\?]?$';
-    expect(normalizePattern(regexPattern)).toEqual(expected);
-});
-test('Escapes front slashes in a regex pattern', () => {
-    const regexPattern = '^(?:/(_next/data/[^/]{1,}))?(?:/([^/.]{1,}))/shows(?:/(.*))(.json)?[/#\\?]?$';
-    const expected = '^(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))\\/shows(?:\\/(.*))(.json)?[/#\\?]?$';
-    expect(normalizePattern(regexPattern)).toEqual(expected);
-});
-test('Ensures pattern match on the whole path', () => {
-    const regexPattern = '/foo/.*/bar';
-    const expected = '^\\/foo\\/.*\\/bar$';
-    expect(normalizePattern(regexPattern)).toEqual(expected);
-});

package/dist/node/deploy_config.test.js

@@ -1,48 +0,0 @@
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { cwd } from 'process';
-import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
-import { load } from './deploy_config.js';
-import { getLogger } from './logger.js';
-const logger = getLogger(console.log);
-test('Returns an empty config object if there is no file at the given path', async () => {
-    const mockPath = join(cwd(), 'some-directory', `a-file-that-does-not-exist-${Date.now()}.json`);
-    const config = await load(mockPath, logger);
-    expect(config.declarations).toEqual([]);
-    expect(config.layers).toEqual([]);
-});
-test('Returns a config object with declarations, layers, and import map', async () => {
-    const importMapFile = await tmp.file({ postfix: '.json' });
-    const importMap = {
-        imports: {
-            'https://deno.land/': 'https://black.hole/',
-        },
-    };
-    await fs.writeFile(importMapFile.path, JSON.stringify(importMap));
-    const configFile = await tmp.file();
-    const config = {
-        functions: [
-            {
-                function: 'func1',
-                path: '/func1',
-                generator: 'internalFunc',
-            },
-        ],
-        layers: [
-            {
-                name: 'layer1',
-                flag: 'edge_functions_layer1_url',
-                local: 'https://some-url.netlify.app/mod.ts',
-            },
-        ],
-        import_map: importMapFile.path,
-        version: 1,
-    };
-    await fs.writeFile(configFile.path, JSON.stringify(config));
-    const parsedConfig = await load(configFile.path, logger);
-    await importMapFile.cleanup();
-    expect(parsedConfig.declarations).toEqual(config.functions);
-    expect(parsedConfig.layers).toEqual(config.layers);
-    expect(parsedConfig.importMap).toBe(importMapFile.path);
-});