@netlify/edge-bundler 8.19.0 → 8.19.1

package/deno/bundle.ts

@@ -3,4 +3,12 @@ import { writeStage2 } from './lib/stage2.ts'
 const [payload] = Deno.args
 const { basePath, destPath, externals, functions, importMapData } = JSON.parse(payload)
 
-await writeStage2({ basePath, destPath, externals, functions, importMapData })
+try {
+  await writeStage2({ basePath, destPath, externals, functions, importMapData })
+} catch (error) {
+  if (error instanceof Error && error.message.includes("The module's source code could not be parsed")) {
+    delete error.stack
+  }
+
+  throw error
+}

package/deno/config.ts

@@ -1,7 +1,9 @@
-const [functionURL, collectorURL, bootstrapURL, rawExitCodes] = Deno.args
+// this needs to be updated whenever there's a change to globalThis.Netlify in bootstrap
+import { Netlify } from "https://64e8753eae24930008fac6d9--edge.netlify.app/bootstrap/index-combined.ts"
+
+const [functionURL, collectorURL, rawExitCodes] = Deno.args
 const exitCodes = JSON.parse(rawExitCodes)
 
-const { Netlify } = await import(bootstrapURL)
 globalThis.Netlify = Netlify
 
 let func

package/dist/node/bundle_error.js

@@ -20,6 +20,10 @@ class BundleError extends Error {
  */
 const wrapBundleError = (input, options) => {
     if (input instanceof Error) {
+        if (input.message.includes("The module's source code could not be parsed")) {
+            // eslint-disable-next-line no-param-reassign
+            input.message = input.stderr;
+        }
         return new BundleError(input, options);
     }
     return input;

package/dist/node/bundler.d.ts

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

package/dist/node/bundler.js

@@ -14,7 +14,7 @@ import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts', } = {}) => {
+const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -63,8 +63,8 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     await createFinalBundles([functionBundle], distDirectory, buildID);
     // Retrieving a configuration object for each function.
     // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
-    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger, bootstrapURL })]);
+    const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
+    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
     // Creating a hash of function names to configuration objects.
     const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
     const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));

package/dist/node/bundler.test.js

@@ -68,7 +68,8 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
     await cleanup();
 });
 test('Adds a custom error property to user errors during bundling', async () => {
-    expect.assertions(2);
+    process.env.NO_COLOR = 'true';
+    expect.assertions(3);
     const { basePath, cleanup, distPath } = await useFixture('invalid_functions');
     const sourceDirectory = join(basePath, 'functions');
     const declarations = [
@@ -82,6 +83,16 @@ test('Adds a custom error property to user errors during bundling', async () =>
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
+        const [messageBeforeStack] = error.message.split('at <anonymous> (file://');
+        expect(messageBeforeStack).toMatchInlineSnapshot(`
+      "error: Uncaught (in promise) Error: The module's source code could not be parsed: Unexpected eof at file:///root/functions/func1.ts:1:27
+
+        export default async () => 
+                                  ~
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+                        ^
+          "
+    `);
         expect(error.customErrorInfo).toEqual({
             location: {
                 format: 'eszip',

package/dist/node/config.d.ts

@@ -19,10 +19,9 @@ export interface FunctionConfig {
     generator?: string;
     method?: HTTPMethod | HTTPMethod[];
 }
-export declare const getFunctionConfig: ({ func, importMap, deno, bootstrapURL, log, }: {
+export declare const getFunctionConfig: ({ func, importMap, deno, log, }: {
     func: EdgeFunction;
     importMap: ImportMap;
     deno: DenoBridge;
-    bootstrapURL: string;
     log: Logger;
 }) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -26,7 +26,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async ({ func, importMap, deno, bootstrapURL, log, }) => {
+export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -50,7 +50,6 @@ export const getFunctionConfig = async ({ func, importMap, deno, bootstrapURL, l
         extractorPath,
         pathToFileURL(func.path).href,
         pathToFileURL(collector.path).href,
-        bootstrapURL,
         JSON.stringify(ConfigExitCode),
     ], { rejectOnExitCode: false });
     if (exitCode !== ConfigExitCode.Success) {

package/dist/node/config.test.js

@@ -9,7 +9,6 @@ import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
 import { ImportMap } from './import_map.js';
-const bootstrapURL = 'https://edge.netlify.com/bootstrap/index-combined.ts';
 const importMapFile = {
     baseURL: new URL('file:///some/path/import-map.json'),
     imports: {
@@ -122,7 +121,6 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
             importMap: new ImportMap([importMapFile]),
             deno,
             log: logger,
-            bootstrapURL,
         });
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
@@ -246,7 +244,6 @@ test('Passes validation if default export exists and is a function', async () =>
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
-        bootstrapURL,
     })).resolves.not.toThrow();
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
@@ -276,7 +273,6 @@ test('Fails validation if default export is not function', async () => {
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
-        bootstrapURL,
     });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
@@ -306,7 +302,6 @@ test('Fails validation if default export is not present', async () => {
         importMap: new ImportMap([importMapFile]),
         deno,
         log: logger,
-        bootstrapURL,
     });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });

package/dist/node/import_map.js

@@ -6,7 +6,7 @@ import { parse } from '@import-maps/resolve';
 import { isFileNotFoundError } from './utils/error.js';
 const INTERNAL_IMPORTS = {
     '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-    'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+    'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
 };
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.

package/dist/node/import_map.test.js

@@ -21,7 +21,8 @@ test('Handles import maps with full URLs without specifying a base URL', () => {
     };
     const map = new ImportMap([inputFile1, inputFile2]);
     const { imports } = map.getContents();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
     expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
 });
@@ -36,7 +37,8 @@ test('Resolves relative paths to absolute paths if a base path is not provided',
     const map = new ImportMap([inputFile1]);
     const { imports } = map.getContents();
     const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets');
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
 });
 describe('Returns the fully resolved import map', () => {
@@ -70,7 +72,7 @@ describe('Returns the fully resolved import map', () => {
             specifier2: 'file:///some/full/path/file2.js',
             specifier1: 'file:///some/full/path/file.js',
             '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
         });
         expect(scopes).toStrictEqual({
             'file:///some/cool/path/with/scopes/': {
@@ -92,7 +94,7 @@ describe('Returns the fully resolved import map', () => {
             specifier2: 'file:///root/full/path/file2.js',
             specifier1: 'file:///root/full/path/file.js',
             '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
-            'netlify:edge': 'https://edge.netlify.com/v1/index.ts',
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
         });
         expect(scopes).toStrictEqual({
             'file:///root/cool/path/with/scopes/': {
@@ -128,6 +130,7 @@ test('Writes import map file to disk', async () => {
     const { imports } = JSON.parse(createdFile);
     const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets', 'file.ts');
     await file.cleanup();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(pathToFileURL(expectedPath).toString());
 });

package/dist/node/server/server.js

@@ -43,7 +43,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         });
         let functionsConfig = [];
         if (options.getFunctionsConfig) {
-            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, bootstrapURL, log: logger })));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, log: logger })));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/package.json

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