@netlify/edge-bundler 5.5.0 → 6.1.0

package/dist/node/bundler.js

@@ -6,11 +6,12 @@ import { importMapSpecifier } from '../shared/consts.js';
 import { DenoBridge } from './bridge.js';
 import { getFunctionConfig } from './config.js';
 import { getDeclarationsFromConfig } from './declaration.js';
+import { getConfig as getDenoConfig } from './deno_config.js';
 import { load as loadDeployConfig } from './deploy_config.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
 import { bundle as bundleESZIP } from './formats/eszip.js';
-import { ImportMap } from './import_map.js';
+import { ImportMap, readFile as readImportMapFile } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { ensureLatestTypes } from './types.js';
@@ -44,6 +45,16 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     if (deployConfig.importMap) {
         importMap.add(deployConfig.importMap);
     }
+    if (featureFlags.edge_functions_read_deno_config) {
+        // Look for a Deno config file and read it if one exists.
+        const denoConfig = await getDenoConfig(logger, basePath);
+        // If the Deno config file defines an import map, read the file and add the
+        // imports to the global import map.
+        if (denoConfig === null || denoConfig === void 0 ? void 0 : denoConfig.importMap) {
+            const importMapFile = await readImportMapFile(denoConfig.importMap);
+            importMap.add(importMapFile);
+        }
+    }
     const functions = await findFunctions(sourceDirectories);
     const functionBundle = await bundleESZIP({
         basePath,

package/dist/node/bundler.test.js

@@ -18,13 +18,17 @@ test('Produces an ESZIP bundle', async () => {
             path: '/func1',
         },
     ];
-    const sourceDirectory = join(basePath, 'functions');
-    const result = await bundle([sourceDirectory], distPath, declarations, {
+    const userDirectory = join(basePath, 'user-functions');
+    const internalDirectory = join(basePath, 'functions');
+    const result = await bundle([userDirectory, internalDirectory], distPath, declarations, {
         basePath,
-        configPath: join(sourceDirectory, 'config.json'),
+        configPath: join(internalDirectory, 'config.json'),
+        featureFlags: {
+            edge_functions_read_deno_config: true,
+        },
     });
     const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(1);
+    expect(result.functions.length).toBe(2);
     expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);

package/dist/node/deno_config.d.ts

@@ -0,0 +1,6 @@
+import { Logger } from './logger.js';
+interface DenoConfigFile {
+    importMap?: string;
+}
+export declare const getConfig: (logger: Logger, basePath?: string) => Promise<DenoConfigFile | undefined>;
+export {};

package/dist/node/deno_config.js

@@ -0,0 +1,43 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import { parse as parseJSONC } from 'jsonc-parser';
+import { isNodeError } from './utils/error.js';
+const filenames = ['deno.json', 'deno.jsonc'];
+export const getConfig = async (logger, basePath) => {
+    if (basePath === undefined) {
+        logger.system('No base path specified, will not attempt to read Deno config');
+        return;
+    }
+    for (const filename of filenames) {
+        const candidatePath = join(basePath, filename);
+        const config = await getConfigFromFile(candidatePath);
+        if (config !== undefined) {
+            logger.system('Loaded Deno config file from path', candidatePath);
+            return normalizeConfig(config, basePath);
+        }
+    }
+    logger.system('No Deno config file found at base path', basePath);
+};
+const getConfigFromFile = async (filePath) => {
+    try {
+        const data = await fs.readFile(filePath, 'utf8');
+        const config = parseJSONC(data);
+        return config;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return;
+        }
+        return {};
+    }
+};
+const normalizeConfig = (rawConfig, basePath) => {
+    const config = {};
+    if (rawConfig.importMap) {
+        if (typeof rawConfig.importMap !== 'string') {
+            throw new TypeError(`'importMap' property in Deno config must be a string`);
+        }
+        config.importMap = resolve(basePath, rawConfig.importMap);
+    }
+    return config;
+};

package/dist/node/deno_config.test.d.ts

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

package/dist/node/deno_config.test.js

@@ -0,0 +1,92 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import tmp from 'tmp-promise';
+import { expect, test } from 'vitest';
+import { testLogger } from '../test/util.js';
+import { getConfig } from './deno_config.js';
+test('Returns `undefined` if no config file is found', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const config = await getConfig(testLogger, path);
+    expect(config).toBeUndefined();
+    await cleanup();
+});
+test('Returns an empty object if the config file cannot be parsed', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    await fs.writeFile(configPath, '{');
+    const config = await getConfig(testLogger, path);
+    expect(config).toEqual({});
+    await cleanup();
+});
+test('Throws a type error if the `importMap` contains anything other than a string', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    const data = JSON.stringify({ importMap: { imports: { foo: './bar/' } } });
+    await fs.writeFile(configPath, data);
+    await expect(getConfig(testLogger, path)).rejects.toThrowError(TypeError);
+    await cleanup();
+});
+test('Excludes unsupported properties', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    const data = JSON.stringify({
+        compilerOptions: {
+            allowJs: true,
+            lib: ['deno.window'],
+            strict: true,
+        },
+        importMap: 'import_map.json',
+        lint: {
+            files: {
+                include: ['src/'],
+                exclude: ['src/testdata/'],
+            },
+            rules: {
+                tags: ['recommended'],
+                include: ['ban-untagged-todo'],
+                exclude: ['no-unused-vars'],
+            },
+        },
+        fmt: {
+            files: {
+                include: ['src/'],
+                exclude: ['src/testdata/'],
+            },
+            options: {
+                useTabs: true,
+                lineWidth: 80,
+                indentWidth: 4,
+                singleQuote: true,
+                proseWrap: 'preserve',
+            },
+        },
+        test: {
+            files: {
+                include: ['src/'],
+                exclude: ['src/testdata/'],
+            },
+        },
+    });
+    await fs.writeFile(configPath, data);
+    const config = await getConfig(testLogger, path);
+    expect(Object.keys(config !== null && config !== void 0 ? config : {})).toEqual(['importMap']);
+    await cleanup();
+});
+test('Resolves `importMap` into an absolute path', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    const data = JSON.stringify({ importMap: 'import_map.json' });
+    await fs.writeFile(configPath, data);
+    const config = await getConfig(testLogger, path);
+    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
+    await cleanup();
+});
+test('Supports JSONC', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.jsonc');
+    const data = JSON.stringify({ importMap: 'import_map.json' });
+    await fs.writeFile(configPath, `// This is a comment\n${data}`);
+    const config = await getConfig(testLogger, path);
+    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
+    await cleanup();
+});

