@netlify/edge-bundler 0.11.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+[![Build](https://github.com/netlify/edge-bundler/workflows/Build/badge.svg)](https://github.com/netlify/edge-bundler/actions)
+[![Node](https://img.shields.io/node/v/@netlify/edge-bundler.svg?logo=node.js)](https://www.npmjs.com/package/@netlify/edge-bundler)
+
+# Edge Bundler
+
+Intelligently prepare Netlify Edge Functions for deployment.
+
+## Usage
+
+1. Install this module as a dependency in your project
+
+    ```
+    npm install @netlify/edge-bundler --save
+    ```
+
+2. Import it and create a bundle from a directory of Edge Functions and a list of declarations.
+
+    ```js
+    import { bundle } from '@netlify/edge-bundler'
+
+    // List of directories to search for Edge Functions.
+    const sourceDirectories = [
+        "/repo/netlify/edge-functions",
+        "/repo/.netlify/edge-functions"
+    ]
+
+    // Directory where bundle should be placed.
+    const distDirectory = "/repo/.netlify/edge-functions-dist"
+
+    // List of Edge Functions declarations.
+    const declarations = [
+        {function: "user-1", path: "/blog/*"},
+        {function: "internal-2", path: "/"}
+    ]
+
+    await bundle(sourceDirectories, distDirectory, declarations)
+    ```
+## Contributors
+
+Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for instructions on how to set up and work on this repository. Thanks
+for contributing!

package/deno/bundle.ts

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

package/dist/bridge.d.ts

@@ -0,0 +1,42 @@
+import { ExecaChildProcess } from 'execa';
+declare type LifecycleHook = () => void | Promise<void>;
+interface DenoOptions {
+    cacheDirectory?: string;
+    debug?: boolean;
+    onAfterDownload?: LifecycleHook;
+    onBeforeDownload?: LifecycleHook;
+    useGlobal?: boolean;
+    versionRange?: string;
+}
+interface ProcessRef {
+    ps?: ExecaChildProcess<string>;
+}
+interface RunOptions {
+    pipeOutput?: boolean;
+}
+declare class DenoBridge {
+    cacheDirectory: string;
+    currentDownload?: ReturnType<DenoBridge['downloadBinary']>;
+    debug: boolean;
+    onAfterDownload?: LifecycleHook;
+    onBeforeDownload?: LifecycleHook;
+    useGlobal: boolean;
+    versionRange: string;
+    constructor(options?: DenoOptions);
+    private downloadBinary;
+    static getBinaryVersion(binaryPath: string): Promise<string | undefined>;
+    private getCachedBinary;
+    private getGlobalBinary;
+    private getRemoteBinary;
+    private log;
+    private static runWithBinary;
+    private writeVersionFile;
+    getBinaryPath(): Promise<{
+        global: boolean;
+        path: string;
+    }>;
+    run(args: string[], { pipeOutput }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
+    runInBackground(args: string[], pipeOutput?: boolean, ref?: ProcessRef): Promise<void>;
+}
+export { DenoBridge };
+export type { LifecycleHook, ProcessRef };

package/dist/bridge.js

@@ -0,0 +1,136 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import process from 'process';
+import { execa } from 'execa';
+import semver from 'semver';
+import { download } from './downloader.js';
+import { getPathInHome } from './home_path.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;
+        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.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;
+    }
+    async downloadBinary() {
+        if (this.onBeforeDownload) {
+            this.onBeforeDownload();
+        }
+        await fs.mkdir(this.cacheDirectory, { recursive: true });
+        this.log(`Downloading Deno CLI to ${this.cacheDirectory}...`);
+        const binaryPath = await download(this.cacheDirectory, this.versionRange);
+        const downloadedVersion = await DenoBridge.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.
+        if (downloadedVersion === undefined) {
+            throw new Error('Could not read downloaded binary');
+        }
+        await this.writeVersionFile(downloadedVersion);
+        if (this.onAfterDownload) {
+            this.onAfterDownload();
+        }
+        return binaryPath;
+    }
+    static async getBinaryVersion(binaryPath) {
+        try {
+            const { stdout } = await execa(binaryPath, ['--version']);
+            const version = stdout.match(/^deno ([\d.]+)/);
+            if (!version) {
+                return;
+            }
+            return version[1];
+        }
+        catch {
+            // no-op
+        }
+    }
+    async getCachedBinary() {
+        const versionFilePath = path.join(this.cacheDirectory, DENO_VERSION_FILE);
+        let cachedVersion;
+        try {
+            cachedVersion = await fs.readFile(versionFilePath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        if (!semver.satisfies(cachedVersion, this.versionRange)) {
+            return;
+        }
+        const binaryName = `deno${getBinaryExtension()}`;
+        return path.join(this.cacheDirectory, binaryName);
+    }
+    async getGlobalBinary() {
+        if (!this.useGlobal) {
+            return;
+        }
+        const globalBinaryName = 'deno';
+        const globalVersion = await DenoBridge.getBinaryVersion(globalBinaryName);
+        if (globalVersion === undefined || !semver.satisfies(globalVersion, this.versionRange)) {
+            return;
+        }
+        return globalBinaryName;
+    }
+    getRemoteBinary() {
+        if (this.currentDownload === undefined) {
+            this.currentDownload = this.downloadBinary();
+        }
+        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);
+        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);
+        }
+        return runDeno;
+    }
+    async writeVersionFile(version) {
+        const versionFilePath = path.join(this.cacheDirectory, DENO_VERSION_FILE);
+        await fs.writeFile(versionFilePath, version);
+    }
+    async getBinaryPath() {
+        const globalPath = await this.getGlobalBinary();
+        if (globalPath !== undefined) {
+            this.log('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);
+            return { global: false, path: cachedPath };
+        }
+        const downloadedPath = await this.getRemoteBinary();
+        return { global: false, path: downloadedPath };
+    }
+    // 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);
+    }
+    // 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);
+        if (ref !== undefined) {
+            // eslint-disable-next-line no-param-reassign
+            ref.ps = ps;
+        }
+    }
+}
+export { DenoBridge };

package/dist/bundle.d.ts

@@ -0,0 +1,6 @@
+interface Bundle {
+    extension: string;
+    format: string;
+    hash: string;
+}
+export type { Bundle };

package/dist/bundle.js

@@ -0,0 +1 @@
+export {};

package/dist/bundle_error.d.ts

@@ -0,0 +1,16 @@
+interface BundleErrorOptions {
+    format: string;
+}
+declare const getCustomErrorInfo: (options: BundleErrorOptions) => {
+    location: {
+        format: string;
+        runtime: string;
+    };
+    type: string;
+};
+declare class BundleError extends Error {
+    customErrorInfo: ReturnType<typeof getCustomErrorInfo>;
+    constructor(originalError: Error, options: BundleErrorOptions);
+}
+declare const wrapBundleError: (input: unknown, options: BundleErrorOptions) => unknown;
+export { BundleError, wrapBundleError };

package/dist/bundle_error.js

@@ -0,0 +1,24 @@
+const getCustomErrorInfo = (options) => ({
+    location: {
+        format: options.format,
+        runtime: 'deno',
+    },
+    type: 'functionsBundling',
+});
+class BundleError extends Error {
+    constructor(originalError, options) {
+        super(originalError.message);
+        this.customErrorInfo = getCustomErrorInfo(options);
+        this.name = 'BundleError';
+        this.stack = originalError.stack;
+        // https://github.com/microsoft/TypeScript-wiki/blob/8a66ecaf77118de456f7cd9c56848a40fe29b9b4/Breaking-Changes.md#implicit-any-error-raised-for-un-annotated-callback-arguments-with-no-matching-overload-arguments
+        Object.setPrototypeOf(this, BundleError.prototype);
+    }
+}
+const wrapBundleError = (input, options) => {
+    if (input instanceof Error) {
+        return new BundleError(input, options);
+    }
+    return input;
+};
+export { BundleError, wrapBundleError };

package/dist/bundler.d.ts

@@ -0,0 +1,17 @@
+import { LifecycleHook } from './bridge.js';
+import type { Declaration } from './declaration.js';
+import { FeatureFlags } from './feature_flags.js';
+import { ImportMapFile } from './import_map.js';
+interface BundleOptions {
+    cacheDirectory?: string;
+    debug?: boolean;
+    distImportMapPath?: string;
+    featureFlags?: FeatureFlags;
+    importMaps?: ImportMapFile[];
+    onAfterDownload?: LifecycleHook;
+    onBeforeDownload?: LifecycleHook;
+}
+declare const bundle: (sourceDirectories: string[], distDirectory: string, declarations?: Declaration[], { cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, }?: BundleOptions) => Promise<{
+    functions: import("./edge_function.js").EdgeFunction[];
+}>;
+export { bundle };

package/dist/bundler.js

@@ -0,0 +1,81 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import commonPathPrefix from 'common-path-prefix';
+import { v4 as uuidv4 } from 'uuid';
+import { DenoBridge } from './bridge.js';
+import { getFlags } from './feature_flags.js';
+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 { writeManifest } from './manifest.js';
+const bundle = async (sourceDirectories, distDirectory, declarations = [], { cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, } = {}) => {
+    const featureFlags = getFlags(inputFeatureFlags);
+    const deno = new DenoBridge({
+        debug,
+        cacheDirectory,
+        onAfterDownload,
+        onBeforeDownload,
+    });
+    const basePath = getBasePath(sourceDirectories);
+    // 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.
+    const buildID = uuidv4();
+    // Creating an ImportMap instance with any import maps supplied by the user,
+    // if any.
+    const importMap = new ImportMap(importMaps);
+    const functions = await findFunctions(sourceDirectories);
+    const bundleOps = [
+        bundleJS({
+            buildID,
+            debug,
+            deno,
+            distDirectory,
+            functions,
+            importMap,
+        }),
+    ];
+    if (featureFlags.edge_functions_produce_eszip) {
+        bundleOps.push(bundleESZIP({
+            basePath,
+            buildID,
+            debug,
+            deno,
+            distDirectory,
+            functions,
+        }));
+    }
+    const bundles = await Promise.all(bundleOps);
+    // The final file name of the bundles contains a SHA256 hash of the contents,
+    // which we can only compute now that the files have been generated. So let's
+    // rename the bundles to their permanent names.
+    await createFinalBundles(bundles, distDirectory, buildID);
+    await writeManifest({
+        bundles,
+        declarations,
+        distDirectory,
+        functions,
+    });
+    if (distImportMapPath) {
+        await importMap.writeToFile(distImportMapPath);
+    }
+    return { functions };
+};
+const createFinalBundles = async (bundles, distDirectory, buildID) => {
+    const renamingOps = bundles.map(async ({ extension, hash }) => {
+        const tempBundlePath = join(distDirectory, `${buildID}${extension}`);
+        const finalBundlePath = join(distDirectory, `${hash}${extension}`);
+        await fs.rename(tempBundlePath, finalBundlePath);
+    });
+    await Promise.all(renamingOps);
+};
+const getBasePath = (sourceDirectories) => {
+    // `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) {
+        return sourceDirectories[0];
+    }
+    return commonPathPrefix(sourceDirectories);
+};
+export { bundle };

