@netlify/edge-bundler 9.5.0 → 10.0.0

package/deno/lib/stage2.test.ts

@@ -0,0 +1,58 @@
+import { assertEquals, assertStringIncludes } from 'https://deno.land/std@0.177.0/testing/asserts.ts'
+
+import { join } from 'https://deno.land/std@0.177.0/path/mod.ts'
+import { pathToFileURL } from 'https://deno.land/std@0.177.0/node/url.ts'
+
+import { getStage2Entry } from './stage2.ts'
+import { virtualRoot } from './consts.ts'
+
+Deno.test('`getStage2Entry` returns a valid stage 2 file', async () => {
+  const directory = await Deno.makeTempDir()
+  const functions = [
+    {
+      name: 'func1',
+      path: join(directory, 'func1.ts'),
+      response: 'Hello from function 1',
+    },
+    {
+      name: 'func2',
+      path: join(directory, 'func2.ts'),
+      response: 'Hello from function 2',
+    },
+  ]
+
+  for (const func of functions) {
+    const contents = `export default async () => new Response(${JSON.stringify(func.response)})`
+
+    await Deno.writeTextFile(func.path, contents)
+  }
+
+  const baseURL = pathToFileURL(directory)
+  const stage2 = getStage2Entry(
+    directory,
+    functions.map(({ name, path }) => ({ name, path })),
+  )
+
+  // Ensuring that the stage 2 paths have the virtual root before we strip it.
+  assertStringIncludes(stage2, virtualRoot)
+
+  // Replacing the virtual root with the URL of the temporary directory so that
+  // we can actually import the module.
+  const normalizedStage2 = stage2.replaceAll(virtualRoot, `${baseURL.href}/`)
+
+  const stage2Path = join(directory, 'stage2.ts')
+  const stage2URL = pathToFileURL(stage2Path)
+
+  await Deno.writeTextFile(stage2Path, normalizedStage2)
+
+  const mod = await import(stage2URL.href)
+
+  await Deno.remove(directory, { recursive: true })
+
+  for (const func of functions) {
+    const result = await mod.functions[func.name]()
+
+    assertEquals(await result.text(), func.response)
+    assertEquals(mod.metadata.functions[func.name].url, pathToFileURL(func.path).toString())
+  }
+})

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

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

package/dist/node/bootstrap.test.js

@@ -0,0 +1,26 @@
+import { Buffer } from 'buffer';
+import { env } from 'process';
+import fetch, { Headers } from 'node-fetch';
+import { test, expect } from 'vitest';
+import { getBootstrapURL } from './formats/javascript.js';
+test('Imports the bootstrap layer from a valid URL', async () => {
+    const importURL = new URL(getBootstrapURL());
+    const headers = new Headers();
+    // `node-fetch` doesn't let us send credentials as part of the URL, so we
+    // have to transform them into an `Authorization` header.
+    if (importURL.username) {
+        const auth = Buffer.from(`${importURL.username}:${importURL.password}`);
+        importURL.username = '';
+        importURL.password = '';
+        headers.set('Authorization', `Basic ${auth.toString('base64')}`);
+    }
+    const canonicalURL = importURL.toString();
+    const { status } = await fetch(canonicalURL, { headers });
+    expect(status).toBe(200);
+});
+test('Imports the bootstrap layer from the URL present in the `NETLIFY_EDGE_BOOTSTRAP` environment variable, if present', () => {
+    const mockURL = 'https://example.com/boot.ts';
+    env.NETLIFY_EDGE_BOOTSTRAP = mockURL;
+    expect(getBootstrapURL()).toBe(mockURL);
+    env.NETLIFY_EDGE_BOOTSTRAP = undefined;
+});

package/dist/node/bundler.d.ts

@@ -15,11 +15,12 @@ export interface BundleOptions {
     internalSrcFolder?: string;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
+    rootPath?: string;
     systemLogger?: LogFunction;
     userLogger?: LogFunction;
     vendorDirectory?: string;
 }
