@netlify/edge-bundler 3.1.1 → 4.0.0

package/dist/node/bridge.test.js

@@ -5,7 +5,6 @@ import { platform, env } from 'process';
 import { PassThrough } from 'stream';
 import nock from 'nock';
 import semver from 'semver';
-import { spy } from 'sinon';
 import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
 import { DenoBridge, DENO_VERSION_RANGE } from './bridge.js';
@@ -27,12 +26,8 @@ const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
     nock('https://dl.deno.land')
         .get(`/release/v${latestVersion}/deno-${target}.zip`)
         .reply(200, () => data);
-    const beforeDownload = spy();
-    const afterDownload = spy();
     return new DenoBridge({
         cacheDirectory: tmpDir.path,
-        onBeforeDownload: beforeDownload,
-        onAfterDownload: afterDownload,
         useGlobal: false,
     });
 };

package/dist/node/bundler.test.js

@@ -87,7 +87,6 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
         basePath: fixturesDir,
         featureFlags: {
             edge_functions_produce_eszip: true,
-            edge_functions_use_vendored_eszip: true,
         },
         importMaps: [
             {

package/dist/node/config.d.ts

@@ -2,12 +2,12 @@ import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
 import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
-export declare const enum Mode {
-    BeforeCache = "before-cache",
-    AfterCache = "after-cache"
+export declare const enum Cache {
+    Off = "off",
+    Manual = "manual"
 }
 export interface FunctionConfig {
-    mode?: Mode;
+    cache?: Cache;
     path?: string;
 }
 export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -3,7 +3,6 @@ import { join } from 'path';
 import { pathToFileURL } from 'url';
 import tmp from 'tmp-promise';
 import { getPackagePath } from './package_json.js';
-// eslint-disable-next-line no-shadow
 var ConfigExitCode;
 (function (ConfigExitCode) {
     ConfigExitCode[ConfigExitCode["Success"] = 0] = "Success";

package/dist/node/config.test.js

@@ -2,9 +2,8 @@ import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
-import { stub } from 'sinon';
 import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 import { fixturesDir } from '../test/util.js';
 import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
@@ -101,8 +100,8 @@ test('`getFunctionConfig` extracts configuration properties from function file',
     ];
     for (const func of functions) {
         const logger = {
-            user: stub().resolves(),
-            system: stub().resolves(),
+            user: vi.fn().mockResolvedValue(null),
+            system: vi.fn().mockResolvedValue(null),
         };
         const path = join(tmpDir, `${func.name}.js`);
         await fs.writeFile(path, func.source);
@@ -112,10 +111,10 @@ test('`getFunctionConfig` extracts configuration properties from function file',
         }, new ImportMap([importMapFile]), deno, logger);
         expect(config).toEqual(func.expectedConfig);
         if (func.userLog) {
-            expect(logger.user.firstCall.firstArg).toMatch(func.userLog);
+            expect(logger.user).toHaveBeenNthCalledWith(1, expect.stringMatching(func.userLog));
         }
         else {
-            expect(logger.user.callCount).toBe(0);
+            expect(logger.user).not.toHaveBeenCalled();
         }
     }
     await deleteAsync(tmpDir, { force: true });

package/dist/node/declaration.d.ts

@@ -1,7 +1,7 @@
 import { FunctionConfig } from './config.js';
 interface BaseDeclaration {
+    cache?: string;
     function: string;
-    mode?: string;
     name?: string;
 }
 declare type DeclarationWithPath = BaseDeclaration & {

package/dist/node/feature_flags.js

@@ -2,7 +2,6 @@ const defaultFlags = {
     edge_functions_cache_deno_dir: false,
     edge_functions_config_export: false,
     edge_functions_produce_eszip: false,
-    edge_functions_use_vendored_eszip: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

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

@@ -13,5 +13,5 @@ interface BundleESZIPOptions {
     functions: EdgeFunction[];
     importMap: ImportMap;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, featureFlags, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
 export { bundleESZIP as bundle };

package/dist/node/formats/eszip.js

@@ -2,7 +2,7 @@ import { join } from 'path';
 import { wrapBundleError } from '../bundle_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, featureFlags, functions, importMap, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
@@ -18,9 +18,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, feat
     }
     // To actually vendor the eszip module, we need to supply the import map that
     // redirects `https://deno.land/` URLs to the local files.
-    if (featureFlags.edge_functions_use_vendored_eszip) {
-        flags.push(`--import-map=${bundlerImportMap}`);
-    }
+    flags.push(`--import-map=${bundlerImportMap}`);
     try {
         await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
     }

package/dist/node/logger.test.js

@@ -1,5 +1,4 @@
-import { stub } from 'sinon';
-import { afterEach, test, expect } from 'vitest';
+import { afterEach, test, expect, vi } from 'vitest';
 import { getLogger } from './logger.js';
 const consoleLog = console.log;
 const noopLogger = () => {
@@ -10,36 +9,36 @@ afterEach(() => {
     console.log = consoleLog;
 });
 test('Prints user logs to stdout', () => {
-    const mockConsoleLog = stub();
+    const mockConsoleLog = vi.fn();
     console.log = mockConsoleLog;
     const logger1 = getLogger(noopLogger, true);
     const logger2 = getLogger(noopLogger, false);
     logger1.user('Hello with `debug: true`');
     logger2.user('Hello with `debug: false`');
-    expect(mockConsoleLog.callCount).toBe(2);
-    expect(mockConsoleLog.firstCall.firstArg).toBe('Hello with `debug: true`');
-    expect(mockConsoleLog.secondCall.firstArg).toBe('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 system logs to the system logger provided', () => {
-    const mockSystemLog = stub();
-    const mockConsoleLog = stub();
+    const mockSystemLog = vi.fn();
+    const mockConsoleLog = vi.fn();
     console.log = mockSystemLog;
     const logger1 = getLogger(mockSystemLog, true);
     const logger2 = getLogger(mockSystemLog, false);
     logger1.system('Hello with `debug: true`');
     logger2.system('Hello with `debug: false`');
-    expect(mockConsoleLog.callCount).toBe(0);
-    expect(mockSystemLog.callCount).toBe(2);
-    expect(mockSystemLog.firstCall.firstArg).toBe('Hello with `debug: true`');
-    expect(mockSystemLog.secondCall.firstArg).toBe('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 = stub();
+    const mockConsoleLog = vi.fn();
     console.log = mockConsoleLog;
     const logger1 = getLogger(undefined, true);
     const logger2 = getLogger(undefined, false);
     logger1.system('Hello with `debug: true`');
     logger2.system('Hello with `debug: false`');
-    expect(mockConsoleLog.callCount).toBe(1);
-    expect(mockConsoleLog.firstCall.firstArg).toBe('Hello with `debug: true`');
+    expect(mockConsoleLog).toHaveBeenCalledTimes(1);
+    expect(mockConsoleLog).toHaveBeenNthCalledWith(1, 'Hello with `debug: true`');
 });

package/dist/node/main.test.js

@@ -5,9 +5,8 @@ import { platform } from 'process';
 import { PassThrough } from 'stream';
 import nock from 'nock';
 import semver from 'semver';
-import { spy } from 'sinon';
 import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
+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);
@@ -27,8 +26,8 @@ test('Downloads the Deno CLI on demand and caches it for subsequent calls', asyn
         .get(`/release/v${latestVersion}/deno-${target}.zip`)
         .reply(200, () => data);
     const tmpDir = await tmp.dir();
-    const beforeDownload = spy();
-    const afterDownload = spy();
+    const beforeDownload = vi.fn();
+    const afterDownload = vi.fn();
     const deno = new DenoBridge({
         cacheDirectory: tmpDir.path,
         onBeforeDownload: beforeDownload,
@@ -42,7 +41,7 @@ test('Downloads the Deno CLI on demand and caches it for subsequent calls', asyn
     expect(downloadMock.isDone()).toBe(true);
     expect((_c = output1 === null || output1 === void 0 ? void 0 : output1.stdout) !== null && _c !== void 0 ? _c : '').toMatch(expectedOutput);
     expect((_d = output2 === null || output2 === void 0 ? void 0 : output2.stdout) !== null && _d !== void 0 ? _d : '').toMatch(expectedOutput);
-    expect(beforeDownload.callCount).toBe(1);
-    expect(afterDownload.callCount).toBe(1);
+    expect(beforeDownload).toHaveBeenCalledTimes(1);
+    expect(afterDownload).toHaveBeenCalledTimes(1);
     await fs.promises.rmdir(tmpDir.path, { recursive: true });
 });

package/dist/node/manifest.js

@@ -18,7 +18,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions }) => {
             name: declaration.name,
             pattern: serializablePattern,
         };
-        if (declaration.mode === "after-cache" /* Mode.AfterCache */) {
+        if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
         }
         else {

package/dist/node/manifest.test.js

@@ -98,8 +98,8 @@ test('Generates a manifest with pre and post-cache routes', () => {
     ];
     const declarations = [
         { function: 'func-1', path: '/f1' },
-        { function: 'func-2', mode: 'not_a_supported_mode', path: '/f2' },
-        { function: 'func-3', mode: 'after-cache', path: '/f3' },
+        { function: 'func-2', cache: 'not_a_supported_value', path: '/f2' },
+        { function: 'func-3', cache: 'manual', path: '/f3' },
     ];
     const manifest = generateManifest({ bundles: [bundle1, bundle2], declarations, functions });
     const expectedBundles = [

package/dist/node/types.test.js

@@ -1,9 +1,8 @@
 import { promises as fs } from 'fs';
 import { join } from 'path';
 import nock from 'nock';
-import { stub } from 'sinon';
 import tmp from 'tmp-promise';
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 import { testLogger } from '../test/util.js';
 import { DenoBridge } from './bridge.js';
 import { ensureLatestTypes } from './types.js';
@@ -16,14 +15,15 @@ test('`ensureLatestTypes` updates the Deno CLI cache if the local version of typ
         cacheDirectory: tmpDir.path,
         logger: testLogger,
     });
-    const mock = stub(deno, 'run').resolves();
+    // @ts-expect-error return value not used
+    const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
     await ensureLatestTypes(deno, testLogger, mockURL);
     const versionFile = await fs.readFile(join(tmpDir.path, 'types-version.txt'), 'utf8');
     expect(latestVersionMock.isDone()).toBe(true);
-    expect(mock.callCount).toBe(1);
-    expect(mock.firstCall.firstArg).toEqual(['cache', '-r', mockURL]);
+    expect(mock).toHaveBeenCalledTimes(1);
+    expect(mock).toHaveBeenCalledWith(['cache', '-r', mockURL]);
     expect(versionFile).toBe(mockVersion);
-    mock.restore();
+    mock.mockRestore();
     await fs.rmdir(tmpDir.path, { recursive: true });
 });
 test('`ensureLatestTypes` does not update the Deno CLI cache if the local version of types is up-to-date', async () => {
@@ -37,11 +37,12 @@ test('`ensureLatestTypes` does not update the Deno CLI cache if the local versio
         cacheDirectory: tmpDir.path,
         logger: testLogger,
     });
-    const mock = stub(deno, 'run').resolves();
+    // @ts-expect-error return value not used
+    const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
     await ensureLatestTypes(deno, testLogger, mockURL);
     expect(latestVersionMock.isDone()).toBe(true);
-    expect(mock.callCount).toBe(0);
-    mock.restore();
+    expect(mock).not.toHaveBeenCalled();
+    mock.mockRestore();
     await fs.rmdir(tmpDir.path, { recursive: true });
 });
 test('`ensureLatestTypes` does not throw if the types URL is not available', async () => {
@@ -52,10 +53,11 @@ test('`ensureLatestTypes` does not throw if the types URL is not available', asy
         cacheDirectory: tmpDir.path,
         logger: testLogger,
     });
-    const mock = stub(deno, 'run').resolves();
+    // @ts-expect-error return value not used
+    const mock = vi.spyOn(deno, 'run').mockResolvedValue({});
     await ensureLatestTypes(deno, testLogger, mockURL);
     expect(latestVersionMock.isDone()).toBe(true);
-    expect(mock.callCount).toBe(0);
-    mock.restore();
+    expect(mock).not.toHaveBeenCalled();
+    mock.mockRestore();
     await fs.rmdir(tmpDir.path, { recursive: true });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "3.1.1",
+  "version": "4.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -57,15 +57,14 @@
     "@types/semver": "^7.3.9",
     "@types/sinon": "^10.0.8",
     "@types/uuid": "^8.3.4",
-    "@vitest/coverage-c8": "^0.24.0",
+    "@vitest/coverage-c8": "^0.25.0",
     "archiver": "^5.3.1",
     "husky": "^8.0.0",
     "nock": "^13.2.4",
-    "sinon": "^14.0.0",
     "tar": "^6.1.11",
     "typescript": "^4.5.4",
     "vite": "^3.1.3",
-    "vitest": "^0.24.0"
+    "vitest": "^0.25.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"