@netlify/edge-bundler 8.14.0 → 8.14.2

package/dist/node/bridge.test.js

@@ -53,7 +53,7 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     });
     output = output.trim().replace(/\n+/g, '\n');
     expect(output).toBe('LULU=LALA');
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is true', async () => {
     var _a;
@@ -78,7 +78,7 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different
     const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
     expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is not set', async () => {
     var _a;
@@ -103,5 +103,5 @@ test('Does inherit environment variables if `extendEnv` is not set', async () =>
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different
     const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
     expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/bundler.js

@@ -63,8 +63,8 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     await createFinalBundles([functionBundle], distDirectory, buildID);
     // Retrieving a configuration object for each function.
     // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
-    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger, featureFlags)]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger, featureFlags)]);
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
     // Creating a hash of function names to configuration objects.
     const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
     const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));

package/dist/node/bundler.test.js

@@ -1,8 +1,7 @@
-import { promises as fs } from 'fs';
+import { access, readdir, readFile, rm, writeFile } from 'fs/promises';
 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, vi } from 'vitest';
 import { importMapSpecifier } from '../shared/consts.js';
@@ -26,10 +25,10 @@ test('Produces an ESZIP bundle', async () => {
         configPath: join(internalDirectory, 'config.json'),
         importMapPaths: [join(userDirectory, 'import_map.json')],
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(3);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     expect(() => validateManifest(manifest)).not.toThrowError();
     const { bundles, import_map: importMapURL } = manifest;
@@ -57,10 +56,10 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
@@ -164,10 +163,10 @@ test('Uses the cache directory as the `DENO_DIR` value', async () => {
         configPath: join(sourceDirectory, 'config.json'),
     };
     const result = await bundle([sourceDirectory], distPath, declarations, options);
-    const outFiles = await fs.readdir(distPath);
+    const outFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(outFiles.length).toBe(2);
-    const denoDir = await fs.readdir(join(cacheDir.path, 'deno_dir'));
+    const denoDir = await readdir(join(cacheDir.path, 'deno_dir'));
     expect(denoDir.includes('gen')).toBe(true);
     await cleanup();
 });
@@ -184,10 +183,10 @@ test('Supports import maps with relative paths', async () => {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
@@ -212,7 +211,7 @@ test('Ignores any user-defined `deno.json` files', async () => {
             'https://deno.land/': 'https://black.hole/',
         },
     };
-    await fs.writeFile(importMapFile.path, JSON.stringify(importMap));
+    await writeFile(importMapFile.path, JSON.stringify(importMap));
     // Deno configuration files need to be in the current working directory.
     // There's not a great way for us to set the working directory of the `deno`
     // process that we'll run, so our best bet is to write the file to whatever
@@ -222,7 +221,7 @@ test('Ignores any user-defined `deno.json` files', async () => {
         importMap: importMapFile.path,
     };
     try {
-        await fs.access(denoConfigPath);
+        await access(denoConfigPath);
         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) {
@@ -230,13 +229,14 @@ test('Ignores any user-defined `deno.json` files', async () => {
             throw error;
         }
     }
-    await fs.writeFile(denoConfigPath, JSON.stringify(denoConfig));
+    await writeFile(denoConfigPath, JSON.stringify(denoConfig));
     expect(() => bundle([sourceDirectory], distPath, declarations, {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     })).not.toThrow();
     await cleanup();
-    await deleteAsync([denoConfigPath, importMapFile.path], { force: true });
+    await rm(denoConfigPath, { force: true, recursive: true, maxRetries: 10 });
+    await rm(importMapFile.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Processes a function that imports a custom layer', async () => {
     const { basePath, cleanup, distPath } = await useFixture('with_layers');
@@ -252,10 +252,10 @@ test('Processes a function that imports a custom layer', async () => {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, layers } = manifest;
     expect(bundles.length).toBe(1);
@@ -278,10 +278,10 @@ test('Loads declarations and import maps from the deploy configuration and in-so
         configPath: join(basePath, '.netlify', 'edge-functions', 'manifest.json'),
         internalSrcFolder: directories[1],
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(3);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, function_config: functionConfig } = manifest;
     expect(bundles.length).toBe(1);
@@ -317,7 +317,7 @@ test("Ignores entries in `importMapPaths` that don't point to an existing import
             },
         },
     };
-    await fs.writeFile(importMap.path, JSON.stringify(importMapContents));
+    await writeFile(importMap.path, JSON.stringify(importMapContents));
     const nonExistingImportMapPath = join(distPath, 'some-file-that-does-not-exist.json');
     const result = await bundle([sourceDirectory], distPath, [
         {
@@ -329,7 +329,7 @@ test("Ignores entries in `importMapPaths` that don't point to an existing import
         importMapPaths: [nonExistingImportMapPath, importMap.path],
         systemLogger,
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(2);
     expect(generatedFiles.length).toBe(2);
     expect(systemLogger).toHaveBeenCalledWith(`Did not find an import map file at '${nonExistingImportMapPath}'.`);

package/dist/node/config.d.ts

@@ -1,6 +1,5 @@
 import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
-import { FeatureFlags } from './feature_flags.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
 export declare const enum Cache {
@@ -18,4 +17,4 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger, featureFlags: FeatureFlags) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -26,7 +26,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async (func, importMap, deno, log, featureFlags) => {
+export const getFunctionConfig = async (func, importMap, deno, log) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -53,7 +53,7 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
         JSON.stringify(ConfigExitCode),
     ], { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {
-        handleConfigError(func, exitCode, stderr, log, featureFlags);
+        handleConfigError(func, exitCode, stderr, log);
         return {};
     }
     if (stdout !== '') {
@@ -65,7 +65,7 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
         collectorData = JSON.parse(collectorDataJSON);
     }
     catch {
-        handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log, featureFlags);
+        handleConfigError(func, ConfigExitCode.UnhandledError, stderr, log);
     }
     finally {
         await collector.cleanup();
@@ -75,35 +75,20 @@ export const getFunctionConfig = async (func, importMap, deno, log, featureFlags
     }
     return collectorData;
 };
-const handleConfigError = (func, exitCode, stderr, log, featureFlags) => {
+const handleConfigError = (func, exitCode, stderr, log) => {
     switch (exitCode) {
         case ConfigExitCode.ImportError:
             log.user(stderr);
-            if (featureFlags.edge_functions_invalid_config_throw) {
-                throw new BundleError(new Error(`Could not load edge function at '${func.path}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
-            }
-            else {
-                log.user(`Could not load edge function at '${func.path}'`);
-            }
+            throw new BundleError(new Error(`Could not load edge function at '${func.path}'. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
             break;
         case ConfigExitCode.NoConfig:
             log.system(`No in-source config found for edge function at '${func.path}'`);
             break;
         case ConfigExitCode.InvalidExport:
-            if (featureFlags.edge_functions_invalid_config_throw) {
-                throw new BundleError(new Error(`The 'config' export in edge function at '${func.path}' must be an object. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
-            }
-            else {
-                log.user(`'config' export in edge function at '${func.path}' must be an object`);
-            }
+            throw new BundleError(new Error(`The 'config' export in edge function at '${func.path}' must be an object. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
             break;
         case ConfigExitCode.SerializationError:
-            if (featureFlags.edge_functions_invalid_config_throw) {
-                throw new BundleError(new Error(`The 'config' object in the edge function at '${func.path}' must contain primitive values only. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
-            }
-            else {
-                log.user(`'config' object in edge function at '${func.path}' must contain primitive values only`);
-            }
+            throw new BundleError(new Error(`The 'config' object in the edge function at '${func.path}' must contain primitive values only. More on the Edge Functions API at https://ntl.fyi/edge-api.`));
             break;
         case ConfigExitCode.InvalidDefaultExport:
             throw new BundleError(new Error(`Default export in '${func.path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`));

package/dist/node/config.test.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
+import { rm } from 'fs/promises';
 import { join, resolve } from 'path';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect, vi, describe } from 'vitest';
 import { fixturesDir, useFixture } from '../test/util.js';
@@ -34,8 +34,7 @@ const functions = [
       `,
     },
     {
-        testName: 'config with wrong type (throw)',
-        expectedConfig: {},
+        testName: 'config with wrong type',
         name: 'func3',
         source: `
       export default async () => new Response("Hello from function two")
@@ -43,27 +42,9 @@ const functions = [
       export const config = () => ({})
     `,
         error: /^The 'config' export in edge function at '(.*)' must be an object\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: true,
-        },
-    },
-    {
-        testName: 'config with wrong type (log)',
-        expectedConfig: {},
-        name: 'func3',
-        source: `
-      export default async () => new Response("Hello from function two")
-
-      export const config = () => ({})
-    `,
-        userLog: /^'config' export in edge function at '(.*)' must be an object$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: false,
-        },
     },
     {
-        testName: 'config with syntax error (throw)',
-        expectedConfig: {},
+        testName: 'config with syntax error',
         name: 'func4',
         source: `
       export default async () => new Response("Hello from function two")
@@ -71,23 +52,6 @@ const functions = [
       export const config
     `,
         error: /^Could not load edge function at '(.*)'\. More on the Edge Functions API at https:\/\/ntl\.fyi\/edge-api\.$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: true,
-        },
-    },
-    {
-        testName: 'config with syntax error (log)',
-        expectedConfig: {},
-        name: 'func4',
-        source: `
-      export default async () => new Response("Hello from function two")
-
-      export const config
-    `,
-        userLog: /^Could not load edge function at '(.*)'$/,
-        featureFlags: {
-            edge_functions_invalid_config_throw: false,
-        },
     },
     {
         testName: 'config with correct onError',
@@ -152,7 +116,7 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
         const funcCall = () => getFunctionConfig({
             name: func.name,
             path,
-        }, new ImportMap([importMapFile]), deno, logger, func.featureFlags || {});
+        }, new ImportMap([importMapFile]), deno, logger);
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
         }
@@ -165,7 +129,7 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
             expect(config).toEqual(func.expectedConfig);
             expect(logger.user).not.toHaveBeenCalled();
         }
-        await deleteAsync(tmpDir, { force: true });
+        await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
     });
 });
 test('Loads function paths from the in-source `config` function', async () => {
@@ -231,8 +195,8 @@ test('Passes validation if default export exists and is a function', async () =>
     await expect(getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger, {})).resolves.not.toThrow();
-    await deleteAsync(tmpDir, { force: true });
+    }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
+    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not function', async () => {
     const { path: tmpDir } = await tmp.dir();
@@ -255,9 +219,9 @@ test('Fails validation if default export is not function', async () => {
     const config = getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger, {});
+    }, new ImportMap([importMapFile]), deno, logger);
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not present', async () => {
     const { path: tmpDir } = await tmp.dir();
@@ -279,7 +243,7 @@ test('Fails validation if default export is not present', async () => {
     const config = getFunctionConfig({
         name: func.name,
         path,
-    }, new ImportMap([importMapFile]), deno, logger, {});
+    }, new ImportMap([importMapFile]), deno, logger);
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/declaration.d.ts

@@ -15,6 +15,6 @@ type DeclarationWithPattern = BaseDeclaration & {
     excludedPattern?: string;
 };
 export type Declaration = DeclarationWithPath | DeclarationWithPattern;
-export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], featureFlags?: FeatureFlags) => Declaration[];
+export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], _featureFlags?: FeatureFlags) => Declaration[];
 export declare const parsePattern: (pattern: string) => string;
 export {};

package/dist/node/declaration.js

@@ -1,30 +1,20 @@
 import regexpAST from 'regexp-tree';
-export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, featureFlags = {}) => {
+export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_featureFlags = {}) => {
     const functionsVisited = new Set();
-    let declarations = getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited);
-    // eslint-disable-next-line unicorn/prefer-ternary
-    if (featureFlags.edge_functions_correct_order) {
-        declarations = [
-            // INTEGRATIONS
-            // 1. Declarations from the integrations deploy config
-            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
-            // 2. Declarations from the integrations ISC
-            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
-            // USER
-            // 3. Declarations from the users toml config
-            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
-            // 4. Declarations from the users ISC
-            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
-        ];
-    }
-    else {
-        declarations = [
-            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
-            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
-            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
-            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
-        ];
-    }
+    const declarations = [
+        // INTEGRATIONS
+        // 1. Declarations from the integrations deploy config
+        ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
+        // 2. Declarations from the integrations ISC
+        ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
+        // USER
+        // 3. Declarations from the users toml config
+        ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
+        // 4. Declarations from the users ISC
+        ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
+    ];
     return declarations;
 };
 const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsVisited) => {

package/dist/node/declaration.test.js

@@ -18,30 +18,7 @@ test('Ensure the order of edge functions with FF', () => {
     const internalFuncConfig = {
         'framework-isc-c': { path: ['/path1', '/path2'] },
     };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
-        edge_functions_correct_order: true,
-    })).toMatchSnapshot();
-});
-test('Ensure the order of edge functions without FF', () => {
-    const deployConfigDeclarations = [
-        { function: 'framework-manifest-a', path: '/path1' },
-        { function: 'framework-manifest-c', path: '/path3' },
-        { function: 'framework-manifest-b', path: '/path2' },
-    ];
-    const tomlConfig = [
-        { function: 'user-toml-a', path: '/path1' },
-        { function: 'user-toml-c', path: '/path3' },
-        { function: 'user-toml-b', path: '/path2' },
-    ];
-    const userFuncConfig = {
-        'user-isc-c': { path: ['/path1', '/path2'] },
-    };
-    const internalFuncConfig = {
-        'framework-isc-c': { path: ['/path1', '/path2'] },
-    };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
-        edge_functions_correct_order: false,
-    })).toMatchSnapshot();
+    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations)).toMatchSnapshot();
 });
 test('In-source config takes precedence over netlify.toml config', () => {
     const tomlConfig = [

package/dist/node/downloader.js

@@ -42,7 +42,6 @@ const downloadVersion = async (versionRange) => {
     const version = await getLatestVersionForRange(versionRange);
     const url = getReleaseURL(version);
     const res = await fetch(url);
-    // eslint-disable-next-line no-magic-numbers
     if (res.body === null || res.status < 200 || res.status > 299) {
         throw new Error(`Download failed with status code ${res.status}`);
     }

package/dist/node/downloader.test.js

@@ -30,7 +30,7 @@ beforeEach(async (ctx) => {
     ctx.tmpDir = tmpDir.path;
 });
 afterEach(async (ctx) => {
-    await rm(ctx.tmpDir, { force: true, recursive: true });
+    await rm(ctx.tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('tries downloading binary up to 4 times', async (ctx) => {
     nock.disableNetConnect();

package/dist/node/feature_flags.d.ts

@@ -1,14 +1,10 @@
 declare const defaultFlags: {
-    edge_functions_correct_order: boolean;
     edge_functions_fail_unsupported_regex: boolean;
-    edge_functions_invalid_config_throw: boolean;
 };
 type FeatureFlag = keyof typeof defaultFlags;
 type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
 declare const getFlags: (input?: Record<string, boolean>, flags?: {
-    edge_functions_correct_order: boolean;
     edge_functions_fail_unsupported_regex: boolean;
-    edge_functions_invalid_config_throw: boolean;
 }) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

package/dist/node/feature_flags.js

@@ -1,7 +1,5 @@
 const defaultFlags = {
-    edge_functions_correct_order: false,
     edge_functions_fail_unsupported_regex: false,
-    edge_functions_invalid_config_throw: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/formats/javascript.js

@@ -1,15 +1,14 @@
-import { promises as fs } from 'fs';
+import { mkdir, rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImportError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ bootstrapURL, distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {
-    await deleteAsync(distDirectory, { force: true });
-    await fs.mkdir(distDirectory, { recursive: true });
+    await rm(distDirectory, { force: true, recursive: true, maxRetries: 3 });
+    await mkdir(distDirectory, { recursive: true });
     const entryPoint = getLocalEntryPoint(functions, { bootstrapURL, formatExportTypeError, formatImportError });
     const stage2Path = join(distDirectory, fileName);
-    await fs.writeFile(stage2Path, entryPoint);
+    await writeFile(stage2Path, entryPoint);
     return stage2Path;
 };
 // For the local development environment, we import the user functions with

package/dist/node/main.test.js

@@ -43,5 +43,5 @@ test('Downloads the Deno CLI on demand and caches it for subsequent calls', asyn
     expect((_d = output2 === null || output2 === void 0 ? void 0 : output2.stdout) !== null && _d !== void 0 ? _d : '').toMatch(expectedOutput);
     expect(beforeDownload).toHaveBeenCalledTimes(1);
     expect(afterDownload).toHaveBeenCalledTimes(1);
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/server/server.js

@@ -43,7 +43,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger, {})));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig(func, importMap, deno, logger)));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/dist/node/stage_2.test.js

@@ -1,7 +1,6 @@
-import { promises as fs } from 'fs';
+import { rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 import { execa } from 'execa';
 import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
@@ -23,18 +22,18 @@ test('`getLocalEntryPoint` returns a valid stage 2 file for local development',
   `;
     const printerPath = join(tmpDir, 'printer.mjs');
     const bootstrapURL = pathToFileURL(printerPath).toString();
-    await fs.writeFile(printerPath, printer);
+    await writeFile(printerPath, printer);
     const functions = [
         { name: 'func1', path: join(tmpDir, 'func1.mjs'), response: 'Hello from function 1' },
         { name: 'func2', path: join(tmpDir, 'func2.mjs'), response: 'Hello from function 2' },
     ];
     for (const func of functions) {
         const contents = `export default () => ${JSON.stringify(func.response)}`;
-        await fs.writeFile(func.path, contents);
+        await writeFile(func.path, contents);
     }
     const stage2 = getLocalEntryPoint(functions.map(({ name, path }) => ({ name, path })), { bootstrapURL });
     const stage2Path = join(tmpDir, 'stage2.mjs');
-    await fs.writeFile(stage2Path, stage2);
+    await writeFile(stage2Path, stage2);
     const { stdout, stderr } = await execa('deno', ['run', '--allow-all', stage2Path]);
     expect(stderr).toBe('');
     const { metadata, responses } = JSON.parse(stdout);
@@ -42,5 +41,5 @@ test('`getLocalEntryPoint` returns a valid stage 2 file for local development',
         expect(responses[func.name]).toBe(func.response);
         expect(metadata.functions[func.name].url).toBe(pathToFileURL(func.path).toString());
     }
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true });
 });

package/dist/node/types.test.js

@@ -24,7 +24,7 @@ test('`ensureLatestTypes` updates the Deno CLI cache if the local version of typ
     expect(mock).toHaveBeenCalledWith(['cache', '-r', mockURL]);
     expect(versionFile).toBe(mockVersion);
     mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('`ensureLatestTypes` does not update the Deno CLI cache if the local version of types is up-to-date', async () => {
     const mockURL = 'https://edge.netlify';
@@ -43,7 +43,7 @@ test('`ensureLatestTypes` does not update the Deno CLI cache if the local versio
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).not.toHaveBeenCalled();
     mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('`ensureLatestTypes` does not throw if the types URL is not available', async () => {
     const mockURL = 'https://edge.netlify';
@@ -59,5 +59,5 @@ test('`ensureLatestTypes` does not throw if the types URL is not available', asy
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).not.toHaveBeenCalled();
     mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.14.0",
+  "version": "8.14.2",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -58,7 +58,7 @@
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^9.0.0",
-    "@vitest/coverage-c8": "^0.30.0",
+    "@vitest/coverage-c8": "^0.31.0",
     "archiver": "^5.3.1",
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
@@ -67,7 +67,7 @@
     "nock": "^13.2.4",
     "tar": "^6.1.11",
     "typescript": "^5.0.0",
-    "vitest": "^0.30.0"
+    "vitest": "^0.31.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
@@ -78,7 +78,6 @@
     "ajv-errors": "^3.0.0",
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
-    "del": "^7.0.0",
     "env-paths": "^3.0.0",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",