@netlify/edge-bundler 1.8.0 → 1.11.0

package/dist/bridge.d.ts

@@ -1,10 +1,13 @@
+/// <reference types="node" />
 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;
@@ -15,19 +18,22 @@ interface ProcessRef {
 }
 interface RunOptions {
     pipeOutput?: boolean;
+    env?: NodeJS.ProcessEnv;
+    extendEnv?: boolean;
 }
 declare class DenoBridge {
     cacheDirectory: string;
     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;
@@ -38,10 +44,9 @@ declare class DenoBridge {
         global: boolean;
         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>;
+    getEnvironmentVariables(inputEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+    run(args: string[], { pipeOutput, env: inputEnv, extendEnv }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
+    runInBackground(args: string[], ref?: ProcessRef, { pipeOutput, env: inputEnv, extendEnv }?: RunOptions): Promise<void>;
 }
 export { DenoBridge };
 export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };

package/dist/bridge.js

@@ -5,27 +5,29 @@ import { execa } from 'execa';
 import semver from 'semver';
 import { download } from './downloader.js';
 import { getPathInHome } from './home_path.js';
+import { getLogger } from './logger.js';
 import { getBinaryExtension } from './platform.js';
 const DENO_VERSION_FILE = 'version.txt';
 const DENO_VERSION_RANGE = '^1.20.3';
 class DenoBridge {
-    constructor(options = {}) {
-        var _a, _b, _c, _d;
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
         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 = (_c = options.logger) !== null && _c !== void 0 ? _c : getLogger(undefined, options.debug);
         this.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
-        this.useGlobal = (_c = options.useGlobal) !== null && _c !== void 0 ? _c : true;
-        this.versionRange = (_d = options.versionRange) !== null && _d !== void 0 ? _d : DENO_VERSION_RANGE;
+        this.useGlobal = (_d = options.useGlobal) !== null && _d !== void 0 ? _d : true;
+        this.versionRange = (_e = options.versionRange) !== null && _e !== void 0 ? _e : DENO_VERSION_RANGE;
     }
     async downloadBinary() {
         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 +40,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 +49,8 @@ class DenoBridge {
             }
             return version[1];
         }
-        catch {
-            // no-op
+        catch (error) {
+            this.logger.system('Error checking Deno binary version', error);
         }
     }
     async getCachedBinary() {
@@ -71,7 +73,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,44 +105,38 @@ 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();
         return { global: false, path: downloadedPath };
     }
-    getEnvironmentVariables() {
-        const env = {};
+    getEnvironmentVariables(inputEnv = {}) {
+        const env = { ...inputEnv };
         if (this.denoDir !== undefined) {
             env.DENO_DIR = this.denoDir;
         }
         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 } = {}) {
+    async run(args, { pipeOutput, env: inputEnv, extendEnv = true } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
-        const env = this.getEnvironmentVariables();
-        const options = { env };
+        const env = this.getEnvironmentVariables(inputEnv);
+        const options = { env, extendEnv };
         return DenoBridge.runWithBinary(binaryPath, args, options, pipeOutput);
     }
     // Runs the Deno CLI in the background, assigning a reference of the child
     // process to a `ps` property in the `ref` argument, if one is supplied.
-    async runInBackground(args, pipeOutput, ref) {
+    async runInBackground(args, ref, { pipeOutput, env: inputEnv, extendEnv = true } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
-        const env = this.getEnvironmentVariables();
-        const options = { env };
+        const env = this.getEnvironmentVariables(inputEnv);
+        const options = { env, extendEnv };
         const ps = DenoBridge.runWithBinary(binaryPath, args, options, pipeOutput);
         if (ref !== undefined) {
             // eslint-disable-next-line no-param-reassign

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,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 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 +23,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[], env?: NodeJS.ProcessEnv) => Promise<{
     graph: any;
     success: boolean;
 }>>;

package/dist/server/server.js

@@ -2,11 +2,12 @@ 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, }) => {
     const processRef = {};
-    const startIsolate = async (newFunctions) => {
+    const startIsolate = async (newFunctions, env = {}) => {
         if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
             await killProcess(processRef.ps);
         }
@@ -31,7 +32,14 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
             // no-op
         }
         const bootstrapFlags = ['--port', port.toString()];
-        await deno.runInBackground(['run', ...denoFlags, stage2Path, ...bootstrapFlags], true, processRef);
+        // We set `extendEnv: false` to avoid polluting the edge function context
+        // with variables from the user's system, since those will not be available
+        // in the production environment.
+        await deno.runInBackground(['run', ...denoFlags, stage2Path, ...bootstrapFlags], processRef, {
+            pipeOutput: true,
+            env,
+            extendEnv: false,
+        });
         const success = await waitForServer(port, processRef.ps);
         return {
             graph,
@@ -40,9 +48,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 +62,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.11.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/index.js",