@netlify/edge-bundler 9.3.0 → 9.4.1

package/dist/node/bundler.js

@@ -158,6 +158,7 @@ const safelyVendorNPMSpecifiers = async ({ basePath, featureFlags, functions, im
             functions: functions.map(({ path }) => path),
             importMap,
             logger,
+            referenceTypes: false,
         });
     }
     catch (error) {

package/dist/node/npm_dependencies.d.ts

@@ -7,8 +7,9 @@ interface VendorNPMSpecifiersOptions {
     functions: string[];
     importMap: ImportMap;
     logger: Logger;
+    referenceTypes: boolean;
 }
-export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, }: VendorNPMSpecifiersOptions) => Promise<{
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, referenceTypes, }: VendorNPMSpecifiersOptions) => Promise<{
     cleanup: () => Promise<void>;
     directory: string;
     importMap: {

package/dist/node/npm_dependencies.js

@@ -5,9 +5,63 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { resolve } from '@import-maps/resolve';
 import { nodeFileTrace, resolve as nftResolve } from '@vercel/nft';
 import { build } from 'esbuild';
+import { findUp } from 'find-up';
 import getPackageName from 'get-package-name';
 import tmp from 'tmp-promise';
 const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.cts', '.mts']);
+const slugifyPackageName = (specifier) => {
+    if (!specifier.startsWith('@'))
+        return specifier;
+    const [scope, pkg] = specifier.split('/');
+    return `${scope.replace('@', '')}__${pkg}`;
+};
+/**
+ * Returns the name of the `@types/` package used by a given specifier. Most of
+ * the times this is just the specifier itself, but scoped packages suffer a
+ * transformation (e.g. `@netlify/functions` -> `@types/netlify__functions`).
+ * https://github.com/DefinitelyTyped/DefinitelyTyped#what-about-scoped-packages
+ */
+const getTypesPackageName = (specifier) => path.join('@types', slugifyPackageName(specifier));
+/**
+ * Finds corresponding DefinitelyTyped packages (`@types/...`) and returns path to declaration file.
+ */
+const getTypePathFromTypesPackage = async (packageName, packageJsonPath) => {
+    const typesPackagePath = await findUp(`node_modules/${getTypesPackageName(packageName)}/package.json`, {
+        cwd: packageJsonPath,
+    });
+    if (!typesPackagePath) {
+        return undefined;
+    }
+    const { types, typings } = JSON.parse(await fs.readFile(typesPackagePath, 'utf8'));
+    const declarationPath = types !== null && types !== void 0 ? types : typings;
+    if (typeof declarationPath === 'string') {
+        return path.join(typesPackagePath, '..', declarationPath);
+    }
+    return undefined;
+};
+/**
+ * Starting from a `package.json` file, this tries detecting a TypeScript declaration file.
+ * It first looks at the `types` and `typings` fields in `package.json`.
+ * If it doesn't find them, it falls back to DefinitelyTyped packages (`@types/...`).
+ */
+const getTypesPath = async (packageJsonPath) => {
+    const { name, types, typings } = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    // this only looks at `.types` and `.typings` fields. there might also be data in `exports -> . -> types -> import/default`.
+    // we're ignoring that for now.
+    const declarationPath = types !== null && types !== void 0 ? types : typings;
+    if (typeof declarationPath === 'string') {
+        return path.join(packageJsonPath, '..', declarationPath);
+    }
+    return await getTypePathFromTypesPackage(name, packageJsonPath);
+};
+const safelyDetectTypes = async (packageJsonPath) => {
+    try {
+        return await getTypesPath(packageJsonPath);
+    }
+    catch {
+        return undefined;
+    }
+};
 // Workaround for https://github.com/evanw/esbuild/issues/1921.
 const banner = {
     js: `
@@ -26,8 +80,9 @@ const banner = {
  * @param basePath Root of the project
  * @param functions Functions to parse
  * @param importMap Import map to apply when resolving imports
+ * @param referenceTypes Whether to detect typescript declarations and reference them in the output
  */
-const getNPMSpecifiers = async (basePath, functions, importMap) => {
+const getNPMSpecifiers = async (basePath, functions, importMap, referenceTypes) => {
     const baseURL = pathToFileURL(basePath);
     const { reasons } = await nodeFileTrace(functions, {
         base: basePath,
@@ -60,22 +115,10 @@ const getNPMSpecifiers = async (basePath, functions, importMap) => {
             return nftResolve(specifier, ...args);
         },
     });
-    const npmSpecifiers = new Set();
+    const npmSpecifiers = [];
     const npmSpecifiersWithExtraneousFiles = new Set();
-    reasons.forEach((reason, filePath) => {
-        const packageName = getPackageName(filePath);
-        if (packageName === undefined) {
-            return;
-        }
+    for (const [filePath, reason] of reasons.entries()) {
         const parents = [...reason.parents];
-        const isDirectDependency = parents.some((parentPath) => !parentPath.startsWith(`node_modules${path.sep}`));
-        // We're only interested in capturing the specifiers that are first-level
-        // dependencies. Because we'll bundle all modules in a subsequent step,
-        // any transitive dependencies will be handled then.
-        if (isDirectDependency) {
-            const specifier = getPackageName(filePath);
-            npmSpecifiers.add(specifier);
-        }
         const isExtraneousFile = reason.type.every((type) => type === 'asset');
         // An extraneous file is a dependency that was traced by NFT and marked
         // as not being statically imported. We can't process dynamic importing
@@ -89,13 +132,40 @@ const getNPMSpecifiers = async (basePath, functions, importMap) => {
                 }
             });
         }
-    });
+        // every dependency will have its `package.json` in `reasons` exactly once.
+        // by only looking at this file, we save us from doing duplicate work.
+        const isPackageJson = filePath.endsWith('package.json');
+        if (!isPackageJson)
+            continue;
+        const packageName = getPackageName(filePath);
+        if (packageName === undefined)
+            continue;
+        const isDirectDependency = parents.some((parentPath) => {
+            var _a, _b;
+            if (!parentPath.startsWith(`node_modules${path.sep}`))
+                return true;
+            // typically, edge functions have no direct dependency on the `package.json` of a module.
+            // it's the impl files that depend on `package.json`, so we need to check the parents of
+            // the `package.json` file as well to see if the module is a direct dependency.
+            const parents = [...((_b = (_a = reasons.get(parentPath)) === null || _a === void 0 ? void 0 : _a.parents) !== null && _b !== void 0 ? _b : [])];
+            return parents.some((parentPath) => !parentPath.startsWith(`node_modules${path.sep}`));
+        });
+        // We're only interested in capturing the specifiers that are first-level
+        // dependencies. Because we'll bundle all modules in a subsequent step,
+        // any transitive dependencies will be handled then.
+        if (isDirectDependency) {
+            npmSpecifiers.push({
+                specifier: packageName,
+                types: referenceTypes ? await safelyDetectTypes(path.join(basePath, filePath)) : undefined,
+            });
+        }
+    }
     return {
-        npmSpecifiers: [...npmSpecifiers],
+        npmSpecifiers,
         npmSpecifiersWithExtraneousFiles: [...npmSpecifiersWithExtraneousFiles],
     };
 };
-export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, }) => {
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, referenceTypes, }) => {
     // The directories that esbuild will use when resolving Node modules. We must
     // set these manually because esbuild will be operating from a temporary
     // directory that will not live inside the project root, so the normal
@@ -105,25 +175,25 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
     // project directory. If a custom directory has been specified, we use it.
     // Otherwise, create a random temporary directory.
     const temporaryDirectory = directory ? { path: directory } : await tmp.dir();
-    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers(basePath, functions, importMap.getContentsWithURLObjects());
+    const { npmSpecifiers, npmSpecifiersWithExtraneousFiles } = await getNPMSpecifiers(basePath, functions, importMap.getContentsWithURLObjects(), referenceTypes);
     // If we found no specifiers, there's nothing left to do here.
-    if (npmSpecifiers.length === 0) {
+    if (Object.keys(npmSpecifiers).length === 0) {
         return;
     }
-    // To bundle an entire module and all its dependencies, create a barrel file
+    // To bundle an entire module and all its dependencies, create a entrypoint file
     // where we re-export everything from that specifier. We do this for every
     // specifier, and each of these files will become entry points to esbuild.
-    const ops = await Promise.all(npmSpecifiers.map(async (specifier, index) => {
+    const ops = await Promise.all(npmSpecifiers.map(async ({ specifier, types }) => {
         const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
-        const filePath = path.join(temporaryDirectory.path, `barrel-${index}.js`);
+        const filePath = path.join(temporaryDirectory.path, `bundled-${slugifyPackageName(specifier)}.js`);
         await fs.writeFile(filePath, code);
-        return { filePath, specifier };
+        return { filePath, specifier, types };
     }));
     const entryPoints = ops.map(({ filePath }) => filePath);
-    // Bundle each of the barrel files we created. We'll end up with a compiled
-    // version of each of the barrel files, plus any chunks of shared code
+    // Bundle each of the entrypoints we created. We'll end up with a compiled
+    // version of each, plus any chunks of shared code
     // between them (such that a common module isn't bundled twice).
-    await build({
+    const { outputFiles } = await build({
         allowOverwrite: true,
         banner,
         bundle: true,
@@ -135,7 +205,17 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         platform: 'node',
         splitting: true,
         target: 'es2020',
+        write: false,
     });
+    await Promise.all(outputFiles.map(async (file) => {
+        var _a;
+        const types = (_a = ops.find((op) => path.basename(file.path) === path.basename(op.filePath))) === null || _a === void 0 ? void 0 : _a.types;
+        let content = file.text;
+        if (types) {
+            content = `/// <reference types="${path.relative(path.dirname(file.path), types)}" />\n${content}`;
+        }
+        await fs.writeFile(file.path, content);
+    }));
     // Add all Node.js built-ins to the import map, so any unprefixed specifiers
     // (e.g. `process`) resolve to the prefixed versions (e.g. `node:prefix`),
     // which Deno can process.