package/dist/declaration.d.ts

@@ -0,0 +1,10 @@
+interface DeclarationWithPath {
+    function: string;
+    path: string;
+}
+interface DeclarationWithPattern {
+    function: string;
+    pattern: string;
+}
+declare type Declaration = DeclarationWithPath | DeclarationWithPattern;
+export { Declaration, DeclarationWithPath, DeclarationWithPattern };

package/dist/declaration.js

@@ -0,0 +1 @@
+export {};

package/dist/downloader.d.ts

@@ -0,0 +1,2 @@
+declare const download: (targetDirectory: string, versionRange: string) => Promise<string>;
+export { download };

package/dist/downloader.js

@@ -0,0 +1,78 @@
+import fs from 'fs';
+import path from 'path';
+import fetch from 'node-fetch';
+import StreamZip from 'node-stream-zip';
+import semver from 'semver';
+import { getBinaryExtension, getPlatformTarget } from './platform.js';
+const download = async (targetDirectory, versionRange) => {
+    const zipPath = path.join(targetDirectory, 'deno-cli-latest.zip');
+    const data = await downloadVersion(versionRange);
+    const binaryName = `deno${getBinaryExtension()}`;
+    const binaryPath = path.join(targetDirectory, binaryName);
+    const file = fs.createWriteStream(zipPath);
+    await new Promise((resolve, reject) => {
+        data.pipe(file);
+        data.on('error', reject);
+        file.on('finish', resolve);
+    });
+    await extractBinaryFromZip(zipPath, binaryPath, binaryName);
+    try {
+        await fs.promises.unlink(zipPath);
+    }
+    catch {
+        // no-op
+    }
+    return binaryPath;
+};
+const downloadVersion = async (versionRange) => {
+    const version = await getLatestVersionForRange(versionRange);
+    const url = getReleaseURL(version);
+    const res = await fetch(url);
+    if (res.body === null) {
+        throw new Error('Could not download Deno');
+    }
+    return res.body;
+};
+const extractBinaryFromZip = async (zipPath, binaryPath, binaryName) => {
+    const { async: StreamZipAsync } = StreamZip;
+    const zip = new StreamZipAsync({ file: zipPath });
+    await zip.extract(binaryName, binaryPath);
+    await zip.close();
+    await fs.promises.chmod(binaryPath, '755');
+};
+const getLatestVersion = async () => {
+    try {
+        const response = await fetch('https://dl.deno.land/release-latest.txt');
+        const data = await response.text();
+        // We want to extract <VERSION> from the format `v<VERSION>`.
+        const version = data.match(/^v?(\d+\.\d+\.\d+)/);
+        if (version === null) {
+            return;
+        }
+        return version[1];
+    }
+    catch {
+        // This is a no-op. If we failed to retrieve the latest version, let's
+        // return `undefined` and let the code upstream handle it.
+    }
+};
+const getLatestVersionForRange = async (range) => {
+    var _a;
+    const minimumVersion = (_a = semver.minVersion(range)) === null || _a === void 0 ? void 0 : _a.version;
+    // 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.
+    if (minimumVersion === undefined) {
+        throw new Error('Incorrect version range specified by Edge Bundler');
+    }
+    const latestVersion = await getLatestVersion();
+    if (latestVersion === undefined || !semver.satisfies(latestVersion, range)) {
+        return minimumVersion;
+    }
+    return latestVersion;
+};
+const getReleaseURL = (version) => {
+    const target = getPlatformTarget();
+    return `https://dl.deno.land/release/v${version}/deno-${target}.zip`;
+};
+export { download };