package/dist/node/feature_flags.js

@@ -1,6 +1,7 @@
 const defaultFlags = {
     edge_functions_cache_deno_dir: false,
     edge_functions_config_export: false,
+    edge_functions_read_deno_config: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/server/server.d.ts

@@ -18,6 +18,7 @@ interface InspectSettings {
     address?: string;
 }
 interface ServeOptions {
+    basePath: string;
     certificatePath?: string;
     debug?: boolean;
     distImportMapPath?: string;
@@ -30,7 +31,7 @@ interface ServeOptions {
     port: number;
     systemLogger?: LogFunction;
 }
-declare const serve: ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+declare const serve: ({ basePath, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
     functionsConfig: FunctionConfig[];
     graph: any;
     success: boolean;

package/dist/node/server/server.js

@@ -1,8 +1,9 @@
 import { tmpName } from 'tmp-promise';
 import { DenoBridge } from '../bridge.js';
 import { getFunctionConfig } from '../config.js';
+import { getConfig as getDenoConfig } from '../deno_config.js';
 import { generateStage2 } from '../formats/javascript.js';
-import { ImportMap } from '../import_map.js';
+import { ImportMap, readFile as readImportMapFile } from '../import_map.js';
 import { getLogger } from '../logger.js';
 import { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
@@ -53,7 +54,7 @@ const prepareServer = ({ deno, distDirectory, flags: denoFlags, formatExportType
     };
     return startServer;
 };
-const serve = async ({ certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
+const serve = async ({ basePath, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMaps, onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
     const logger = getLogger(systemLogger, debug);
     const deno = new DenoBridge({
         debug,
@@ -71,6 +72,14 @@ const serve = async ({ certificatePath, debug, distImportMapPath, inspectSetting
     // Creating an ImportMap instance with any import maps supplied by the user,
     // if any.
     const importMap = new ImportMap(importMaps);
+    // Look for a Deno config file and read it if one exists.
+    const denoConfig = await getDenoConfig(logger, basePath);
+    // If the Deno config file defines an import map, read the file and add the
+    // imports to the global import map.
+    if (denoConfig === null || denoConfig === void 0 ? void 0 : denoConfig.importMap) {
+        const importMapFile = await readImportMapFile(denoConfig.importMap);
+        importMap.add(importMapFile);
+    }
     const flags = ['--allow-all', '--unstable', `--import-map=${importMap.toDataURL()}`, '--no-config'];
     if (certificatePath) {
         flags.push(`--cert=${certificatePath}`);

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

@@ -1,19 +1,37 @@
 import { join } from 'path';
+import { pathToFileURL } from 'url';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
+import { v4 as uuidv4 } from 'uuid';
 import { test, expect } from 'vitest';
 import { fixturesDir } from '../../test/util.js';
 import { serve } from '../index.js';
 test('Starts a server and serves requests for edge functions', async () => {
+    const basePath = join(fixturesDir, 'serve_test');
+    const functionPaths = {
+        internal: join(basePath, '.netlify', 'edge-functions', 'greet.ts'),
+        user: join(basePath, 'netlify', 'edge-functions', 'echo_env.ts'),
+    };
     const port = await getPort();
+    const internalImportMap = {
+        baseURL: pathToFileURL(functionPaths.internal),
+        imports: {
+            'internal-helper': '../../helper.ts',
+        },
+    };
     const server = await serve({
+        basePath,
+        importMaps: [internalImportMap],
         port,
     });
-    const functionPath = join(fixturesDir, 'serve_test', 'echo_env.ts');
     const functions = [
         {
             name: 'echo_env',
-            path: functionPath,
+            path: functionPaths.user,
+        },
+        {
+            name: 'greet',
+            path: functionPaths.internal,
         },
     ];
     const options = {
@@ -23,19 +41,29 @@ 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' }]);
-    const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
-    // @ts-expect-error TODO: Module graph is currently not typed
-    ({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functionPath);
-    expect(graphEntry).toBe(true);
-    const response = await fetch(`http://0.0.0.0:${port}/foo`, {
+    expect(functionsConfig).toEqual([{ path: '/my-function' }, {}]);
+    for (const key in functionPaths) {
+        const graphEntry = graph === null || graph === void 0 ? void 0 : graph.modules.some(
+        // @ts-expect-error TODO: Module graph is currently not typed
+        ({ kind, mediaType, local }) => kind === 'esm' && mediaType === 'TypeScript' && local === functionPaths[key]);
+        expect(graphEntry).toBe(true);
+    }
+    const response1 = await fetch(`http://0.0.0.0:${port}/foo`, {
         headers: {
             'x-deno-functions': 'echo_env',
             'x-deno-pass': 'passthrough',
-            'X-NF-Request-ID': 'foo',
+            'X-NF-Request-ID': uuidv4(),
+        },
+    });
+    expect(response1.status).toBe(200);
+    expect(await response1.text()).toBe('I LOVE NETLIFY');
+    const response2 = await fetch(`http://0.0.0.0:${port}/greet`, {
+        headers: {
+            'x-deno-functions': 'greet',
+            'x-deno-pass': 'passthrough',
+            'X-NF-Request-ID': uuidv4(),
         },
     });
-    expect(response.status).toBe(200);
-    const body = (await response.json());
-    expect(body.very_secret_secret).toBe('i love netlify');
+    expect(response2.status).toBe(200);
+    expect(await response2.text()).toBe('HELLO!');
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "5.5.0",
+  "version": "6.1.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -84,6 +84,7 @@
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",
     "glob-to-regexp": "^0.4.1",
+    "jsonc-parser": "^3.2.0",
     "node-fetch": "^3.1.1",
     "node-stream-zip": "^1.15.0",
     "p-retry": "^5.1.1",