@netlify/edge-bundler 14.8.2 → 14.8.4

package/dist/node/server/server.test.js

@@ -1,144 +0,0 @@
-import { createWriteStream } from 'fs';
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-import process from 'process';
-// @ts-expect-error TypeScript is complaining about the values for the `module`
-// and `moduleResolution` configuration properties, but changing those to more
-// modern values causes other packages to fail. Leaving this for now, but we
-// should have a proper fix for this.
-import { getURL as getBootstrapURL } from '@netlify/edge-functions-bootstrap/version';
-import getPort from 'get-port';
-import tmp from 'tmp-promise';
-import { v4 as uuidv4 } from 'uuid';
-import { test, expect } from 'vitest';
-import { fixturesDir } from '../../test/util.js';
-import { serve } from '../index.js';
-test('Starts a server and serves requests for edge functions', async () => {
-    const basePath = join(fixturesDir, 'serve_test');
-    const paths = {
-        internal: join(basePath, '.netlify', 'edge-functions'),
-        user: join(basePath, 'netlify', 'edge-functions'),
-    };
-    const port = await getPort();
-    const importMapPaths = [join(paths.internal, 'import_map.json'), join(paths.user, 'import-map.json')];
-    const servePath = join(basePath, '.netlify', 'edge-functions-serve');
-    const server = await serve({
-        basePath,
-        bootstrapURL: await getBootstrapURL(),
-        port,
-        servePath,
-    });
-    const functions = [
-        {
-            name: 'echo_env',
-            path: join(paths.user, 'echo_env.ts'),
-        },
-        {
-            name: 'greet',
-            path: join(paths.internal, 'greet.ts'),
-        },
-        {
-            name: 'global_netlify',
-            path: join(paths.user, 'global_netlify.ts'),
-        },
-    ];
-    const options = {
-        getFunctionsConfig: true,
-        importMapPaths,
-    };
-    const { features, functionsConfig, graph, success } = await server(functions, {
-        very_secret_secret: 'i love netlify',
-    }, options);
-    expect(features).toEqual({ npmModules: true });
-    expect(success).toBe(true);
-    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
-    const modules = graph?.modules.filter(({ kind, mediaType }) => kind === 'esm' && mediaType === 'TypeScript');
-    for (const key in functions) {
-        const graphEntry = modules?.some(({ local }) => local === functions[key].path);
-        expect(graphEntry).toBe(true);
-    }
-    const response1 = await fetch(`http://0.0.0.0:${port}/foo`, {
-        headers: {
-            'x-nf-edge-functions': 'echo_env',
-            'x-ef-passthrough': 'passthrough',
-            'X-NF-Request-ID': uuidv4(),
-        },
-    });
-    expect(response1.status).toBe(200);
-    expect(await response1.text()).toBe('I LOVE NETLIFY');
-    const response2 = await fetch(`http://0.0.0.0:${port}/greet`, {
-        headers: {
-            'x-nf-edge-functions': 'greet',
-            'x-ef-passthrough': 'passthrough',
-            'X-NF-Request-ID': uuidv4(),
-        },
-    });
-    expect(response2.status).toBe(200);
-    expect(await response2.text()).toBe('HELLO!');
-    const response3 = await fetch(`http://0.0.0.0:${port}/global-netlify`, {
-        headers: {
-            'x-nf-edge-functions': 'global_netlify',
-            'x-ef-passthrough': 'passthrough',
-            'X-NF-Request-ID': uuidv4(),
-        },
-    });
-    expect(await response3.json()).toEqual({
-        global: 'i love netlify',
-        local: 'i love netlify',
-    });
-    const idBarrelFile = await readFile(join(servePath, 'bundled-id.js'), 'utf-8');
-    expect(idBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', 'id', 'types.d.ts')}" />`);
-    const identidadeBarrelFile = await readFile(join(servePath, 'bundled-@pt-committee_identidade.js'), 'utf-8');
-    expect(identidadeBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', '@types', 'pt-committee__identidade', 'index.d.ts')}" />`);
-});
-test('Serves edge functions in a monorepo setup', async () => {
-    const tmpFile = await tmp.file();
-    const stderr = createWriteStream(tmpFile.path);
-    const rootPath = join(fixturesDir, 'monorepo_npm_module');
-    const basePath = join(rootPath, 'packages', 'frontend');
-    const paths = {
-        user: join(basePath, 'functions'),
-    };
-    const port = await getPort();
-    const importMapPaths = [join(basePath, 'import_map.json')];
-    const servePath = join(basePath, '.netlify', 'edge-functions-serve');
-    const server = await serve({
-        basePath,
-        bootstrapURL: await getBootstrapURL(),
-        port,
-        rootPath,
-        servePath,
-        stderr,
-    });
-    const functions = [
-        {
-            name: 'func1',
-            path: join(paths.user, 'func1.ts'),
-        },
-    ];
-    const options = {
-        getFunctionsConfig: true,
-        importMapPaths,
-    };
-    const { features, functionsConfig, graph, success } = await server(functions, {
-        very_secret_secret: 'i love netlify',
-    }, options);
-    expect(features).toEqual({ npmModules: true });
-    expect(success).toBe(true);
-    expect(functionsConfig).toEqual([{ path: '/func1' }]);
-    for (const key in functions) {
-        const graphEntry = graph?.modules.some(({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functions[key].path);
-        expect(graphEntry).toBe(true);
-    }
-    const response1 = await fetch(`http://0.0.0.0:${port}/func1`, {
-        headers: {
-            'x-nf-edge-functions': 'func1',
-            'x-ef-passthrough': 'passthrough',
-            'X-NF-Request-ID': uuidv4(),
-        },
-    });
-    expect(response1.status).toBe(200);
-    expect(await response1.text()).toBe(`<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>`);
-    expect(await readFile(tmpFile.path, 'utf8')).toContain('[func1] Something is on fire');
-    await tmpFile.cleanup();
-});

package/dist/node/stage_2.test.js

@@ -1,53 +0,0 @@
-import { rm, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { pathToFileURL } from 'url';
-import { execa } from 'execa';
-import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
-import { getLocalEntryPoint } from './formats/javascript.js';
-test('`getLocalEntryPoint` returns a valid stage 2 file for local development', async () => {
-    const { path: tmpDir } = await tmp.dir();
-    // This is a fake bootstrap that we'll create just for the purpose of logging
-    // the functions and the metadata that are sent to the `boot` function.
-    const printer = `
-    export const boot = async (functionsLoader) => {
-      const functions = await functionsLoader()
-      const metadata = { functions: {} }
-
-      // Generate metadata for each function (simulating what the real bootstrap would have)
-      for (const name in functions) {
-        metadata.functions[name] = { url: new URL('./' + name + '.mjs', import.meta.url).href }
-      }
-
-      const responses = {}
-
-      for (const name in functions) {
-        responses[name] = await functions[name]()
-      }
-
-      console.log(JSON.stringify({ responses, metadata }))
-    }
-  `;
-    const printerPath = join(tmpDir, 'printer.mjs');
-    const bootstrapURL = pathToFileURL(printerPath).toString();
-    await writeFile(printerPath, printer);
-    const functions = [
-        { name: 'func1', path: join(tmpDir, 'func1.mjs'), response: 'Hello from function 1' },
-        { name: 'func2', path: join(tmpDir, 'func2.mjs'), response: 'Hello from function 2' },
-    ];
-    for (const func of functions) {
-        const contents = `export default () => ${JSON.stringify(func.response)}`;
-        await writeFile(func.path, contents);
-    }
-    const stage2 = getLocalEntryPoint(functions.map(({ name, path }) => ({ name, path })), { bootstrapURL });
-    const stage2Path = join(tmpDir, 'stage2.mjs');
-    await writeFile(stage2Path, stage2);
-    const { stdout, stderr } = await execa('deno', ['run', '--allow-all', stage2Path]);
-    expect(stderr).toBe('');
-    const { metadata, responses } = JSON.parse(stdout);
-    for (const func of functions) {
-        expect(responses[func.name]).toBe(func.response);
-        expect(metadata.functions[func.name].url).toBe(pathToFileURL(func.path).toString());
-    }
-    await rm(tmpDir, { force: true, recursive: true });
-});

package/dist/node/types.test.js

@@ -1,63 +0,0 @@
-import { readFile, rm, writeFile } from 'fs/promises';
-import { join } from 'path';
-import nock from 'nock';
-import tmp from 'tmp-promise';
-import { test, expect, vi } from 'vitest';
-import { testLogger } from '../test/util.js';
-import { DenoBridge } from './bridge.js';
-import { ensureLatestTypes } from './types.js';
-test('`ensureLatestTypes` updates the Deno CLI cache if the local version of types is outdated', async () => {
-    const mockURL = 'https://edge.netlify';
-    const mockVersion = '123456789';
-    const latestVersionMock = nock(mockURL).get('/version.txt').reply(200, mockVersion);
-    const tmpDir = await tmp.dir();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir.path,
-        logger: testLogger,
-    });
-    // @ts-expect-error return value not used
-    const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
-    await ensureLatestTypes(deno, testLogger, mockURL);
-    const versionFile = await readFile(join(tmpDir.path, 'types-version.txt'), 'utf8');
-    expect(latestVersionMock.isDone()).toBe(true);
-    expect(mock).toHaveBeenCalledTimes(1);
-    expect(mock).toHaveBeenCalledWith(['cache', '-r', mockURL]);
-    expect(versionFile).toBe(mockVersion);
-    mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});
-test('`ensureLatestTypes` does not update the Deno CLI cache if the local version of types is up-to-date', async () => {
-    const mockURL = 'https://edge.netlify';
-    const mockVersion = '987654321';
-    const tmpDir = await tmp.dir();
-    const versionFilePath = join(tmpDir.path, 'types-version.txt');
-    await writeFile(versionFilePath, mockVersion);
-    const latestVersionMock = nock(mockURL).get('/version.txt').reply(200, mockVersion);
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir.path,
-        logger: testLogger,
-    });
-    // @ts-expect-error return value not used
-    const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
-    await ensureLatestTypes(deno, testLogger, mockURL);
-    expect(latestVersionMock.isDone()).toBe(true);
-    expect(mock).not.toHaveBeenCalled();
-    mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});
-test('`ensureLatestTypes` does not throw if the types URL is not available', async () => {
-    const mockURL = 'https://edge.netlify';
-    const latestVersionMock = nock(mockURL).get('/version.txt').reply(500);
-    const tmpDir = await tmp.dir();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir.path,
-        logger: testLogger,
-    });
-    // @ts-expect-error return value not used
-    const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
-    await ensureLatestTypes(deno, testLogger, mockURL);
-    expect(latestVersionMock.isDone()).toBe(true);
-    expect(mock).not.toHaveBeenCalled();
-    mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});

