@netlify/edge-bundler 4.0.2 → 4.2.0

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

@@ -3,6 +3,7 @@ import { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { ImportMapFile } from './import_map.js';
+import { Layer } from './layer.js';
 import { LogFunction } from './logger.js';
 interface BundleOptions {
     basePath?: string;
@@ -11,11 +12,12 @@ interface BundleOptions {
     distImportMapPath?: string;
     featureFlags?: FeatureFlags;
     importMaps?: ImportMapFile[];
+    layers?: Layer[];
     onAfterDownload?: OnAfterDownloadHook;
     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/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/layer.d.ts

@@ -0,0 +1,4 @@
+export interface Layer {
+    flag: string;
+    name: string;
+}

package/dist/node/layer.js

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

package/dist/node/manifest.d.ts

@@ -1,10 +1,12 @@
 import type { Bundle } from './bundle.js';
 import type { Declaration } from './declaration.js';
 import { EdgeFunction } from './edge_function.js';
+import { Layer } from './layer.js';
 interface GenerateManifestOptions {
     bundles?: Bundle[];
-    functions: EdgeFunction[];
     declarations?: Declaration[];
+    functions: EdgeFunction[];
+    layers?: Layer[];
 }
 interface Manifest {
     bundler_version: string;
@@ -22,13 +24,18 @@ interface Manifest {
         name?: string;
         pattern: string;
     }[];
+    layers: {
+        name: string;
+        flag: string;
+    }[];
 }
-declare const generateManifest: ({ bundles, declarations, functions }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, functions, layers }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions {
     bundles: Bundle[];
     declarations: Declaration[];
     distDirectory: string;
     functions: EdgeFunction[];
+    layers?: Layer[];
 }
-declare const writeManifest: ({ bundles, declarations, distDirectory, functions }: WriteManifestOptions) => Promise<Manifest>;
+declare const writeManifest: ({ bundles, declarations, distDirectory, functions, layers, }: WriteManifestOptions) => Promise<Manifest>;
 export { generateManifest, Manifest, writeManifest };

package/dist/node/manifest.js

@@ -3,7 +3,7 @@ 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 generateManifest = ({ bundles = [], declarations = [], functions, layers = [] }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     declarations.forEach((declaration) => {
@@ -34,6 +34,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions }) => {
         routes: preCacheRoutes.filter(nonNullable),
         post_cache_routes: postCacheRoutes.filter(nonNullable),
         bundler_version: getPackageVersion(),
+        layers,
     };
     return manifest;
 };
@@ -50,8 +51,8 @@ const getRegularExpression = (declaration) => {
     const normalizedSource = `^${regularExpression.source}\\/?$`;
     return new RegExp(normalizedSource);
 };
-const writeManifest = async ({ bundles, declarations = [], distDirectory, functions }) => {
-    const manifest = generateManifest({ bundles, declarations, functions });
+const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, layers, }) => {
+    const manifest = generateManifest({ bundles, declarations, functions, layers });
     const manifestPath = join(distDirectory, 'manifest.json');
     await fs.writeFile(manifestPath, JSON.stringify(manifest));
     return manifest;

package/dist/node/manifest.test.js

@@ -116,3 +116,29 @@ test('Generates a manifest with pre and post-cache routes', () => {
     expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
+test('Generates a manifest with layers', () => {
+    const functions = [
+        { name: 'func-1', path: '/path/to/func-1.ts' },
+        { name: 'func-2', path: '/path/to/func-2.ts' },
+    ];
+    const declarations = [
+        { function: 'func-1', path: '/f1/*' },
+        { function: 'func-2', path: '/f2/*' },
+    ];
+    const expectedRoutes = [
+        { function: 'func-1', pattern: '^/f1/.*/?$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$' },
+    ];
+    const layers = [
+        {
+            name: 'onion',
+            flag: 'edge_functions_onion_layer',
+        },
+    ];
+    const manifest1 = generateManifest({ bundles: [], declarations, functions });
+    const manifest2 = generateManifest({ bundles: [], declarations, functions, layers });
+    expect(manifest1.routes).toEqual(expectedRoutes);
+    expect(manifest1.layers).toEqual([]);
+    expect(manifest2.routes).toEqual(expectedRoutes);
+    expect(manifest2.layers).toEqual(layers);
+});

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