@netlify/edge-bundler 9.5.0 → 10.1.0

package/README.md

@@ -9,32 +9,42 @@ Intelligently prepare Netlify Edge Functions for deployment.
 
 1. Install this module as a dependency in your project
 
-    ```
-    npm install @netlify/edge-bundler --save
-    ```
+   ```
+   npm install @netlify/edge-bundler --save
+   ```
 
 2. Import it and create a bundle from a directory of Edge Functions and a list of declarations.
 
-    ```js
-    import { bundle } from '@netlify/edge-bundler'
+   ```js
+   import { bundle } from '@netlify/edge-bundler'
 
-    // List of directories to search for Edge Functions.
-    const sourceDirectories = [
-        "/repo/netlify/edge-functions",
-        "/repo/.netlify/edge-functions"
-    ]
+   // List of directories to search for Edge Functions.
+   const sourceDirectories = ['/repo/netlify/edge-functions', '/repo/.netlify/edge-functions']
 
-    // Directory where bundle should be placed.
-    const distDirectory = "/repo/.netlify/edge-functions-dist"
+   // Directory where bundle should be placed.
+   const distDirectory = '/repo/.netlify/edge-functions-dist'
 
-    // List of Edge Functions declarations.
-    const declarations = [
-        {function: "user-1", path: "/blog/*"},
-        {function: "internal-2", path: "/"}
-    ]
+   // List of Edge Functions declarations.
+   const declarations = [
+     { function: 'user-1', path: '/blog/*' },
+     { function: 'internal-2', path: '/' },
+   ]
+
+   await bundle(sourceDirectories, distDirectory, declarations)
+   ```
+
+## Vendored modules
+
+To avoid pulling in additional dependencies at runtime, this package vendors some Deno modules in the `deno/vendor`
+directory.
+
+You can recreate this directory by running `npm run vendor`.
+
+> [!WARNING]  
+> At the time of writing, the underlying Deno CLI command doesn't correctly pull the WASM binary required by the ESZIP
+> module. If you run the command to update the list of vendores modules, please ensure you're not deleting
+> `eszip_wasm_bg.wasm`.
 
-    await bundle(sourceDirectories, distDirectory, declarations)
-    ```
 ## Contributors
 
 Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for instructions on how to set up and work on this repository. Thanks

package/deno/vendor/deno.land/x/deno_graph@0.59.2/media_type.ts

@@ -0,0 +1,20 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+export enum MediaType {
+  JavaScript = "JavaScript",
+  Mjs = "Mjs",
+  Cjs = "Cjs",
+  Jsx = "Jsx",
+  TypeScript = "TypeScript",
+  Mts = "Mts",
+  Cts = "Cts",
+  Dts = "Dts",
+  Dmts = "Dmts",
+  Dcts = "Dcts",
+  Tsx = "Tsx",
+  Json = "Json",
+  Wasm = "Wasm",
+  TsBuildInfo = "TsBuildInfo",
+  SourceMap = "SourceMap",
+  Unknown = "Unknown",
+}

package/deno/vendor/deno.land/x/deno_graph@0.59.2/types.d.ts