-export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, userLogger, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
+export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, rootPath, userLogger, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -15,7 +15,7 @@ import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
-export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, userLogger, systemLogger, vendorDirectory, } = {}) => {
+export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, rootPath, userLogger, systemLogger, vendorDirectory, } = {}) => {
     const logger = getLogger(systemLogger, userLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -53,6 +53,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         functions,
         importMap,
         logger,
+        rootPath: rootPath !== null && rootPath !== void 0 ? rootPath : basePath,
         vendorDirectory,
     });
     if (vendor) {
@@ -147,7 +148,7 @@ const createFunctionConfig = ({ internalFunctionsWithConfig, declarations }) =>
         [functionName]: addGeneratorFallback(mergedConfigFields),
     };
 }, {});
-const safelyVendorNPMSpecifiers = async ({ basePath, functions, importMap, logger, vendorDirectory, }) => {
+const safelyVendorNPMSpecifiers = async ({ basePath, functions, importMap, logger, rootPath, vendorDirectory, }) => {
     try {
         return await vendorNPMSpecifiers({
             basePath,
@@ -156,6 +157,7 @@ const safelyVendorNPMSpecifiers = async ({ basePath, functions, importMap, logge
             importMap,
             logger,
             referenceTypes: false,
+            rootPath,
         });
     }
     catch (error) {

package/dist/node/bundler.test.js

@@ -380,6 +380,34 @@ test('Loads npm modules from bare specifiers', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
+test('Loads npm modules in a monorepo setup', async () => {
+    const systemLogger = vi.fn();
+    const { basePath: rootPath, cleanup, distPath } = await useFixture('monorepo_npm_module');
+    const basePath = join(rootPath, 'packages', 'frontend');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        importMapPaths: [join(basePath, 'import_map.json')],
+        rootPath,
+        vendorDirectory: vendorDirectory.path,
+        systemLogger,
+    });
+    expect(systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:')).toBeUndefined();
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(func1).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>`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});
 test('Loads JSON modules', async () => {
     const { basePath, cleanup, distPath } = await useFixture('imports_json');
     const sourceDirectory = join(basePath, 'functions');

package/dist/node/deno_config.d.ts

@@ -0,0 +1,5 @@
+interface DenoConfigFile {
+    importMap?: string;
+}
+export declare const getConfig: (basePath?: string) => Promise<DenoConfigFile | undefined>;
+export {};

package/dist/node/deno_config.js

@@ -0,0 +1,40 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import { parse as parseJSONC } from 'jsonc-parser';
+import { isNodeError } from './utils/error.js';
+const filenames = ['deno.json', 'deno.jsonc'];
+export const getConfig = async (basePath) => {
+    if (basePath === undefined) {
+        return;
+    }
+    for (const filename of filenames) {
+        const candidatePath = join(basePath, filename);
+        const config = await getConfigFromFile(candidatePath);
+        if (config !== undefined) {
+            return normalizeConfig(config, basePath);
+        }
+    }
+};
+const getConfigFromFile = async (filePath) => {
+    try {
+        const data = await fs.readFile(filePath, 'utf8');
+        const config = parseJSONC(data);
+        return config;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return;
+        }
+        return {};
+    }
+};
+const normalizeConfig = (rawConfig, basePath) => {
+    const config = {};
+    if (rawConfig.importMap) {
+        if (typeof rawConfig.importMap !== 'string') {
+            throw new TypeError(`'importMap' property in Deno config must be a string`);
+        }
+        config.importMap = resolve(basePath, rawConfig.importMap);
+    }
+    return config;
+};

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

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

package/dist/node/deno_config.test.js

@@ -0,0 +1,37 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import tmp from 'tmp-promise';
+import { expect, test } from 'vitest';
+import { getConfig } from './deno_config.js';
+test('Returns `undefined` if no config file is found', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const config = await getConfig(path);
+    expect(config).toBeUndefined();
+    await cleanup();
+});
+test('Returns an empty object if the config file cannot be parsed', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    await fs.writeFile(configPath, '{');
+    const config = await getConfig(path);
+    expect(config).toEqual({});
+    await cleanup();
+});
+test('Resolves `importMap` into an absolute path', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    const data = JSON.stringify({ importMap: 'import_map.json' });
+    await fs.writeFile(configPath, data);
+    const config = await getConfig(path);
+    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
+    await cleanup();
+});
+test('Supports JSONC', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.jsonc');
+    const data = JSON.stringify({ importMap: 'import_map.json' });
+    await fs.writeFile(configPath, `// This is a comment\n${data}`);
+    const config = await getConfig(path);
+    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
+    await cleanup();
+});

package/dist/node/index.d.ts

@@ -5,5 +5,6 @@ export { Declaration, mergeDeclarations } from './declaration.js';
 export type { EdgeFunction } from './edge_function.js';
 export { findFunctions as find } from './finder.js';
 export { generateManifest } from './manifest.js';
+export type { EdgeFunctionConfig, Manifest } from './manifest.js';
 export { serve } from './server/server.js';
 export { validateManifest, ManifestValidationError } from './validation/manifest/index.js';

package/dist/node/manifest.d.ts

@@ -11,7 +11,7 @@ interface Route {
     path?: string;
     methods?: string[];
 }
-interface EdgeFunctionConfig {
+export interface EdgeFunctionConfig {
     excluded_patterns: string[];
     on_error?: string;
     generator?: string;
@@ -42,7 +42,11 @@ interface GenerateManifestOptions {
     layers?: Layer[];
     userFunctionConfig?: Record<string, FunctionConfig>;
 }
-declare const generateManifest: ({ bundles, declarations, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, functions, userFunctionConfig, internalFunctionConfig, importMap, layers, }: GenerateManifestOptions) => {
+    declarationsWithoutFunction: string[];
+    manifest: Manifest;
+    unroutedFunctions: string[];
+};
 interface WriteManifestOptions extends GenerateManifestOptions {
     distDirectory: string;
 }

package/dist/node/manifest.js

@@ -29,7 +29,7 @@ const sanitizeEdgeFunctionConfig = (config) => {
 const addExcludedPatterns = (name, manifestFunctionConfig, excludedPath) => {
     if (excludedPath) {
         const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
-        const excludedPatterns = paths.map((path) => pathToRegularExpression(path)).map(serializePattern);
+        const excludedPatterns = paths.map(pathToRegularExpression).filter(nonNullable).map(serializePattern);
         manifestFunctionConfig[name].excluded_patterns.push(...excludedPatterns);
     }
 };
@@ -50,6 +50,8 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     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)) {
         // If the config block is for a function that is not defined, discard it.
         if (manifestFunctionConfig[name] === undefined) {
@@ -69,9 +71,16 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
     declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
         if (func === undefined) {
+            declarationsWithoutFunction.add(declaration.function);
             return;
         }
         const pattern = getRegularExpression(declaration);
+        // If there is no `pattern`, the declaration will never be triggered, so we
+        // can discard it.
+        if (!pattern) {
+            return;
+        }
+        routedFunctions.add(declaration.function);
         const excludedPattern = getExcludedRegularExpressions(declaration);
         const route = {
             function: func.name,
@@ -104,9 +113,13 @@ const generateManifest = ({ bundles = [], declarations = [], functions, userFunc
         import_map: importMap,
         function_config: sanitizeEdgeFunctionConfig(manifestFunctionConfig),
     };
-    return manifest;
+    const unroutedFunctions = functions.filter(({ name }) => !routedFunctions.has(name)).map(({ name }) => name);
+    return { declarationsWithoutFunction: [...declarationsWithoutFunction], manifest, unroutedFunctions };
 };
 const pathToRegularExpression = (path) => {
+    if (!path) {
+        return null;
+    }
     try {
         const pattern = new ExtendedURLPattern({ pathname: path });
         // Removing the `^` and `$` delimiters because we'll need to modify what's
@@ -149,12 +162,12 @@ const getExcludedRegularExpressions = (declaration) => {
     }
     if ('path' in declaration && declaration.excludedPath) {
         const paths = Array.isArray(declaration.excludedPath) ? declaration.excludedPath : [declaration.excludedPath];
-        return paths.map((path) => pathToRegularExpression(path));
+        return paths.map(pathToRegularExpression).filter(nonNullable);
     }
     return [];
 };
 const writeManifest = async ({ distDirectory, ...rest }) => {
-    const manifest = generateManifest(rest);
+    const { manifest } = generateManifest(rest);
     const manifestPath = join(distDirectory, 'manifest.json');
     await fs.writeFile(manifestPath, JSON.stringify(manifest));
     return manifest;

package/dist/node/manifest.test.js

@@ -17,7 +17,7 @@ test('Generates a manifest with different bundles', () => {
     };
     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 { 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 },
@@ -35,7 +35,7 @@ test('Generates a manifest with display names', () => {
             name: 'Display Name',
         },
     };
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -56,7 +56,7 @@ test('Generates a manifest with a generator field', () => {
             generator: '@netlify/fake-plugin@1.0.0',
         },
     };
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -79,7 +79,7 @@ test('Generates a manifest with excluded paths and patterns', () => {
         { function: 'func-2', pattern: '^/f2(?:/(.*))/?$', excludedPattern: ['^/f2/exclude$', '^/f2/exclude-as-well$'] },
         { function: 'func-3', path: '/*', excludedPath: '/**/*.html' },
     ];
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -111,7 +111,7 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
     const userFunctionConfig = {
         'func-1': { excludedPath: '/f1/exclude' },
     };
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -153,7 +153,7 @@ test('Filters out internal in-source configurations in user created functions',
             generator: 'internal-generator',
         },
     };
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -186,7 +186,7 @@ test('excludedPath from ISC goes into function_config, TOML goes into routes', (
         },
     };
     const internalFunctionConfig = {};
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -224,7 +224,7 @@ test('URLPattern named groups are supported', () => {
     const declarations = [{ function: 'customisation', path: '/products/:productId' }];
     const userFunctionConfig = {};
     const internalFunctionConfig = {};
-    const manifest = generateManifest({
+    const { manifest } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -269,7 +269,7 @@ test('Includes failure modes in manifest', () => {
             onError: '/custom-error',
         },
     };
-    const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
+    const { manifest } = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
     expect(manifest.function_config).toEqual({
         'func-1': { on_error: '/custom-error' },
     });
@@ -285,7 +285,7 @@ test('Excludes functions for which there are function files but no matching conf
         { name: 'func-2', path: '/path/to/func-2.ts' },
     ];
     const declarations = [{ function: 'func-1', path: '/f1' }];
-    const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
+    const { manifest } = generateManifest({ bundles: [bundle1], declarations, functions });
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
@@ -300,14 +300,14 @@ test('Excludes functions for which there are config declarations but no matching
         { function: 'func-1', path: '/f1' },
         { function: 'func-2', path: '/f2' },
     ];
-    const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
+    const { manifest } = generateManifest({ bundles: [bundle1], declarations, functions });
     const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$', excluded_patterns: [], path: '/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 { manifest } = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
     expect(manifest.bundles).toEqual([]);
     expect(manifest.routes).toEqual(expectedRoutes);
@@ -334,7 +334,7 @@ test('Generates a manifest with pre and post-cache routes', () => {
         { function: 'func-2', cache: 'not_a_supported_value', path: '/f2' },
         { function: 'func-3', cache: 'manual', path: '/f3' },
     ];
-    const manifest = generateManifest({ bundles: [bundle1, bundle2], declarations, functions });
+    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 },
@@ -370,12 +370,12 @@ test('Generates a manifest with layers', () => {
             flag: 'edge_functions_onion_layer',
         },
     ];
-    const manifest1 = generateManifest({
+    const { manifest: manifest1 } = generateManifest({
         bundles: [],
         declarations,
         functions,
     });
-    const manifest2 = generateManifest({
+    const { manifest: manifest2 } = generateManifest({
         bundles: [],
         declarations,
         functions,
@@ -398,6 +398,34 @@ test('Throws an error if the regular expression contains a negative lookahead',
 test('Converts named capture groups to unnamed capture groups in regular expressions', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^/(?<name>\\w+)$' }];
-    const manifest = generateManifest({ bundles: [], declarations, functions });
+    const { manifest } = generateManifest({ bundles: [], declarations, functions });
     expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(\\w+)$', excluded_patterns: [] }]);
 });
+test('Returns functions without a declaration and unrouted functions', () => {
+    const bundle = {
+        extension: '.ext1',
+        format: BundleFormat.ESZIP2,
+        hash: '123456',
+    };
+    const functions = [
+        { name: 'func-1', path: '/path/to/func-1.ts' },
+        { name: 'func-2', path: '/path/to/func-2.ts' },
+        { name: 'func-4', path: '/path/to/func-4.ts' },
+    ];
+    const declarations = [
+        { function: 'func-1', path: '/f1' },
+        { function: 'func-3', path: '/f3' },
+        // @ts-expect-error Error is expected due to neither `path` or `pattern`
+        // being present.
+        { function: 'func-4', name: 'Some name' },
+    ];
+    const { declarationsWithoutFunction, manifest, unroutedFunctions } = generateManifest({
+        bundles: [bundle],
+        declarations,
+        functions,
+    });
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [], path: '/f1' }];
+    expect(manifest.routes).toEqual(expectedRoutes);
+    expect(declarationsWithoutFunction).toEqual(['func-3']);
+    expect(unroutedFunctions).toEqual(['func-2', 'func-4']);
+});

package/dist/node/npm_dependencies.d.ts

@@ -8,8 +8,9 @@ interface VendorNPMSpecifiersOptions {
     importMap: ImportMap;
     logger: Logger;
     referenceTypes: boolean;
+    rootPath?: string;
 }
-export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, referenceTypes, }: VendorNPMSpecifiersOptions) => Promise<{
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, referenceTypes, rootPath, }: VendorNPMSpecifiersOptions) => Promise<{
     cleanup: () => Promise<void>;
     directory: string;
     importMap: {

package/dist/node/npm_dependencies.js

@@ -8,6 +8,7 @@ import { build } from 'esbuild';
 import { findUp } from 'find-up';
 import getPackageName from 'get-package-name';
 import tmp from 'tmp-promise';
+import { pathsBetween } from './utils/fs.js';
 const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.cts', '.mts']);
 const slugifyPackageName = (specifier) => {
     if (!specifier.startsWith('@'))
@@ -76,16 +77,12 @@ const banner = {
 /**
  * Parses a set of functions and returns a list of specifiers that correspond
  * to npm modules.
- *
- * @param basePath Root of the project
- * @param functions Functions to parse
- * @param importMap Import map to apply when resolving imports
- * @param referenceTypes Whether to detect typescript declarations and reference them in the output
  */
-const getNPMSpecifiers = async (basePath, functions, importMap, referenceTypes) => {
+const getNPMSpecifiers = async ({ basePath, functions, importMap, referenceTypes, rootPath, }) => {
     const baseURL = pathToFileURL(basePath);
     const { reasons } = await nodeFileTrace(functions, {
-        base: basePath,
+        base: rootPath,
+        processCwd: basePath,
         readFile: async (filePath) => {
             // If this is a TypeScript file, we need to compile in before we can
             // parse it.
@@ -165,17 +162,23 @@ const getNPMSpecifiers = async (basePath, functions, importMap, referenceTypes)
         npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
     };
 };
-export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, referenceTypes, }) => {
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, referenceTypes, rootPath = basePath, }) => {
     // The directories that esbuild will use when resolving Node modules. We must
     // set these manually because esbuild will be operating from a temporary
     // directory that will not live inside the project root, so the normal
     // resolution logic won't work.
-    const nodePaths = [path.join(basePath, 'node_modules')];
+    const nodePaths = pathsBetween(basePath, rootPath).map((directory) => path.join(directory, 'node_modules'));
     // We need to create some files on disk, which we don't want to write to the
     // project directory. If a custom directory has been specified, we use it.
     // Otherwise, create a random temporary directory.
     const temporaryDirectory = directory ? { path: directory } : await tmp.dir();
-    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers(basePath, functions, importMap.getContentsWithURLObjects(), referenceTypes);
+    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers({
+        basePath,
+        functions,
+        importMap: importMap.getContentsWithURLObjects(),
+        referenceTypes,
+        rootPath,
+    });
     // If we found no specifiers, there's nothing left to do here.
     if (Object.keys(npmSpecifiers).length === 0) {
         return;

package/dist/node/server/server.d.ts

@@ -1,8 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
@@ -31,11 +26,12 @@ interface ServeOptions {
     formatExportTypeError?: FormatFunction;
     formatImportError?: FormatFunction;
     port: number;
+    rootPath?: string;
     servePath: string;
     userLogger?: LogFunction;
     systemLogger?: LogFunction;
 }
-export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, servePath, userLogger, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, rootPath, servePath, userLogger, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
     features: Record<string, boolean>;
     functionsConfig: FunctionConfig[];
     graph: any;

package/dist/node/server/server.js

@@ -18,7 +18,7 @@ const cleanDirectory = async (directory, except) => {
     const toBeDeleted = files.filter((file) => !except.includes(join(directory, file)));
     await Promise.all(toBeDeleted.map((file) => unlink(join(directory, file))));
 };
-const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, importMap: baseImportMap, logger, port, }) => {
+const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, importMap: baseImportMap, logger, port, rootPath, }) => {
     const processRef = {};
     const startServer = async (functions, env = {}, options = {}) => {
         if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
@@ -45,6 +45,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             importMap,
             logger,
             referenceTypes: true,
+            rootPath,
         });
         if (vendor) {
             features.npmModules = true;
@@ -92,7 +93,85 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
     };
     return startServer;
 };
-export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, featureFlags, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, servePath, userLogger, systemLogger, }) => {
+export const serve = async ({ 
+/**
+ * Path that is common to all functions. Works as the root directory in the
+ * generated bundle.
+ */
+basePath, 
+/**
+ * URL of the bootstrap layer to use.
+ */
+bootstrapURL, 
+/**
+ * Path to an SSL certificate to run the Deno server with.
+ */
+certificatePath, 
+/**
+ * Whether to print verbose information about the server process.
+ */
+debug, 
+/**
+ * Path of an import map file to be generated using the built-in specifiers
+ * and any npm modules found during the bundling process.
+ */
+distImportMapPath, 
+/**
+ * Debug settings to use with Deno's `--inspect` and `--inspect-brk` flags.
+ */
+inspectSettings, 
+/**
+ * Map of feature flags.
+ */
+featureFlags, 
+/**
+ * Callback function to be triggered whenever a function has a default export
+ * with the wrong type.
+ */
+formatExportTypeError, 
+/**
+ * Callback function to be triggered whenever an error occurs while importing
+ * a function.
+ */
+formatImportError, 
+/**
+ * Paths to any additional import map files.
+ */
+importMapPaths = [], 
+/**
+ * Callback function to be triggered after the Deno CLI has been downloaded.
+ */
+onAfterDownload, 
+/**
+ * Callback function to be triggered before we attempt to download the Deno
+ * CLI.
+ */
+onBeforeDownload, 
+/**
+ * Port where the server should listen on.
+ */
+port, 
+/**
+ * Root path of the project. Defines a boundary outside of which files or npm
+ * modules cannot be included from. This is usually the same as `basePath`,
+ * with monorepos being the main exception, where `basePath` maps to the
+ * package path and `rootPath` is the repository root.
+ */
+rootPath, 
+/**
+ * Path to write ephemeral files that need to be generated for the server to
+ * operate.
+ */
+servePath, 
+/**
+ * Custom logging function to be used for user-facing messages. Defaults to
+ * `console.log`.
+ */
+userLogger, 
+/**
+ * Custom logging function to be used for system-level messages.
+ */
+systemLogger, }) => {
     const logger = getLogger(systemLogger, userLogger, debug);
     const deno = new DenoBridge({
         debug,
@@ -137,6 +216,7 @@ export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, di
         importMap,
         logger,
         port,
+        rootPath,
     });
     return server;
 };

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

@@ -1,5 +1,6 @@
 import { readFile } from 'fs/promises';
 import { join } from 'path';
+import process from 'process';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
 import { v4 as uuidv4 } from 'uuid';
@@ -86,3 +87,52 @@ test('Starts a server and serves requests for edge functions', async () => {
     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 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: 'https://edge.netlify.com/bootstrap/index-combined.ts',
+        importMapPaths,
+        port,
+        rootPath,
+        servePath,
+    });
+    const functions = [
+        {
+            name: 'func1',
+            path: join(paths.user, 'func1.ts'),
+        },
+    ];
+    const options = {
+        getFunctionsConfig: true,
+    };
+    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
+        very_secret_secret: 'i love netlify',
+    }, options);
+    expect(features).toEqual({ npmModules: true });
+    expect(success).toBe(true);
+    expect(functionsConfig).toEqual([{ path: '/func1' }]);
+    expect(npmSpecifiersWithExtraneousFiles).toEqual(['child-1']);
+    for (const key in functions) {
+        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
+        // @ts-expect-error TODO: Module graph is currently not typed
+        ({ 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>`);
+});

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

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

package/dist/node/serving.test.js

@@ -0,0 +1,31 @@
+import { join } from 'path';
+import getPort from 'get-port';
+import fetch from 'node-fetch';
+import { test, expect } from 'vitest';
+import { fixturesDir } from '../test/util.js';
+import { serve } from './index.js';
+test('bundler serving functionality', async () => {
+    const port = await getPort();
+    const server = await serve({
+        port,
+    });
+    const { success } = await server([
+        {
+            name: 'echo_env',
+            path: join(fixturesDir, 'serve_test', 'echo_env.ts'),
+        },
+    ], {
+        very_secret_secret: 'i love netlify',
+    });
+    expect(success).toBe(true);
+    const response = await fetch(`http://0.0.0.0:${port}/foo`, {
+        headers: {
+            'x-deno-functions': 'echo_env',
+            'x-deno-pass': 'passthrough',
+            'X-NF-Request-ID': 'foo',
+        },
+    });
+    expect(response.status).toBe(200);
+    const body = (await response.json());
+    expect(body.very_secret_secret).toBe('i love netlify');
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Returns all the directories obtained by traversing `inner` and its parents
+ * all the way to `outer`, inclusive.
+ */
+export declare const pathsBetween: (inner: string, outer: string, paths?: string[]) => string[];

package/dist/node/utils/fs.js

@@ -0,0 +1,12 @@
+import path from 'path';
+/**
+ * Returns all the directories obtained by traversing `inner` and its parents
+ * all the way to `outer`, inclusive.
+ */
+export const pathsBetween = (inner, outer, paths = []) => {
+    const parent = path.dirname(inner);
+    if (inner === outer || inner === parent) {
+        return [...paths, outer];
+    }
+    return [inner, ...pathsBetween(parent, outer)];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "9.5.0",
+  "version": "10.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -80,7 +80,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
-    "esbuild": "0.19.4",
+    "esbuild": "0.19.5",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-package-name": "^2.2.0",