@testsmith/api-spector 0.4.9 → 0.5.1

package/out/main/index.js

@@ -22,12 +22,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 const electron = require("electron");
-const handle = require("./chunks/handle-CF2LjTGV.js");
+const handle = require("./chunks/handle-b6bp3fb0.js");
 const path = require("path");
-const fs = require("fs");
+const fs$1 = require("fs");
 const promises = require("fs/promises");
 const crypto = require("crypto");
-const requestExec = require("./chunks/request-exec-DeXgxps8.js");
+const requestExec = require("./chunks/request-exec-D_xyyt3_.js");
 const ipcValidate = require("./chunks/ipc-validate-k6KI8adf.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
@@ -37,15 +37,18 @@ const requestCollection = require("./chunks/request-collection-CJoXpvOw.js");
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
 const http = require("http");
 const WebSocket = require("ws");
-const soapHandler = require("./chunks/soap-handler-pOrJ625E.js");
-const os = require("os");
-const snapshots = require("./chunks/snapshots-8wLrfQcq.js");
+const fs = require("node:fs");
+const os = require("node:os");
+const path$1 = require("node:path");
+const grpc = require("@grpc/grpc-js");
+const protoLoader = require("@grpc/proto-loader");
+const soapHandler = require("./chunks/soap-handler-BYkE6MyE.js");
+const promises$1 = require("node:fs/promises");
+const os$1 = require("os");
+const snapshots = require("./chunks/snapshots-BJiZNuRN.js");
 const simpleGit = require("simple-git");
 const recorder = require("./chunks/recorder-0Ij921El.js");
 require("tls");
-require("node:fs");
-require("node:os");
-require("node:path");
 require("node:crypto");
 require("dayjs");
 require("vm");
@@ -54,6 +57,27 @@ require("jsonpath-plus");
 require("@xmldom/xmldom");
 require("ajv");
 require("https");
+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 fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path$1);
+const grpc__namespace = /* @__PURE__ */ _interopNamespaceDefault(grpc);
+const protoLoader__namespace = /* @__PURE__ */ _interopNamespaceDefault(protoLoader);
 const LAST_WS_FILE = path.join(electron.app.getPath("userData"), "last-workspace.json");
 const RECENTS_FILE = path.join(electron.app.getPath("userData"), "recent-workspaces.json");
 const MAX_RECENTS = 10;
@@ -179,29 +203,29 @@ function readmeContents(workspaceFileName) {
   ].join("\n");
 }
 async function ensureReadme(workspaceDir2, workspaceFileName) {
-  const path$1 = path.join(workspaceDir2, "README.md");
+  const path$12 = path.join(workspaceDir2, "README.md");
   try {
-    await promises.readFile(path$1, "utf8");
+    await promises.readFile(path$12, "utf8");
     return;
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn("file-handler: could not check README.md", err);
       return;
     }
-    await atomicWrite(path$1, readmeContents(workspaceFileName));
+    await atomicWrite(path$12, readmeContents(workspaceFileName));
   }
 }
 async function ensureGitignore(workspaceDir2) {
-  const path$1 = path.join(workspaceDir2, ".gitignore");
+  const path$12 = path.join(workspaceDir2, ".gitignore");
   try {
-    await promises.readFile(path$1, "utf8");
+    await promises.readFile(path$12, "utf8");
     return;
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.warn("file-handler: could not check .gitignore", err);
       return;
     }
-    await atomicWrite(path$1, SPECTOR_GITIGNORE);
+    await atomicWrite(path$12, SPECTOR_GITIGNORE);
   }
 }
 async function ensureVscodeFileAssociation(workspaceDir2) {
@@ -4775,6 +4799,152 @@ function registerWsHandlers(ipc) {
     }
   });
 }