package/dist/node/server/server.js

@@ -31,6 +31,7 @@ const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImport
                 functions: functions.map(({ path }) => path),
                 importMap,
                 logger,
+                referenceTypes: true,
             });
             if (vendor) {
                 features.npmModules = true;

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

@@ -1,7 +1,7 @@
+import { readFile } from 'fs/promises';
 import { join } from 'path';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
-import { tmpName } from 'tmp-promise';
 import { v4 as uuidv4 } from 'uuid';
 import { test, expect } from 'vitest';
 import { fixturesDir } from '../../test/util.js';
@@ -14,13 +14,16 @@ test('Starts a server and serves requests for edge functions', async () => {
     };
     const port = await getPort();
     const importMapPaths = [join(paths.internal, 'import_map.json'), join(paths.user, 'import-map.json')];
-    const servePath = await tmpName();
+    const servePath = join(basePath, '.netlify', 'edge-functions-serve');
     const server = await serve({
         basePath,
         bootstrapURL: 'https://edge.netlify.com/bootstrap/index-combined.ts',
         importMapPaths,
         port,
         servePath,
+        featureFlags: {
+            edge_functions_npm_modules: true,
+        },
     });
     const functions = [
         {
@@ -39,12 +42,13 @@ test('Starts a server and serves requests for edge functions', async () => {
     const options = {
         getFunctionsConfig: true,
     };
-    const { features, functionsConfig, graph, success } = await server(functions, {
+    const { features, functionsConfig, graph, success, npmSpecifiersWithExtraneousFiles } = await server(functions, {
         very_secret_secret: 'i love netlify',
     }, options);
-    expect(features).toEqual({});
+    expect(features).toEqual({ npmModules: true });
     expect(success).toBe(true);
     expect(functionsConfig).toEqual([{ path: '/my-function' }, {}, { path: '/global-netlify' }]);
+    expect(npmSpecifiersWithExtraneousFiles).toEqual(['dictionary']);
     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
@@ -80,4 +84,8 @@ test('Starts a server and serves requests for edge functions', async () => {
         global: 'i love netlify',
         local: 'i love netlify',
     });
+    const idBarrelFile = await readFile(join(servePath, 'bundled-id.js'), 'utf-8');
+    expect(idBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', 'id', 'types.d.ts')}" />`);
+    const identidadeBarrelFile = await readFile(join(servePath, 'bundled-pt-committee__identidade.js'), 'utf-8');
+    expect(identidadeBarrelFile).toContain(`/// <reference types="${join('..', '..', 'node_modules', '@types', 'pt-committee__identidade', 'index.d.ts')}" />`);
 });

package/package.json

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