package/dist/edge_function.d.ts

@@ -0,0 +1,4 @@
+export interface EdgeFunction {
+    name: string;
+    path: string;
+}

package/dist/edge_function.js

@@ -0,0 +1 @@
+export {};

package/dist/feature_flags.d.ts

@@ -0,0 +1,6 @@
+declare const defaultFlags: Record<string, boolean>;
+declare type FeatureFlag = keyof typeof defaultFlags;
+declare type FeatureFlags = Record<FeatureFlag, boolean>;
+declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => Record<FeatureFlag, string>;
+export { defaultFlags, getFlags };
+export type { FeatureFlag, FeatureFlags };

package/dist/feature_flags.js

@@ -0,0 +1,8 @@
+const defaultFlags = {
+    edge_functions_produce_eszip: false,
+};
+const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
+    ...result,
+    [key]: input[key] === undefined ? defaultValue : input[key],
+}), {});
+export { defaultFlags, getFlags };

package/dist/finder.d.ts

@@ -0,0 +1,3 @@
+import { EdgeFunction } from './edge_function.js';
+declare const findFunctions: (directories: string[]) => Promise<EdgeFunction[]>;
+export { findFunctions };

package/dist/finder.js

@@ -0,0 +1,55 @@
+import { promises as fs } from 'fs';
+import { basename, extname, join } from 'path';
+import { nonNullable } from './utils/non_nullable.js';
+const ALLOWED_EXTENSIONS = new Set(['.js', '.ts']);
+const findFunctionInDirectory = async (directory) => {
+    const name = basename(directory);
+    const candidatePaths = [`${name}.js`, `index.js`, `${name}.ts`, `index.ts`].map((filename) => join(directory, filename));
+    let functionPath;
+    for (const candidatePath of candidatePaths) {
+        try {
+            const stats = await fs.stat(candidatePath);
+            // eslint-disable-next-line max-depth
+            if (stats.isFile()) {
+                functionPath = candidatePath;
+                break;
+            }
+        }
+        catch {
+            // no-op
+        }
+    }
+    if (functionPath === undefined) {
+        return;
+    }
+    return {
+        name,
+        path: functionPath,
+    };
+};
+const findFunctionInPath = async (path) => {
+    const stats = await fs.stat(path);
+    if (stats.isDirectory()) {
+        return findFunctionInDirectory(path);
+    }
+    const extension = extname(path);
+    if (ALLOWED_EXTENSIONS.has(extension)) {
+        return { name: basename(path, extension), path };
+    }
+};
+const findFunctionsInDirectory = async (baseDirectory) => {
+    let items = [];
+    try {
+        items = await fs.readdir(baseDirectory);
+    }
+    catch {
+        // no-op
+    }
+    const functions = await Promise.all(items.map((item) => findFunctionInPath(join(baseDirectory, item))));
+    return functions.filter(nonNullable);
+};
+const findFunctions = async (directories) => {
+    const functions = await Promise.all(directories.map(findFunctionsInDirectory));
+    return functions.flat();
+};
+export { findFunctions };

