@netlify/edge-bundler 4.1.0 → 4.3.0

package/deno/config.ts

@@ -11,6 +11,10 @@ try {
   Deno.exit(exitCodes.ImportError)
 }
 
+if (typeof func.default !== 'function') {
+  Deno.exit(exitCodes.InvalidDefaultExport)
+}
+
 if (func.config === undefined) {
   Deno.exit(exitCodes.NoConfig)
 }

package/deno/lib/consts.ts

@@ -1,4 +1,5 @@
-export const PUBLIC_SPECIFIER = "netlify:edge";
-export const STAGE1_SPECIFIER = "netlify:bootstrap-stage1";
-export const STAGE2_SPECIFIER = "netlify:bootstrap-stage2";
-export const virtualRoot = "file:///root/";
+export const CUSTOM_LAYER_PREFIX = 'layer:'
+export const PUBLIC_SPECIFIER = 'netlify:edge'
+export const STAGE1_SPECIFIER = 'netlify:bootstrap-stage1'
+export const STAGE2_SPECIFIER = 'netlify:bootstrap-stage2'
+export const virtualRoot = 'file:///root/'

package/deno/lib/stage2.ts

@@ -3,7 +3,7 @@ import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.28.0/mod.ts'
 import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
-import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
+import { CUSTOM_LAYER_PREFIX, PUBLIC_SPECIFIER, STAGE2_SPECIFIER, virtualRoot } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
 interface FunctionReference {
@@ -70,7 +70,7 @@ const stage2Loader = (basePath: string, functions: InputFunction[]) => {
       return inlineModule(specifier, stage2Entry)
     }
 
-    if (specifier === PUBLIC_SPECIFIER) {
+    if (specifier === PUBLIC_SPECIFIER || specifier.startsWith(CUSTOM_LAYER_PREFIX)) {
       return {
         kind: 'external',
         specifier,
@@ -88,6 +88,9 @@ const stage2Loader = (basePath: string, functions: InputFunction[]) => {
 const writeStage2 = async ({ basePath, destPath, functions, importMapURL }: WriteStage2Options) => {
   const loader = stage2Loader(basePath, functions)
   const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
+  const directory = path.dirname(destPath)
+
+  await Deno.mkdir(directory, { recursive: true })
 
   return await Deno.writeFile(destPath, bytes)
 }

package/dist/node/bundle_error.d.ts

@@ -12,5 +12,8 @@ declare class BundleError extends Error {
     customErrorInfo: ReturnType<typeof getCustomErrorInfo>;
     constructor(originalError: Error, options: BundleErrorOptions);
 }
+/**
+ * BundleErrors are treated as user-error, so Netlify Team is not alerted about them.
+ */
 declare const wrapBundleError: (input: unknown, options: BundleErrorOptions) => unknown;
 export { BundleError, wrapBundleError };

package/dist/node/bundle_error.js

@@ -15,6 +15,9 @@ class BundleError extends Error {
         Object.setPrototypeOf(this, BundleError.prototype);
     }
 }
+/**
+ * BundleErrors are treated as user-error, so Netlify Team is not alerted about them.
+ */
 const wrapBundleError = (input, options) => {
     if (input instanceof Error) {
         return new BundleError(input, options);

package/dist/node/bundler.d.ts

@@ -17,7 +17,7 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
+declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, layers, onAfterDownload, onBeforeDownload, systemLogger, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -35,7 +35,7 @@ const createBundle = ({ basePath, buildID, debug, deno, distDirectory, functions
         importMap,
     });
 };
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMaps, layers, onAfterDownload, onBeforeDownload, systemLogger, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -90,6 +90,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         declarations,
         distDirectory,
         functions,
+        layers,
     });
     if (distImportMapPath) {
         await importMap.writeToFile(distImportMapPath);

package/dist/node/bundler.test.js

@@ -132,6 +132,28 @@ test('Adds a custom error property to user errors during bundling', async () =>
         });
     }
 });
