@netlify/edge-bundler 4.4.3 → 5.0.0

package/deno/bundle.ts

@@ -1,6 +1,6 @@
 import { writeStage2 } from './lib/stage2.ts'
 
 const [payload] = Deno.args
-const { basePath, destPath, functions, importMapURL } = JSON.parse(payload)
+const { basePath, destPath, externals, functions, importMapURL } = JSON.parse(payload)
 
-await writeStage2({ basePath, destPath, functions, importMapURL })
+await writeStage2({ basePath, destPath, externals, functions, importMapURL })

package/deno/lib/consts.ts

@@ -1,4 +1,3 @@
-export const CUSTOM_LAYER_PREFIX = 'layer:'
 export const PUBLIC_SPECIFIER = 'netlify:edge'
 export const STAGE1_SPECIFIER = 'netlify:bootstrap-stage1'
 export const STAGE2_SPECIFIER = 'netlify:bootstrap-stage2'

package/deno/lib/stage2.ts

@@ -3,7 +3,7 @@ import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.28.0/mod.ts'
 import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
-import { CUSTOM_LAYER_PREFIX, PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
+import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
 interface FunctionReference {
@@ -62,7 +62,7 @@ const getVirtualPath = (basePath: string, filePath: string) => {
   return url
 }
 
-const stage2Loader = (basePath: string, functions: InputFunction[]) => {
+const stage2Loader = (basePath: string, functions: InputFunction[], externals: Set<string>) => {
   return async (specifier: string): Promise<LoadResponse | undefined> => {
     if (specifier === STAGE2_SPECIFIER) {
       const stage2Entry = getStage2Entry(basePath, functions)
@@ -70,7 +70,7 @@ const stage2Loader = (basePath: string, functions: InputFunction[]) => {
       return inlineModule(specifier, stage2Entry)
     }
 
-    if (specifier === PUBLIC_SPECIFIER || specifier.startsWith(CUSTOM_LAYER_PREFIX)) {
+    if (specifier === PUBLIC_SPECIFIER || externals.has(specifier)) {
       return {
         kind: 'external',
         specifier,
@@ -85,8 +85,8 @@ const stage2Loader = (basePath: string, functions: InputFunction[]) => {
   }
 }
 
-const writeStage2 = async ({ basePath, destPath, functions, importMapURL }: WriteStage2Options) => {
-  const loader = stage2Loader(basePath, functions)
+const writeStage2 = async ({ basePath, destPath, externals, functions, importMapURL }: WriteStage2Options) => {
+  const loader = stage2Loader(basePath, functions, new Set(externals))
   const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
   const directory = path.dirname(destPath)
 

package/dist/node/bundler.d.ts

@@ -1,24 +1,20 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from './bridge.js';
 import { Declaration } from './declaration.js';
-import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
-import { ImportMapFile } from './import_map.js';
-import { Layer } from './layer.js';
 import { LogFunction } from './logger.js';
 interface BundleOptions {
     basePath?: string;
     cacheDirectory?: string;
+    configPath?: string;
     debug?: boolean;
     distImportMapPath?: string;
     featureFlags?: FeatureFlags;
-    importMaps?: ImportMapFile[];
-    layers?: Layer[];
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, layers, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
-    functions: EdgeFunction[];
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
+    functions: import("./edge_function.js").EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;
 export { bundle };

package/dist/node/bundler.js

@@ -5,37 +5,15 @@ import { v4 as uuidv4 } from 'uuid';
 import { DenoBridge } from './bridge.js';
 import { getFunctionConfig } from './config.js';
 import { getDeclarationsFromConfig } from './declaration.js';
+import { load as loadDeployConfig } from './deploy_config.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
 import { bundle as bundleESZIP } from './formats/eszip.js';
-import { bundle as bundleJS } from './formats/javascript.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
-const createBundle = ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, featureFlags, }) => {
-    if (featureFlags.edge_functions_produce_eszip) {
-        return bundleESZIP({
-            basePath,
-            buildID,
-            debug,
-            deno,
-            distDirectory,
-            featureFlags,
-            functions,
-            importMap,
-        });
-    }
-    return bundleJS({
-        buildID,
-        debug,
-        deno,
-        distDirectory,
-        functions,
-        importMap,
-    });
-};
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, layers, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -55,19 +33,27 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     // compute until we run the bundle process. For now, we'll use a random ID
     // to create the bundle artifacts and rename them later.
     const buildID = uuidv4();
-    // Creating an ImportMap instance with any import maps supplied by the user,
-    // if any.
-    const importMap = new ImportMap(importMaps);
+    // Loading any configuration options from the deploy configuration API, if it
+    // exists.
+    const deployConfig = await loadDeployConfig(configPath, logger);
+    // Layers are marked as externals in the ESZIP, so that those specifiers are
+    // not actually included in the bundle.
+    const externals = deployConfig.layers.map((layer) => layer.name);
+    const importMap = new ImportMap();
+    if (deployConfig.importMap) {
+        importMap.add(deployConfig.importMap);
+    }
     const functions = await findFunctions(sourceDirectories);
-    const functionBundle = await createBundle({
+    const functionBundle = await bundleESZIP({
         basePath,
         buildID,
         debug,
         deno,
         distDirectory,
+        externals,
         functions,
-        importMap,
         featureFlags,
+        importMap,
     });
     // The final file name of the bundles contains a SHA256 hash of the contents,
     // which we can only compute now that the files have been generated. So let's
@@ -82,15 +68,15 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     }));
     // Creating a hash of function names to configuration objects.
     const functionsWithConfig = functions.reduce((acc, func, index) => ({ ...acc, [func.name]: functionsConfig[index] }), {});
-    // Creating a final declarations array by combining the TOML entries with the
-    // function configuration objects.
-    const declarations = getDeclarationsFromConfig(tomlDeclarations, functionsWithConfig);
+    // Creating a final declarations array by combining the TOML file with the
+    // deploy configuration API and the in-source configuration.
+    const declarations = getDeclarationsFromConfig(tomlDeclarations, functionsWithConfig, deployConfig);
     const manifest = await writeManifest({
         bundles: [functionBundle],
         declarations,
         distDirectory,
         functions,
-        layers,
+        layers: deployConfig.layers,
     });
     if (distImportMapPath) {
         await importMap.writeToFile(distImportMapPath);

package/dist/node/bundler.test.js

@@ -1,14 +1,14 @@
 import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
 import process from 'process';
-import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
 import { fixturesDir } from '../test/util.js';
 import { BundleError } from './bundle_error.js';
 import { bundle } from './bundler.js';
-test('Produces a JavaScript bundle and a manifest file', async () => {
+import { isNodeError } from './utils/error.js';
+test('Produces an ESZIP bundle', async () => {
     const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
     const tmpDir = await tmp.dir();
     const declarations = [
@@ -19,49 +19,7 @@ test('Produces a JavaScript bundle and a manifest file', async () => {
     ];
     const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
         basePath: fixturesDir,
-        importMaps: [
-            {
-                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
-                imports: {
-                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
-                },
-            },
-        ],
-    });
-    const generatedFiles = await fs.readdir(tmpDir.path);
-    expect(result.functions.length).toBe(1);
-    expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
-    const manifest = JSON.parse(manifestFile);
-    const { bundles } = manifest;
-    expect(bundles.length).toBe(1);
-    expect(bundles[0].format).toBe('js');
-    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(result.manifest).toEqual(manifest);
-    await fs.rmdir(tmpDir.path, { recursive: true });
-});
-test('Produces only a ESZIP bundle when the `edge_functions_produce_eszip` feature flag is set', async () => {
-    const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
-    const tmpDir = await tmp.dir();
-    const declarations = [
-        {
-            function: 'func1',
-            path: '/func1',
-        },
-    ];
-    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
-        basePath: fixturesDir,
-        featureFlags: {
-            edge_functions_produce_eszip: true,
-        },
-        importMaps: [
-            {
-                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
-                imports: {
-                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
-                },
-            },
-        ],
+        configPath: join(sourceDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
     expect(result.functions.length).toBe(1);
@@ -85,17 +43,7 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
     ];
     const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
         basePath: fixturesDir,
-        featureFlags: {
-            edge_functions_produce_eszip: true,
-        },
-        importMaps: [
-            {
-                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
-                imports: {
-                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
-                },
-            },
-        ],
+        configPath: join(sourceDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
     expect(result.functions.length).toBe(1);
@@ -125,7 +73,7 @@ test('Adds a custom error property to user errors during bundling', async () =>
         expect(error).toBeInstanceOf(BundleError);
         expect(error.customErrorInfo).toEqual({
             location: {
-                format: 'javascript',
+                format: 'eszip',
                 runtime: 'deno',
             },
             type: 'functionsBundling',
@@ -143,11 +91,7 @@ test('Prints a nice error message when user tries importing NPM module', async (
         },
     ];
     try {
-        await bundle([sourceDirectory], tmpDir.path, declarations, {
-            featureFlags: {
-                edge_functions_produce_eszip: true,
-            },
-        });
+        await bundle([sourceDirectory], tmpDir.path, declarations);
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
@@ -165,7 +109,7 @@ test('Does not add a custom error property to system errors during bundling', as
     }
 });
 test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_cache_deno_dir` feature flag is set', async () => {
-    expect.assertions(7);
+    expect.assertions(6);
     const sourceDirectory = resolve(fixturesDir, 'with_import_maps', 'functions');
     const outDir = await tmp.dir();
     const cacheDir = await tmp.dir();
@@ -178,14 +122,7 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
     const options = {
         basePath: fixturesDir,
         cacheDirectory: cacheDir.path,
-        importMaps: [
-            {
-                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
-                imports: {
-                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
-                },
-            },
-        ],
+        configPath: join(sourceDirectory, 'config.json'),
     };
     // Run #1, feature flag off: The directory should not be populated.
     const result1 = await bundle([sourceDirectory], outDir.path, declarations, options);
@@ -209,7 +146,6 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
     expect(result2.functions.length).toBe(1);
     expect(outFiles2.length).toBe(2);
     const denoDir2 = await fs.readdir(join(cacheDir.path, 'deno_dir'));
-    expect(denoDir2.includes('deps')).toBe(true);
     expect(denoDir2.includes('gen')).toBe(true);
     await fs.rmdir(outDir.path, { recursive: true });
 });
@@ -224,17 +160,7 @@ test('Supports import maps with relative paths', async () => {
     ];
     const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
         basePath: fixturesDir,
-        featureFlags: {
-            edge_functions_produce_eszip: true,
-        },
-        importMaps: [
-            {
-                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
-                imports: {
-                    'alias:helper': './helper.ts',
-                },
-            },
-        ],
+        configPath: join(sourceDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
     expect(result.functions.length).toBe(1);
@@ -278,25 +204,14 @@ test('Ignores any user-defined `deno.json` files', async () => {
         throw new Error(`The file at '${denoConfigPath} would be overwritten by this test. Please move the file to a different location and try again.'`);
     }
     catch (error) {
-        // @ts-expect-error Error is not typed
-        if (error.code !== 'ENOENT') {
+        if (isNodeError(error) && error.code !== 'ENOENT') {
             throw error;
         }
     }
     await fs.writeFile(denoConfigPath, JSON.stringify(denoConfig));
     expect(() => bundle([join(fixtureDir, 'functions')], tmpDir.path, declarations, {
         basePath: fixturesDir,
-        featureFlags: {
-            edge_functions_produce_eszip: true,
-        },
-        importMaps: [
-            {
-                baseURL: pathToFileURL(join(fixturesDir, 'import-map.json')),
-                imports: {
-                    'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
-                },
-            },
-        ],
+        configPath: join(fixtureDir, 'functions', 'config.json'),
     })).not.toThrow();
     await deleteAsync([tmpDir.path, denoConfigPath, importMapFile.path], { force: true });
 });
@@ -309,13 +224,10 @@ test('Processes a function that imports a custom layer', async () => {
             path: '/func1',
         },
     ];
-    const layer = { name: 'test', flag: 'edge-functions-layer-test' };
+    const layer = { name: 'layer:test', flag: 'edge-functions-layer-test' };
     const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
         basePath: fixturesDir,
-        featureFlags: {
-            edge_functions_produce_eszip: true,
-        },
-        layers: [layer],
+        configPath: join(sourceDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
     expect(result.functions.length).toBe(1);
@@ -329,3 +241,28 @@ test('Processes a function that imports a custom layer', async () => {
     expect(layers).toEqual([layer]);
     await fs.rmdir(tmpDir.path, { recursive: true });
 });
+test('Loads declarations and import maps from the deploy configuration', async () => {
+    const fixtureDir = resolve(fixturesDir, 'with_deploy_config');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const directories = [join(fixtureDir, 'netlify', 'edge-functions'), join(fixtureDir, '.netlify', 'edge-functions')];
+    const result = await bundle(directories, tmpDir.path, declarations, {
+        basePath: fixtureDir,
+        configPath: join(fixtureDir, '.netlify', 'edge-functions', 'config.json'),
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(2);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const { bundles } = manifest;
+    expect(bundles.length).toBe(1);
+    expect(bundles[0].format).toBe('eszip2');
+    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    await fs.rmdir(tmpDir.path, { recursive: true });
+});

package/dist/node/config.test.js

@@ -127,10 +127,7 @@ test('Ignores function paths from the in-source `config` function if the feature
     const declarations = [];
     const result = await bundle([internalDirectory, userDirectory], tmpDir.path, declarations, {
         basePath: fixturesDir,
-        featureFlags: {
-            edge_functions_produce_eszip: true,
-        },
-        importMaps: [importMapFile],
+        configPath: join(internalDirectory, 'config.json'),
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
     expect(result.functions.length).toBe(6);
@@ -160,11 +157,10 @@ test('Loads function paths from the in-source `config` function', async () => {
     ];
     const result = await bundle([internalDirectory, userDirectory], tmpDir.path, declarations, {
         basePath: fixturesDir,
+        configPath: join(internalDirectory, 'config.json'),
         featureFlags: {
             edge_functions_config_export: true,
-            edge_functions_produce_eszip: true,
         },
-        importMaps: [importMapFile],
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
     expect(result.functions.length).toBe(6);

package/dist/node/declaration.d.ts

@@ -1,4 +1,5 @@
 import { FunctionConfig } from './config.js';
+import type { DeployConfig } from './deploy_config.js';
 interface BaseDeclaration {
     cache?: string;
     function: string;
@@ -11,5 +12,5 @@ type DeclarationWithPattern = BaseDeclaration & {
     pattern: string;
 };
 type Declaration = DeclarationWithPath | DeclarationWithPattern;
-export declare const getDeclarationsFromConfig: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>) => Declaration[];
+export declare const getDeclarationsFromConfig: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>, deployConfig: DeployConfig) => Declaration[];
 export { Declaration, DeclarationWithPath, DeclarationWithPattern };

package/dist/node/declaration.js

@@ -1,12 +1,12 @@
-export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig) => {
+export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig, deployConfig) => {
     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
-    // defined config (currently path or cache or both) because that object takes
-    // precedence.
-    for (const declaration of tomlDeclarations) {
+    // We start by iterating over all the declarations in the TOML file and in
+    // the deploy configuration file. 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, ...deployConfig.declarations]) {
         const config = (_a = functionsConfig[declaration.function]) !== null && _a !== void 0 ? _a : {};
         functionsVisited.add(declaration.function);
         declarations.push({ ...declaration, ...config });

package/dist/node/declaration.test.js

@@ -1,5 +1,10 @@
 import { test, expect } from 'vitest';
 import { getDeclarationsFromConfig } from './declaration.js';
+// TODO: Add tests with the deploy config.
+const deployConfig = {
+    declarations: [],
+    layers: [],
+};
 test('In source config takes precedence over netlify.toml config', () => {
     const tomlConfig = [
         { function: 'geolocation', path: '/geo', cache: 'off' },
@@ -13,7 +18,7 @@ test('In source config takes precedence over netlify.toml config', () => {
         { function: 'geolocation', path: '/geo-isc', cache: 'manual' },
         { function: 'json', path: '/json', cache: 'off' },
     ];
-    const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig);
+    const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig);
     expect(declarations).toEqual(expectedDeclarations);
 });
 test("Declarations don't break if no in source config is provided", () => {
@@ -29,7 +34,7 @@ test("Declarations don't break if no in source config is provided", () => {
         { function: 'geolocation', path: '/geo-isc', cache: 'manual' },
         { function: 'json', path: '/json', cache: 'manual' },
     ];
-    const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig);
+    const declarations = getDeclarationsFromConfig(tomlConfig, funcConfig, deployConfig);
     expect(declarations).toEqual(expectedDeclarations);
 });
 test('In source config works independent of the netlify.toml file if a path is defined and otherwise if no path is set', () => {
@@ -45,8 +50,8 @@ test('In source config works independent of the netlify.toml file if a path is d
         { function: 'json', path: '/json', cache: 'off' },
     ];
     const expectedDeclarationsWithoutISCPath = [{ function: 'geolocation', path: '/geo', cache: 'off' }];
-    const declarationsWithISCPath = getDeclarationsFromConfig(tomlConfig, funcConfigWithPath);
-    const declarationsWithoutISCPath = getDeclarationsFromConfig(tomlConfig, funcConfigWithoutPath);
+    const declarationsWithISCPath = getDeclarationsFromConfig(tomlConfig, funcConfigWithPath, deployConfig);
     expect(declarationsWithISCPath).toEqual(expectedDeclarationsWithISCPath);
+    const declarationsWithoutISCPath = getDeclarationsFromConfig(tomlConfig, funcConfigWithoutPath, deployConfig);
     expect(declarationsWithoutISCPath).toEqual(expectedDeclarationsWithoutISCPath);
 });

package/dist/node/deploy_config.d.ts

@@ -0,0 +1,10 @@
+import type { Declaration } from './declaration.js';
+import { ImportMapFile } from './import_map.js';
+import type { Layer } from './layer.js';
+import type { Logger } from './logger.js';
+export interface DeployConfig {
+    declarations: Declaration[];
+    importMap?: ImportMapFile;
+    layers: Layer[];
+}
+export declare const load: (path: string | undefined, logger: Logger) => Promise<DeployConfig>;

package/dist/node/deploy_config.js

@@ -0,0 +1,45 @@
+import { promises as fs } from 'fs';
+import { dirname, resolve } from 'path';
+import { readFile as readImportMap } from './import_map.js';
+import { isNodeError } from './utils/error.js';
+export const load = async (path, logger) => {
+    if (path === undefined) {
+        return {
+            declarations: [],
+            layers: [],
+        };
+    }
+    try {
+        const data = await fs.readFile(path, 'utf8');
+        const config = JSON.parse(data);
+        return parse(config, path);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code !== 'ENOENT') {
+            logger.system('Error while parsing internal edge functions manifest:', error);
+        }
+    }
+    return {
+        declarations: [],
+        layers: [],
+    };
+};
+const parse = async (data, path) => {
+    var _a, _b;
+    if (data.version !== 1) {
+        throw new Error(`Unsupported file version: ${data.version}`);
+    }
+    const config = {
+        declarations: (_a = data.functions) !== null && _a !== void 0 ? _a : [],
+        layers: (_b = data.layers) !== null && _b !== void 0 ? _b : [],
+    };
+    if (data.import_map) {
+        const importMapPath = resolve(dirname(path), data.import_map);
+        const importMap = await readImportMap(importMapPath);
+        return {
+            ...config,
+            importMap,
+        };
+    }
+    return config;
+};

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

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

package/dist/node/deploy_config.test.js

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

package/dist/node/feature_flags.js

@@ -1,7 +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]) => ({
     ...result,

package/dist/node/formats/eszip.d.ts

@@ -9,9 +9,10 @@ interface BundleESZIPOptions {
     debug?: boolean;
     deno: DenoBridge;
     distDirectory: string;
+    externals: string[];
     featureFlags: FeatureFlags;
     functions: EdgeFunction[];
     importMap: ImportMap;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
 export { bundleESZIP as bundle };

package/dist/node/formats/eszip.js

@@ -4,13 +4,14 @@ import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
     const payload = {
         basePath,
         destPath,
+        externals,
         functions,
         importMapURL: importMap.toDataURL(),
     };

package/dist/node/formats/javascript.d.ts

@@ -1,30 +1,17 @@
-import { DenoBridge } from '../bridge.js';
-import { Bundle } from '../bundle.js';
 import { EdgeFunction } from '../edge_function.js';
-import { ImportMap } from '../import_map.js';
 import type { FormatFunction } from '../server/server.js';
-interface BundleJSOptions {
-    buildID: string;
-    debug?: boolean;
-    deno: DenoBridge;
-    distDirectory: string;
-    functions: EdgeFunction[];
-    importMap: ImportMap;
-}
-declare const bundleJS: ({ buildID, debug, deno, distDirectory, functions, importMap, }: BundleJSOptions) => Promise<Bundle>;
 interface GenerateStage2Options {
     distDirectory: string;
     fileName: string;
     formatExportTypeError?: FormatFunction;
     formatImportError?: FormatFunction;
     functions: EdgeFunction[];
-    type?: 'local' | 'production';
 }
-declare const generateStage2: ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, type, }: GenerateStage2Options) => Promise<string>;
+declare const generateStage2: ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, }: GenerateStage2Options) => Promise<string>;
 declare const getBootstrapURL: () => string;
 interface GetLocalEntryPointOptions {
     formatExportTypeError?: FormatFunction;
     formatImportError?: FormatFunction;
 }
 declare const getLocalEntryPoint: (functions: EdgeFunction[], { formatExportTypeError, formatImportError, }: GetLocalEntryPointOptions) => string;
-export { bundleJS as bundle, generateStage2, getBootstrapURL, getLocalEntryPoint };
+export { generateStage2, getBootstrapURL, getLocalEntryPoint };

package/dist/node/formats/javascript.js

@@ -3,37 +3,13 @@ import { join } from 'path';
 import { env } from 'process';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
-import { BundleFormat } from '../bundle.js';
-import { wrapBundleError } from '../bundle_error.js';
-import { wrapNpmImportError } from '../npm_import_error.js';
-import { getFileHash } from '../utils/sha256.js';
 const BOOTSTRAP_LATEST = 'https://637cf7ce9214b300099b3aa8--edge.netlify.com/bootstrap/index-combined.ts';
-const bundleJS = async ({ buildID, debug, deno, distDirectory, functions, importMap, }) => {
-    const stage2Path = await generateStage2({ distDirectory, functions, fileName: `${buildID}-pre.js` });
-    const extension = '.js';
-    const jsBundlePath = join(distDirectory, `${buildID}${extension}`);
-    const flags = [`--import-map=${importMap.toDataURL()}`, '--no-config'];
-    if (!debug) {
-        flags.push('--quiet');
-    }
-    try {
-        await deno.run(['bundle', ...flags, stage2Path, jsBundlePath], { pipeOutput: true });
-    }
-    catch (error) {
-        throw wrapBundleError(wrapNpmImportError(error), { format: 'javascript' });
-    }
-    await fs.unlink(stage2Path);
-    const hash = await getFileHash(jsBundlePath);
-    return { extension, format: BundleFormat.JS, hash };
-};
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImpoortError = (name) => `There was an error with Edge Function "${name}".`;
-const generateStage2 = async ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, type = 'production', }) => {
+const generateStage2 = async ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {
     await deleteAsync(distDirectory, { force: true });
     await fs.mkdir(distDirectory, { recursive: true });
-    const entryPoint = type === 'local'
-        ? getLocalEntryPoint(functions, { formatExportTypeError, formatImportError })
-        : getProductionEntryPoint(functions);
+    const entryPoint = getLocalEntryPoint(functions, { formatExportTypeError, formatImportError });
     const stage2Path = join(distDirectory, fileName);
     await fs.writeFile(stage2Path, entryPoint);
     return stage2Path;
@@ -69,21 +45,4 @@ const getLocalEntryPoint = (functions, { formatExportTypeError = defaultFormatEx
     const bootCall = `boot(functions, metadata);`;
     return [bootImport, declaration, ...imports, bootCall].join('\n\n');
 };
-const getProductionEntryPoint = (functions) => {
-    const bootImport = `import { boot } from "${getBootstrapURL()}";`;
-    const lines = functions.map((func, index) => {
-        const importName = `func${index}`;
-        const exportLine = `"${func.name}": ${importName}`;
-        const url = pathToFileURL(func.path);
-        return {
-            exportLine,
-            importLine: `import ${importName} from "${url}";`,
-        };
-    });
-    const importLines = lines.map(({ importLine }) => importLine).join('\n');
-    const exportLines = lines.map(({ exportLine }) => exportLine).join(', ');
-    const exportDeclaration = `const functions = {${exportLines}};`;
-    const defaultExport = 'boot(functions);';
-    return [bootImport, importLines, exportDeclaration, defaultExport].join('\n\n');
-};
-export { bundleJS as bundle, generateStage2, getBootstrapURL, getLocalEntryPoint };
+export { generateStage2, getBootstrapURL, getLocalEntryPoint };

package/dist/node/import_map.d.ts

@@ -4,12 +4,14 @@ interface ImportMapFile {
     scopes?: Record<string, Record<string, string>>;
 }
 declare class ImportMap {
-    imports: Record<string, URL | null>;
+    files: ImportMapFile[];
     constructor(files?: ImportMapFile[]);
     static resolve(importMapFile: ImportMapFile): import("@import-maps/resolve/types/src/types").ParsedImportMap;
+    add(file: ImportMapFile): void;
     getContents(): string;
     toDataURL(): string;
     writeToFile(path: string): Promise<void>;
 }
-export { ImportMap };
+declare const readFile: (path: string) => Promise<ImportMapFile>;
+export { ImportMap, readFile };
 export type { ImportMapFile };

package/dist/node/import_map.js

@@ -1,14 +1,31 @@
 import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
 import { dirname } from 'path';
+import { pathToFileURL } from 'url';
 import { parse } from '@import-maps/resolve';
 const INTERNAL_IMPORTS = {
     'netlify:edge': new URL('https://edge.netlify.com/v1/index.ts'),
 };
+// ImportMap can take several import map files and merge them into a final
+// import map object, also adding the internal imports in the right order.
 class ImportMap {
     constructor(files = []) {
-        let imports = {};
+        this.files = [];
         files.forEach((file) => {
+            this.add(file);
+        });
+    }
+    static resolve(importMapFile) {
+        const { baseURL, ...importMap } = importMapFile;
+        const parsedImportMap = parse(importMap, baseURL);
+        return parsedImportMap;
+    }
+    add(file) {
+        this.files.push(file);
+    }
+    getContents() {
+        let imports = {};
+        this.files.forEach((file) => {
             const importMap = ImportMap.resolve(file);
             imports = { ...imports, ...importMap.imports };
         });
@@ -18,16 +35,8 @@ class ImportMap {
             const [specifier, url] = internalImport;
             imports[specifier] = url;
         });
-        this.imports = imports;
-    }
-    static resolve(importMapFile) {
-        const { baseURL, ...importMap } = importMapFile;
-        const parsedImportMap = parse(importMap, baseURL);
-        return parsedImportMap;
-    }
-    getContents() {
         const contents = {
-            imports: this.imports,
+            imports,
         };
         return JSON.stringify(contents);
     }
@@ -41,4 +50,22 @@ class ImportMap {
         await fs.writeFile(path, contents);
     }
 }
-export { ImportMap };
+const readFile = async (path) => {
+    const baseURL = pathToFileURL(path);
+    try {
+        const data = await fs.readFile(path, 'utf8');
+        const importMap = JSON.parse(data);
+        return {
+            ...importMap,
+            baseURL,
+        };
+    }
+    catch {
+        // no-op
+    }
+    return {
+        baseURL,
+        imports: {},
+    };
+};
+export { ImportMap, readFile };

package/dist/node/server/server.js

@@ -19,7 +19,6 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
             functions,
             formatExportTypeError,
             formatImportError,
-            type: 'local',
         });
         try {
             // This command will print a JSON object with all the modules found in
@@ -71,7 +70,7 @@ const serve = async ({ certificatePath, debug, distImportMapPath, inspectSetting
     await ensureLatestTypes(deno, logger);
     // Creating an ImportMap instance with any import maps supplied by the user,
     // if any.
-    const importMap = new ImportMap(importMaps);
+    const importMap = new ImportMap(importMaps !== null && importMaps !== void 0 ? importMaps : []);
     const flags = ['--allow-all', '--unstable', `--import-map=${importMap.toDataURL()}`, '--no-config'];
     if (certificatePath) {
         flags.push(`--cert=${certificatePath}`);

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

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const isNodeError: (error: any) => error is NodeJS.ErrnoException;

package/dist/node/utils/error.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isNodeError = (error) => error instanceof Error;

package/dist/shared/stage2.d.ts

@@ -5,6 +5,7 @@ export interface InputFunction {
 export interface WriteStage2Options {
     basePath: string;
     destPath: string;
+    externals: string[];
     functions: InputFunction[];
     importMapURL?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "4.4.3",
+  "version": "5.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",

package/shared/stage2.ts

@@ -6,6 +6,7 @@ export interface InputFunction {
 export interface WriteStage2Options {
   basePath: string
   destPath: string
+  externals: string[]
   functions: InputFunction[]
   importMapURL?: string
 }