package/dist/formats/eszip.d.ts

@@ -0,0 +1,13 @@
+import { DenoBridge } from '../bridge.js';
+import type { Bundle } from '../bundle.js';
+import { EdgeFunction } from '../edge_function.js';
+interface BundleESZIPOptions {
+    basePath: string;
+    buildID: string;
+    debug?: boolean;
+    deno: DenoBridge;
+    distDirectory: string;
+    functions: EdgeFunction[];
+}
+declare const bundle: (options: BundleESZIPOptions) => Promise<Bundle>;
+export { bundle };

package/dist/formats/eszip.js

@@ -0,0 +1,36 @@
+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 extension = '.eszip';
+    const destPath = join(distDirectory, `${buildID}${extension}`);
+    const bundler = getESZIPBundler();
+    const payload = {
+        basePath,
+        destPath,
+        functions,
+    };
+    const flags = ['--allow-all'];
+    if (!debug) {
+        flags.push('--quiet');
+    }
+    await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
+    const hash = await getFileHash(destPath);
+    return { extension, format: 'eszip2', hash };
+};
+const getESZIPBundler = () => {
+    const url = new URL(import.meta.url);
+    const pathname = fileURLToPath(url);
+    const bundlerPath = resolve(pathname, '../../../deno/bundle.ts');
+    return bundlerPath;
+};
+export { bundle };

package/dist/formats/javascript.d.ts

@@ -0,0 +1,25 @@
+import { DenoBridge } from '../bridge.js';
+import type { Bundle } from '../bundle.js';
+import { EdgeFunction } from '../edge_function.js';
+import { ImportMap } from '../import_map.js';
+import type { FormatFunction } from '../server/server.js';
+interface BundleJSOptions {
+    buildID: string;
+    debug?: boolean;
+    deno: DenoBridge;
+    distDirectory: string;
+    functions: EdgeFunction[];
+    importMap: ImportMap;
+}
+declare const bundle: (options: BundleJSOptions) => Promise<Bundle>;
+interface GenerateStage2Options {
+    distDirectory: string;
+    fileName: string;
+    formatExportTypeError?: FormatFunction;
+    formatImportError?: FormatFunction;
+    functions: EdgeFunction[];
+    type?: 'local' | 'production';
+}
+declare const generateStage2: ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, type, }: GenerateStage2Options) => Promise<string>;
+declare const getBootstrapURL: () => string;
+export { bundle, generateStage2, getBootstrapURL };