package/dist/node/validation/manifest/index.test.js

@@ -1,237 +0,0 @@
-import chalk from 'chalk';
-import { test, expect, describe } from 'vitest';
-import { validateManifest, ManifestValidationError } from './index.js';
-// We need to disable all color outputs for the tests as they are different on different platforms, CI, etc.
-// This only works if this is the same instance of chalk that better-ajv-errors uses
-chalk.level = 0;
-// Factory so we have a new object per test
-const getBaseManifest = () => ({
-    bundles: [
-        {
-            asset: 'f35baff44129a8f6be7db68590b2efd86ed4ba29000e2edbcaddc5d620d7d043.js',
-            format: 'js',
-        },
-    ],
-    routes: [
-        {
-            name: 'name',
-            function: 'hello',
-            pattern: '^/hello/?$',
-            generator: '@netlify/fake-plugin@1.0.0',
-        },
-    ],
-    post_cache_routes: [
-        {
-            name: 'name',
-            function: 'hello',
-            pattern: '^/hello/?$',
-            generator: '@netlify/fake-plugin@1.0.0',
-        },
-    ],
-    layers: [
-        {
-            flag: 'flag',
-            name: 'name',
-            local: 'local',
-        },
-    ],
-    bundler_version: '1.6.0',
-});
-test('should not throw on valid manifest', () => {
-    expect(() => validateManifest(getBaseManifest())).not.toThrowError();
-});
-test('should throw ManifestValidationError with correct message', () => {
-    expect(() => validateManifest('manifest')).toThrowError(ManifestValidationError);
-    expect(() => validateManifest('manifest')).toThrowError(/^Validation of Edge Functions manifest failed/);
-});
-test('should throw ManifestValidationError with customErrorInfo', () => {
-    try {
-        validateManifest('manifest');
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(ManifestValidationError);
-        const { customErrorInfo } = error;
-        expect(customErrorInfo).toBeDefined();
-        expect(customErrorInfo.type).toBe('functionsBundling');
-        return;
-    }
-    expect.fail('should have thrown');
-});
-test('should throw on additional property on root level', () => {
-    const manifest = getBaseManifest();
-    manifest.foo = 'bar';
-    expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-});
-test('should show multiple errors', () => {
-    const manifest = getBaseManifest();
-    manifest.foo = 'bar';
-    manifest.baz = 'bar';
-    expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-});
-describe('bundle', () => {
-    test('should throw on additional property in bundle', () => {
-        const manifest = getBaseManifest();
-        manifest.bundles[0].foo = 'bar';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on missing asset', () => {
-        const manifest = getBaseManifest();
-        delete manifest.bundles[0].asset;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on missing format', () => {
-        const manifest = getBaseManifest();
-        delete manifest.bundles[0].format;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on invalid format', () => {
-        const manifest = getBaseManifest();
-        manifest.bundles[0].format = 'foo';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-});
-describe('route', () => {
-    test('should throw on additional property', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].foo = 'bar';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on invalid pattern', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].pattern = '/^/hello/?$/';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on missing function', () => {
-        const manifest = getBaseManifest();
-        delete manifest.routes[0].function;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on missing pattern', () => {
-        const manifest = getBaseManifest();
-        delete manifest.routes[0].pattern;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-});
-// No tests for post_cache_routes as schema shared with routes
-describe('layers', () => {
-    test('should throw on additional property', () => {
-        const manifest = getBaseManifest();
-        manifest.layers[0].foo = 'bar';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on missing name', () => {
-        const manifest = getBaseManifest();
-        delete manifest.layers[0].name;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on missing flag', () => {
-        const manifest = getBaseManifest();
-        delete manifest.layers[0].flag;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-});
-describe('import map URL', () => {
-    test('should accept string value', () => {
-        const manifest = getBaseManifest();
-        manifest.import_map = 'file:///root/.netlify/edge-functions-dist/import_map.json';
-        expect(() => validateManifest(manifest)).not.toThrowError();
-    });
-    test('should throw on wrong type', () => {
-        const manifest = getBaseManifest();
-        manifest.import_map = ['file:///root/.netlify/edge-functions-dist/import_map.json'];
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-});
-describe('route headers', () => {
-    test('should accept valid headers with exists matcher', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'exists',
-            },
-        };
-        expect(() => validateManifest(manifest)).not.toThrowError();
-    });
-    test('should accept valid headers with missing matcher', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'missing',
-            },
-        };
-        expect(() => validateManifest(manifest)).not.toThrowError();
-    });
-    test('should accept valid headers with regex matcher and pattern', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'regex',
-                pattern: 'Bearer .+',
-            },
-        };
-        expect(() => validateManifest(manifest)).not.toThrowError();
-    });
-    test('should throw on missing matcher property', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                pattern: '^Bearer .+$',
-            },
-        };
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on invalid matcher value', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'invalid',
-            },
-        };
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw when matcher is regex but pattern is missing', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'regex',
-            },
-        };
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on invalid pattern format', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'regex',
-                pattern: /^Bearer .+/,
-            },
-        };
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should throw on additional property in headers', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-custom-header': {
-                matcher: 'exists',
-                foo: 'bar',
-            },
-        };
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should accept multiple headers with different matchers', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].headers = {
-            'x-exists-header': {
-                matcher: 'exists',
-            },
-            'x-missing-header': {
-                matcher: 'missing',
-            },
-            authorization: {
-                matcher: 'regex',
-                pattern: '^Bearer [a-zA-Z0-9]+$',
-            },
-        };
-        expect(() => validateManifest(manifest)).not.toThrowError();
-    });
-});