@testsmith/api-spector 0.0.1

package/bin/cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict'
+
+const path = require('path')
+const { spawn } = require('child_process')
+const electron = require('electron')
+
+const [, , cmd = 'ui', ...rest] = process.argv
+
+function printHelp() {
+  console.log('')
+  console.log('  api Spector — local-first API testing tool')
+  console.log('')
+  console.log('  Usage:')
+  console.log('    api-spector ui                            Launch the app')
+  console.log('    api-spector run  --workspace <path>       Run tests from CLI')
+  console.log('    api-spector mock --workspace <path>       Start mock servers from CLI')
+  console.log('')
+  console.log('  Options:')
+  console.log('    api-spector run  --help                   Show run options')
+  console.log('    api-spector mock --help                   Show mock options')
+  console.log('')
+}
+
+if (cmd === '--help' || cmd === '-h') {
+  printHelp()
+  process.exit(0)
+} else if (cmd === 'ui') {
+  const appDir = path.join(__dirname, '..')
+  const proc = spawn(String(electron), [appDir], {
+    stdio: 'inherit',
+    env: process.env,
+  })
+  proc.on('close', code => process.exit(code ?? 0))
+} else if (cmd === 'run') {
+  const runnerPath = path.join(__dirname, '..', 'out', 'main', 'runner.js')
+  const proc = spawn(process.execPath, [runnerPath, ...rest], {
+    stdio: 'inherit',
+    env: process.env,
+  })
+  proc.on('close', code => process.exit(code ?? 0))
+} else if (cmd === 'mock') {
+  const mockPath = path.join(__dirname, '..', 'out', 'main', 'mock.js')
+  const proc = spawn(process.execPath, [mockPath, ...rest], {
+    stdio: 'inherit',
+    env: process.env,
+  })
+  proc.on('close', code => process.exit(code ?? 0))
+} else {
+  console.error(`api Spector — unknown command: "${cmd}"`)
+  printHelp()
+  process.exit(1)
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+const http = require("http");
+const crypto = require("crypto");
+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, "[^/]+");
+  const regex = new RegExp("^" + regexStr + "/?$");
+  return regex.test(urlPath.split("?")[0]);
+}
+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;
+}
+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();
+    const method = (req.method ?? "GET").toUpperCase();
+    const urlPath = req.url ?? "/";
+    if (urlPath === "/favicon.ico") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const routes = liveRoutes.get(server.id) ?? [];
+    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: server.id,
+        timestamp: reqStart,
+        method,
+        path: urlPath,
+        matchedRouteId: null,
+        status: 404,
+        durationMs: Date.now() - reqStart
+      });
+      return;
+    }
+    const respond = () => {
+      const headers = { "Content-Type": "application/json", ...route.headers };
+      res.writeHead(route.statusCode, headers);
+      res.end(route.body);
+      hitCallback?.({
+        id: crypto.randomUUID(),
+        serverId: server.id,
+        timestamp: reqStart,
+        method,
+        path: urlPath,
+        matchedRouteId: route.id,
+        status: route.statusCode,
+        durationMs: Date.now() - reqStart
+      });
+    };
+    if (route.delay && route.delay > 0) {
+      setTimeout(respond, route.delay);
+    } else {
+      respond();
+    }
+  });
+  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;

package/out/main/chunks/script-runner-Ci5t2-bo.js

