@vercel/node 3.0.28 → 3.1.0

package/dist/dev-server.mjs

@@ -248,20 +248,9 @@ var require_cookie = __commonJS({
 // src/serverless-functions/helpers-web.ts
 var helpers_web_exports = {};
 __export(helpers_web_exports, {
-  getWebExportsHandler: () => getWebExportsHandler
+  createWebExportsHandler: () => createWebExportsHandler
 });
 import { buildToNodeHandler } from "@edge-runtime/node-utils";
-import Edge from "@edge-runtime/primitives";
-function getWebExportsHandler(listener, methods) {
-  const handlerByMethod = {};
-  for (const key of methods) {
-    handlerByMethod[key] = typeof listener[key] !== "undefined" ? webHandlerToNodeHandler(listener[key]) : defaultHttpHandler;
-  }
-  return (req, res) => {
-    const method = req.method ?? "GET";
-    handlerByMethod[method](req, res);
-  };
-}
 function addDuplexToInit(init2) {
   if (typeof init2 === "undefined" || typeof init2 === "object") {
     return { duplex: "half", ...init2 };
@@ -272,25 +261,43 @@ function defaultHttpHandler(_, res) {
   res.statusCode = 405;
   res.end();
 }
-var webHandlerToNodeHandler;
+var createWebExportsHandler;
 var init_helpers_web = __esm({
   "src/serverless-functions/helpers-web.ts"() {
     "use strict";
-    webHandlerToNodeHandler = buildToNodeHandler(
-      {
-        Headers,
-        ReadableStream,
-        // @ts-expect-error Property 'duplex' is missing in type 'Request'
-        Request: class extends Request {
-          constructor(input, init2) {
-            super(input, addDuplexToInit(init2));
+    createWebExportsHandler = (awaiter) => {
+      const webHandlerToNodeHandler = buildToNodeHandler(
+        {
+          Headers,
+          ReadableStream,
+          // @ts-expect-error Property 'duplex' is missing in type 'Request'
+          Request: class extends Request {
+            constructor(input, init2) {
+              super(input, addDuplexToInit(init2));
+            }
+          },
+          Uint8Array,
+          // @ts-expect-error Property 'waitUntil' is missing in type 'FetchEvent'
+          FetchEvent: class {
+            constructor() {
+              this.waitUntil = (promise) => awaiter.waitUntil(promise);
+            }
           }
         },
-        Uint8Array,
-        FetchEvent: Edge.FetchEvent
-      },
-      { defaultOrigin: "https://vercel.com" }
-    );
+        { defaultOrigin: "https://vercel.com" }
+      );
+      function getWebExportsHandler(listener, methods) {
+        const handlerByMethod = {};
+        for (const key of methods) {
+          handlerByMethod[key] = typeof listener[key] !== "undefined" ? webHandlerToNodeHandler(listener[key]) : defaultHttpHandler;
+        }
+        return (req, res) => {
+          const method = req.method ?? "GET";
+          handlerByMethod[method](req, res);
+        };
+      }
+      return getWebExportsHandler;
+    };
   }
 });
 
@@ -524,6 +531,12 @@ import { readFileSync } from "fs";
 import { debug, streamToBuffer } from "@vercel/build-utils";
 import { pathToRegexp } from "path-to-regexp";
 import { extname } from "path";
+var WAIT_UNTIL_TIMEOUT = 10;
+var WAIT_UNTIL_TIMEOUT_MS = 10 * 1e3;
+var waitUntilWarning = (entrypointPath) => `
+The function \`${entrypointPath.split("/").pop()}\` is still running after ${WAIT_UNTIL_TIMEOUT}s.
+(hint: do you have a long-running waitUntil() promise?)
+`.trim();
 function entrypointToOutputPath(entrypoint2, zeroConfig) {
   if (zeroConfig) {
     const ext = extname(entrypoint2);
@@ -578,6 +591,31 @@ async function serializeBody(request) {
 import esbuild from "esbuild";
 import { buildToHeaders } from "@edge-runtime/node-utils";
 import { fileURLToPath } from "url";
+
+// src/awaiter.ts
+var Awaiter = class {
+  constructor({ onError } = {}) {
+    this.promises = /* @__PURE__ */ new Set();
+    this.awaiting = () => this.waitForBatch().then(
+      () => this.promises.size > 0 ? this.waitForBatch() : Promise.resolve()
+    );
+    this.waitUntil = (promise) => {
+      this.promises.add(promise);
+    };
+    this.waitForBatch = async () => {
+      const promises = Array.from(this.promises);
+      this.promises.clear();
+      await Promise.all(
+        promises.map(
+          (promise) => Promise.resolve(promise).then(() => void 0, this.onError)
+        )
+      );
+    };
+    this.onError = onError ?? console.error;
+  }
+};
+
+// src/edge-functions/edge-handler.mts
 var NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
 var NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
 if (!NODE_VERSION_MAJOR) {
@@ -655,9 +693,11 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
       registerFetchListener(userModule, options, dependencies);
     `;
     return {
+      entrypointPath: entrypointFullPath,
       userCode,
       wasmAssets,
-      nodeCompatBindings: nodeCompatPlugin.bindings
+      nodeCompatBindings: nodeCompatPlugin.bindings,
+      awaiter: new Awaiter()
     };
   } catch (error) {
     console.error(`Failed to compile user code for edge runtime.`);
@@ -688,27 +728,32 @@ async function createEdgeRuntimeServer(params) {
           // These are the global bindings for Node.js compatibility
           ...nodeCompatBindings,
           // These are the global bindings for WebAssembly module
-          ...wasmBindings
+          ...wasmBindings,
+          FetchEvent: class extends context.FetchEvent {
+            constructor() {
+              super(...arguments);
+              this.waitUntil = (promise) => {
+                params.awaiter.waitUntil(promise);
+              };
+            }
+          }
         });
         return context;
       }
     });
     const server = await runServer({ runtime });
-    const onExit2 = async () => {
-      const WAIT_UNTIL_TIMEOUT = 10 * 1e3;
-      const waitUntil = server.close();
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          console.warn(
-            `Edge Runtime server is still running after ${WAIT_UNTIL_TIMEOUT} ms (hint: do you have a long-running waitUntil() promise?)`
-          );
-          resolve();
-        }, WAIT_UNTIL_TIMEOUT);
-        waitUntil.then(() => resolve()).catch(reject).finally(() => {
-          clearTimeout(timeout);
-        });
-      });
+    runtime.context.globalThis[Symbol.for("@vercel/request-context")] = {
+      get: () => ({
+        waitUntil: params.awaiter.waitUntil.bind(params.awaiter)
+      })
     };
+    const onExit2 = () => new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        console.warn(waitUntilWarning(params.entrypointPath));
+        resolve();
+      }, WAIT_UNTIL_TIMEOUT_MS);
+      Promise.all([params.awaiter.awaiting(), server.close()]).then(() => resolve()).catch(reject).finally(() => clearTimeout(timeout));
+    });
     return { server, onExit: onExit2 };
   } catch (error) {
     console.error("Failed to instantiate edge runtime.");
@@ -985,6 +1030,7 @@ import { listen } from "async-listen";
 import { isAbsolute } from "path";
 import { pathToFileURL } from "url";
 import { buildToHeaders as buildToHeaders2 } from "@edge-runtime/node-utils";
+import { promisify } from "util";
 var toHeaders2 = buildToHeaders2({ Headers: Headers3 });
 var [NODE_MAJOR] = process.versions.node.split(".").map((v) => Number(v));
 var HTTP_METHODS = [
@@ -1000,12 +1046,10 @@ async function createServerlessServer(userCode) {
   const server = createServer(userCode);
   return {
     url: await listen(server, { host: "127.0.0.1", port: 0 }),
-    onExit: async () => {
-      server.close();
-    }
+    onExit: promisify(server.close.bind(server))
   };
 }
-async function compileUserCode2(entrypointPath, options) {
+async function compileUserCode2(entrypointPath, awaiter, options) {
   const id = isAbsolute(entrypointPath) ? pathToFileURL(entrypointPath).href : entrypointPath;
   let listener = await import(id);
   for (let i = 0; i < 5; i++) {
@@ -1018,8 +1062,9 @@ async function compileUserCode2(entrypointPath, options) {
         "Node.js v18 or above is required to use HTTP method exports in your functions."
       );
     }
-    const { getWebExportsHandler: getWebExportsHandler2 } = await Promise.resolve().then(() => (init_helpers_web(), helpers_web_exports));
-    return getWebExportsHandler2(listener, HTTP_METHODS);
+    const { createWebExportsHandler: createWebExportsHandler2 } = await Promise.resolve().then(() => (init_helpers_web(), helpers_web_exports));
+    const getWebExportsHandler = createWebExportsHandler2(awaiter);
+    return getWebExportsHandler(listener, HTTP_METHODS);
   }
   return async (req, res) => {
     if (options.shouldAddHelpers)
@@ -1028,7 +1073,17 @@ async function compileUserCode2(entrypointPath, options) {
   };
 }
 async function createServerlessEventHandler(entrypointPath, options) {
-  const userCode = await compileUserCode2(entrypointPath, options);
+  const awaiter = new Awaiter();
+  Object.defineProperty(globalThis, Symbol.for("@vercel/request-context"), {
+    enumerable: false,
+    configurable: true,
+    value: {
+      get: () => ({
+        waitUntil: awaiter.waitUntil.bind(awaiter)
+      })
+    }
+  });
+  const userCode = await compileUserCode2(entrypointPath, awaiter, options);
   const server = await createServerlessServer(userCode);
   const isStreaming = options.mode === "streaming";
   const handler = async function(request) {
@@ -1055,9 +1110,16 @@ async function createServerlessEventHandler(entrypointPath, options) {
       encoding: "utf8"
     };
   };
+  const onExit2 = () => new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      console.warn(waitUntilWarning(entrypointPath));
+      resolve();
+    }, WAIT_UNTIL_TIMEOUT_MS);
+    Promise.all([awaiter.awaiting(), server.onExit()]).then(() => resolve()).catch(reject).finally(() => clearTimeout(timeout));
+  });
   return {
     handler,
-    onExit: server.onExit
+    onExit: onExit2
   };
 }
 

package/dist/edge-handler-template.js

@@ -88,7 +88,12 @@ function registerFetchListener(module, options, dependencies) {
           `No default or HTTP-named export was found at ${url}. Add one to handle requests. Learn more: https://vercel.link/creating-edge-middleware`
         );
       }
-      const response = await respond(handler, event, options, dependencies);
+      const response = await respond(
+        (req, ctx) => handler(req, { waitUntil: ctx.waitUntil.bind(ctx) }),
+        event,
+        options,
+        dependencies
+      );
       event.respondWith(response);
     } catch (error) {
       event.respondWith(toResponseError(error, dependencies.Response));

package/dist/index.js

@@ -69912,6 +69912,7 @@ function filterDiagnostics(diagnostics, ignore) {
 var import_build_utils2 = require("@vercel/build-utils");
 var import_path_to_regexp = require("path-to-regexp");
 var import_path2 = require("path");
+var WAIT_UNTIL_TIMEOUT_MS = 10 * 1e3;
 function getRegExpFromMatchers(matcherOrMatchers) {
   if (!matcherOrMatchers) {
     return "^/.*$";
@@ -70007,9 +70008,18 @@ function forkDevServer(options) {
       TS_NODE_TRANSPILE_ONLY: "1",
       TS_NODE_COMPILER_OPTIONS: options.tsConfig?.compilerOptions ? JSON.stringify(options.tsConfig.compilerOptions) : void 0,
       NODE_OPTIONS: nodeOptions
-    })
+    }),
+    stdio: options.printLogs ? "pipe" : void 0
   };
   const child = (0, import_child_process.fork)(devServerPath, [], forkOptions);
+  if (options.printLogs) {
+    child.stdout?.on("data", (data) => {
+      console.log(`stdout: ${data}`);
+    });
+    child.stderr?.on("data", (data) => {
+      console.error(`stderr: ${data}`);
+    });
+  }
   checkForPid(devServerPath, child);
   return child;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "3.0.28",
+  "version": "3.1.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -16,7 +16,7 @@
     "@edge-runtime/node-utils": "2.3.0",
     "@edge-runtime/primitives": "4.1.0",
     "@edge-runtime/vm": "3.2.0",
-    "@types/node": "14.18.33",
+    "@types/node": "16.18.11",
     "@vercel/build-utils": "8.0.0",
     "@vercel/error-utils": "2.0.2",
     "@vercel/nft": "0.26.4",
@@ -50,7 +50,8 @@
     "fs-extra": "11.1.0",
     "jest-junit": "16.0.0",
     "source-map-support": "0.5.12",
-    "tree-kill": "1.2.2"
+    "tree-kill": "1.2.2",
+    "@vercel/functions": "1.0.0"
   },
   "scripts": {
     "build": "node build.mjs",