@testsmith/api-spector 0.0.7 → 0.0.9

package/out/main/chunks/mock-server-C0RlwZf_.js

@@ -0,0 +1,240 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const http = require("http");
+const crypto = require("crypto");
+const vm = require("vm");
+const dayjs = require("dayjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const vm__namespace = /* @__PURE__ */ _interopNamespaceDefault(vm);
+let _fakerCache = null;
+async function getFaker() {
+  if (!_fakerCache) _fakerCache = await import("@faker-js/faker");
+  return _fakerCache.faker;
+}
+const running = /* @__PURE__ */ new Map();
+const liveRoutes = /* @__PURE__ */ new Map();
+let hitCallback = null;
+function setHitCallback(cb) {
+  hitCallback = cb;
+}
+function updateMockRoutes(id, routes) {
+  liveRoutes.set(id, routes);
+}
+function matchPath(pattern, urlPath) {
+  const regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/:[^/]+/g, "[^/]+");
+  try {
+    const regex = new RegExp("^" + regexStr + "/?$");
+    return regex.test(urlPath.split("?")[0]);
+  } catch {
+    return false;
+  }
+}
+function findRoute(routes, method, urlPath) {
+  const path = urlPath.split("?")[0];
+  return routes.find((r) => r.method === method && matchPath(r.path, path)) ?? routes.find((r) => r.method === "ANY" && matchPath(r.path, path)) ?? null;
+}
+function extractPathParams(pattern, urlPath) {
+  const params = {};
+  const patParts = pattern.split("/");
+  const urlParts = urlPath.split("?")[0].split("/");
+  patParts.forEach((part, i) => {
+    if (part.startsWith(":")) {
+      params[part.slice(1)] = decodeURIComponent(urlParts[i] ?? "");
+    }
+  });
+  return params;
+}
+function extractQueryParams(url) {
+  const params = {};
+  const qs = url.split("?")[1];
+  if (qs) new URLSearchParams(qs).forEach((v, k) => {
+    params[k] = v;
+  });
+  return params;
+}
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk.toString();
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", () => resolve(""));
+  });
+}
+function interpolateMockBody(body, context) {
+  return body.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    const expr = key.trim();
+    if (expr.includes(".") || expr.includes("(")) {
+      try {
+        const result = vm__namespace.runInNewContext(expr, context);
+        if (result !== void 0 && result !== null) return String(result);
+      } catch {
+      }
+    }
+    return match;
+  });
+}
+async function handleRequest(serverId, req, res, reqStart) {
+  const method = (req.method ?? "GET").toUpperCase();
+  const urlPath = req.url ?? "/";
+  if (urlPath === "/favicon.ico") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const bodyRaw = await readBody(req);
+  let bodyParsed = {};
+  try {
+    bodyParsed = JSON.parse(bodyRaw);
+  } catch {
+  }
+  const routes = liveRoutes.get(serverId) ?? [];
+  const route = findRoute(routes, method, urlPath);
+  if (!route) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "No matching mock route", method, path: urlPath }));
+    hitCallback?.({
+      id: crypto.randomUUID(),
+      serverId,
+      timestamp: reqStart,
+      method,
+      path: urlPath,
+      matchedRouteId: null,
+      status: 404,
+      durationMs: Date.now() - reqStart
+    });
+    return;
+  }
+  const reqHeaders = {};
+  Object.entries(req.headers).forEach(([k, v]) => {
+    if (v !== void 0) reqHeaders[k] = Array.isArray(v) ? v.join(", ") : v;
+  });
+  const requestCtx = {
+    method,
+    path: urlPath.split("?")[0],
+    params: extractPathParams(route.path, urlPath),
+    query: extractQueryParams(urlPath),
+    body: bodyParsed,
+    bodyRaw,
+    headers: reqHeaders
+  };
+  const responseDraft = {
+    statusCode: route.statusCode,
+    body: route.body,
+    headers: { "Content-Type": "application/json", ...route.headers }
+  };
+  if (route.script?.trim()) {
+    try {
+      const faker2 = await getFaker();
+      vm__namespace.runInNewContext(route.script, {
+        request: requestCtx,
+        response: responseDraft,
+        faker: faker2,
+        dayjs,
+        console: { log: (...args) => console.log("[mock-script]", ...args) }
+      });
+    } catch (err) {
+      console.error("[mock-script error]", err);
+    }
+  }
+  const faker = await getFaker();
+  const exprCtx = { request: requestCtx, faker, dayjs };
+  const finalBody = interpolateMockBody(responseDraft.body, exprCtx);
+  const respond = () => {
+    res.writeHead(responseDraft.statusCode, responseDraft.headers);
+    res.end(finalBody);
+    hitCallback?.({
+      id: crypto.randomUUID(),
+      serverId,
+      timestamp: reqStart,
+      method,
+      path: urlPath,
+      matchedRouteId: route.id,
+      status: responseDraft.statusCode,
+      durationMs: Date.now() - reqStart
+    });
+  };
+  if (route.delay && route.delay > 0) setTimeout(respond, route.delay);
+  else respond();
+}
+async function startMock(server) {
+  if (running.has(server.id)) await stopMock(server.id);
+  liveRoutes.set(server.id, server.routes ?? []);
+  const httpServer = http.createServer((req, res) => {
+    const reqStart = Date.now();
+    handleRequest(server.id, req, res, reqStart).catch((err) => {
+      console.error("[mock-handler uncaught]", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Mock handler error", message: String(err) }));
+      }
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(server.port, "127.0.0.1", resolve);
+  });
+  running.set(server.id, httpServer);
+}
+async function stopMock(id) {
+  const srv = running.get(id);
+  if (!srv) return;
+  await new Promise(
+    (resolve, reject) => srv.close((err) => err ? reject(err) : resolve())
+  );
+  running.delete(id);
+  liveRoutes.delete(id);
+}
+function isRunning(id) {
+  return running.has(id);
+}
+function getRunningIds() {
+  return [...running.keys()];
+}
+async function stopAll() {
+  await Promise.all([...running.keys()].map(stopMock));
+}
+exports.getRunningIds = getRunningIds;
+exports.isRunning = isRunning;
+exports.setHitCallback = setHitCallback;
+exports.startMock = startMock;
+exports.stopAll = stopAll;
+exports.stopMock = stopMock;
+exports.updateMockRoutes = updateMockRoutes;