package/dist/formats/javascript.js

@@ -0,0 +1,83 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { env } from 'process';
+import { pathToFileURL } from 'url';
+import del from 'del';
+import { wrapBundleError } from '../bundle_error.js';
+import { getFileHash } from '../utils/sha256.js';
+const BOOTSTRAP_LATEST = 'https://625d32be1b90870009edfc99--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 bundleJS = async ({ buildID, debug, deno, distDirectory, functions, importMap, }) => {
+    const stage2Path = await generateStage2({ distDirectory, functions, fileName: `${buildID}-pre.js` });
+    const extension = '.js';
+    const jsBundlePath = join(distDirectory, `${buildID}${extension}`);
+    const flags = [`--import-map=${importMap.toDataURL()}`];
+    if (!debug) {
+        flags.push('--quiet');
+    }
+    await deno.run(['bundle', ...flags, stage2Path, jsBundlePath], { pipeOutput: true });
+    await fs.unlink(stage2Path);
+    const hash = await getFileHash(jsBundlePath);
+    return { extension, format: 'js', hash };
+};
+const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
+const defaultFormatImpoortError = (name) => `There was an error with Edge Function "${name}".`;
+const generateStage2 = async ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, type = 'production', }) => {
+    await del(distDirectory, { force: true });
+    await fs.mkdir(distDirectory, { recursive: true });
+    const entryPoint = type === 'local'
+        ? getLocalEntryPoint(functions, { formatExportTypeError, formatImportError })
+        : getProductionEntryPoint(functions);
+    const stage2Path = join(distDirectory, fileName);
+    await fs.writeFile(stage2Path, entryPoint);
+    return stage2Path;
+};
+const getBootstrapURL = () => { var _a; return (_a = env.NETLIFY_EDGE_BOOTSTRAP) !== null && _a !== void 0 ? _a : BOOTSTRAP_LATEST; };
+// For the local development environment, we import the user functions with
+// dynamic imports to gracefully handle the case where the file doesn't have
+// a valid default export.
+const getLocalEntryPoint = (functions, { formatExportTypeError = defaultFormatExportTypeError, formatImportError = defaultFormatImpoortError, }) => {
+    const bootImport = `import { boot } from "${getBootstrapURL()}";`;
+    const declaration = `const functions = {};`;
+    const imports = functions.map((func) => `
+  try {
+    const { default: func } = await import("${pathToFileURL(func.path)}");
+
+    if (typeof func === "function") {
+      functions["${func.name}"] = func;
+    } else {
+      console.log(${JSON.stringify(formatExportTypeError(func.name))});
+    }
+  } catch (error) {
+    console.log(${JSON.stringify(formatImportError(func.name))});
+    console.error(error);
+  }
+  `);
+    const bootCall = `boot(functions);`;
+    return [bootImport, declaration, ...imports, bootCall].join('\n\n');
+};
+const getProductionEntryPoint = (functions) => {
+    const bootImport = `import { boot } from "${getBootstrapURL()}";`;
+    const lines = functions.map((func, index) => {
+        const importName = `func${index}`;
+        const exportLine = `"${func.name}": ${importName}`;
+        const url = pathToFileURL(func.path);
+        return {
+            exportLine,
+            importLine: `import ${importName} from "${url}";`,
+        };
+    });
+    const importLines = lines.map(({ importLine }) => importLine).join('\n');
+    const exportLines = lines.map(({ exportLine }) => exportLine).join(', ');
+    const exportDeclaration = `const functions = {${exportLines}};`;
+    const defaultExport = 'boot(functions);';
+    return [bootImport, importLines, exportDeclaration, defaultExport].join('\n\n');
+};
+export { bundle, generateStage2, getBootstrapURL };

package/dist/home_path.d.ts

@@ -0,0 +1,2 @@
+declare const getPathInHome: (path: string) => string;
+export { getPathInHome };

package/dist/home_path.js

@@ -0,0 +1,5 @@
+import { join } from 'path';
+import envPaths from 'env-paths';
+const OSBasedPaths = envPaths('netlify', { suffix: '' });
+const getPathInHome = (path) => join(OSBasedPaths.config, path);
+export { getPathInHome };

package/dist/import_map.d.ts

@@ -0,0 +1,13 @@
+interface ImportMapFile {
+    imports: Record<string, string>;
+    scopes?: Record<string, string>;
+}
+declare class ImportMap {
+    imports: Record<string, string>;
+    constructor(input?: ImportMapFile[]);
+    getContents(): string;
+    toDataURL(): string;
+    writeToFile(path: string): Promise<void>;
+}
+export { ImportMap };
+export type { ImportMapFile };

package/dist/import_map.js