@@ -0,0 +1,182 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import type { MediaType } from "./media_type.ts";
+
+/** Additional meta data that is used to enrich the output of the module
+ * graph. */
+export interface CacheInfo {
+  /** The string path to where the local version of the content is located. For
+   * non `file:` URLs, this is the location of the cached content, otherwise it
+   * is the absolute path to the local file. */
+  local?: string;
+  /** The string path to where a transpiled version of the source content is
+   * located, if any. */
+  emit?: string;
+  /** The string path to where an external source map of the transpiled source
+   * content is located, if any. */
+  map?: string;
+}
+
+export interface TypesDependency {
+  /** The string URL to the type information for the module. */
+  types: string;
+  /** An optional range which indicates the source of the dependency. */
+  source?: Range;
+}
+
+export interface LoadResponseModule {
+  /** A module with code has been loaded. */
+  kind: "module";
+  /** The string URL of the resource. If there were redirects, the final
+   * specifier should be set here, otherwise the requested specifier. */
+  specifier: string;
+  /** For remote resources, a record of headers should be set, where the key's
+   * have been normalized to be lower case values. */
+  headers?: Record<string, string>;
+  /** The string value of the loaded resources. */
+  content: string;
+}
+
+export interface LoadResponseExternal {
+  /** The loaded module is either _external_ or _built-in_ to the runtime. */
+  kind: "external";
+  /** The strung URL of the resource. If there were redirects, the final
+   * specifier should be set here, otherwise the requested specifier. */
+  specifier: string;
+}
+
+export type LoadResponse = LoadResponseModule | LoadResponseExternal;
+
+export interface PositionJson {
+  /** The line number of a position within a source file. The number is a zero
+   * based index. */
+  line: number;
+  /** The character number of a position within a source file. The number is a
+   * zero based index. */
+  character: number;
+}
+
+export interface Range {
+  /** A string URL representing a source of a dependency. */
+  specifier: string;
+  /** The start location of a range of text in a source file. */
+  start?: PositionJson;
+  /** The end location of a range of text in a source file. */
+  end?: PositionJson;
+}
+
+export interface RangeJson {
+  /** The start location of a range of text in a source file. */
+  start: PositionJson;
+  /** The end location of a range of text in a source file. */
+  end: PositionJson;
+}
+
+export interface ResolvedDependency {
+  /** The fully resolved string URL of the dependency, which should be
+   * resolvable in the module graph. If there was an error, `error` will be set
+   * and this will be undefined. */
+  specifier?: string;
+  /** Any error encountered when trying to resolved the specifier. If this is
+   * defined, `specifier` will be undefined. */
+  error?: string;
+  /** The range within the source code where the specifier was identified. */
+  span: RangeJson;
+}
+
+export interface TypesDependencyJson {
+  /** The string specifier that was used for the dependency. */
+  specifier: string;
+  /** An object pointing to the resolved dependency. */
+  dependency: ResolvedDependency;
+}
+
+/** The kind of module.
+ *
+ * For asserted modules, the value of the `asserted` property is set to the
+ * `type` value of the import attribute.
+ *
+ * Dependency analysis is not performed for asserted or Script modules
+ * currently. Synthetic modules were injected into the graph with their own
+ * dependencies provided. */
+export type ModuleKind =
+  | "asserted"
+  | "esm"
+  | "npm"
+  | "external";
+
+export interface DependencyJson {
+  /** The string specifier that was used for the dependency. */
+  specifier: string;
+  /** An object pointing to the resolved _code_ dependency. */
+  code?: ResolvedDependency;
+  /** An object pointing to the resolved _type_ dependency of a module. This is
+   * populated when the `@deno-types` directive was used to supply a type
+   * definition file for a dependency. */
+  type?: ResolvedDependency;
+  /** A flag indicating if the dependency was dynamic. (e.g.
+   * `await import("mod.ts")`) */
+  isDynamic?: true;
+  assertionType?: string;
+}
+
+// todo(dsherret): split this up into separate types based on the "kind"
+
+export interface ModuleJson extends CacheInfo {
+  /** The string URL of the module. */
+  specifier: string;
+  /** Any error encountered when attempting to load the module. */
+  error?: string;
+  /** The module kind that was determined when the module was resolved. This is
+   * used by loaders to indicate how a module needs to be loaded at runtime. */
+  kind?: ModuleKind;
+  /** An array of dependencies that were identified in the module. */
+  dependencies?: DependencyJson[];
+  /** If the module had a types dependency, the information about that
+   * dependency. */
+  typesDependency?: TypesDependencyJson;
+  /** The resolved media type of the module, which determines how Deno will
+   * handle the module. */
+  mediaType?: MediaType;
+  /** The size of the source content of the module in bytes. */
+  size?: number;
+}
+
+export interface GraphImportJson {
+  /** The referrer (URL string) that was used as a base when resolving the
+   * imports added to the graph. */
+  referrer: string;
+  /** An array of resolved dependencies which were imported using the
+   * referrer. */
+  dependencies?: DependencyJson[];
+}
+
+/** The plain-object representation of a module graph that is suitable for
+ * serialization to JSON. */
+export interface ModuleGraphJson {
+  /** The module specifiers (URL string) of the _roots_ of the module graph of
+   * which the module graph was built for. */
+  roots: string[];
+  /** An array of modules that are part of the module graph. */
+  modules: ModuleJson[];
+  /** External imports that were added to the graph when it was being built.
+   * The key is the referrer which was used as a base to resolve the
+   * dependency. The value is the resolved dependency. */
+  imports?: GraphImportJson[];
+  /** A record/map of any redirects encountered when resolving modules. The
+   * key was the requested module specifier and the value is the redirected
+   * module specifier. */
+  redirects: Record<string, string>;
+}
+
+export interface Dependency {
+  /** An object pointing to the resolved _code_ dependency. */
+  code?: ResolvedDependency;
+  /** An object pointing to the resolved _type_ dependency of a module. This is
+   * populated when the `@deno-types` directive was used to supply a type
+   * definition file for a dependency. */
+  type?: ResolvedDependency;
+  /** A flag indicating if the dependency was dynamic. (e.g.
+   * `await import("mod.ts")`) */
+  isDynamic?: true;
+}