+test('Prints a nice error message when user tries importing NPM module', async () => {
+    expect.assertions(2);
+    const sourceDirectory = resolve(fixturesDir, 'imports_npm_module', 'functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    try {
+        await bundle([sourceDirectory], tmpDir.path, declarations, {
+            featureFlags: {
+                edge_functions_produce_eszip: true,
+            },
+        });
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(BundleError);
+        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported in Deno via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
+    }
+});
 test('Does not add a custom error property to system errors during bundling', async () => {
     expect.assertions(1);
     try {
@@ -278,3 +300,32 @@ test('Ignores any user-defined `deno.json` files', async () => {
     })).not.toThrow();
     await deleteAsync([tmpDir.path, denoConfigPath, importMapFile.path], { force: true });
 });
+test('Processes a function that imports a custom layer', async () => {
+    const sourceDirectory = resolve(fixturesDir, 'with_layers', 'functions');
+    const tmpDir = await tmp.dir();
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const layer = { name: 'test', flag: 'edge-functions-layer-test' };
+    const result = await bundle([sourceDirectory], tmpDir.path, declarations, {
+        basePath: fixturesDir,
+        featureFlags: {
+            edge_functions_produce_eszip: true,
+        },
+        layers: [layer],
+    });
+    const generatedFiles = await fs.readdir(tmpDir.path);
+    expect(result.functions.length).toBe(1);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const { bundles, layers } = manifest;
+    expect(bundles.length).toBe(1);
+    expect(bundles[0].format).toBe('eszip2');
+    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    expect(layers).toEqual([layer]);
+    await fs.rmdir(tmpDir.path, { recursive: true });
+});

package/dist/node/config.js

@@ -12,6 +12,7 @@ var ConfigExitCode;
     ConfigExitCode[ConfigExitCode["InvalidExport"] = 4] = "InvalidExport";
     ConfigExitCode[ConfigExitCode["RuntimeError"] = 5] = "RuntimeError";
     ConfigExitCode[ConfigExitCode["SerializationError"] = 6] = "SerializationError";
