@netlify/edge-bundler 2.2.0 → 2.3.0

package/dist/node/config.js

@@ -0,0 +1,87 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import tmp from 'tmp-promise';
+import { getPackagePath } from './package_json.js';
+// eslint-disable-next-line no-shadow
+var ConfigExitCode;
+(function (ConfigExitCode) {
+    ConfigExitCode[ConfigExitCode["Success"] = 0] = "Success";
+    ConfigExitCode[ConfigExitCode["UnhandledError"] = 1] = "UnhandledError";
+    ConfigExitCode[ConfigExitCode["ImportError"] = 2] = "ImportError";
+    ConfigExitCode[ConfigExitCode["NoConfig"] = 3] = "NoConfig";
+    ConfigExitCode[ConfigExitCode["InvalidExport"] = 4] = "InvalidExport";
+    ConfigExitCode[ConfigExitCode["RuntimeError"] = 5] = "RuntimeError";
+    ConfigExitCode[ConfigExitCode["SerializationError"] = 6] = "SerializationError";
+})(ConfigExitCode || (ConfigExitCode = {}));
+const getConfigExtractor = () => {
+    const packagePath = getPackagePath();
+    const configExtractorPath = join(packagePath, 'deno', 'config.ts');
+    return configExtractorPath;
+};
+export const getFunctionConfig = async (func, deno, log) => {
+    // The extractor is a Deno script that will import the function and run its
+    // `config` export, if one exists.
+    const extractorPath = getConfigExtractor();
+    // We need to collect the output of the config function, which should be a
+    // JSON object. Rather than printing it to stdout, the extractor will write
+    // it to a temporary file, which we then read in the Node side. This allows
+    // the config function to write to stdout and stderr without that interfering
+    // with the extractor.
+    const collector = await tmp.file();
+    // The extractor will use its exit code to signal different error scenarios,
+    // based on the list of exit codes we send as an argument. We then capture
+    // the exit code to know exactly what happened and guide people accordingly.
+    const { exitCode, stderr, stdout } = await deno.run([
+        'run',
+        '--allow-read',
+        `--allow-write=${collector.path}`,
+        '--quiet',
+        extractorPath,
+        pathToFileURL(func.path).href,
+        pathToFileURL(collector.path).href,
+        JSON.stringify(ConfigExitCode),
+    ], { rejectOnExitCode: false });
+    if (exitCode !== ConfigExitCode.Success) {
+        logConfigError(func, exitCode, stderr, log);
+        return {};
+    }
+    if (stdout !== '') {
+        log.user(stdout);
+    }
+    try {
+        const collectorData = await fs.readFile(collector.path, 'utf8');
+        return JSON.parse(collectorData);
+    }
+    catch {
+        logConfigError(func, ConfigExitCode.UnhandledError, stderr, log);
+        return {};
+    }
+    finally {
+        await collector.cleanup();
+    }
+};
+const logConfigError = (func, exitCode, stderr, log) => {
+    switch (exitCode) {
+        case ConfigExitCode.ImportError:
+            log.user(`Could not load edge function at '${func.path}'`);
+            log.system(stderr);
+            break;
+        case ConfigExitCode.NoConfig:
+            log.system(`No in-source config found for edge function at '${func.path}'`);
+            break;
+        case ConfigExitCode.InvalidExport:
+            log.user(`'config' export in edge function at '${func.path}' must be a function`);
+            break;
+        case ConfigExitCode.RuntimeError:
+            log.user(`Error while running 'config' function in edge function at '${func.path}'`);
+            log.user(stderr);
+            break;
+        case ConfigExitCode.SerializationError:
+            log.user(`'config' function in edge function at '${func.path}' must return an object with primitive values only`);
+            break;
+        default:
+            log.user(`Could not load configuration for edge function at '${func.path}'`);
+            log.user(stderr);
+    }
+};

package/dist/node/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/config.test.js