package/dist/deno/vendor/deno.land/x/deno_graph@0.59.2/media_type.d.ts

@@ -0,0 +1,18 @@
+export declare enum MediaType {
+    JavaScript = "JavaScript",
+    Mjs = "Mjs",
+    Cjs = "Cjs",
+    Jsx = "Jsx",
+    TypeScript = "TypeScript",
+    Mts = "Mts",
+    Cts = "Cts",
+    Dts = "Dts",
+    Dmts = "Dmts",
+    Dcts = "Dcts",
+    Tsx = "Tsx",
+    Json = "Json",
+    Wasm = "Wasm",
+    TsBuildInfo = "TsBuildInfo",
+    SourceMap = "SourceMap",
+    Unknown = "Unknown"
+}

package/dist/deno/vendor/deno.land/x/deno_graph@0.59.2/media_type.js

@@ -0,0 +1,20 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export var MediaType;
+(function (MediaType) {
+    MediaType["JavaScript"] = "JavaScript";
+    MediaType["Mjs"] = "Mjs";
+    MediaType["Cjs"] = "Cjs";
+    MediaType["Jsx"] = "Jsx";
+    MediaType["TypeScript"] = "TypeScript";
+    MediaType["Mts"] = "Mts";
+    MediaType["Cts"] = "Cts";
+    MediaType["Dts"] = "Dts";
+    MediaType["Dmts"] = "Dmts";
+    MediaType["Dcts"] = "Dcts";
+    MediaType["Tsx"] = "Tsx";
+    MediaType["Json"] = "Json";
+    MediaType["Wasm"] = "Wasm";
+    MediaType["TsBuildInfo"] = "TsBuildInfo";
+    MediaType["SourceMap"] = "SourceMap";
+    MediaType["Unknown"] = "Unknown";
+})(MediaType || (MediaType = {}));

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/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 { serve } from './server/server.js';
+export type { EdgeFunctionConfig, Manifest } from './manifest.js';
+export { ModuleGraph, 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

@@ -3,12 +3,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+import type { ModuleGraphJson } from '../../deno/vendor/deno.land/x/deno_graph@0.59.2/types.d.js';
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
 import type { FeatureFlags } from '../feature_flags.js';
 import { LogFunction } from '../logger.js';
 export type FormatFunction = (name: string) => string;
+export type ModuleGraph = ModuleGraphJson;
 interface StartServerOptions {
     getFunctionsConfig?: boolean;
 }
@@ -31,14 +33,15 @@ 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;
+    graph: ModuleGraphJson;
     npmSpecifiersWithExtraneousFiles: string[];
     success: boolean;
 }>>;

package/dist/node/server/server.js

@@ -18,13 +18,17 @@ 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) {
             await killProcess(processRef.ps);
         }
-        let graph;
+        let graph = {
+            roots: [],
+            modules: [],
+            redirects: {},
+        };
         const stage2Path = await generateStage2({
             bootstrapURL,
             distDirectory,
@@ -45,6 +49,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
             importMap,
             logger,
             referenceTypes: true,
+            rootPath,
         });
         if (vendor) {
             features.npmModules = true;
@@ -92,7 +97,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 +220,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';
@@ -47,9 +48,7 @@ test('Starts a server and serves requests for edge functions', async () => {
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
     expect(npmSpecifiersWithExtraneousFiles).toEqual(['dictionary']);
     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);
+        const graphEntry = graph === null || graph === void 0 ? void 0 : 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}/foo`, {
@@ -86,3 +85,50 @@ 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(({ 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/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.1.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -34,7 +34,8 @@
     "test:dev:deno": "deno test --allow-all deno",
     "test:ci:vitest": "vitest run --coverage",
     "test:ci:deno": "deno test --allow-all deno",
-    "test:integration": "node --experimental-modules test/integration/test.js"
+    "test:integration": "node --experimental-modules test/integration/test.js",
+    "vendor": "deno vendor --force --output deno/vendor https://deno.land/x/deno_graph@0.59.2/types.d.ts https://deno.land/x/eszip@v0.55.2/mod.ts https://deno.land/x/retry@v2.0.0/mod.ts https://deno.land/x/std@0.177.0/path/mod.ts"
   },
   "config": {
     "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{node,scripts,.github}/**/*.{js,ts,md,html}\" \"*.{js,ts,md,html}\"",
@@ -80,7 +81,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",