+    ConfigExitCode[ConfigExitCode["InvalidDefaultExport"] = 7] = "InvalidDefaultExport";
 })(ConfigExitCode || (ConfigExitCode = {}));
 const getConfigExtractor = () => {
     const packagePath = getPackagePath();
@@ -82,6 +83,8 @@ const logConfigError = (func, exitCode, stderr, log) => {
         case ConfigExitCode.SerializationError:
             log.user(`'config' function in edge function at '${func.path}' must return an object with primitive values only`);
             break;
+        case ConfigExitCode.InvalidDefaultExport:
+            throw new Error(`Default export in '${func.path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`);
         default:
             log.user(`Could not load configuration for edge function at '${func.path}'`);
             log.user(stderr);

package/dist/node/config.test.js

@@ -15,6 +15,7 @@ const importMapFile = {
         'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
     },
 };
+const invalidDefaultExportErr = (path) => `Default export in '${path}' must be a function. More on the Edge Functions API at https://ntl.fyi/edge-api.`;
 test('`getFunctionConfig` extracts configuration properties from function file', async () => {
     const { path: tmpDir } = await tmp.dir();
     const deno = new DenoBridge({
@@ -184,3 +185,78 @@ test('Loads function paths from the in-source `config` function', async () => {
     expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
     await fs.rmdir(tmpDir.path, { recursive: true });
 });
+test('Passes validation if default export exists and is a function', async () => {
+    const { path: tmpDir } = await tmp.dir();
+    const deno = new DenoBridge({
+        cacheDirectory: tmpDir,
+    });
+    const func = {
+        name: 'func1',
+        source: `
+        const func = () => new Response("Hello world!")
+        export default func
+      `,
+    };
+    const logger = {
+        user: vi.fn().mockResolvedValue(null),
+        system: vi.fn().mockResolvedValue(null),
+    };
+    const path = join(tmpDir, `${func.name}.ts`);
+    await fs.writeFile(path, func.source);
+    expect(async () => {
+        await getFunctionConfig({
+            name: func.name,
+            path,
+        }, new ImportMap([importMapFile]), deno, logger);
+    }).not.toThrow();
+    await deleteAsync(tmpDir, { force: true });
+});
+test('Fails validation if default export is not function', async () => {
+    const { path: tmpDir } = await tmp.dir();
+    const deno = new DenoBridge({
+        cacheDirectory: tmpDir,
+    });
+    const func = {
+        name: 'func2',
+        source: `
+        const func = new Response("Hello world!")
+        export default func
+      `,
+    };
+    const logger = {
+        user: vi.fn().mockResolvedValue(null),
+        system: vi.fn().mockResolvedValue(null),
+    };
+    const path = join(tmpDir, `${func.name}.ts`);
+    await fs.writeFile(path, func.source);
+    const config = getFunctionConfig({
+        name: func.name,
+        path,
+    }, new ImportMap([importMapFile]), deno, logger);
+    await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
+    await deleteAsync(tmpDir, { force: true });
+});
+test('Fails validation if default export is not present', async () => {
+    const { path: tmpDir } = await tmp.dir();
+    const deno = new DenoBridge({
+        cacheDirectory: tmpDir,
+    });
+    const func = {
+        name: 'func3',
+        source: `
+        export const func = () => new Response("Hello world!")
+      `,
+    };
+    const logger = {
+        user: vi.fn().mockResolvedValue(null),
+        system: vi.fn().mockResolvedValue(null),
+    };
+    const path = join(tmpDir, `${func.name}.ts`);
+    await fs.writeFile(path, func.source);
+    const config = getFunctionConfig({
+        name: func.name,
+        path,
+    }, new ImportMap([importMapFile]), deno, logger);
+    await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
+    await deleteAsync(tmpDir, { force: true });
+});

package/dist/node/formats/eszip.js

@@ -1,5 +1,6 @@
 import { join } from 'path';
 import { wrapBundleError } from '../bundle_error.js';
+import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
 const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, functions, importMap, }) => {
@@ -23,7 +24,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, func
         await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
     }
     catch (error) {
-        throw wrapBundleError(error, { format: 'eszip' });
+        throw wrapBundleError(wrapNpmImportError(error), { format: 'eszip' });
     }
     const hash = await getFileHash(destPath);
     return { extension, format: 'eszip2', hash };

package/dist/node/formats/javascript.js

@@ -4,8 +4,9 @@ import { env } from 'process';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 import { wrapBundleError } from '../bundle_error.js';
+import { wrapNpmImportError } from '../npm_import_error.js';
 import { getFileHash } from '../utils/sha256.js';
-const BOOTSTRAP_LATEST = 'https://63735623f23a7a000841dfb9--edge.netlify.com/bootstrap/index-combined.ts';
+const BOOTSTRAP_LATEST = 'https://63760359c1267a000900d7fb--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';
@@ -18,7 +19,7 @@ const bundleJS = async ({ buildID, debug, deno, distDirectory, functions, import
         await deno.run(['bundle', ...flags, stage2Path, jsBundlePath], { pipeOutput: true });
     }
     catch (error) {
-        throw wrapBundleError(error, { format: 'javascript' });
+        throw wrapBundleError(wrapNpmImportError(error), { format: 'javascript' });
     }
     await fs.unlink(stage2Path);
     const hash = await getFileHash(jsBundlePath);

package/dist/node/npm_import_error.d.ts

@@ -0,0 +1,5 @@
+declare class NPMImportError extends Error {
+    constructor(originalError: Error, moduleName: string);
+}
+declare const wrapNpmImportError: (input: unknown) => unknown;
+export { NPMImportError, wrapNpmImportError };

package/dist/node/npm_import_error.js

@@ -0,0 +1,20 @@
+class NPMImportError extends Error {
+    constructor(originalError, moduleName) {
+        super(`It seems like you're trying to import an npm module. This is only supported in Deno via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/${moduleName}"'?`);
+        this.name = 'NPMImportError';
+        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, NPMImportError.prototype);
+    }
+}
+const wrapNpmImportError = (input) => {
+    if (input instanceof Error) {
+        const match = input.message.match(/Relative import path "(.*)" not prefixed with/);
+        if (match !== null) {
+            const [, moduleName] = match;
+            return new NPMImportError(input, moduleName);
+        }
+    }
+    return input;
+};
+export { NPMImportError, wrapNpmImportError };

package/package.json

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