@netlify/edge-bundler 8.14.1 → 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.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.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';
@@ -129,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 () => {
@@ -196,7 +196,7 @@ test('Passes validation if default export exists and is a function', async () =>
         name: func.name,
         path,
     }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
-    await deleteAsync(tmpDir, { force: true });
+    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();
@@ -221,7 +221,7 @@ test('Fails validation if default export is not function', async () => {
         path,
     }, 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();
@@ -245,5 +245,5 @@ test('Fails validation if default export is not present', async () => {
         path,
     }, 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/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/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/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.1",
+  "version": "8.14.2",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -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",