@@ -0,0 +1,174 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import del from 'del';
+import { stub } from 'sinon';
+import tmp from 'tmp-promise';
+import { test, expect } from 'vitest';
+import { fixturesDir } from '../test/util.js';
+import { DenoBridge } from './bridge.js';
+import { bundle } from './bundler.js';
+import { getFunctionConfig } from './config.js';
+test('`getFunctionConfig` extracts configuration properties from function file', async () => {
+    const { path: tmpDir } = await tmp.dir();
+    const deno = new DenoBridge({
+        cacheDirectory: tmpDir,
+    });
+    const functions = [
+        // No config
+        {
+            expectedConfig: {},
+            name: 'func1',
+            source: `export default async () => new Response("Hello from function one")`,
+        },
+        // Empty config
+        {
+            expectedConfig: {},
+            name: 'func2',
+            source: `
+        export default async () => new Response("Hello from function two")
+
+        export const config = () => ({})
+      `,
+        },
+        // Config with the wrong type
+        {
+            expectedConfig: {},
+            name: 'func3',
+            source: `
+      export default async () => new Response("Hello from function two")
+
+      export const config = {}
+    `,
+            userLog: /^'config' export in edge function at '(.*)' must be a function$/,
+        },
+        // Config with a syntax error
+        {
+            expectedConfig: {},
+            name: 'func4',
+            source: `
+      export default async () => new Response("Hello from function two")
+
+      export const config
+    `,
+            userLog: /^Could not load edge function at '(.*)'$/,
+        },
+        // Config that throws
+        {
+            expectedConfig: {},
+            name: 'func5',
+            source: `
+          export default async () => new Response("Hello from function two")
+    
+          export const config = () => {
+            throw new Error('uh-oh')
+          }
+        `,
+            userLog: /^Error while running 'config' function in edge function at '(.*)'$/,
+        },
+        // Config with `path`
+        {
+            expectedConfig: { path: '/home' },
+            name: 'func6',
+            source: `
+        export default async () => new Response("Hello from function three")
+
+        export const config = () => ({ path: "/home" })
+      `,
+        },
+        // Config that prints to stdout
+        {
+            expectedConfig: { path: '/home' },
+            name: 'func7',
+            source: `
+        export default async () => new Response("Hello from function three")
+
+        export const config = () => {
+          console.log("Hello from config!")
+
+          return { path: "/home" }
+        }
+      `,
+            userLog: /^Hello from config!$/,
+        },
+    ];
+    for (const func of functions) {
+        const logger = {
+            user: stub().resolves(),
+            system: stub().resolves(),
+        };
+        const path = join(tmpDir, `${func.name}.js`);
+        await fs.writeFile(path, func.source);
+        const config = await getFunctionConfig({
+            name: func.name,
+            path,
+        }, deno, logger);
+        expect(config).toEqual(func.expectedConfig);
+        if (func.userLog) {
+            expect(logger.user.firstCall.firstArg).toMatch(func.userLog);
+        }
+        else {
+            expect(logger.user.callCount).toBe(0);
+        }
+    }
+    await del(tmpDir, { force: true });
+});
+test('Ignores function paths from the in-source `config` function if the feature flag is off', async () => {
+    const userDirectory = resolve(fixturesDir, 'with_config', 'netlify', 'edge-functions');
+    const internalDirectory = resolve(fixturesDir, 'with_config', '.netlify', 'edge-functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [];
+    const result = await bundle([internalDirectory, userDirectory], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        featureFlags: {
+            edge_functions_produce_eszip: true,
+        },
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(4);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const { bundles, routes } = manifest;
+    expect(bundles.length).toBe(1);
+    expect(bundles[0].format).toBe('eszip2');
+    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    expect(routes.length).toBe(0);
+    await fs.rmdir(tmpDir.path, { recursive: true });
+});
+test('Loads function paths from the in-source `config` function', async () => {
+    const userDirectory = resolve(fixturesDir, 'with_config', 'netlify', 'edge-functions');
+    const internalDirectory = resolve(fixturesDir, 'with_config', '.netlify', 'edge-functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'framework-func2',
+            path: '/framework-func2',
+        },
+        {
+            function: 'user-func2',
+            path: '/user-func2',
+        },
+    ];
+    const result = await bundle([internalDirectory, userDirectory], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        featureFlags: {
+            edge_functions_config_export: true,
+            edge_functions_produce_eszip: true,
+        },
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(4);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const { bundles, routes } = manifest;
+    expect(bundles.length).toBe(1);
+    expect(bundles[0].format).toBe('eszip2');
+    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    expect(routes.length).toBe(4);
+    expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$' });
+    expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$' });
+    expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$' });
+    expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$' });
+    await fs.rmdir(tmpDir.path, { recursive: true });
+});

package/dist/node/declaration.d.ts

@@ -1,3 +1,4 @@
+import { FunctionConfig } from './config.js';
 interface DeclarationWithPath {
     function: string;
     path: string;
@@ -7,4 +8,5 @@ interface DeclarationWithPattern {
     pattern: string;
 }
 declare type Declaration = DeclarationWithPath | DeclarationWithPattern;
+export declare const getDeclarationsFromConfig: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>) => Declaration[];
 export { Declaration, DeclarationWithPath, DeclarationWithPattern };

package/dist/node/declaration.js

@@ -1 +1,27 @@
-export {};
+export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig) => {
+    var _a;
+    const declarations = [];
+    const functionsVisited = new Set();
+    // We start by iterating over all the TOML declarations. For any declaration
+    // for which we also have a function configuration object, we replace the
+    // path because that object takes precedence.
+    for (const declaration of tomlDeclarations) {
+        const { path } = (_a = functionsConfig[declaration.function]) !== null && _a !== void 0 ? _a : {};
+        if (path) {
+            functionsVisited.add(declaration.function);
+            declarations.push({ function: declaration.function, path });
+        }
+        else {
+            declarations.push(declaration);
+        }
+    }
+    // Finally, we must create declarations for functions that are not declared
+    // in the TOML at all.
+    for (const name in functionsConfig) {
+        const { path } = functionsConfig[name];
+        if (!functionsVisited.has(name) && path) {
+            declarations.push({ function: name, path });
+        }
+    }
+    return declarations;
+};

package/dist/node/downloader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/downloader.test.js

@@ -0,0 +1,115 @@
+import { promises as fs } from 'fs';
+import { platform } from 'process';
+import { PassThrough } from 'stream';
+import { execa } from 'execa';
+import nock from 'nock';
+import tmp from 'tmp-promise';
+import { beforeEach, afterEach, test, expect } from 'vitest';
+import { fixturesDir, testLogger } from '../test/util.js';
+import { download } from './downloader.js';
+import { getPlatformTarget } from './platform.js';
+const streamError = () => {
+    const stream = new PassThrough();
+    setTimeout(() => stream.emit('data', 'zipcontent'), 100);
+    setTimeout(() => stream.emit('error', new Error('stream error')), 200);
+    return stream;
+};
+beforeEach(async (ctx) => {
+    const tmpDir = await tmp.dir();
+    // eslint-disable-next-line no-param-reassign
+    ctx.tmpDir = tmpDir.path;
+});
+afterEach(async (ctx) => {
+    await fs.rmdir(ctx.tmpDir, { recursive: true });
+});
+test('tries downloading binary up to 4 times', async (ctx) => {
+    nock.disableNetConnect();
+    const version = '99.99.99';
+    const mockURL = 'https://dl.deno.land:443';
+    const target = getPlatformTarget();
+    const zipPath = `/release/v${version}/deno-${target}.zip`;
+    const latestVersionMock = nock(mockURL)
+        .get('/release-latest.txt')
+        .reply(200, `v${version}\n`)
+        // first attempt
+        .get(zipPath)
+        .reply(500)
+        // second attempt
+        .get(zipPath)
+        .reply(500)
+        // third attempt
+        .get(zipPath)
+        .reply(500)
+        // fourth attempt
+        .get(zipPath)
+        // 1 second delay
+        .delayBody(1000)
+        .replyWithFile(200, platform === 'win32' ? `${fixturesDir}/deno.win.zip` : `${fixturesDir}/deno.zip`, {
+        'Content-Type': 'application/zip',
+    });
+    const deno = await download(ctx.tmpDir, `^${version}`, testLogger);
+    expect(latestVersionMock.isDone()).toBe(true);
+    expect(deno).toBeTruthy();
+    const res = await execa(deno);
+    expect(res.stdout).toBe('hello');
+});
+test('fails downloading binary after 4th time', async (ctx) => {
+    expect.assertions(2);
+    nock.disableNetConnect();
+    const version = '99.99.99';
+    const mockURL = 'https://dl.deno.land:443';
+    const target = getPlatformTarget();
+    const zipPath = `/release/v${version}/deno-${target}.zip`;
+    const latestVersionMock = nock(mockURL)
+        .get('/release-latest.txt')
+        .reply(200, `v${version}\n`)
+        // first attempt
+        .get(zipPath)
+        .reply(500)
+        // second attempt
+        .get(zipPath)
+        .reply(500)
+        // third attempt
+        .get(zipPath)
+        .reply(500)
+        // fourth attempt
+        .get(zipPath)
+        .reply(500);
+    try {
+        await download(ctx.tmpDir, `^${version}`, testLogger);
+    }
+    catch (error) {
+        expect(error).toMatch(/Download failed with status code 500/);
+    }
+    expect(latestVersionMock.isDone()).toBe(true);
+});
+test('fails downloading if response stream throws error', async (ctx) => {
+    expect.assertions(2);
+    nock.disableNetConnect();
+    const version = '99.99.99';
+    const mockURL = 'https://dl.deno.land:443';
+    const target = getPlatformTarget();
+    const zipPath = `/release/v${version}/deno-${target}.zip`;
+    const latestVersionMock = nock(mockURL)
+        .get('/release-latest.txt')
+        .reply(200, `v${version}\n`)
+        // first attempt
+        .get(zipPath)
+        .reply(200, streamError)
+        // second attempt
+        .get(zipPath)
+        .reply(200, streamError)
+        // third attempt
+        .get(zipPath)
+        .reply(200, streamError)
+        // fourth attempt
+        .get(zipPath)
+        .reply(200, streamError);
+    try {
+        await download(ctx.tmpDir, `^${version}`, testLogger);
+    }
+    catch (error) {
+        expect(error).toMatch(/stream error/);
+    }
+    expect(latestVersionMock.isDone()).toBe(true);
+});

package/dist/node/feature_flags.js

@@ -1,5 +1,6 @@
 const defaultFlags = {
     edge_functions_cache_deno_dir: false,
+    edge_functions_config_export: false,
     edge_functions_produce_eszip: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/node/import_map.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/import_map.test.js

@@ -0,0 +1,33 @@
+import { test, expect } from 'vitest';
+import { ImportMap } from './import_map.js';
+test('Handles import maps with full URLs without specifying a base URL', () => {
+    const inputFile1 = {
+        baseURL: new URL('file:///some/path/import-map.json'),
+        imports: {
+            'alias:jamstack': 'https://jamstack.org',
+        },
+    };
+    const inputFile2 = {
+        baseURL: new URL('file:///some/path/import-map.json'),
+        imports: {
+            'alias:pets': 'https://petsofnetlify.com/',
+        },
+    };
+    const map = new ImportMap([inputFile1, inputFile2]);
+    const { imports } = JSON.parse(map.getContents());
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
+    expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
+});
+test('Handles import maps with relative paths', () => {
+    const inputFile1 = {
+        baseURL: new URL('file:///Users/jane-doe/my-site/import-map.json'),
+        imports: {
+            'alias:pets': './heart/pets/',
+        },
+    };
+    const map = new ImportMap([inputFile1]);
+    const { imports } = JSON.parse(map.getContents());
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['alias:pets']).toBe('file:///Users/jane-doe/my-site/heart/pets/');
+});

package/dist/node/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/logger.test.js

@@ -0,0 +1,45 @@
+import { stub } from 'sinon';
+import { afterEach, test, expect } from 'vitest';
+import { getLogger } from './logger.js';
+const consoleLog = console.log;
+const noopLogger = () => {
+    // no-op
+};
+afterEach(() => {
+    // Restoring global `console.log`.
+    console.log = consoleLog;
+});
+test('Prints user logs to stdout', () => {
+    const mockConsoleLog = stub();
+    console.log = mockConsoleLog;
+    const logger1 = getLogger(noopLogger, true);
+    const logger2 = getLogger(noopLogger, false);
+    logger1.user('Hello with `debug: true`');
+    logger2.user('Hello with `debug: false`');
+    expect(mockConsoleLog.callCount).toBe(2);
+    expect(mockConsoleLog.firstCall.firstArg).toBe('Hello with `debug: true`');
+    expect(mockConsoleLog.secondCall.firstArg).toBe('Hello with `debug: false`');
+});
+test('Prints system logs to the system logger provided', () => {
+    const mockSystemLog = stub();
+    const mockConsoleLog = stub();
+    console.log = mockSystemLog;
+    const logger1 = getLogger(mockSystemLog, true);
+    const logger2 = getLogger(mockSystemLog, false);
+    logger1.system('Hello with `debug: true`');
+    logger2.system('Hello with `debug: false`');
+    expect(mockConsoleLog.callCount).toBe(0);
+    expect(mockSystemLog.callCount).toBe(2);
+    expect(mockSystemLog.firstCall.firstArg).toBe('Hello with `debug: true`');
+    expect(mockSystemLog.secondCall.firstArg).toBe('Hello with `debug: false`');
+});
+test('Prints system logs to stdout if there is no system logger provided and `debug` is enabled', () => {
+    const mockConsoleLog = stub();
+    console.log = mockConsoleLog;
+    const logger1 = getLogger(undefined, true);
+    const logger2 = getLogger(undefined, false);
+    logger1.system('Hello with `debug: true`');
+    logger2.system('Hello with `debug: false`');
+    expect(mockConsoleLog.callCount).toBe(1);
+    expect(mockConsoleLog.firstCall.firstArg).toBe('Hello with `debug: true`');
+});

package/dist/node/main.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/main.test.js

@@ -0,0 +1,48 @@
+import { Buffer } from 'buffer';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { platform } from 'process';
+import { PassThrough } from 'stream';
+import nock from 'nock';
+import semver from 'semver';
+import { spy } from 'sinon';
+import tmp from 'tmp-promise';
+import { test, expect } from 'vitest';
+import { DenoBridge, DENO_VERSION_RANGE } from './bridge.js';
+import { getPlatformTarget } from './platform.js';
+const require = createRequire(import.meta.url);
+const archiver = require('archiver');
+test('Downloads the Deno CLI on demand and caches it for subsequent calls', async () => {
+    var _a, _b, _c, _d;
+    const latestVersion = (_b = (_a = semver.minVersion(DENO_VERSION_RANGE)) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '';
+    const mockBinaryOutput = `#!/usr/bin/env sh\n\necho "deno ${latestVersion}"`;
+    const data = new PassThrough();
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    archive.pipe(data);
+    archive.append(Buffer.from(mockBinaryOutput), { name: platform === 'win32' ? 'deno.exe' : 'deno' });
+    archive.finalize();
+    const target = getPlatformTarget();
+    const latestReleaseMock = nock('https://dl.deno.land').get('/release-latest.txt').reply(200, `v${latestVersion}`);
+    const downloadMock = nock('https://dl.deno.land')
+        .get(`/release/v${latestVersion}/deno-${target}.zip`)
+        .reply(200, () => data);
+    const tmpDir = await tmp.dir();
+    const beforeDownload = spy();
+    const afterDownload = spy();
+    const deno = new DenoBridge({
+        cacheDirectory: tmpDir.path,
+        onBeforeDownload: beforeDownload,
+        onAfterDownload: afterDownload,
+        useGlobal: false,
+    });
+    const output1 = await deno.run(['help']);
+    const output2 = await deno.run(['help']);
+    const expectedOutput = /^deno [\d.]+/;
+    expect(latestReleaseMock.isDone()).toBe(true);
+    expect(downloadMock.isDone()).toBe(true);
+    expect((_c = output1 === null || output1 === void 0 ? void 0 : output1.stdout) !== null && _c !== void 0 ? _c : '').toMatch(expectedOutput);
+    expect((_d = output2 === null || output2 === void 0 ? void 0 : output2.stdout) !== null && _d !== void 0 ? _d : '').toMatch(expectedOutput);
+    expect(beforeDownload.callCount).toBe(1);
+    expect(afterDownload.callCount).toBe(1);
+    await fs.promises.rmdir(tmpDir.path, { recursive: true });
+});

package/dist/node/manifest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/manifest.test.js

@@ -0,0 +1,65 @@
+import { env } from 'process';
+import { test, expect } from 'vitest';
+import { generateManifest } from './manifest.js';
+test('Generates a manifest with different bundles', () => {
+    const bundle1 = {
+        extension: '.ext1',
+        format: 'format1',
+        hash: '123456',
+    };
+    const bundle2 = {
+        extension: '.ext2',
+        format: 'format2',
+        hash: '654321',
+    };
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1' }];
+    const manifest = generateManifest({ bundles: [bundle1, bundle2], declarations, functions });
+    const expectedBundles = [
+        { asset: bundle1.hash + bundle1.extension, format: bundle1.format },
+        { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
+    ];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    expect(manifest.bundles).toEqual(expectedBundles);
+    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',
+        format: 'format1',
+        hash: '123456',
+    };
+    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', path: '/f1' }];
+    const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    expect(manifest.routes).toEqual(expectedRoutes);
+});
+test('Excludes functions for which there are config declarations but no matching function files', () => {
+    const bundle1 = {
+        extension: '.ext2',
+        format: 'format1',
+        hash: '123456',
+    };
+    const functions = [{ name: 'func-2', path: '/path/to/func-2.ts' }];
+    const declarations = [
+        { function: 'func-1', path: '/f1' },
+        { function: 'func-2', path: '/f2' },
+    ];
+    const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
+    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$' }];
+    expect(manifest.routes).toEqual(expectedRoutes);
+});
+test('Generates a manifest without bundles', () => {
+    const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
+    const declarations = [{ function: 'func-1', path: '/f1' }];
+    const manifest = generateManifest({ bundles: [], declarations, functions });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    expect(manifest.bundles).toEqual([]);
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(manifest.bundler_version).toBe(env.npm_package_version);
+});

package/dist/node/package_json.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/package_json.test.js

@@ -0,0 +1,7 @@
+import semver from 'semver';
+import { test, expect } from 'vitest';
+import { getPackageVersion } from './package_json.js';
+test('`getPackageVersion` returns the package version`', () => {
+    const version = getPackageVersion();
+    expect(semver.valid(version)).not.toBeNull();
+});

package/dist/node/serving.test.d.ts

@@ -0,0 +1 @@
+export {};