@netlify/edge-bundler 14.8.2 → 14.8.4

package/dist/node/downloader.test.js

@@ -1,124 +0,0 @@
-import { rm } from 'fs/promises';
-import { platform } from 'process';
-import { PassThrough } from 'stream';
-import { execa } from 'execa';
-import nock from 'nock';
-import tmp from 'tmp-promise';
-import { beforeEach, afterEach, test, expect, vi } from 'vitest';
-import { fixturesDir, testLogger } from '../test/util.js';
-import { download } from './downloader.js';
-import { getPlatformTarget } from './platform.js';
-// This changes the defaults for p-retry
-// minTimeout 1000 -> 10
-// factor 2 -> 1
-// This reduces the wait time in the tests from `2s, 4s, 8s` to `10ms, 10ms, 10ms` for 3 retries
-vi.mock('p-retry', async (importOriginal) => {
-    const pRetry = (await importOriginal());
-    return {
-        default: (func, options) => pRetry.default(func, { minTimeout: 10, factor: 1, ...options }),
-    };
-});
-const streamError = () => {
-    const stream = new PassThrough();
-    setTimeout(() => stream.emit('data', 'zipcontent'), 100);
-    setTimeout(() => stream.emit('error', new Error('stream error')), 200);
-    return stream;
-};
-beforeEach(async (ctx) => {
-    const tmpDir = await tmp.dir();
-    ctx.tmpDir = tmpDir.path;
-});
-afterEach(async (ctx) => {
-    await rm(ctx.tmpDir, { force: true, recursive: true, maxRetries: 10 });
-});
-test('tries downloading binary up to 4 times', async (ctx) => {
-    nock.disableNetConnect();
-    const version = '99.99.99';
-    const mockURL = 'https://dl.deno.land:443';
-    const target = getPlatformTarget();
-    const zipPath = `/release/v${version}/deno-${target}.zip`;
-    const latestVersionMock = nock(mockURL)
-        .get('/release-latest.txt')
-        .reply(200, `v${version}\n`)
-        // first attempt
-        .get(zipPath)
-        .reply(500)
-        // second attempt
-        .get(zipPath)
-        .reply(500)
-        // third attempt
-        .get(zipPath)
-        .reply(500)
-        // fourth attempt
-        .get(zipPath)
-        // 1 second delay
-        .delayBody(1000)
-        .replyWithFile(200, platform === 'win32' ? `${fixturesDir}/deno.win.zip` : `${fixturesDir}/deno.zip`, {
-        'Content-Type': 'application/zip',
-    });
-    const deno = await download(ctx.tmpDir, `^${version}`, testLogger);
-    expect(latestVersionMock.isDone()).toBe(true);
-    expect(deno).toBeTruthy();
-    const res = await execa(deno);
-    expect(res.stdout).toBe('hello');
-});
-test('fails downloading binary after 4th time', async (ctx) => {
-    expect.assertions(2);
-    nock.disableNetConnect();
-    const version = '99.99.99';
-    const mockURL = 'https://dl.deno.land:443';
-    const target = getPlatformTarget();
-    const zipPath = `/release/v${version}/deno-${target}.zip`;
-    const latestVersionMock = nock(mockURL)
-        .get('/release-latest.txt')
-        .reply(200, `v${version}\n`)
-        // first attempt
-        .get(zipPath)
-        .reply(500)
-        // second attempt
-        .get(zipPath)
-        .reply(500)
-        // third attempt
-        .get(zipPath)
-        .reply(500)
-        // fourth attempt
-        .get(zipPath)
-        .reply(500);
-    try {
-        await download(ctx.tmpDir, `^${version}`, testLogger);
-    }
-    catch (error) {
-        expect(error.message).toMatch(/Download failed with status code 500/);
-    }
-    expect(latestVersionMock.isDone()).toBe(true);
-});
-test('fails downloading if response stream throws error', async (ctx) => {
-    expect.assertions(2);
-    nock.disableNetConnect();
-    const version = '99.99.99';
-    const mockURL = 'https://dl.deno.land:443';
-    const target = getPlatformTarget();
-    const zipPath = `/release/v${version}/deno-${target}.zip`;
-    const latestVersionMock = nock(mockURL)
-        .get('/release-latest.txt')
-        .reply(200, `v${version}\n`)
-        // first attempt
-        .get(zipPath)
-        .reply(200, streamError)
-        // second attempt
-        .get(zipPath)
-        .reply(200, streamError)
-        // third attempt
-        .get(zipPath)
-        .reply(200, streamError)
-        // fourth attempt
-        .get(zipPath)
-        .reply(200, streamError);
-    try {
-        await download(ctx.tmpDir, `^${version}`, testLogger);
-    }
-    catch (error) {
-        expect(error.message).toMatch(/stream error/);
-    }
-    expect(latestVersionMock.isDone()).toBe(true);
-});

