@netlify/edge-bundler 2.8.0 → 2.9.0

package/dist/node/bundler.js

@@ -78,7 +78,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         if (!featureFlags.edge_functions_config_export) {
             return {};
         }
-        return getFunctionConfig(func, deno, logger);
+        return getFunctionConfig(func, importMap, deno, logger);
     }));
     // Creating a hash of function names to configuration objects.
     const functionsWithConfig = functions.reduce((acc, func, index) => ({ ...acc, [func.name]: functionsConfig[index] }), {});

package/dist/node/config.d.ts

@@ -1,7 +1,13 @@
 import { DenoBridge } from './bridge.js';
 import { EdgeFunction } from './edge_function.js';
+import { ImportMap } from './import_map.js';
 import { Logger } from './logger.js';
+export declare const enum Mode {
+    BeforeCache = "before-cache",
+    AfterCache = "after-cache"
+}
 export interface FunctionConfig {
+    mode?: Mode;
     path?: string;
 }
-export declare const getFunctionConfig: (func: EdgeFunction, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;
+export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger) => Promise<FunctionConfig>;

package/dist/node/config.js

@@ -19,7 +19,7 @@ const getConfigExtractor = () => {
     const configExtractorPath = join(packagePath, 'deno', 'config.ts');
     return configExtractorPath;
 };