@@ -0,0 +1,30 @@
+import { Buffer } from 'buffer';
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+const DEFAULT_IMPORTS = {
+    'netlify:edge': 'https://edge-bootstrap.netlify.app/v1/index.ts',
+};
+class ImportMap {
+    constructor(input = []) {
+        const inputImports = input.reduce((acc, { imports }) => ({ ...acc, ...imports }), {});
+        // `DEFAULT_IMPORTS` must come last because we want our internal imports to
+        // take precedence.
+        this.imports = { ...inputImports, ...DEFAULT_IMPORTS };
+    }
+    getContents() {
+        const contents = {
+            imports: this.imports,
+        };
+        return JSON.stringify(contents);
+    }
+    toDataURL() {
+        const encodedImportMap = Buffer.from(this.getContents()).toString('base64');
+        return `data:application/json;base64,${encodedImportMap}`;
+    }
+    async writeToFile(path) {
+        await fs.mkdir(dirname(path), { recursive: true });
+        const contents = this.getContents();
+        await fs.writeFile(path, contents);
+    }
+}
+export { ImportMap };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { bundle } from './bundler.js';
+export { DenoBridge } from './bridge.js';
+export { findFunctions as find } from './finder.js';
+export { generateManifest } from './manifest.js';
+export { serve } from './server/server.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { bundle } from './bundler.js';
+export { DenoBridge } from './bridge.js';
+export { findFunctions as find } from './finder.js';
+export { generateManifest } from './manifest.js';
+export { serve } from './server/server.js';

package/dist/manifest.d.ts

@@ -0,0 +1,28 @@
+import type { Bundle } from './bundle.js';
+import type { Declaration } from './declaration.js';
+import { EdgeFunction } from './edge_function.js';
+interface GenerateManifestOptions {
+    bundles?: Bundle[];
+    functions: EdgeFunction[];
+    declarations?: Declaration[];
+}
+interface Manifest {
+    bundler_version: string;
+    bundles: {
+        asset: string;
+        format: string;
+    }[];
+    routes: {
+        function: string;
+        pattern: string;
+    }[];
+}
+declare const generateManifest: ({ bundles, declarations, functions }: GenerateManifestOptions) => Manifest;
+interface WriteManifestOptions {
+    bundles: Bundle[];
+    declarations: Declaration[];
+    distDirectory: string;
+    functions: EdgeFunction[];
+}
+declare const writeManifest: ({ bundles, declarations, distDirectory, functions }: WriteManifestOptions) => Promise<void>;
+export { generateManifest, Manifest, writeManifest };

package/dist/manifest.js