+const calls = /* @__PURE__ */ new Map();
+function closeAllGrpcConnections() {
+  for (const [, c] of calls) {
+    try {
+      c.cancel();
+    } catch {
+    }
+  }
+  calls.clear();
+}
+const LOADER_OPTS = {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+};
+function resolveProtoFile(src) {
+  const importPaths = (src.importPaths ?? []).filter(Boolean);
+  if (src.protoPath) {
+    return { file: src.protoPath, includeDirs: [path__namespace.dirname(src.protoPath), ...importPaths] };
+  }
+  if (src.protoSource && src.protoSource.trim()) {
+    const dir = fs__namespace.mkdtempSync(path__namespace.join(os__namespace.tmpdir(), "apispector-proto-"));
+    const file = path__namespace.join(dir, "main.proto");
+    fs__namespace.writeFileSync(file, src.protoSource, "utf8");
+    return { file, includeDirs: [dir, ...importPaths] };
+  }
+  throw new Error("No proto source: paste a .proto or provide a file path.");
+}
+function loadPackage(src) {
+  const { file, includeDirs } = resolveProtoFile(src);
+  return protoLoader__namespace.loadSync(file, { ...LOADER_OPTS, includeDirs });
+}
+function enumerateServices(pkgDef) {
+  const services = [];
+  for (const [name, def] of Object.entries(pkgDef)) {
+    const methods = Object.entries(def).filter(([, m]) => m && typeof m === "object" && "requestStream" in m).map(([mName, m]) => {
+      const md = m;
+      return { name: mName, requestStream: !!md.requestStream, responseStream: !!md.responseStream };
+    });
+    if (methods.length) services.push({ name, methods });
+  }
+  return services;
+}
+function resolveService(grpcObj, serviceName) {
+  let node = grpcObj;
+  for (const part of serviceName.split(".")) {
+    node = node?.[part];
+    if (!node) throw new Error(`Service "${serviceName}" not found in the proto.`);
+  }
+  if (typeof node !== "function") throw new Error(`"${serviceName}" is not a service.`);
+  return node;
+}
+function normalizeTarget(url) {
+  return url.replace(/^[a-z0-9+.-]+:\/\//i, "").replace(/\/+$/, "");
+}
+function registerGrpcHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.grpc.loadProto, async (_e, src) => {
+    return { services: enumerateServices(loadPackage(src)) };
+  });
+  handle.handleIpc(ipc, handle.IPC.grpc.invoke, async (event, requestId, opts) => {
+    calls.get(requestId)?.cancel();
+    calls.delete(requestId);
+    const sendStatus = (status, extra = {}) => event.sender.send(handle.IPC.grpc.status, { requestId, status, ...extra });
+    const sendMessage = (data) => {
+      const message = {
+        id: uuid.v4(),
+        direction: "received",
+        data: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+        timestamp: Date.now()
+      };
+      event.sender.send(handle.IPC.grpc.message, { requestId, message });
+    };
+    let pkgDef;
+    let ServiceCtor;
+    let request;
+    try {
+      pkgDef = loadPackage(opts);
+      const grpcObj = grpc__namespace.loadPackageDefinition(pkgDef);
+      ServiceCtor = resolveService(grpcObj, opts.serviceName);
+      request = opts.message.trim() ? JSON.parse(opts.message) : {};
+    } catch (err) {
+      sendStatus("error", { error: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+    const serviceDef = ServiceCtor.service;
+    const methodKey = Object.keys(serviceDef).find((k) => k === opts.methodName) ?? Object.keys(serviceDef).find((k) => k.toLowerCase() === opts.methodName.toLowerCase());
+    if (!methodKey) {
+      sendStatus("error", { error: `Method "${opts.methodName}" not found on ${opts.serviceName}.` });
+      return;
+    }
+    const def = serviceDef[methodKey];
+    if (def.requestStream) {
+      sendStatus("error", { error: "Client-streaming methods are not supported yet." });
+      return;
+    }
+    const creds = opts.plaintext ? grpc__namespace.credentials.createInsecure() : grpc__namespace.credentials.createSsl();
+    const client = new ServiceCtor(normalizeTarget(opts.target), creds);
+    const metadata = new grpc__namespace.Metadata();
+    for (const [k, v] of Object.entries(opts.metadata ?? {})) metadata.set(k, v);
+    const statusName = (code) => Object.keys(grpc__namespace.status).find((k) => grpc__namespace.status[k] === code) ?? String(code);
+    const cleanup = () => {
+      calls.delete(requestId);
+      try {
+        client.close();
+      } catch {
+      }
+    };
+    sendStatus("running");
+    try {
+      const method = client[methodKey].bind(client);
+      if (def.responseStream) {
+        const call = method(request, metadata);
+        calls.set(requestId, { cancel: () => call.cancel() });
+        call.on("data", (d) => sendMessage(d));
+        call.on("error", (e) => {
+          sendStatus("error", { code: e.code, codeName: e.code !== void 0 ? statusName(e.code) : void 0, error: e.details || e.message });
+          cleanup();
+        });
+        call.on("status", (s) => {
+          if (s.code === grpc__namespace.status.OK) sendStatus("completed", { code: s.code, codeName: statusName(s.code) });
+          cleanup();
+        });
+      } else {
+        const call = method(request, metadata, (err, response) => {
+          if (err) {
+            sendStatus("error", { code: err.code, codeName: err.code !== void 0 ? statusName(err.code) : void 0, error: err.details || err.message });
+          } else {
+            sendMessage(response);
+            sendStatus("completed", { code: grpc__namespace.status.OK, codeName: "OK" });
+          }
+          cleanup();
+        });
+        calls.set(requestId, { cancel: () => call.cancel() });
+      }
+    } catch (err) {
+      sendStatus("error", { error: err instanceof Error ? err.message : String(err) });
+      cleanup();
+    }
+  });
+  handle.handleIpc(ipc, handle.IPC.grpc.cancel, async (_e, requestId) => {
+    calls.get(requestId)?.cancel();
+    calls.delete(requestId);
+  });
+}
 function isJsonContentType(ct) {
   return !!ct && /\bjson\b/i.test(ct);
 }
@@ -5065,6 +5235,26 @@ function registerDocsHandlers(ipc) {
     return generateMarkdown(payload);
   });
 }
