@vercel/go 3.10.5 → 4.0.0

package/dist/index.js

@@ -10938,6 +10938,288 @@ var require_xdg_app_paths = __commonJS({
   }
 });
 
+// ../../internals/ipc-proxy/dist/dev-proxy.js
+var require_dev_proxy = __commonJS({
+  "../../internals/ipc-proxy/dist/dev-proxy.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var dev_proxy_exports = {};
+    __export2(dev_proxy_exports, {
+      createDevProxyServer: () => createDevProxyServer,
+      findFreePort: () => findFreePort,
+      normalizeServiceRoutePrefix: () => normalizeServiceRoutePrefix,
+      resolveServiceRoutePrefix: () => resolveServiceRoutePrefix,
+      rewriteRequestUrl: () => rewriteRequestUrl,
+      sanitizeHeaders: () => sanitizeHeaders,
+      startDevProxy: () => startDevProxy,
+      stripServiceRoutePrefix: () => stripServiceRoutePrefix,
+      waitForPort: () => waitForPort2
+    });
+    module2.exports = __toCommonJS2(dev_proxy_exports);
+    var import_node_http = require("http");
+    var import_node_net = require("net");
+    var PING_PATH = "/_vercel/ping";
+    var INTERNAL_HEADER_PREFIX = "x-vercel-internal-";
+    var LOCALHOST = "127.0.0.1";
+    var DEFAULT_READINESS_TIMEOUT = 5 * 6e4;
+    var READINESS_POLL_INTERVAL = 100;
+    var READINESS_DIAL_TIMEOUT = 1e3;
+    function normalizeServiceRoutePrefix(rawPrefix) {
+      if (!rawPrefix)
+        return "";
+      let prefix = rawPrefix.trim();
+      if (!prefix)
+        return "";
+      if (!prefix.startsWith("/")) {
+        prefix = `/${prefix}`;
+      }
+      if (prefix !== "/") {
+        prefix = prefix.replace(/\/+$/, "");
+        if (!prefix)
+          prefix = "/";
+      }
+      return prefix === "/" ? "" : prefix;
+    }
+    function resolveServiceRoutePrefix(env = process.env) {
+      const strip = (env.VERCEL_SERVICE_ROUTE_PREFIX_STRIP ?? "").trim().toLowerCase();
+      if (strip !== "1" && strip !== "true")
+        return "";
+      return normalizeServiceRoutePrefix(env.VERCEL_SERVICE_ROUTE_PREFIX);
+    }
+    function stripServiceRoutePrefix(pathValue, prefix) {
+      if (pathValue === "*")
+        return pathValue;
+      let normalized = pathValue;
+      if (!normalized) {
+        normalized = "/";
+      } else if (!normalized.startsWith("/")) {
+        normalized = `/${normalized}`;
+      }
+      if (!prefix)
+        return normalized;
+      if (normalized === prefix)
+        return "/";
+      if (normalized.startsWith(`${prefix}/`)) {
+        return normalized.slice(prefix.length) || "/";
+      }
+      return normalized;
+    }
+    function splitUrl(url) {
+      const queryIndex = url.indexOf("?");
+      if (queryIndex === -1)
+        return { pathname: url, search: "" };
+      return { pathname: url.slice(0, queryIndex), search: url.slice(queryIndex) };
+    }
+    function rewriteRequestUrl(url, prefix) {
+      const { pathname, search } = splitUrl(url || "/");
+      return `${stripServiceRoutePrefix(pathname, prefix)}${search}`;
+    }
+    function sanitizeHeaders(headers) {
+      const sanitized = {};
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase().startsWith(INTERNAL_HEADER_PREFIX))
+          continue;
+        sanitized[key] = value;
+      }
+      const forwardedHost = headers["x-forwarded-host"];
+      const host = Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost;
+      if (host) {
+        sanitized.host = host;
+      }
+      return sanitized;
+    }
+    function findFreePort() {
+      return new Promise((resolve, reject) => {
+        const server = (0, import_node_net.createServer)();
+        server.unref();
+        server.once("error", reject);
+        server.listen(0, LOCALHOST, () => {
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            server.close(() => reject(new Error("Failed to allocate a free port")));
+            return;
+          }
+          const { port } = address;
+          server.close(() => resolve(port));
+        });
+      });
+    }
+    function isPortReachable2(port) {
+      return new Promise((resolve) => {
+        const socket = (0, import_node_net.createConnection)({ port, host: LOCALHOST });
+        const done = (reachable) => {
+          socket.removeAllListeners();
+          socket.destroy();
+          resolve(reachable);
+        };
+        socket.setTimeout(READINESS_DIAL_TIMEOUT);
+        socket.once("connect", () => done(true));
+        socket.once("timeout", () => done(false));
+        socket.once("error", () => done(false));
+      });
+    }
+    function sleep2(ms2) {
+      return new Promise((resolve) => setTimeout(resolve, ms2));
+    }
+    async function waitForPort2(port, child, timeout, label = "Dev server") {
+      let exited;
+      let spawnError;
+      const onExit = (code, signal) => {
+        exited = { code, signal };
+      };
+      const onError = (err) => {
+        spawnError = err;
+      };
+      child.once("exit", onExit);
+      child.once("error", onError);
+      try {
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+          if (spawnError)
+            throw spawnError;
+          if (exited) {
+            throw new Error(
+              `${label} exited before it started listening (code: ${exited.code}, signal: ${exited.signal})`
+            );
+          }
+          if (await isPortReachable2(port))
+            return;
+          await sleep2(READINESS_POLL_INTERVAL);
+        }
+        throw new Error(`${label} did not start listening within ${timeout}ms`);
+      } finally {
+        child.removeListener("exit", onExit);
+        child.removeListener("error", onError);
+      }
+    }
+    function createDevProxyServer(options) {
+      const { targetPort } = options;
+      const routePrefix = normalizeServiceRoutePrefix(options.routePrefix);
+      const server = (0, import_node_http.createServer)((req, res) => {
+        const { pathname } = splitUrl(req.url || "/");
+        if (pathname === PING_PATH) {
+          res.writeHead(200, { "content-type": "text/plain" });
+          res.end("OK");
+          return;
+        }
+        const proxyReq = (0, import_node_http.request)(
+          {
+            host: LOCALHOST,
+            port: targetPort,
+            method: req.method,
+            path: rewriteRequestUrl(req.url || "/", routePrefix),
+            headers: sanitizeHeaders(req.headers)
+          },
+          (proxyRes) => {
+            res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.once("error", (err) => {
+          if (!res.headersSent) {
+            res.writeHead(502, { "content-type": "text/plain" });
+          }
+          res.end(`Dev proxy error: ${err.message}`);
+        });
+        res.once("close", () => {
+          if (!res.writableFinished)
+            proxyReq.destroy();
+        });
+        req.pipe(proxyReq);
+      });
+      server.on("upgrade", (req, clientSocket, head) => {
+        const headers = sanitizeHeaders(req.headers);
+        const path = rewriteRequestUrl(req.url || "/", routePrefix);
+        const upstream = (0, import_node_net.createConnection)(
+          { host: LOCALHOST, port: targetPort },
+          () => {
+            const lines = [`${req.method} ${path} HTTP/${req.httpVersion}`];
+            for (const [key, value] of Object.entries(headers)) {
+              if (Array.isArray(value)) {
+                for (const entry of value)
+                  lines.push(`${key}: ${entry}`);
+              } else if (value !== void 0) {
+                lines.push(`${key}: ${value}`);
+              }
+            }
+            upstream.write(`${lines.join("\r\n")}\r
+\r
+`);
+            if (head?.length)
+              upstream.write(new Uint8Array(head));
+            upstream.pipe(clientSocket);
+            clientSocket.pipe(upstream);
+          }
+        );
+        const destroy = () => {
+          upstream.destroy();
+          clientSocket.destroy();
+        };
+        upstream.once("error", destroy);
+        clientSocket.once("error", destroy);
+      });
+      return server;
+    }
+    async function startDevProxy(options) {
+      const {
+        spawnServer,
+        env = process.env,
+        readinessTimeout = DEFAULT_READINESS_TIMEOUT,
+        label = "Dev server"
+      } = options;
+      const internalPort = await findFreePort();
+      const child = spawnServer(internalPort);
+      let server;
+      const close = async () => {
+        if (server) {
+          await new Promise((resolve) => {
+            server?.close(() => resolve());
+            server?.closeAllConnections?.();
+          });
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+          child.kill("SIGTERM");
+        }
+      };
+      try {
+        await waitForPort2(internalPort, child, readinessTimeout, label);
+        server = createDevProxyServer({
+          targetPort: internalPort,
+          routePrefix: resolveServiceRoutePrefix(env)
+        });
+        const listenPort = options.port ?? await findFreePort();
+        await new Promise((resolve, reject) => {
+          server?.once("error", reject);
+          server?.listen(listenPort, () => resolve());
+        });
+        if (!child.pid) {
+          throw new Error(`${label} started without a PID`);
+        }
+        return { port: listenPort, pid: child.pid, child, close };
+      } catch (err) {
+        await close();
+        throw err;
+      }
+    }
+  }
+});
+
 // ../../internals/ipc-proxy/dist/index.js
 var require_dist2 = __commonJS({
   "../../internals/ipc-proxy/dist/index.js"(exports, module2) {
@@ -10958,6 +11240,7 @@ var require_dist2 = __commonJS({
       }
       return to2;
     };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var src_exports2 = {};
     __export2(src_exports2, {
@@ -10970,6 +11253,7 @@ var require_dist2 = __commonJS({
     var import_node_fs7 = require("fs");
     var import_promises2 = require("fs/promises");
     var import_build_utils6 = require("@vercel/build-utils");
+    __reExport(src_exports2, require_dev_proxy(), module2.exports);
     function proxyBinaryName(architecture) {
       return architecture === "arm64" ? "proxy-linux-arm64" : "proxy-linux-amd64";
     }
@@ -14894,15 +15178,29 @@ async function generateProjectManifest({
 var diagnostics = (0, import_build_utils3.createDiagnostics)("go");
 
 // src/standalone-server.ts
+var STANDALONE_LAMBDA_PATH = "go";
+function ownsRouteTable(service) {
+  return !(service?.name && service.type);
+}
 function getStandaloneServerRoutes(service) {
-  if (!service?.name || service.type) {
+  if (!ownsRouteTable(service)) {
     return void 0;
   }
   return [
     { handle: "filesystem" },
+    // This route matches the resolved destination after rewrites. Copy that
+    // path into the runtime request before dispatching the Go server so its
+    // application routing observes the rewrite.
     {
       src: "/(.*)",
-      dest: "/index"
+      dest: `/${STANDALONE_LAMBDA_PATH}`,
+      transforms: [
+        {
+          type: "request.path",
+          op: "set",
+          args: "/$1"
+        }
+      ]
     }
   ];
 }
@@ -14925,7 +15223,21 @@ async function findGoModPath(entrypointDir, workPath) {
     isGoModInRootDir
   };
 }
-async function buildStandaloneServer({
+async function buildStandaloneServer(options) {
+  const lambda = await createStandaloneServerLambda(options);
+  const { service } = options;
+  if (!ownsRouteTable(service)) {
+    return { resultVersion: 3, result: { output: lambda } };
+  }
+  return {
+    resultVersion: 2,
+    result: {
+      output: { [STANDALONE_LAMBDA_PATH]: lambda },
+      routes: getStandaloneServerRoutes(service)
+    }
+  };
+}
+async function createStandaloneServerLambda({
   files,
   entrypoint,
   config,
@@ -15019,8 +15331,7 @@ async function buildStandaloneServer({
     framework: config.framework ?? void 0,
     serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
   });
-  const routes = getStandaloneServerRoutes(service);
-  return { output: lambda, ...routes ? { routes } : {} };
+  return lambda;
 }
 var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
@@ -15231,7 +15542,7 @@ function getRenamedEntrypoint(entrypoint) {
   }
   return void 0;
 }
-var version = 3;
+var version = -1;
 async function build(options) {
   const {
     files,
@@ -15396,7 +15707,8 @@ Manually assigning 'GO111MODULE' is not recommended.
       });
     }
     return {
-      output: lambda
+      resultVersion: 3,
+      result: { output: lambda }
     };
   } catch (error) {
     (0, import_build_utils5.debug)(`Go Builder Error: ${error}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "3.10.5",
+  "version": "4.0.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -15,6 +15,10 @@
     "bin",
     "bootstrap"
   ],
+  "dependencies": {},
+  "peerDependencies": {
+    "@vercel/build-utils": "14.3.0"
+  },
   "devDependencies": {
     "@tootallnate/once": "1.1.2",
     "@types/async-retry": "1.4.5",
@@ -32,13 +36,14 @@
     "vitest": "4.1.10",
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
-    "@vercel/build-utils": "14.0.5",
+    "@vercel/build-utils": "14.3.0",
     "@vercel-internals/ipc-proxy": "1.0.0"
   },
   "scripts": {
     "build": "node build.mjs",
     "test": "vitest run --config ../../vitest.config.mts",
     "test-e2e": "vitest run --config ../../vitest.config.mts test/integration-",
+    "test-e2e-builder": "pnpm run test-e2e",
     "type-check": "tsc --noEmit"
   }
 }