@rpcbase/server 0.486.0 → 0.487.0

package/dist/index.js

@@ -6,13 +6,16 @@ import { MongoClient } from "mongodb";
 import env from "@rpcbase/env";
 import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
 import { dirname, posix, sep } from "path";
-import { createReadStream, readFileSync } from "node:fs";
+import fs, { createReadStream, readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { AsyncLocalStorage } from "node:async_hooks";
 import assert$1 from "assert";
 import crypto, { hkdfSync, scrypt } from "crypto";
 import httpProxy from "http-proxy-3";
-import fs from "node:fs/promises";
+import fsPromises from "node:fs/promises";
+import inspector from "node:inspector";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { Transform } from "node:stream";
 import { StrictMode, createElement } from "react";
 import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
@@ -216,8 +219,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname(proces
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path) {
-  return path.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path2) {
+  return path2.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 const normalizeFlagsResponse = (flagsResponse) => {
   if ("flags" in flagsResponse) {
@@ -1857,9 +1860,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path, ranges, output) {
+function getContextLinesFromFile(path2, ranges, output) {
   return new Promise((resolve) => {
-    const stream = createReadStream(path);
+    const stream = createReadStream(path2);
     const lineReaded = createInterface({
       input: stream
     });
@@ -1874,7 +1877,7 @@ function getContextLinesFromFile(path, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path2, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -1935,8 +1938,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path) {
-  return path.startsWith("node:") || path.endsWith(".min.js") || path.endsWith(".min.cjs") || path.endsWith(".min.mjs") || path.startsWith("data:");
+function shouldSkipContextLinesForFile(path2) {
+  return path2.startsWith("node:") || path2.endsWith(".min.js") || path2.endsWith(".min.cjs") || path2.endsWith(".min.mjs") || path2.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -3492,6 +3495,283 @@ const checkInitReplicaSet = async (serverEnv) => {
     }
   }
 };
+const VITE_FS_PREFIX = "/@fs/";
+let activeRun = null;
+const post = async (session2, method, params) => {
+  return await new Promise((resolve, reject) => {
+    session2.post(method, params, (error, result) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(result);
+    });
+  });
+};
+const describeError = (error) => {
+  return error instanceof Error ? error.message : String(error);
+};
+const findWorkspaceRoot = (projectRoot) => {
+  let dir = path.resolve(projectRoot);
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    try {
+      if (fs.existsSync(pkgPath)) {
+        const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (parsed && typeof parsed === "object" && parsed.workspaces) {
+          return dir;
+        }
+      }
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return path.resolve(projectRoot);
+    }
+    dir = parent;
+  }
+};
+const stripQuery = (url) => {
+  const queryIndex = url.indexOf("?");
+  const hashIndex = url.indexOf("#");
+  const endIndex = Math.min(
+    queryIndex === -1 ? Number.POSITIVE_INFINITY : queryIndex,
+    hashIndex === -1 ? Number.POSITIVE_INFINITY : hashIndex
+  );
+  if (!Number.isFinite(endIndex)) {
+    return url;
+  }
+  return url.slice(0, endIndex);
+};
+const resolveAbsoluteFromUrl = (rawUrl, roots) => {
+  const cleaned = stripQuery(rawUrl);
+  try {
+    if (cleaned.startsWith("file://")) {
+      return path.normalize(fileURLToPath(cleaned));
+    }
+  } catch {
+  }
+  let pathname = cleaned;
+  try {
+    const parsed = new URL(cleaned);
+    pathname = parsed.pathname;
+  } catch {
+  }
+  const decoded = decodeURIComponent(pathname);
+  if (decoded.startsWith(VITE_FS_PREFIX)) {
+    return path.normalize(decoded.slice(VITE_FS_PREFIX.length));
+  }
+  if (!path.isAbsolute(decoded)) {
+    return null;
+  }
+  if (fs.existsSync(decoded)) {
+    return path.normalize(decoded);
+  }
+  const projectRoot = path.resolve(roots.projectRoot);
+  const workspaceRoot = path.resolve(roots.workspaceRoot);
+  if (decoded.startsWith(projectRoot + path.sep) || decoded.startsWith(workspaceRoot + path.sep)) {
+    return path.normalize(decoded);
+  }
+  return path.resolve(projectRoot, `.${decoded}`);
+};
+const normalizeScriptUrl = async (rawUrl, roots) => {
+  if (!rawUrl || rawUrl.startsWith("node:")) {
+    return null;
+  }
+  const absolute = resolveAbsoluteFromUrl(rawUrl, roots);
+  if (!absolute) {
+    return null;
+  }
+  let realPath = absolute;
+  try {
+    realPath = await fsPromises.realpath(absolute);
+  } catch {
+  }
+  const normalized = path.normalize(realPath);
+  if (normalized.includes(`${path.sep}node_modules${path.sep}`)) {
+    return null;
+  }
+  const workspaceRoot = path.resolve(roots.workspaceRoot);
+  const projectRoot = path.resolve(roots.projectRoot);
+  if (normalized.startsWith(workspaceRoot + path.sep) || normalized === workspaceRoot) {
+    return {
+      absolutePath: normalized,
+      relativePath: path.relative(workspaceRoot, normalized)
+    };
+  }
+  if (normalized.startsWith(projectRoot + path.sep) || normalized === projectRoot) {
+    return {
+      absolutePath: normalized,
+      relativePath: path.relative(projectRoot, normalized)
+    };
+  }
+  return null;
+};
+const fetchScriptSource = async (session2, scriptId) => {
+  try {
+    const response = await post(session2, "Debugger.getScriptSource", { scriptId });
+    return typeof response?.scriptSource === "string" ? response.scriptSource : "";
+  } catch {
+    return "";
+  }
+};
+const resolveScriptSource = async (session2, cache, scriptId) => {
+  const cached = cache.get(scriptId);
+  if (cached) {
+    return await cached;
+  }
+  const promise = fetchScriptSource(session2, scriptId);
+  cache.set(scriptId, promise);
+  return await promise;
+};
+const shutdownSession = async (session2) => {
+  await Promise.allSettled([
+    post(session2, "Profiler.stopPreciseCoverage").catch(() => void 0),
+    post(session2, "Profiler.disable").catch(() => void 0),
+    post(session2, "Debugger.disable").catch(() => void 0)
+  ]);
+  try {
+    session2.disconnect();
+  } catch {
+  }
+};
+const toPosixPath = (input) => input.split(path.sep).join("/");
+const isSubpath = (candidate, root) => {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+};
+const classifyServerTarget = (absolutePath, projectRoot) => {
+  if (!isSubpath(absolutePath, projectRoot)) {
+    return "ssr";
+  }
+  const relative = toPosixPath(path.relative(projectRoot, absolutePath));
+  if (relative.startsWith("src/api/") || relative.includes("/src/api/")) {
+    return "api";
+  }
+  if (relative.startsWith("src/worker/") || relative.includes("/src/worker/")) {
+    return "worker";
+  }
+  if (relative.startsWith("src/server/") || relative.includes("/src/server/")) {
+    return "ssr";
+  }
+  if (relative.startsWith("build/dist/api/") || relative.includes("/build/dist/api/")) {
+    return "api";
+  }
+  if (relative.startsWith("build/dist/worker/") || relative.includes("/build/dist/worker/")) {
+    return "worker";
+  }
+  if (relative.startsWith("build/dist/ssr/") || relative.includes("/build/dist/ssr/")) {
+    return "ssr";
+  }
+  return "ssr";
+};
+function registerDevCoverageEndpoints(app) {
+  app.post("/api/dev/coverage/start", async (_req, res) => {
+    if (process.env.NODE_ENV === "production") {
+      res.status(404).json({ error: "Not Found" });
+      return;
+    }
+    if (activeRun) {
+      res.json({ ok: true, status: "already_started", startedAt: activeRun.startedAt });
+      return;
+    }
+    const roots = {
+      projectRoot: path.resolve(process.cwd()),
+      workspaceRoot: findWorkspaceRoot(process.cwd())
+    };
+    const session2 = new inspector.Session();
+    session2.connect();
+    try {
+      await post(session2, "Debugger.enable");
+      await post(session2, "Profiler.enable");
+      await post(session2, "Profiler.startPreciseCoverage", { callCount: false, detailed: true });
+      activeRun = {
+        roots,
+        session: session2,
+        sourceCache: /* @__PURE__ */ new Map(),
+        startedAt: Date.now()
+      };
+      res.json({ ok: true, status: "started", startedAt: activeRun.startedAt });
+    } catch (error) {
+      await shutdownSession(session2);
+      activeRun = null;
+      res.status(500).json({ ok: false, error: describeError(error) });
+    }
+  });
+  app.post("/api/dev/coverage/stop", async (req, res) => {
+    if (process.env.NODE_ENV === "production") {
+      res.status(404).json({ error: "Not Found" });
+      return;
+    }
+    const run = activeRun;
+    if (!run) {
+      res.status(409).json({ ok: false, error: "coverage_not_started" });
+      return;
+    }
+    activeRun = null;
+    const outputRoot = path.join(run.roots.projectRoot, "build", "coverage", "server");
+    const outputFiles = {
+      api: path.join(outputRoot, "api", "v8-coverage.json"),
+      worker: path.join(outputRoot, "worker", "v8-coverage.json"),
+      ssr: path.join(outputRoot, "ssr", "v8-coverage.json")
+    };
+    try {
+      const taken = await post(run.session, "Profiler.takePreciseCoverage");
+      const result = Array.isArray(taken?.result) ? taken.result : [];
+      const scriptsByTarget = {
+        api: [],
+        worker: [],
+        ssr: []
+      };
+      for (const entry of result) {
+        const scriptId = typeof entry?.scriptId === "string" ? entry.scriptId : null;
+        const url = typeof entry?.url === "string" ? entry.url : null;
+        if (!scriptId || !url) {
+          continue;
+        }
+        const normalized = await normalizeScriptUrl(url, run.roots);
+        if (!normalized) {
+          continue;
+        }
+        const source = await resolveScriptSource(run.session, run.sourceCache, scriptId);
+        const script = {
+          absolutePath: normalized.absolutePath,
+          relativePath: normalized.relativePath,
+          source,
+          functions: Array.isArray(entry?.functions) ? entry.functions : [],
+          url
+        };
+        const target = classifyServerTarget(script.absolutePath, run.roots.projectRoot);
+        scriptsByTarget[target].push(script);
+      }
+      await Promise.all(
+        Object.keys(outputFiles).map(async (target) => {
+          const outputFile = outputFiles[target];
+          const payload = {
+            testId: `node-${target}`,
+            scripts: scriptsByTarget[target]
+          };
+          await fsPromises.mkdir(path.dirname(outputFile), { recursive: true });
+          await fsPromises.writeFile(outputFile, JSON.stringify(payload, null, 2), "utf8");
+        })
+      );
+      res.json({
+        ok: true,
+        status: "stopped",
+        outputFiles,
+        scriptCount: {
+          api: scriptsByTarget.api.length,
+          worker: scriptsByTarget.worker.length,
+          ssr: scriptsByTarget.ssr.length
+        }
+      });
+    } catch (error) {
+      res.status(500).json({ ok: false, error: describeError(error) });
+    } finally {
+      await shutdownSession(run.session);
+    }
+  });
+}
 process.env = {
   ...env,
   ...__rb_env__,
@@ -3614,6 +3894,9 @@ const initServer = async (app, serverEnv) => {
     sessionConfig.cookie.secure = "auto";
   }
   const sessionMiddleware = session(sessionConfig);
+  if (!isProduction$1) {
+    registerDevCoverageEndpoints(app);
+  }
   app.use(sessionMiddleware);
   return {
     sessionMiddleware
@@ -4225,7 +4508,7 @@ const ssrMiddleware = ({
     if (isProduction) {
       template = templateHtml;
     } else {
-      template = await fs.readFile("./src/client/index.html", "utf-8");
+      template = await fsPromises.readFile("./src/client/index.html", "utf-8");
       template = await viteInstance.transformIndexHtml(url, template);
     }
     const placeholderIndex = template.indexOf(APP_HTML_PLACEHOLDER);
@@ -4342,3 +4625,4 @@ export {
   ssrMiddleware,
   verifyPasswordFromStorage
 };
+//# sourceMappingURL=index.js.map