package/dist/node/finder.test.js

@@ -1,17 +0,0 @@
-import { test, expect } from 'vitest';
-import { removeDuplicatesByExtension } from './finder.js';
-test('filters out any duplicate files based on the extension', () => {
-    const functions = [
-        'file1.js',
-        'file1.ts',
-        'file2.tsx',
-        'file2.jsx',
-        'file3.tsx',
-        'file3.js',
-        'file4.ts',
-        'file5.ts',
-        'file5.tsx',
-    ];
-    const expected = ['file1.js', 'file2.jsx', 'file3.js', 'file4.ts', 'file5.ts'];
-    expect(removeDuplicatesByExtension(functions)).toStrictEqual(expected);
-});

package/dist/node/import_map.test.js

@@ -1,212 +0,0 @@
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { cwd } from 'process';
-import { pathToFileURL } from 'url';
-import tmp from 'tmp-promise';
-import { describe, test, expect } from 'vitest';
-import { ImportMap } from './import_map.js';
-import { getLogger } from './logger.js';
-test('Handles import maps with full URLs without specifying a base URL', () => {
-    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
-    const inputFile1 = {
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            'alias:jamstack': 'https://jamstack.org',
-        },
-    };
-    const inputFile2 = {
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            'alias:pets': 'https://petsofnetlify.com/',
-        },
-    };
-    const map = new ImportMap([inputFile1, inputFile2]);
-    const m1 = map.getContents();
-    expect(m1.imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(m1.imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(m1.imports['alias:jamstack']).toBe('https://jamstack.org/');
-    expect(m1.imports['alias:pets']).toBe('https://petsofnetlify.com/');
-    const m2 = map.getContentsWithURLObjects();
-    expect(m2.imports['netlify:edge']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts?v=legacy'));
-    expect(m2.imports['@netlify/edge-functions']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts'));
-    expect(m2.imports['alias:jamstack']).toStrictEqual(new URL('https://jamstack.org/'));
-    expect(m2.imports['alias:pets']).toStrictEqual(new URL('https://petsofnetlify.com/'));
-});
-test('Resolves relative paths to absolute paths if a base path is not provided', () => {
-    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
-    const inputFile1 = {
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            'alias:pets': './heart/pets/',
-        },
-    };
-    const map = new ImportMap([inputFile1]);
-    const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets');
-    const m1 = map.getContents();
-    expect(m1.imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(m1.imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(m1.imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
-    const m2 = map.getContentsWithURLObjects();
-    expect(m2.imports['netlify:edge']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts?v=legacy'));
-    expect(m2.imports['@netlify/edge-functions']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts'));
-    expect(m2.imports['alias:pets']).toStrictEqual(new URL(`${pathToFileURL(expectedPath).toString()}/`));
-});
-describe('Returns the fully resolved import map', () => {
-    const inputFile1 = {
-        baseURL: new URL('file:///some/full/path/import-map.json'),
-        imports: {
-            specifier1: 'file:///some/full/path/file.js',
-            specifier2: './file2.js',
-            specifier3: 'file:///different/full/path/file3.js',
-        },
-    };
-    const inputFile2 = {
-        baseURL: new URL('file:///some/cool/path/import-map.json'),
-        imports: {
-            'lib/*': './library/',
-        },
-        scopes: {
-            'with/scopes/': {
-                'lib/*': 'https://external.netlify/lib/',
-                foo: './foo-alias',
-                bar: 'file:///different/full/path/bar.js',
-            },
-        },
-    };
-    test('Without prefixes', () => {
-        const map = new ImportMap([inputFile1, inputFile2]);
-        const { imports, scopes } = map.getContents();
-        expect(imports).toStrictEqual({
-            'lib/*': 'file:///some/cool/path/library/',
-            specifier3: 'file:///different/full/path/file3.js',
-            specifier2: 'file:///some/full/path/file2.js',
-            specifier1: 'file:///some/full/path/file.js',
-            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
-        });
-        expect(scopes).toStrictEqual({
-            'file:///some/cool/path/with/scopes/': {
-                'lib/*': 'https://external.netlify/lib/',
-                foo: 'file:///some/cool/path/foo-alias',
-                bar: 'file:///different/full/path/bar.js',
-            },
-        });
-    });
-    test('With prefixes', () => {
-        const map = new ImportMap([inputFile1, inputFile2]);
-        const { imports, scopes } = map.getContents({
-            'file:///some/': 'file:///root/',
-            'file:///different/': 'file:///vendor/',
-        });
-        expect(imports).toStrictEqual({
-            'lib/*': 'file:///root/cool/path/library/',
-            specifier3: 'file:///vendor/full/path/file3.js',
-            specifier2: 'file:///root/full/path/file2.js',
-            specifier1: 'file:///root/full/path/file.js',
-            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
-        });
-        expect(scopes).toStrictEqual({
-            'file:///root/cool/path/with/scopes/': {
-                'lib/*': 'https://external.netlify/lib/',
-                foo: 'file:///root/cool/path/foo-alias',
-                bar: 'file:///vendor/full/path/bar.js',
-            },
-        });
-    });
-});
-test('Throws when an import map uses a relative path to reference a file outside of the base path', () => {
-    const inputFile1 = {
-        baseURL: pathToFileURL(join(cwd(), 'import-map.json')),
-        imports: {
-            'alias:file': '../file.js',
-        },
-    };
-    const map = new ImportMap([inputFile1], cwd());
-    expect(() => map.getContents()).toThrowError(`Import map cannot reference '${join(cwd(), '..', 'file.js')}' as it's outside of the base directory '${cwd()}'`);
-});
-test('Writes import map file to disk', async () => {
-    const file = await tmp.file();
-    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
-    const inputFile1 = {
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            'alias:pets': './heart/pets/file.ts',
-        },
-    };
-    const map = new ImportMap([inputFile1]);
-    await map.writeToFile(file.path);
-    const createdFile = await fs.readFile(file.path, 'utf8');
-    const { imports } = JSON.parse(createdFile);
-    const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets', 'file.ts');
-    await file.cleanup();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:pets']).toBe(pathToFileURL(expectedPath).toString());
-});
-test('Respects import map when it has only scoped key', async () => {
-    const file = await tmp.file();
-    const importMap = {
-        scopes: {
-            './foo': {
-                'alias:pets': './heart/pets/file.ts',
-            },
-        },
-    };
-    await fs.writeFile(file.path, JSON.stringify(importMap));
-    const map = new ImportMap();
-    await map.addFile(file.path, getLogger());
-    expect(map.getContents()).toEqual({
-        imports: {
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
-            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-        },
-        scopes: {
-            [pathToFileURL(join(file.path, '../foo')).href]: {
-                'alias:pets': pathToFileURL(join(file.path, '../heart/pets/file.ts')).href,
-            },
-        },
-    });
-});
-test('Clones an import map', () => {
-    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
-    const inputFile1 = {
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            'alias:jamstack': 'https://jamstack.org',
-        },
-    };
-    const inputFile2 = {
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            'alias:pets': 'https://petsofnetlify.com/',
-        },
-    };
-    const map1 = new ImportMap([inputFile1, inputFile2]);
-    const map2 = map1.clone();
-    map2.add({
-        baseURL: pathToFileURL(basePath),
-        imports: {
-            netlify: 'https://netlify.com',
-        },
-    });
-    expect(map1.getContents()).toStrictEqual({
-        imports: {
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
-            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-            'alias:jamstack': 'https://jamstack.org/',
-            'alias:pets': 'https://petsofnetlify.com/',
-        },
-        scopes: {},
-    });
-    expect(map2.getContents()).toStrictEqual({
-        imports: {
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
-            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-            'alias:jamstack': 'https://jamstack.org/',
-            'alias:pets': 'https://petsofnetlify.com/',
-            netlify: 'https://netlify.com/',
-        },
-        scopes: {},
-    });
-});

package/dist/node/logger.test.js

@@ -1,51 +0,0 @@
-import { afterEach, test, expect, vi } from 'vitest';
-import { getLogger } from './logger.js';
-const consoleLog = console.log;
-const noopLogger = () => {
-    // no-op
-};
-afterEach(() => {
-    // Restoring global `console.log`.
-    console.log = consoleLog;
-});
-test('Prints user logs to stdout if no user logger is provided', () => {
-    const mockConsoleLog = vi.fn();
-    console.log = mockConsoleLog;
-    const logger1 = getLogger(noopLogger, undefined, true);
-    const logger2 = getLogger(noopLogger, undefined, false);
-    logger1.user('Hello with `debug: true`');
-    logger2.user('Hello with `debug: false`');
-    expect(mockConsoleLog).toHaveBeenCalledTimes(2);
-    expect(mockConsoleLog).toHaveBeenNthCalledWith(1, 'Hello with `debug: true`');
-    expect(mockConsoleLog).toHaveBeenNthCalledWith(2, 'Hello with `debug: false`');
-});
-test('Prints user logs to user logger provided', () => {
-    const userLogger = vi.fn();
-    const logger = getLogger(noopLogger, userLogger, true);
-    logger.user('Hello!');
-    expect(userLogger).toHaveBeenCalledTimes(1);
-    expect(userLogger).toHaveBeenNthCalledWith(1, 'Hello!');
-});
-test('Prints system logs to the system logger provided', () => {
-    const mockSystemLog = vi.fn();
-    const mockConsoleLog = vi.fn();
-    console.log = mockSystemLog;
-    const logger1 = getLogger(mockSystemLog, undefined, true);
-    const logger2 = getLogger(mockSystemLog, undefined, false);
-    logger1.system('Hello with `debug: true`');
-    logger2.system('Hello with `debug: false`');
-    expect(mockConsoleLog).toHaveBeenCalledTimes(0);
-    expect(mockSystemLog).toHaveBeenCalledTimes(2);
-    expect(mockSystemLog).toHaveBeenNthCalledWith(1, 'Hello with `debug: true`');
-    expect(mockSystemLog).toHaveBeenNthCalledWith(2, 'Hello with `debug: false`');
-});
-test('Prints system logs to stdout if there is no system logger provided and `debug` is enabled', () => {
-    const mockConsoleLog = vi.fn();
-    console.log = mockConsoleLog;
-    const logger1 = getLogger(undefined, undefined, true);
-    const logger2 = getLogger(undefined, undefined, false);
-    logger1.system('Hello with `debug: true`');
-    logger2.system('Hello with `debug: false`');
-    expect(mockConsoleLog).toHaveBeenCalledTimes(1);
-    expect(mockConsoleLog).toHaveBeenNthCalledWith(1, 'Hello with `debug: true`');
-});

package/dist/node/main.test.js

@@ -1,46 +0,0 @@
-import { Buffer } from 'buffer';
-import { rm } from 'fs/promises';
-import { createRequire } from 'module';
-import { platform } from 'process';
-import { PassThrough } from 'stream';
-import nock from 'nock';
-import semver from 'semver';
-import tmp from 'tmp-promise';
-import { test, expect, vi } from 'vitest';
-import { DenoBridge, DENO_VERSION_RANGE } from './bridge.js';
-import { getPlatformTarget } from './platform.js';
-const require = createRequire(import.meta.url);
-const archiver = require('archiver');
-test('Downloads the Deno CLI on demand and caches it for subsequent calls', async () => {
-    const latestVersion = semver.minVersion(DENO_VERSION_RANGE)?.version ?? '';
-    const mockBinaryOutput = `#!/usr/bin/env sh\n\necho "deno ${latestVersion}"`;
-    const data = new PassThrough();
-    const archive = archiver('zip', { zlib: { level: 9 } });
-    archive.pipe(data);
-    archive.append(Buffer.from(mockBinaryOutput), { name: platform === 'win32' ? 'deno.exe' : 'deno' });
-    archive.finalize();
-    const target = getPlatformTarget();
-    const latestReleaseMock = nock('https://dl.deno.land').get('/release-latest.txt').reply(200, `v${latestVersion}`);
-    const downloadMock = nock('https://dl.deno.land')
-        .get(`/release/v${latestVersion}/deno-${target}.zip`)
-        .reply(200, () => data);
-    const tmpDir = await tmp.dir();
-    const beforeDownload = vi.fn();
-    const afterDownload = vi.fn();
-    const deno = new DenoBridge({
-        cacheDirectory: tmpDir.path,
-        onBeforeDownload: beforeDownload,
-        onAfterDownload: afterDownload,
-        useGlobal: false,
-    });
-    const output1 = await deno.run(['help']);
-    const output2 = await deno.run(['help']);
-    const expectedOutput = /^deno [\d.]+/;
-    expect(latestReleaseMock.isDone()).toBe(true);
-    expect(downloadMock.isDone()).toBe(true);
-    expect(output1?.stdout ?? '').toMatch(expectedOutput);
-    expect(output2?.stdout ?? '').toMatch(expectedOutput);
-    expect(beforeDownload).toHaveBeenCalledTimes(1);
-    expect(afterDownload).toHaveBeenCalledTimes(1);
-    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
-});