@netlify/edge-bundler 1.6.0 → 1.9.0

package/dist/bridge.d.ts

@@ -1,9 +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;
@@ -19,13 +22,15 @@ 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;
@@ -36,9 +41,9 @@ declare class DenoBridge {
         global: boolean;
         path: string;
     }>;
-    log(...data: unknown[]): void;
+    getEnvironmentVariables(): Record<string, string>;
     run(args: string[], { pipeOutput }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
     runInBackground(args: string[], pipeOutput?: boolean, ref?: ProcessRef): Promise<void>;
 }
 export { DenoBridge };
-export type { OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };
+export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };

package/dist/bridge.js

@@ -9,10 +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;
@@ -22,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.
@@ -37,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.]+)/);
@@ -46,8 +48,8 @@ class DenoBridge {
             }
             return version[1];
         }
-        catch {
-            // no-op
+        catch (error) {
+            this.logger.system('Error checking Deno binary version', error);
         }
     }
     async getCachedBinary() {
@@ -70,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;
         }
@@ -82,9 +84,9 @@ class DenoBridge {
         }
         return this.currentDownload;
     }
-    static runWithBinary(binaryPath, args, pipeOutput) {
+    static runWithBinary(binaryPath, args, options, pipeOutput) {
         var _a, _b;
-        const runDeno = execa(binaryPath, args);
+        const runDeno = execa(binaryPath, args, options);
         if (pipeOutput) {
             (_a = runDeno.stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout);
             (_b = runDeno.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
@@ -102,34 +104,39 @@ 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 };
     }
-    log(...data) {
-        if (!this.debug) {
-            return;
+    getEnvironmentVariables() {
+        const env = {};
+        if (this.denoDir !== undefined) {
+            env.DENO_DIR = this.denoDir;
         }
-        console.log(...data);
+        return env;
     }
     // Runs the Deno CLI in the background and returns a reference to the child
     // process, awaiting its execution.
     async run(args, { pipeOutput } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
-        return DenoBridge.runWithBinary(binaryPath, args, pipeOutput);
+        const env = this.getEnvironmentVariables();
+        const options = { env };
+        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) {
         const { path: binaryPath } = await this.getBinaryPath();
-        const ps = DenoBridge.runWithBinary(binaryPath, args, pipeOutput);
+        const env = this.getEnvironmentVariables();
+        const options = { env };
+        const ps = DenoBridge.runWithBinary(binaryPath, args, options, pipeOutput);
         if (ref !== undefined) {
             // eslint-disable-next-line no-param-reassign
             ref.ps = ps;

package/dist/bundler.d.ts

@@ -3,7 +3,9 @@ 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;
     debug?: boolean;
     distImportMapPath?: string;
@@ -11,9 +13,11 @@ interface BundleOptions {
     importMaps?: ImportMapFile[];
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
+    systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { 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;
 }>;
 export { bundle };
+export type { BundleOptions };

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,16 +36,22 @@ const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functi
     }
     return bundleOps;
 };
-const bundle = async (sourceDirectories, distDirectory, declarations = [], { 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 deno = new DenoBridge({
+    const options = {
         debug,
         cacheDirectory,
+        logger,
         onAfterDownload,
         onBeforeDownload,
-    });
-    const basePath = getBasePath(sourceDirectories);
-    await ensureLatestTypes(deno);
+    };
+    if (cacheDirectory !== undefined && featureFlags.edge_functions_cache_deno_dir) {
+        options.denoDir = join(cacheDirectory, 'deno_dir');
+    }
+    const deno = new DenoBridge(options);
+    const basePath = getBasePath(sourceDirectories, inputBasePath);
+    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.
@@ -87,7 +94,11 @@ const createFinalBundles = async (bundles, distDirectory, buildID) => {
     });
     await Promise.all(renamingOps);
 };
-const getBasePath = (sourceDirectories) => {
+const getBasePath = (sourceDirectories, inputBasePath) => {
+    // If there's a specific base path supplied, that takes precedence.
+    if (inputBasePath !== undefined) {
+        return inputBasePath;
+    }
     // `common-path-prefix` returns an empty string when called with a single
     // path, so we check for that case and return the path itself instead.
     if (sourceDirectories.length === 1) {

package/dist/feature_flags.js

@@ -1,4 +1,5 @@
 const defaultFlags = {
+    edge_functions_cache_deno_dir: false,
     edge_functions_produce_eszip: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

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.6.0",
+  "version": "1.9.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/index.js",