@@ -0,0 +1,35 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import globToRegExp from 'glob-to-regexp';
+import { getPackageVersion } from './package_json.js';
+import { nonNullable } from './utils/non_nullable.js';
+const generateManifest = ({ bundles = [], declarations = [], functions }) => {
+    const routes = declarations.map((declaration) => {
+        const func = functions.find(({ name }) => declaration.function === name);
+        if (func === undefined) {
+            return;
+        }
+        const pattern = 'pattern' in declaration ? new RegExp(declaration.pattern) : globToRegExp(declaration.path);
+        const serializablePattern = pattern.source.replace(/\\\//g, '/');
+        return {
+            function: func.name,
+            pattern: serializablePattern,
+        };
+    });
+    const manifestBundles = bundles.map(({ extension, format, hash }) => ({
+        asset: hash + extension,
+        format,
+    }));
+    const manifest = {
+        bundles: manifestBundles,
+        routes: routes.filter(nonNullable),
+        bundler_version: getPackageVersion(),
+    };
+    return manifest;
+};
+const writeManifest = ({ bundles, declarations = [], distDirectory, functions }) => {
+    const manifest = generateManifest({ bundles, declarations, functions });
+    const manifestPath = join(distDirectory, 'manifest.json');
+    return fs.writeFile(manifestPath, JSON.stringify(manifest));
+};
+export { generateManifest, writeManifest };

package/dist/package_json.d.ts

@@ -0,0 +1,2 @@
+declare const getPackageVersion: () => string;
+export { getPackageVersion };

package/dist/package_json.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkgJson = require('../package.json');
+const getPackageVersion = () => pkgJson.version;
+export { getPackageVersion };

package/dist/platform.d.ts

@@ -0,0 +1,3 @@
+declare const getBinaryExtension: () => ".exe" | "";
+declare const getPlatformTarget: () => "x86_64-pc-windows-msvc" | "aarch64-apple-darwin" | "x86_64-apple-darwin" | "x86_64-unknown-linux-gnu";
+export { getBinaryExtension, getPlatformTarget };

package/dist/platform.js

@@ -0,0 +1,13 @@
+import { arch, platform } from 'process';
+const getBinaryExtension = () => (platform === 'win32' ? '.exe' : '');
+const getPlatformTarget = () => {
+    if (platform === 'win32') {
+        return 'x86_64-pc-windows-msvc';
+    }
+    const isArm64 = arch === 'arm64';
+    if (platform === 'darwin') {
+        return isArm64 ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+    }
+    return 'x86_64-unknown-linux-gnu';
+};
+export { getBinaryExtension, getPlatformTarget };

package/dist/server/server.d.ts

@@ -0,0 +1,20 @@
+import { LifecycleHook } from '../bridge.js';
+import type { EdgeFunction } from '../edge_function.js';
+import { ImportMapFile } from '../import_map.js';
+declare type FormatFunction = (name: string) => string;
+interface ServeOptions {
+    debug?: boolean;
+    distImportMapPath?: string;
+    importMaps?: ImportMapFile[];
+    onAfterDownload?: LifecycleHook;
+    onBeforeDownload?: LifecycleHook;
+    formatExportTypeError?: FormatFunction;
+    formatImportError?: FormatFunction;
+    port: number;
+}
+declare const serve: ({ debug, distImportMapPath, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, }: ServeOptions) => Promise<(newFunctions: EdgeFunction[]) => Promise<{
+    graph: any;
+    success: boolean;
+}>>;
+export { serve };
+export type { FormatFunction };

package/dist/server/server.js

@@ -0,0 +1,68 @@
+import { tmpName } from 'tmp-promise';
+import { DenoBridge } from '../bridge.js';
+import { generateStage2 } from '../formats/javascript.js';
+import { ImportMap } from '../import_map.js';
+import { killProcess, waitForServer } from './util.js';
+const prepareServer = ({ deno, distDirectory, flags, formatExportTypeError, formatImportError, port, }) => {
+    const processRef = {};
+    const startIsolate = async (newFunctions) => {
+        if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
+            await killProcess(processRef.ps);
+        }
+        let graph;
+        const stage2Path = await generateStage2({
+            distDirectory,
+            fileName: 'dev.js',
+            functions: newFunctions,
+            formatExportTypeError,
+            formatImportError,
+            type: 'local',
+        });
+        try {
+            // This command will print a JSON object with all the modules found in
+            // the `stage2Path` file as well as all of their dependencies.
+            // Consumers such as the CLI can use this information to watch all the
+            // relevant files and issue an isolate restart when one of them changes.
+            const { stdout } = await deno.run(['info', '--json', stage2Path]);
+            graph = JSON.parse(stdout);
+        }
+        catch {
+            // no-op
+        }
+        await deno.runInBackground(['run', ...flags, stage2Path, port.toString()], true, processRef);
+        const success = await waitForServer(port, processRef.ps);
+        return {
+            graph,
+            success,
+        };
+    };
+    return startIsolate;
+};
+const serve = async ({ debug, distImportMapPath, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, }) => {
+    const deno = new DenoBridge({
+        debug,
+        onAfterDownload,
+        onBeforeDownload,
+    });
+    // We need to generate a stage 2 file and write it somewhere. We use a
+    // temporary directory for that.
+    const distDirectory = await tmpName();
+    // Wait for the binary to be downloaded if needed.
+    await deno.getBinaryPath();
+    // Creating an ImportMap instance with any import maps supplied by the user,
+    // if any.
+    const importMap = new ImportMap(importMaps);
+    const flags = ['--allow-all', '--unstable', `--import-map=${importMap.toDataURL()}`];
+    if (debug) {
+        flags.push('--log-level=debug');
+    }
+    else {
+        flags.push('--quiet');
+    }
+    const server = await prepareServer({ deno, distDirectory, flags, formatExportTypeError, formatImportError, port });
+    if (distImportMapPath) {
+        await importMap.writeToFile(distImportMapPath);
+    }
+    return server;
+};
+export { serve };

package/dist/server/util.d.ts

@@ -0,0 +1,4 @@
+import { ExecaChildProcess } from 'execa';
+declare const killProcess: (ps: ExecaChildProcess<string>) => Promise<unknown> | undefined;
+declare const waitForServer: (port: number, ps?: ExecaChildProcess<string> | undefined) => Promise<boolean>;
+export { killProcess, waitForServer };

package/dist/server/util.js

@@ -0,0 +1,48 @@
+import fetch from 'node-fetch';
+import waitFor from 'p-wait-for';
+// 1 second
+const SERVER_KILL_TIMEOUT = 1e3;
+// 1 second
+const SERVER_POLL_INTERNAL = 1e3;
+// 10 seconds
+const SERVER_POLL_TIMEOUT = 1e4;
+const isServerReady = async (port, successRef, ps) => {
+    // If the process has been killed or if it exited with an error, we return
+    // early with `success: false`.
+    if ((ps === null || ps === void 0 ? void 0 : ps.killed) || ((ps === null || ps === void 0 ? void 0 : ps.exitCode) && ps.exitCode > 0)) {
+        return true;
+    }
+    try {
+        await fetch(`http://127.0.0.1:${port}`);
+        // eslint-disable-next-line no-param-reassign
+        successRef.success = true;
+    }
+    catch {
+        return false;
+    }
+    return true;
+};
+const killProcess = (ps) => {
+    // If the process is no longer running, there's nothing left to do.
+    if ((ps === null || ps === void 0 ? void 0 : ps.exitCode) !== null) {
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        ps.on('close', resolve);
+        ps.on('error', reject);
+        ps.kill('SIGTERM', {
+            forceKillAfterTimeout: SERVER_KILL_TIMEOUT,
+        });
+    });
+};
+const waitForServer = async (port, ps) => {
+    const successRef = {
+        success: false,
+    };
+    await waitFor(() => isServerReady(port, successRef, ps), {
+        interval: SERVER_POLL_INTERNAL,
+        timeout: SERVER_POLL_TIMEOUT,
+    });
+    return successRef.success;
+};
+export { killProcess, waitForServer };