+function registerCoverageHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.coverage.loadSpec, async (_e, source) => {
+    if (source.text && source.text.trim()) {
+      const t = source.text.trim();
+      return t.startsWith("{") ? JSON.parse(t) : jsYaml.load(t);
+    }
+    if (source.url) {
+      const resp = await undici.fetch(source.url);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status} fetching ${source.url}`);
+      const raw = await resp.text();
+      const ct = resp.headers.get("content-type") ?? "";
+      return ct.includes("yaml") || /\.ya?ml$/i.test(source.url) ? jsYaml.load(raw) : JSON.parse(raw);
+    }
+    if (source.path) {
+      const raw = await promises$1.readFile(source.path, "utf8");
+      return /\.ya?ml$/i.test(source.path) ? jsYaml.load(raw) : JSON.parse(raw);
+    }
+    throw new Error("No spec source: provide a file path, URL, or pasted text.");
+  });
+}
 function inferSchema(data) {
   if (data === null || data === void 0) return { type: "null" };
   if (typeof data === "boolean") return { type: "boolean" };
@@ -5101,7 +5291,7 @@ async function resolveSnapshotSpec(relPath) {
   const dir = getWorkspaceDir();
   if (!dir) throw new Error("No workspace open - cannot resolve snapshot.");
   const snap = await snapshots.loadSnapshot(dir, relPath);
-  const tmp = path.join(os.tmpdir(), `api-spector-${crypto.randomUUID()}.${snap.format === "yaml" ? "yaml" : "json"}`);
+  const tmp = path.join(os$1.tmpdir(), `api-spector-${crypto.randomUUID()}.${snap.format === "yaml" ? "yaml" : "json"}`);
   await promises.writeFile(tmp, snap.spec, "utf8");
   return { specPath: tmp };
 }
@@ -5602,7 +5792,7 @@ function isNewer(a, b) {
   return a2 > b2;
 }
 async function checkForUpdate() {
-  const current = "0.4.9";
+  const current = "0.5.1";
   try {
     const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(4e3) });
     if (!res.ok) return null;
@@ -5647,15 +5837,15 @@ function loadAppIcon() {
     path.join(__dirname, "../../build/icon.png")
   ];
   for (const p of pngCandidates) {
-    if (fs.existsSync(p)) return electron.nativeImage.createFromPath(p);
+    if (fs$1.existsSync(p)) return electron.nativeImage.createFromPath(p);
   }
   const svgCandidates = [
     path.join(electron.app.getAppPath(), "resources/icon.svg"),
     path.join(__dirname, "../../resources/icon.svg")
   ];
   for (const p of svgCandidates) {
-    if (fs.existsSync(p)) {
-      const dataUrl = "data:image/svg+xml;base64," + fs.readFileSync(p).toString("base64");
+    if (fs$1.existsSync(p)) {
+      const dataUrl = "data:image/svg+xml;base64," + fs$1.readFileSync(p).toString("base64");
       return electron.nativeImage.createFromDataURL(dataUrl);
     }
   }
@@ -5718,8 +5908,10 @@ electron.app.whenReady().then(async () => {
   registerOAuth2Handlers(electron.ipcMain);
   registerVaultHandlers(electron.ipcMain);
   registerWsHandlers(electron.ipcMain);
+  registerGrpcHandlers(electron.ipcMain);
   soapHandler.registerSoapHandlers(electron.ipcMain);
   registerDocsHandlers(electron.ipcMain);
+  registerCoverageHandlers(electron.ipcMain);
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);
   registerRecordHandlers(electron.ipcMain, () => electron.BrowserWindow.getAllWindows()[0]?.webContents ?? null);
@@ -5736,5 +5928,6 @@ electron.app.on("window-all-closed", () => {
 });
 electron.app.on("before-quit", async () => {
   closeAllWsConnections();
+  closeAllGrpcConnections();
   await mockServer.stopAll();
 });

package/out/main/lib.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
-const requestExec = require("./chunks/request-exec-DeXgxps8.js");
+const requestExec = require("./chunks/request-exec-D_xyyt3_.js");
 require("http");
 require("crypto");
 require("vm");
@@ -10,7 +10,7 @@ require("@xmldom/xmldom");
 require("undici");
 require("fs/promises");
 require("tls");
-require("./chunks/handle-CF2LjTGV.js");
+require("./chunks/handle-b6bp3fb0.js");
 require("node:fs");
 require("node:os");
 require("node:path");

package/out/main/runner.js

@@ -2,13 +2,13 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
-const requestExec = require("./chunks/request-exec-DeXgxps8.js");
+const requestExec = require("./chunks/request-exec-D_xyyt3_.js");
 const requestCollection = require("./chunks/request-collection-CJoXpvOw.js");
 const environments = require("./chunks/environments-iM3SUM-4.js");
 const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
 require("undici");
 require("tls");
-require("./chunks/handle-CF2LjTGV.js");
+require("./chunks/handle-b6bp3fb0.js");
 require("node:fs");
 require("node:os");
 require("node:path");
@@ -402,7 +402,7 @@ async function main() {
   } else if (!envName && workspace.settings?.defaultEnvironment && !env) {
     console.warn(cliCommon.color(`Warning: default environment "${workspace.settings.defaultEnvironment}" not found. Running without environment.`, cliCommon.C.yellow));
   }
-  const version = `v${"0.4.9"}`;
+  const version = `v${"0.5.1"}`;
   console.log("");
   console.log(cliCommon.color("  API Test Runner" + (version ? ` ${version}` : ""), cliCommon.C.bold, cliCommon.C.white));
   console.log(cliCommon.color(`  Workspace:   ${wsPath}`, cliCommon.C.gray));

package/out/main/wsdl.js

@@ -4,10 +4,10 @@ const promises = require("fs/promises");
 const path = require("path");
 const https = require("https");
 const http = require("http");
-const soapHandler = require("./chunks/soap-handler-pOrJ625E.js");
-const _import = require("./chunks/import-ChCkdHOB.js");
+const soapHandler = require("./chunks/soap-handler-BYkE6MyE.js");
+const _import = require("./chunks/import-BeY7gjWL.js");
 const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
-require("./chunks/handle-CF2LjTGV.js");
+require("./chunks/handle-b6bp3fb0.js");
 require("@xmldom/xmldom");
 require("uuid");
 require("crypto");

package/out/preload/index.js

@@ -105,10 +105,28 @@ const IPC = {
     fetch: "wsdl:fetch",
     import: "wsdl:import"
   },
+  // ─── gRPC ──────────────────────────────────────────────────────────────────
+  grpc: {
+    /** Load a .proto (source or path) and enumerate its services/methods. */
+    loadProto: "grpc:loadProto",
+    /** Invoke a method (unary or server-streaming). Streams back messages. */
+    invoke: "grpc:invoke",
+    /** Cancel an in-flight call. */
+    cancel: "grpc:cancel",
+    /** Event: a received message frame. */
+    message: "grpc:message",
+    /** Event: call status change (running / completed / error, with code). */
+    status: "grpc:status"
+  },
   // ─── Docs generation ───────────────────────────────────────────────────────
   docs: {
     generate: "docs:generate"
   },
+  // ─── OpenAPI coverage ────────────────────────────────────────────────────────
+  coverage: {
+    /** Read + parse an OpenAPI spec (file path, URL, or raw text). */
+    loadSpec: "coverage:loadSpec"
+  },
   // ─── Contract testing ──────────────────────────────────────────────────────
   contract: {
     run: "contract:run",
@@ -288,6 +306,20 @@ const api = {
     electron.ipcRenderer.removeAllListeners(IPC.ws.message);
     electron.ipcRenderer.removeAllListeners(IPC.ws.status);
   },
+  // ─── gRPC ─────────────────────────────────────────────────────────────────
+  grpcLoadProto: (src) => electron.ipcRenderer.invoke(IPC.grpc.loadProto, src),
+  grpcInvoke: (requestId, opts) => electron.ipcRenderer.invoke(IPC.grpc.invoke, requestId, opts),
+  grpcCancel: (requestId) => electron.ipcRenderer.invoke(IPC.grpc.cancel, requestId),
+  onGrpcMessage: (cb) => {
+    electron.ipcRenderer.on(IPC.grpc.message, (_e, payload) => cb(payload));
+  },
+  onGrpcStatus: (cb) => {
+    electron.ipcRenderer.on(IPC.grpc.status, (_e, payload) => cb(payload));
+  },
+  offGrpcEvents: () => {
+    electron.ipcRenderer.removeAllListeners(IPC.grpc.message);
+    electron.ipcRenderer.removeAllListeners(IPC.grpc.status);
+  },
   // ─── Streamed responses (SSE / NDJSON / chunked) ──────────────────────────
   onRequestStreamEvent: (cb) => {
     electron.ipcRenderer.on(IPC.request.streamEvent, (_e, payload) => cb(payload));
@@ -304,6 +336,8 @@ const api = {
   wsdlImport: (opts) => electron.ipcRenderer.invoke(IPC.wsdl.import, opts),
   // ─── Docs generation ──────────────────────────────────────────────────────
   generateDocs: (payload) => electron.ipcRenderer.invoke(IPC.docs.generate, payload),
+  // ─── OpenAPI coverage ─────────────────────────────────────────────────────
+  coverageLoadSpec: (source) => electron.ipcRenderer.invoke(IPC.coverage.loadSpec, source),
   // ─── Contract testing ─────────────────────────────────────────────────────
   runContracts: (payload) => electron.ipcRenderer.invoke(IPC.contract.run, payload),
   inferContractSchema: (jsonBody) => electron.ipcRenderer.invoke(IPC.contract.inferSchema, jsonBody),