@@ -0,0 +1,399 @@
+"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 promises = require("fs/promises");
+const path = require("path");
+const crypto = require("crypto");
+const vm = require("vm");
+const dayjs = require("dayjs");
+const tv4 = require("tv4");
+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 globals = {};
+let currentDir = null;
+function globalsPath(dir) {
+  return path.join(dir, "globals.json");
+}
+async function loadGlobals(workspaceDir) {
+  currentDir = workspaceDir;
+  try {
+    const raw = await promises.readFile(globalsPath(workspaceDir), "utf8");
+    globals = JSON.parse(raw);
+  } catch {
+    globals = {};
+  }
+  return { ...globals };
+}
+async function persistGlobals() {
+  if (!currentDir) return;
+  await promises.writeFile(globalsPath(currentDir), JSON.stringify(globals, null, 2), "utf8");
+}
+function getGlobals() {
+  return { ...globals };
+}
+function setGlobals(next) {
+  globals = { ...next };
+}
+function patchGlobals(patch) {
+  globals = { ...globals, ...patch };
+}
+const MASTER_KEY_ENV = "API_SPECTOR_MASTER_KEY";
+function registerSecretHandlers(ipc) {
+  ipc.handle("secret:checkMasterKey", () => {
+    return { set: Boolean(process.env[MASTER_KEY_ENV]) };
+  });
+  ipc.handle("secret:setMasterKey", (_e, value) => {
+    process.env[MASTER_KEY_ENV] = value;
+  });
+}
+function decryptSecret(encrypted, salt, iv, password) {
+  const saltBuf = Buffer.from(salt, "base64");
+  const ivBuf = Buffer.from(iv, "base64");
+  const encBuf = Buffer.from(encrypted, "base64");
+  const key = crypto.pbkdf2Sync(password, saltBuf, 1e5, 32, "sha256");
+  const authTag = encBuf.subarray(encBuf.length - 16);
+  const ciphertext = encBuf.subarray(0, encBuf.length - 16);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, ivBuf);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+}
+async function getSecret(ref) {
+  return process.env[ref] ?? null;
+}
+function interpolate(str, vars) {
+  return str.replace(/\{\{([^}]+)\}\}/g, (_, key) => vars[key.trim()] ?? `{{${key}}}`);
+}
+function buildUrl(baseUrl, params, vars) {
+  const url = interpolate(baseUrl, vars);
+  const enabled = params.filter((p) => p.enabled && p.key);
+  if (!enabled.length) return url;
+  const sep = url.includes("?") ? "&" : "?";
+  const qs = enabled.map((p) => `${encodeURIComponent(interpolate(p.key, vars))}=${encodeURIComponent(interpolate(p.value, vars))}`).join("&");
+  return url + sep + qs;
+}
+async function buildEnvVars(environment) {
+  const vars = {};
+  if (!environment) return vars;
+  const masterKey = process.env["API_SPECTOR_MASTER_KEY"];
+  for (const v of environment.variables) {
+    if (!v.enabled) continue;
+    if (v.envRef) {
+      const envValue = process.env[v.envRef];
+      if (envValue !== void 0) vars[v.key] = envValue;
+    } else if (v.secret && v.secretEncrypted && v.secretSalt && v.secretIv) {
+      if (masterKey) {
+        try {
+          vars[v.key] = decryptSecret(v.secretEncrypted, v.secretSalt, v.secretIv, masterKey);
+        } catch {
+        }
+      }
+    } else {
+      vars[v.key] = v.value;
+    }
+  }
+  return vars;
+}
+function mergeVars(envVars, collectionVars, globals2, localVars = {}) {
+  return { ...globals2, ...collectionVars, ...envVars, ...localVars };
+}
+let _fakerCache = null;
+async function getFaker() {
+  if (!_fakerCache) _fakerCache = await import("@faker-js/faker");
+  return _fakerCache.faker;
+}
+function makeAsserter(value, negated = false) {
+  function doAssert(condition, msg) {
+    const passed = negated ? !condition : condition;
+    if (!passed) throw new AssertionError(msg);
+  }
+  const asserter = {};
+  const chainer = { get: () => asserter };
+  for (const key of ["to", "be", "been", "have", "that", "and", "is", "deep"]) {
+    Object.defineProperty(asserter, key, chainer);
+  }
+  Object.defineProperty(asserter, "not", { get: () => makeAsserter(value, !negated) });
+  Object.defineProperty(asserter, "ok", { get: () => {
+    doAssert(Boolean(value), `Expected ${JSON.stringify(value)} to be truthy`);
+    return asserter;
+  } });
+  Object.defineProperty(asserter, "true", { get: () => {
+    doAssert(value === true, `Expected ${JSON.stringify(value)} to be true`);
+    return asserter;
+  } });
+  Object.defineProperty(asserter, "false", { get: () => {
+    doAssert(value === false, `Expected ${JSON.stringify(value)} to be false`);
+    return asserter;
+  } });
+  Object.defineProperty(asserter, "null", { get: () => {
+    doAssert(value === null, `Expected ${JSON.stringify(value)} to be null`);
+    return asserter;
+  } });
+  Object.defineProperty(asserter, "undefined", { get: () => {
+    doAssert(value === void 0, `Expected value to be undefined`);
+    return asserter;
+  } });
+  asserter.equal = (expected) => {
+    doAssert(
+      value === expected,
+      `Expected ${JSON.stringify(value)} to ${negated ? "not " : ""}equal ${JSON.stringify(expected)}`
+    );
+    return asserter;
+  };
+  asserter.eq = asserter.equal;
+  asserter.eql = (expected) => {
+    doAssert(
+      JSON.stringify(value) === JSON.stringify(expected),
+      `Expected deep equal: ${JSON.stringify(value)} ${negated ? "!=" : "=="} ${JSON.stringify(expected)}`
+    );
+    return asserter;
+  };
+  asserter.include = (substr) => {
+    if (typeof value === "string") {
+      doAssert(
+        value.includes(String(substr)),
+        `Expected "${value}" to ${negated ? "not " : ""}include "${substr}"`
+      );
+    } else if (Array.isArray(value)) {
+      doAssert(
+        value.includes(substr),
+        `Expected array to ${negated ? "not " : ""}include ${JSON.stringify(substr)}`
+      );
+    }
+    return asserter;
+  };
+  asserter.contain = asserter.include;
+  asserter.property = (name, expected) => {
+    doAssert(
+      value != null && name in Object(value),
+      `Expected object to ${negated ? "not " : ""}have property "${name}"`
+    );
+    if (expected !== void 0) {
+      doAssert(
+        value[name] === expected,
+        `Expected property "${name}" to equal ${JSON.stringify(expected)}`
+      );
+    }
+    return asserter;
+  };
+  asserter.a = (type) => {
+    const actual = Array.isArray(value) ? "array" : typeof value;
+    doAssert(
+      actual === type,
+      `Expected ${JSON.stringify(value)} to ${negated ? "not " : ""}be a ${type}`
+    );
+    return asserter;
+  };
+  asserter.above = (n) => {
+    doAssert(value > n, `Expected ${value} to ${negated ? "not " : ""}be above ${n}`);
+    return asserter;
+  };
+  asserter.below = (n) => {
+    doAssert(value < n, `Expected ${value} to ${negated ? "not " : ""}be below ${n}`);
+    return asserter;
+  };
+  asserter.least = (n) => {
+    doAssert(value >= n, `Expected ${value} to ${negated ? "not " : ""}be at least ${n}`);
+    return asserter;
+  };
+  asserter.most = (n) => {
+    doAssert(value <= n, `Expected ${value} to ${negated ? "not " : ""}be at most ${n}`);
+    return asserter;
+  };
+  asserter.gt = asserter.above;
+  asserter.gte = asserter.least;
+  asserter.lt = asserter.below;
+  asserter.lte = asserter.most;
+  return asserter;
+}
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+  }
+}
+function buildAt(ctx, testResults, consoleOutput) {
+  const { envVars, collectionVars, globals: globals2, localVars } = ctx;
+  function makeVarScope(store, scopeName) {
+    return {
+      get: (key) => store[key] ?? null,
+      set: (key, value) => {
+        store[key] = String(value);
+        consoleOutput.push(`[set] ${scopeName}.${key} = ${JSON.stringify(String(value))}`);
+      },
+      clear: (key) => {
+        delete store[key];
+        consoleOutput.push(`[set] ${scopeName}.${key} cleared`);
+      },
+      has: (key) => key in store,
+      toObject: () => ({ ...store })
+    };
+  }
+  const sp = {
+    // Variable scopes
+    variables: makeVarScope(localVars, "variables"),
+    environment: makeVarScope(envVars, "environment"),
+    collectionVariables: makeVarScope(collectionVars, "collectionVariables"),
+    globals: makeVarScope(globals2, "globals"),
+    // Convenience: get/set across all scopes (local wins)
+    variables_get: (key) => localVars[key] ?? envVars[key] ?? collectionVars[key] ?? globals2[key] ?? null,
+    variables_set: (key, value) => {
+      localVars[key] = String(value);
+    },
+    // Test runner
+    test: (name, fn) => {
+      try {
+        fn();
+        testResults.push({ name, passed: true });
+      } catch (err) {
+        testResults.push({
+          name,
+          passed: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
+    // Expect / assertions
+    expect: (value) => makeAsserter(value, false)
+  };
+  if (ctx.response) {
+    const resp = ctx.response;
+    let parsedJson = void 0;
+    sp.response = {
+      code: resp.status,
+      status: `${resp.status} ${resp.statusText}`,
+      statusText: resp.statusText,
+      responseTime: resp.durationMs,
+      responseSize: resp.bodySize,
+      headers: {
+        get: (name) => resp.headers[name.toLowerCase()] ?? null,
+        toObject: () => resp.headers
+      },
+      json: () => {
+        if (parsedJson === void 0) parsedJson = JSON.parse(resp.body);
+        return parsedJson;
+      },
+      text: () => resp.body,
+      to: {
+        have: {
+          status: (code) => {
+            if (resp.status !== code) throw new AssertionError(`Expected status ${resp.status} to be ${code}`);
+          }
+        }
+      }
+    };
+  }
+  return sp;
+}
+async function runScript(code, ctx, timeoutMs = 5e3) {
+  const faker = await getFaker();
+  const testResults = [];
+  const consoleOutput = [];
+  const envVarsCopy = { ...ctx.envVars };
+  const collectionCopy = { ...ctx.collectionVars };
+  const globalsCopy = { ...ctx.globals };
+  const localVarsCopy = { ...ctx.localVars };
+  const scriptCtx = {
+    envVars: envVarsCopy,
+    collectionVars: collectionCopy,
+    globals: globalsCopy,
+    localVars: localVarsCopy,
+    response: ctx.response
+  };
+  const sp = buildAt(scriptCtx, testResults, consoleOutput);
+  const captureConsole = {
+    log: (...args) => consoleOutput.push(args.map(String).join(" ")),
+    warn: (...args) => consoleOutput.push("[warn] " + args.map(String).join(" ")),
+    error: (...args) => consoleOutput.push("[error] " + args.map(String).join(" ")),
+    info: (...args) => consoleOutput.push("[info] " + args.map(String).join(" "))
+  };
+  const sandbox = {
+    sp,
+    dayjs,
+    faker,
+    tv4,
+    console: captureConsole,
+    JSON,
+    Math,
+    Date,
+    parseInt,
+    parseFloat,
+    isNaN,
+    isFinite,
+    encodeURIComponent,
+    decodeURIComponent,
+    btoa: (s) => Buffer.from(s, "binary").toString("base64"),
+    atob: (s) => Buffer.from(s, "base64").toString("binary"),
+    setTimeout: void 0,
+    // not available in sync vm context
+    setInterval: void 0
+  };
+  try {
+    vm__namespace.runInNewContext(code, sandbox, { timeout: timeoutMs, filename: "script.js" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      testResults,
+      consoleOutput,
+      updatedEnvVars: envVarsCopy,
+      updatedCollectionVars: collectionCopy,
+      updatedGlobals: globalsCopy,
+      updatedLocalVars: localVarsCopy,
+      error: message
+    };
+  }
+  return {
+    testResults,
+    consoleOutput,
+    updatedEnvVars: envVarsCopy,
+    updatedCollectionVars: collectionCopy,
+    updatedGlobals: globalsCopy,
+    updatedLocalVars: localVarsCopy
+  };
+}
+exports.buildEnvVars = buildEnvVars;
+exports.buildUrl = buildUrl;
+exports.getGlobals = getGlobals;
+exports.getSecret = getSecret;
+exports.interpolate = interpolate;
+exports.loadGlobals = loadGlobals;
+exports.mergeVars = mergeVars;
+exports.patchGlobals = patchGlobals;
+exports.persistGlobals = persistGlobals;
+exports.registerSecretHandlers = registerSecretHandlers;
+exports.runScript = runScript;
+exports.setGlobals = setGlobals;