package/dist/utils/non_nullable.d.ts

@@ -0,0 +1,2 @@
+declare const nonNullable: <T>(value: T) => value is NonNullable<T>;
+export { nonNullable };

package/dist/utils/non_nullable.js

@@ -0,0 +1,2 @@
+const nonNullable = (value) => value !== null && value !== undefined;
+export { nonNullable };

package/dist/utils/sha256.d.ts

@@ -0,0 +1,2 @@
+declare const getFileHash: (path: string) => Promise<string>;
+export { getFileHash };

package/dist/utils/sha256.js

@@ -0,0 +1,16 @@
+import crypto from 'crypto';
+import fs from 'fs';
+const getFileHash = (path) => {
+    const hash = crypto.createHash('sha256');
+    hash.setEncoding('hex');
+    return new Promise((resolve, reject) => {
+        const file = fs.createReadStream(path);
+        file.on('end', () => {
+            hash.end();
+            resolve(hash.read());
+        });
+        file.on('error', reject);
+        file.pipe(hash);
+    });
+};
+export { getFileHash };

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@netlify/edge-bundler",
+  "version": "0.11.0",
+  "description": "Intelligently prepare Netlify Edge Functions for deployment",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "files": [
+    "deno/**",
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "husky install node_modules/@netlify/eslint-config-node/.husky/",
+    "prepublishOnly": "npm ci && npm test",
+    "prepack": "npm run build",
+    "test": "run-s build format test:dev",
+    "format": "run-s build format:check-fix:*",
+    "format:ci": "run-s build format:check:*",
+    "format:check-fix:lint": "run-e format:check:lint format:fix:lint",
+    "format:check:lint": "cross-env-shell eslint $npm_package_config_eslint",
+    "format:fix:lint": "cross-env-shell eslint --fix $npm_package_config_eslint",
+    "format:check-fix:prettier": "run-e format:check:prettier format:fix:prettier",
+    "format:check:prettier": "cross-env-shell prettier --check $npm_package_config_prettier",
+    "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
+    "test:dev": "run-s build test:dev:*",
+    "test:ci": "run-s build test:ci:*",
+    "test:dev:ava": "ava",
+    "test:ci:ava": "nyc -r lcovonly -r text -r json ava"
+  },
+  "config": {
+    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,scripts,.github}/**/*.{js,ts,md,html}\" \"*.{js,ts,md,html}\"",
+    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,scripts,.github}/**/*.{js,ts,md,yml,json,html}\" \"*.{js,ts,yml,json,html}\" \".*.{js,ts,yml,json,html}\" \"!**/package-lock.json\" \"!package-lock.json\""
+  },
+  "ava": {
+    "files": [
+      "test/**/*.ts",
+      "!test/fixtures/**"
+    ],
+    "extensions": {
+      "ts": "module"
+    },
+    "nodeArguments": [
+      "--loader=ts-node/esm",
+      "--no-warnings"
+    ]
+  },
+  "keywords": [],
+  "license": "MIT",
+  "repository": "netlify-labs/edge-bundler",
+  "bugs": {
+    "url": "https://github.com/netlify-labs/edge-bundler/issues"
+  },
+  "author": "Netlify Inc.",
+  "directories": {
+    "test": "test"
+  },
+  "devDependencies": {
+    "@ava/typescript": "^3.0.1",
+    "@commitlint/cli": "^16.0.0",
+    "@commitlint/config-conventional": "^16.0.0",
+    "@netlify/eslint-config-node": "^4.1.7",
+    "@types/glob-to-regexp": "^0.4.1",
+    "@types/node": "^17.0.21",
+    "@types/semver": "^7.3.9",
+    "@types/sinon": "^10.0.8",
+    "@types/uuid": "^8.3.4",
+    "ava": "^4.0.1",
+    "husky": "^7.0.4",
+    "nyc": "^15.0.0",
+    "sinon": "^12.0.1",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.4"
+  },
+  "engines": {
+    "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
+  },
+  "dependencies": {
+    "common-path-prefix": "^3.0.0",
+    "del": "^6.0.0",
+    "env-paths": "^3.0.0",
+    "execa": "^6.0.0",
+    "glob-to-regexp": "^0.4.1",
+    "node-fetch": "^3.1.1",
+    "node-stream-zip": "^1.15.0",
+    "p-wait-for": "^4.1.0",
+    "semver": "^7.3.5",
+    "tmp-promise": "^3.0.3",
+    "uuid": "^8.3.2"
+  }
+}