@netlify/edge-bundler 1.5.0 → 1.8.0

package/deno/bundle.ts

@@ -1,6 +1,6 @@
-import { writeStage2 } from 'https://62bae4994570970008142f1e--edge-bootstrap.netlify.app/bundler/mod.ts'
+import { writeStage2 } from 'https://62d144a15553b50009af7ac6--edge.netlify.com/bundler/mod.ts'
 
 const [payload] = Deno.args
-const { basePath, destPath, functions } = JSON.parse(payload)
+const { basePath, destPath, functions, imports } = JSON.parse(payload)
 
-await writeStage2({ basePath, functions, destPath })
+await writeStage2({ basePath, destPath, functions, imports })

package/dist/bridge.d.ts

@@ -4,6 +4,7 @@ declare type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 interface DenoOptions {
     cacheDirectory?: string;
     debug?: boolean;
+    denoDir?: string;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     useGlobal?: boolean;
@@ -19,6 +20,7 @@ declare class DenoBridge {
     cacheDirectory: string;
     currentDownload?: ReturnType<DenoBridge['downloadBinary']>;
     debug: boolean;
+    denoDir?: string;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     useGlobal: boolean;
@@ -31,13 +33,15 @@ declare class DenoBridge {
     private getRemoteBinary;
     private static runWithBinary;
     private writeVersionFile;
+    ensureCacheDirectory(): Promise<void>;
     getBinaryPath(): Promise<{
         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>;
 }
 export { DenoBridge };
-export type { OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };
+export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };

package/dist/bridge.js

@@ -13,6 +13,7 @@ class DenoBridge {
         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.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
         this.useGlobal = (_c = options.useGlobal) !== null && _c !== void 0 ? _c : true;
@@ -21,7 +22,7 @@ class DenoBridge {
     async downloadBinary() {
         var _a, _b, _c;
         await ((_a = this.onBeforeDownload) === null || _a === void 0 ? void 0 : _a.call(this));
-        await fs.mkdir(this.cacheDirectory, { recursive: true });
+        await this.ensureCacheDirectory();
         this.log(`Downloading Deno CLI to ${this.cacheDirectory}...`);
         const binaryPath = await download(this.cacheDirectory, this.versionRange);
         const downloadedVersion = await DenoBridge.getBinaryVersion(binaryPath);
@@ -82,9 +83,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);
@@ -92,9 +93,13 @@ class DenoBridge {
         return runDeno;
     }
     async writeVersionFile(version) {
+        await this.ensureCacheDirectory();
         const versionFilePath = path.join(this.cacheDirectory, DENO_VERSION_FILE);
         await fs.writeFile(versionFilePath, version);
     }
+    async ensureCacheDirectory() {
+        await fs.mkdir(this.cacheDirectory, { recursive: true });
+    }
     async getBinaryPath() {
         const globalPath = await this.getGlobalBinary();
         if (globalPath !== undefined) {
@@ -109,6 +114,13 @@ class DenoBridge {
         const downloadedPath = await this.getRemoteBinary();
         return { global: false, path: downloadedPath };
     }
+    getEnvironmentVariables() {
+        const env = {};
+        if (this.denoDir !== undefined) {
+            env.DENO_DIR = this.denoDir;
+        }
+        return env;
+    }
     log(...data) {
         if (!this.debug) {
             return;
@@ -119,13 +131,17 @@ class DenoBridge {
     // 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

@@ -4,6 +4,7 @@ import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { ImportMapFile } from './import_map.js';
 interface BundleOptions {
+    basePath?: string;
     cacheDirectory?: string;
     debug?: boolean;
     distImportMapPath?: string;
@@ -12,8 +13,9 @@ interface BundleOptions {
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
 }
-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, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;
 export { bundle };
+export type { BundleOptions };

package/dist/bundler.js

@@ -20,6 +20,7 @@ const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functi
             deno,
             distDirectory,
             functions,
+            importMap,
         }));
     }
     else {
@@ -34,15 +35,19 @@ 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, } = {}) => {
     const featureFlags = getFlags(inputFeatureFlags);
-    const deno = new DenoBridge({
+    const options = {
         debug,
         cacheDirectory,
         onAfterDownload,
         onBeforeDownload,
-    });
-    const basePath = getBasePath(sourceDirectories);
+    };
+    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);
     // 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
@@ -86,7 +91,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/formats/eszip.d.ts

@@ -1,6 +1,7 @@
 import { DenoBridge } from '../bridge.js';
 import type { Bundle } from '../bundle.js';
 import { EdgeFunction } from '../edge_function.js';
+import { ImportMap } from '../import_map.js';
 interface BundleESZIPOptions {
     basePath: string;
     buildID: string;
@@ -8,6 +9,7 @@ interface BundleESZIPOptions {
     deno: DenoBridge;
     distDirectory: string;
     functions: EdgeFunction[];
+    importMap: ImportMap;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, functions, }: BundleESZIPOptions) => Promise<Bundle>;
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
 export { bundleESZIP as bundle };

package/dist/formats/eszip.js

@@ -2,7 +2,7 @@ import { join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { wrapBundleError } from '../bundle_error.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, functions, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const bundler = getESZIPBundler();
@@ -10,6 +10,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, func
         basePath,
         destPath,
         functions,
+        imports: importMap.imports,
     };
     const flags = ['--allow-all'];
     if (!debug) {

package/dist/formats/javascript.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from 'url';
 import del from 'del';
 import { wrapBundleError } from '../bundle_error.js';
 import { getFileHash } from '../utils/sha256.js';
-const BOOTSTRAP_LATEST = 'https://62bae4994570970008142f1e--edge-bootstrap.netlify.app/bootstrap/index-combined.ts';
+const BOOTSTRAP_LATEST = 'https://62d144a15553b50009af7ac6--edge.netlify.com/bootstrap/index-combined.ts';
 const bundleJS = async ({ buildID, debug, deno, distDirectory, functions, importMap, }) => {
     const stage2Path = await generateStage2({ distDirectory, functions, fileName: `${buildID}-pre.js` });
     const extension = '.js';

package/dist/import_map.js

@@ -2,7 +2,7 @@ import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
 import { dirname } from 'path';
 const INTERNAL_IMPORTS = {
-    'netlify:edge': 'https://edge-bootstrap.netlify.app/v1/index.ts',
+    'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
 };
 class ImportMap {
     constructor(input = []) {

package/dist/types.js

@@ -51,6 +51,7 @@ const getRemoteVersion = async (typesURL) => {
     return version;
 };
 const writeVersionFile = async (deno, version) => {
+    await deno.ensureCacheDirectory();
     const versionFilePath = join(deno.cacheDirectory, 'types-version.txt');
     await fs.writeFile(versionFilePath, version);
 };

package/package.json

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