@netlify/edge-bundler 8.17.0 → 8.17.1

package/deno/config.ts

@@ -1,6 +1,9 @@
-const [functionURL, collectorURL, rawExitCodes] = Deno.args
+const [functionURL, collectorURL, bootstrapURL, rawExitCodes] = Deno.args
 const exitCodes = JSON.parse(rawExitCodes)
 
+const { Netlify } = await import(bootstrapURL)
+globalThis.Netlify = Netlify
+
 let func
 
 try {

package/dist/node/bundler.d.ts

@@ -14,8 +14,9 @@ interface BundleOptions {
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
     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, }?: BundleOptions) => Promise<{
+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<{
     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, } = {}) => {
+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 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, logger)]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig(func, importMap, deno, logger)]);
+    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 })]);
     // 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/config.d.ts

@@ -17,4 +17,10 @@ export interface FunctionConfig {
     name?: string;
     generator?: string;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: ({ func, importMap, deno, bootstrapURL, 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, log) => {
+export const getFunctionConfig = async ({ func, importMap, deno, bootstrapURL, log, }) => {
     // The extractor is a Deno script that will import the function and run its
     // `config` export, if one exists.
     const extractorPath = getConfigExtractor();
@@ -50,6 +50,7 @@ export const getFunctionConfig = async (func, importMap, deno, log) => {
         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,6 +9,7 @@ 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: {
@@ -114,9 +115,15 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
         const path = join(tmpDir, `${func.name}.js`);
         await fs.writeFile(path, func.source);
         const funcCall = () => getFunctionConfig({
-            name: func.name,
-            path,
-        }, new ImportMap([importMapFile]), deno, logger);
+            func: {
+                name: func.name,
+                path,
+            },
+            importMap: new ImportMap([importMapFile]),
+            deno,
+            log: logger,
+            bootstrapURL,
+        });
         if (func.error) {
             await expect(funcCall()).rejects.toThrowError(func.error);
         }
@@ -194,9 +201,15 @@ test('Passes validation if default export exists and is a function', async () =>
     const path = join(tmpDir, `${func.name}.ts`);
     await fs.writeFile(path, func.source);
     await expect(getFunctionConfig({
-        name: func.name,
-        path,
-    }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    })).resolves.not.toThrow();
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not function', async () => {
@@ -218,9 +231,15 @@ test('Fails validation if default export is not function', async () => {
     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);
+        func: {
+            name: func.name,
+            path,
+        },
+        importMap: new ImportMap([importMapFile]),
+        deno,
+        log: logger,
+        bootstrapURL,
+    });
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
     await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
@@ -242,9 +261,15 @@ test('Fails validation if default export is not present', async () => {
     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);
+        func: {
+            name: func.name,
+            path,
+        },
+        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/declaration.js

@@ -66,7 +66,12 @@ const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited
 // Validates and normalizes a pattern so that it's a valid regular expression
 // in Go, which is the engine used by our edge nodes.
 export const parsePattern = (pattern) => {
-    const regexp = new RegExp(pattern);
+    let enclosedPattern = pattern;
+    if (!pattern.startsWith('^'))
+        enclosedPattern = `^${enclosedPattern}`;
+    if (!pattern.endsWith('$'))
+        enclosedPattern = `${enclosedPattern}$`;
+    const regexp = new RegExp(enclosedPattern);
     const newRegexp = regexpAST.transform(regexp, {
         Assertion(path) {
             // Lookaheads are not supported. If we find one, throw an error.

package/dist/node/declaration.test.js

@@ -126,3 +126,9 @@ test('Escapes front slashes in a regex pattern', () => {
     const actual = parsePattern(regexPattern);
     expect(actual).toEqual(expected);
 });
+test('Ensures pattern match on the whole path', () => {
+    const regexPattern = '/foo/.*/bar';
+    const expected = '^\\/foo\\/.*\\/bar$';
+    const actual = parsePattern(regexPattern);
+    expect(actual).toEqual(expected);
+});

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, logger)));
+            functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, bootstrapURL, log: logger })));
         }
         const success = await waitForServer(port, processRef.ps);
         return {

package/dist/node/server/server.test.js

@@ -27,6 +27,10 @@ test('Starts a server and serves requests for edge functions', async () => {
             name: 'greet',
             path: join(paths.internal, 'greet.ts'),
         },
+        {
+            name: 'global_netlify',
+            path: join(paths.user, 'global_netlify.ts'),
+        },
     ];
     const options = {
         getFunctionsConfig: true,
@@ -35,7 +39,7 @@ test('Starts a server and serves requests for edge functions', async () => {
         very_secret_secret: 'i love netlify',
     }, options);
     expect(success).toBe(true);
-    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}]);
+    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
     for (const key in functions) {
         const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
         // @ts-expect-error TODO: Module graph is currently not typed
@@ -60,4 +64,15 @@ test('Starts a server and serves requests for edge functions', async () => {
     });
     expect(response2.status).toBe(200);
     expect(await response2.text()).toBe('HELLO!');
+    const response3 = await fetch(`http://0.0.0.0:${port}/global-netlify`, {
+        headers: {
+            'x-nf-edge-functions': 'global_netlify',
+            'x-ef-passthrough': 'passthrough',
+            'X-NF-Request-ID': uuidv4(),
+        },
+    });
+    expect(await response3.json()).toEqual({
+        global: 'i love netlify',
+        local: 'i love netlify',
+    });
 });

package/package.json

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