@netlify/edge-bundler 1.4.2 → 1.6.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

@@ -29,13 +29,14 @@ declare class DenoBridge {
     private getCachedBinary;
     private getGlobalBinary;
     private getRemoteBinary;
-    private log;
     private static runWithBinary;
     private writeVersionFile;
+    ensureCacheDirectory(): Promise<void>;
     getBinaryPath(): Promise<{
         global: boolean;
         path: 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

@@ -21,7 +21,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,12 +82,6 @@ class DenoBridge {
         }
         return this.currentDownload;
     }
-    log(...data) {
-        if (!this.debug) {
-            return;
-        }
-        console.log(...data);
-    }
     static runWithBinary(binaryPath, args, pipeOutput) {
         var _a, _b;
         const runDeno = execa(binaryPath, args);
@@ -98,9 +92,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) {
@@ -115,6 +113,12 @@ class DenoBridge {
         const downloadedPath = await this.getRemoteBinary();
         return { global: false, path: downloadedPath };
     }
+    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.js

@@ -9,6 +9,7 @@ import { bundle as bundleESZIP } from './formats/eszip.js';
 import { bundle as bundleJS } from './formats/javascript.js';
 import { ImportMap } from './import_map.js';
 import { writeManifest } from './manifest.js';
+import { ensureLatestTypes } from './types.js';
 const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, featureFlags, }) => {
     const bundleOps = [];
     if (featureFlags.edge_functions_produce_eszip) {
@@ -19,6 +20,7 @@ const createBundleOps = ({ basePath, buildID, debug, deno, distDirectory, functi
             deno,
             distDirectory,
             functions,
+            importMap,
         }));
     }
     else {
@@ -42,6 +44,7 @@ const bundle = async (sourceDirectories, distDirectory, declarations = [], { cac
         onBeforeDownload,
     });
     const basePath = getBasePath(sourceDirectories);
+    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
     // to create the bundle artifacts and rename them later.

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 bundle: (options: BundleESZIPOptions) => Promise<Bundle>;
-export { bundle };
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
+export { bundleESZIP as bundle };

package/dist/formats/eszip.js

@@ -2,15 +2,7 @@ import { join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { wrapBundleError } from '../bundle_error.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundle = async (options) => {
-    try {
-        return await bundleESZIP(options);
-    }
-    catch (error) {
-        throw wrapBundleError(error, { format: 'eszip' });
-    }
-};
-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();
@@ -18,12 +10,18 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, func
         basePath,
         destPath,
         functions,
+        imports: importMap.imports,
     };
     const flags = ['--allow-all'];
     if (!debug) {
         flags.push('--quiet');
     }
-    await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
+    try {
+        await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
+    }
+    catch (error) {
+        throw wrapBundleError(error, { format: 'eszip' });
+    }
     const hash = await getFileHash(destPath);
     return { extension, format: 'eszip2', hash };
 };
@@ -33,4 +31,4 @@ const getESZIPBundler = () => {
     const bundlerPath = resolve(pathname, '../../../deno/bundle.ts');
     return bundlerPath;
 };
-export { bundle };
+export { bundleESZIP as bundle };

package/dist/formats/javascript.d.ts

@@ -11,7 +11,7 @@ interface BundleJSOptions {
     functions: EdgeFunction[];
     importMap: ImportMap;
 }
-declare const bundle: (options: BundleJSOptions) => Promise<Bundle>;
+declare const bundleJS: ({ buildID, debug, deno, distDirectory, functions, importMap, }: BundleJSOptions) => Promise<Bundle>;
 interface GenerateStage2Options {
     distDirectory: string;
     fileName: string;
@@ -22,4 +22,4 @@ interface GenerateStage2Options {
 }
 declare const generateStage2: ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, type, }: GenerateStage2Options) => Promise<string>;
 declare const getBootstrapURL: () => string;
-export { bundle, generateStage2, getBootstrapURL };
+export { bundleJS as bundle, generateStage2, getBootstrapURL };

package/dist/formats/javascript.js

@@ -5,15 +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 bundle = async (options) => {
-    try {
-        return await bundleJS(options);
-    }
-    catch (error) {
-        throw wrapBundleError(error, { format: 'javascript' });
-    }
-};
+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';
@@ -22,7 +14,12 @@ const bundleJS = async ({ buildID, debug, deno, distDirectory, functions, import
     if (!debug) {
         flags.push('--quiet');
     }
-    await deno.run(['bundle', ...flags, stage2Path, jsBundlePath], { pipeOutput: true });
+    try {
+        await deno.run(['bundle', ...flags, stage2Path, jsBundlePath], { pipeOutput: true });
+    }
+    catch (error) {
+        throw wrapBundleError(error, { format: 'javascript' });
+    }
     await fs.unlink(stage2Path);
     const hash = await getFileHash(jsBundlePath);
     return { extension, format: 'js', hash };
@@ -80,4 +77,4 @@ const getProductionEntryPoint = (functions) => {
     const defaultExport = 'boot(functions);';
     return [bootImport, importLines, exportDeclaration, defaultExport].join('\n\n');
 };
-export { bundle, generateStage2, getBootstrapURL };
+export { bundleJS as bundle, generateStage2, getBootstrapURL };

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/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 { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
 const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportTypeError, formatImportError, port, }) => {
     const processRef = {};
@@ -39,7 +40,6 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
     };
     return startIsolate;
 };
-// eslint-disable-next-line complexity, max-statements
 const serve = async ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, }) => {
     const deno = new DenoBridge({
         debug,
@@ -51,6 +51,8 @@ const serve = async ({ certificatePath, debug, distImportMapPath, inspectSetting
     const distDirectory = await tmpName();
     // Wait for the binary to be downloaded if needed.
     await deno.getBinaryPath();
+    // Downloading latest types if needed.
+    await ensureLatestTypes(deno);
     // Creating an ImportMap instance with any import maps supplied by the user,
     // if any.
     const importMap = new ImportMap(importMaps);

package/dist/types.d.ts

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

package/dist/types.js

@@ -0,0 +1,58 @@
+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 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);
+        return;
+    }
+    if (localVersion === remoteVersion) {
+        deno.log('Local version of types is up-to-date:', localVersion);
+        return;
+    }
+    deno.log('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);
+        return;
+    }
+    try {
+        await writeVersionFile(deno, remoteVersion);
+    }
+    catch {
+        // no-op
+    }
+};
+const getLocalVersion = async (deno) => {
+    const versionFilePath = join(deno.cacheDirectory, 'types-version.txt');
+    try {
+        const version = await fs.readFile(versionFilePath, 'utf8');
+        return version;
+    }
+    catch {
+        // no-op
+    }
+};
+const getRemoteVersion = async (typesURL) => {
+    const versionURL = new URL('/version.txt', typesURL);
+    const res = await fetch(versionURL.toString());
+    if (res.status !== 200) {
+        throw new Error('Unexpected status code from version endpoint');
+    }
+    const version = await res.text();
+    return version;
+};
+const writeVersionFile = async (deno, version) => {
+    await deno.ensureCacheDirectory();
+    const versionFilePath = join(deno.cacheDirectory, 'types-version.txt');
+    await fs.writeFile(versionFilePath, version);
+};
+export { ensureLatestTypes };

package/package.json

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