@netlify/edge-bundler 1.8.0 → 1.9.0

package/dist/bridge.d.ts

@@ -1,10 +1,12 @@
 import { ExecaChildProcess } from 'execa';
+import { Logger } from './logger.js';
 declare type OnBeforeDownloadHook = () => void | Promise<void>;
 declare type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 interface DenoOptions {
     cacheDirectory?: string;
     debug?: boolean;
     denoDir?: string;
+    logger: Logger;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     useGlobal?: boolean;
@@ -21,13 +23,14 @@ declare class DenoBridge {
     currentDownload?: ReturnType<DenoBridge['downloadBinary']>;
     debug: boolean;
     denoDir?: string;
+    logger: Logger;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     useGlobal: boolean;
     versionRange: string;
-    constructor(options?: DenoOptions);
+    constructor(options: DenoOptions);
     private downloadBinary;
-    static getBinaryVersion(binaryPath: string): Promise<string | undefined>;
+    private getBinaryVersion;
     private getCachedBinary;
     private getGlobalBinary;
     private getRemoteBinary;
@@ -39,7 +42,6 @@ declare class DenoBridge {
         path: string;
     }>;
     getEnvironmentVariables(): Record<string, string>;
-    log(...data: unknown[]): void;
     run(args: string[], { pipeOutput }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
     runInBackground(args: string[], pipeOutput?: boolean, ref?: ProcessRef): Promise<void>;
 }

package/dist/bridge.js

@@ -9,11 +9,12 @@ import { getBinaryExtension } from './platform.js';
 const DENO_VERSION_FILE = 'version.txt';
 const DENO_VERSION_RANGE = '^1.20.3';
 class DenoBridge {
-    constructor(options = {}) {
+    constructor(options) {
         var _a, _b, _c, _d;
         this.cacheDirectory = (_a = options.cacheDirectory) !== null && _a !== void 0 ? _a : getPathInHome('deno-cli');
         this.debug = (_b = options.debug) !== null && _b !== void 0 ? _b : false;
         this.denoDir = options.denoDir;
+        this.logger = options.logger;
         this.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
         this.useGlobal = (_c = options.useGlobal) !== null && _c !== void 0 ? _c : true;
@@ -23,9 +24,9 @@ class DenoBridge {
         var _a, _b, _c;
         await ((_a = this.onBeforeDownload) === null || _a === void 0 ? void 0 : _a.call(this));
         await this.ensureCacheDirectory();
-        this.log(`Downloading Deno CLI to ${this.cacheDirectory}...`);
+        this.logger.system(`Downloading Deno CLI to ${this.cacheDirectory}`);
         const binaryPath = await download(this.cacheDirectory, this.versionRange);
-        const downloadedVersion = await DenoBridge.getBinaryVersion(binaryPath);
+        const downloadedVersion = await this.getBinaryVersion(binaryPath);
         // We should never get here, because it means that `DENO_VERSION_RANGE` is
         // a malformed semver range. If this does happen, let's throw an error so
         // that the tests catch it.
@@ -38,7 +39,7 @@ class DenoBridge {
         await ((_c = this.onAfterDownload) === null || _c === void 0 ? void 0 : _c.call(this));
         return binaryPath;
     }
-    static async getBinaryVersion(binaryPath) {
+    async getBinaryVersion(binaryPath) {
         try {
             const { stdout } = await execa(binaryPath, ['--version']);
             const version = stdout.match(/^deno ([\d.]+)/);
@@ -47,8 +48,8 @@ class DenoBridge {
             }
             return version[1];
         }
-        catch {
-            // no-op
+        catch (error) {
+            this.logger.system('Error checking Deno binary version', error);
         }
     }
     async getCachedBinary() {
@@ -71,7 +72,7 @@ class DenoBridge {
             return;
         }
         const globalBinaryName = 'deno';
-        const globalVersion = await DenoBridge.getBinaryVersion(globalBinaryName);
+        const globalVersion = await this.getBinaryVersion(globalBinaryName);
         if (globalVersion === undefined || !semver.satisfies(globalVersion, this.versionRange)) {
             return;
         }
@@ -103,12 +104,12 @@ class DenoBridge {
     async getBinaryPath() {
         const globalPath = await this.getGlobalBinary();
         if (globalPath !== undefined) {
-            this.log('Using global installation of Deno CLI');
+            this.logger.system('Using global installation of Deno CLI');
             return { global: true, path: globalPath };
         }
         const cachedPath = await this.getCachedBinary();
         if (cachedPath !== undefined) {
-            this.log('Using cached Deno CLI from', cachedPath);
+            this.logger.system('Using cached Deno CLI from', cachedPath);
             return { global: false, path: cachedPath };
         }
         const downloadedPath = await this.getRemoteBinary();
@@ -121,12 +122,6 @@ class DenoBridge {
         }
         return env;
     }
-    log(...data) {
-        if (!this.debug) {
-            return;
-        }
-        console.log(...data);
-    }
     // Runs the Deno CLI in the background and returns a reference to the child
     // process, awaiting its execution.
     async run(args, { pipeOutput } = {}) {

package/dist/bundler.d.ts

@@ -3,6 +3,7 @@ import type { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { ImportMapFile } from './import_map.js';
+import { LogFunction } from './logger.js';
 interface BundleOptions {
     basePath?: string;
     cacheDirectory?: string;
@@ -12,8 +13,9 @@ interface BundleOptions {
     importMaps?: ImportMapFile[];
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
+    systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/bundler.js

@@ -8,6 +8,7 @@ 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 createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, featureFlags, }) => {
@@ -35,11 +36,13 @@ const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functi
     }
     return bundleOps;
 };
-const bundle = async (sourceDirectories, distDirectory, declarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, declarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
+    const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
         debug,
         cacheDirectory,
+        logger,
         onAfterDownload,
         onBeforeDownload,
     };
@@ -48,7 +51,7 @@ const bundle = async (sourceDirectories, distDirectory, declarations = [], { bas
     }
     const deno = new DenoBridge(options);
     const basePath = getBasePath(sourceDirectories, inputBasePath);
-    await ensureLatestTypes(deno);
+    await ensureLatestTypes(deno, logger);
     // The name of the bundle will be the hash of its contents, which we can't
     // compute until we run the bundle process. For now, we'll use a random ID
     // to create the bundle artifacts and rename them later.

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+declare type LogFunction = (...args: unknown[]) => void;
+interface Logger {
+    system: LogFunction;
+    user: LogFunction;
+}
+declare const getLogger: (systemLogger?: LogFunction, debug?: boolean) => Logger;
+export { getLogger };
+export type { LogFunction, Logger };

package/dist/logger.js

@@ -0,0 +1,14 @@
+const noopLogger = () => {
+    // no-op
+};
+const getLogger = (systemLogger, debug = false) => {
+    // If there is a system logger configured, we'll use that. If there isn't,
+    // we'll pipe system logs to stdout if `debug` is enabled and swallow them
+    // otherwise.
+    const system = systemLogger !== null && systemLogger !== void 0 ? systemLogger : (debug ? console.log : noopLogger);
+    return {
+        system,
+        user: console.log,
+    };
+};
+export { getLogger };

package/dist/server/server.d.ts

@@ -1,6 +1,7 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import type { EdgeFunction } from '../edge_function.js';
 import { ImportMapFile } from '../import_map.js';
+import { LogFunction } from '../logger.js';
 declare type FormatFunction = (name: string) => string;
 interface InspectSettings {
     enabled: boolean;
@@ -18,8 +19,9 @@ interface ServeOptions {
     formatExportTypeError?: FormatFunction;
     formatImportError?: FormatFunction;
     port: number;
+    systemLogger?: LogFunction;
 }
-declare const serve: ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, }: ServeOptions) => Promise<(newFunctions: EdgeFunction[]) => Promise<{
+declare const serve: ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(newFunctions: EdgeFunction[]) => Promise<{
     graph: any;
     success: boolean;
 }>>;

package/dist/server/server.js

@@ -2,6 +2,7 @@ import { tmpName } from 'tmp-promise';
 import { DenoBridge } from '../bridge.js';
 import { generateStage2 } from '../formats/javascript.js';
 import { ImportMap } from '../import_map.js';
+import { getLogger } from '../logger.js';
 import { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
 const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportTypeError, formatImportError, port, }) => {
@@ -40,9 +41,11 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
     };
     return startIsolate;
 };
-const serve = async ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, }) => {
+const serve = async ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
+    const logger = getLogger(systemLogger, debug);
     const deno = new DenoBridge({
         debug,
+        logger,
         onAfterDownload,
         onBeforeDownload,
     });
@@ -52,7 +55,7 @@ const serve = async ({ certificatePath, debug, distImportMapPath, inspectSetting
     // Wait for the binary to be downloaded if needed.
     await deno.getBinaryPath();
     // Downloading latest types if needed.
-    await ensureLatestTypes(deno);
+    await ensureLatestTypes(deno, logger);
     // Creating an ImportMap instance with any import maps supplied by the user,
     // if any.
     const importMap = new ImportMap(importMaps);

package/dist/types.d.ts

@@ -1,3 +1,4 @@
 import type { DenoBridge } from './bridge.js';
-declare const ensureLatestTypes: (deno: DenoBridge, customTypesURL?: string) => Promise<void>;
+import type { Logger } from './logger.js';
+declare const ensureLatestTypes: (deno: DenoBridge, logger: Logger, customTypesURL?: string) => Promise<void>;
 export { ensureLatestTypes };

package/dist/types.js

@@ -2,26 +2,26 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 import fetch from 'node-fetch';
 const TYPES_URL = 'https://edge.netlify.com';
-const ensureLatestTypes = async (deno, customTypesURL) => {
+const ensureLatestTypes = async (deno, logger, customTypesURL) => {
     const typesURL = customTypesURL !== null && customTypesURL !== void 0 ? customTypesURL : TYPES_URL;
     let [localVersion, remoteVersion] = [await getLocalVersion(deno), ''];
     try {
         remoteVersion = await getRemoteVersion(typesURL);
     }
     catch (error) {
-        deno.log('Could not check latest version of types:', error);
+        logger.system('Could not check latest version of types:', error);
         return;
     }
     if (localVersion === remoteVersion) {
-        deno.log('Local version of types is up-to-date:', localVersion);
+        logger.system('Local version of types is up-to-date:', localVersion);
         return;
     }
-    deno.log('Local version of types is outdated, updating:', localVersion);
+    logger.system('Local version of types is outdated, updating:', localVersion);
     try {
         await deno.run(['cache', '-r', typesURL]);
     }
     catch (error) {
-        deno.log('Could not download latest types:', error);
+        logger.system('Could not download latest types:', error);
         return;
     }
     try {

package/package.json

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