-export const getFunctionConfig = async (func, deno, 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();
@@ -38,6 +38,7 @@ export const getFunctionConfig = async (func, deno, log) => {
         '--allow-read',
         `--allow-write=${collector.path}`,
         '--quiet',
+        `--import-map=${importMap.toDataURL()}`,
         extractorPath,
         pathToFileURL(func.path).href,
         pathToFileURL(collector.path).href,

package/dist/node/config.test.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
 import del from 'del';
 import { stub } from 'sinon';
 import tmp from 'tmp-promise';
@@ -8,6 +9,13 @@ import { fixturesDir } from '../test/util.js';
 import { DenoBridge } from './bridge.js';
 import { bundle } from './bundler.js';
 import { getFunctionConfig } from './config.js';
+import { ImportMap } from './import_map.js';
+const importMapFile = {
+    baseURL: new URL('file:///some/path/import-map.json'),
+    imports: {
+        'alias:helper': pathToFileURL(join(fixturesDir, 'helper.ts')).toString(),
+    },
+};
 test('`getFunctionConfig` extracts configuration properties from function file', async () => {
     const { path: tmpDir } = await tmp.dir();
     const deno = new DenoBridge({
@@ -101,7 +109,7 @@ test('`getFunctionConfig` extracts configuration properties from function file',
         const config = await getFunctionConfig({
             name: func.name,
             path,
-        }, deno, logger);
+        }, new ImportMap([importMapFile]), deno, logger);
         expect(config).toEqual(func.expectedConfig);
         if (func.userLog) {
             expect(logger.user.firstCall.firstArg).toMatch(func.userLog);
@@ -122,9 +130,10 @@ test('Ignores function paths from the in-source `config` function if the feature
         featureFlags: {
             edge_functions_produce_eszip: true,
         },
+        importMaps: [importMapFile],
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
-    expect(result.functions.length).toBe(4);
+    expect(result.functions.length).toBe(6);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
@@ -155,20 +164,24 @@ test('Loads function paths from the in-source `config` function', async () => {
             edge_functions_config_export: true,
             edge_functions_produce_eszip: true,
         },
+        importMaps: [importMapFile],
     });
     const generatedFiles = await fs.readdir(tmpDir.path);
-    expect(result.functions.length).toBe(4);
+    expect(result.functions.length).toBe(6);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(tmpDir.path, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles, routes } = manifest;
+    const { bundles, routes, post_cache_routes: postCacheRoutes } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(routes.length).toBe(4);
+    expect(routes.length).toBe(5);
     expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$' });
     expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$' });
     expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$' });
     expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$' });
+    expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$' });
+    expect(postCacheRoutes.length).toBe(1);
+    expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
     await fs.rmdir(tmpDir.path, { recursive: true });
 });

package/dist/node/declaration.d.ts

@@ -1,6 +1,7 @@
 import { FunctionConfig } from './config.js';
 interface BaseDeclaration {
     function: string;
+    mode?: string;
     name?: string;
 }
 declare type DeclarationWithPath = BaseDeclaration & {

package/dist/node/declaration.js

@@ -9,7 +9,7 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig) =>
         const { path } = (_a = functionsConfig[declaration.function]) !== null && _a !== void 0 ? _a : {};
         if (path) {
             functionsVisited.add(declaration.function);
-            declarations.push({ function: declaration.function, path });
+            declarations.push({ ...declaration, path });
         }
         else {
             declarations.push(declaration);
@@ -18,9 +18,9 @@ export const getDeclarationsFromConfig = (tomlDeclarations, functionsConfig) =>
     // Finally, we must create declarations for functions that are not declared
     // in the TOML at all.
     for (const name in functionsConfig) {
-        const { path } = functionsConfig[name];
+        const { path, ...config } = functionsConfig[name];
         if (!functionsVisited.has(name) && path) {
-            declarations.push({ function: name, path });
+            declarations.push({ ...config, function: name, path });
         }
     }
     return declarations;

package/dist/node/manifest.d.ts

@@ -17,6 +17,11 @@ interface Manifest {
         name?: string;
         pattern: string;
     }[];
+    post_cache_routes: {
+        function: string;
+        name?: string;
+        pattern: string;
+    }[];
 }
 declare const generateManifest: ({ bundles, declarations, functions }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions {

package/dist/node/manifest.js

@@ -4,18 +4,26 @@ 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 preCacheRoutes = [];
+    const postCacheRoutes = [];
+    declarations.forEach((declaration) => {
         const func = functions.find(({ name }) => declaration.function === name);
         if (func === undefined) {
             return;
         }
         const pattern = getRegularExpression(declaration);
         const serializablePattern = pattern.source.replace(/\\\//g, '/');
-        return {
+        const route = {
             function: func.name,
             name: declaration.name,
             pattern: serializablePattern,
         };
+        if (declaration.mode === "after-cache" /* Mode.AfterCache */) {
+            postCacheRoutes.push(route);
+        }
+        else {
+            preCacheRoutes.push(route);
+        }
     });
     const manifestBundles = bundles.map(({ extension, format, hash }) => ({
         asset: hash + extension,
@@ -23,7 +31,8 @@ const generateManifest = ({ bundles = [], declarations = [], functions }) => {
     }));
     const manifest = {
         bundles: manifestBundles,
-        routes: routes.filter(nonNullable),
+        routes: preCacheRoutes.filter(nonNullable),
+        post_cache_routes: postCacheRoutes.filter(nonNullable),
         bundler_version: getPackageVersion(),
     };
     return manifest;

package/dist/node/manifest.test.js

@@ -80,3 +80,39 @@ test('Generates a manifest without bundles', () => {
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
 });
+test('Generates a manifest with pre and post-cache routes', () => {
+    const bundle1 = {
+        extension: '.ext1',
+        format: 'format1',
+        hash: '123456',
+    };
+    const bundle2 = {
+        extension: '.ext2',
+        format: 'format2',
+        hash: '654321',
+    };
+    const functions = [
+        { name: 'func-1', path: '/path/to/func-1.ts' },
+        { name: 'func-2', path: '/path/to/func-2.ts' },
+        { name: 'func-3', path: '/path/to/func-3.ts' },
+    ];
+    const declarations = [
+        { function: 'func-1', path: '/f1' },
+        { function: 'func-2', mode: 'not_a_supported_mode', path: '/f2' },
+        { function: 'func-3', mode: 'after-cache', path: '/f3' },
+    ];
+    const manifest = generateManifest({ bundles: [bundle1, bundle2], declarations, functions });
+    const expectedBundles = [
+        { asset: bundle1.hash + bundle1.extension, format: bundle1.format },
+        { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
+    ];
+    const expectedPreCacheRoutes = [
+        { function: 'func-1', name: undefined, pattern: '^/f1/?$' },
+        { function: 'func-2', name: undefined, pattern: '^/f2/?$' },
+    ];
+    const expectedPostCacheRoutes = [{ function: 'func-3', name: undefined, pattern: '^/f3/?$' }];
+    expect(manifest.bundles).toEqual(expectedBundles);
+    expect(manifest.routes).toEqual(expectedPreCacheRoutes);
+    expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
+    expect(manifest.bundler_version).toBe(env.npm_package_version);
+});

package/package.json

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