bruno-lifecycle-adapter 0.1.0

package/dist/index.js

@@ -0,0 +1,668 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BruFileScanner: () => BruFileScanner,
+  BrunoJsonReportParser: () => BrunoJsonReportParser,
+  BrunoLifecycleAdapter: () => BrunoLifecycleAdapter,
+  TypedEventBus: () => TypedEventBus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/application/BrunoLifecycleAdapter.ts
+var import_node_child_process = require("child_process");
+var import_node_path2 = require("path");
+
+// src/infrastructure/BrunoJsonReportParser.ts
+var import_promises = require("fs/promises");
+
+// src/shared/utils.ts
+var import_node_crypto = require("crypto");
+function generateRunId() {
+  return (0, import_node_crypto.randomUUID)();
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function elapsedMs(startedAt) {
+  return Date.now() - new Date(startedAt).getTime();
+}
+
+// src/infrastructure/BrunoJsonReportParser.ts
+var BrunoJsonReportParser = class {
+  async parse(reportPath) {
+    const raw = await this.readRaw(reportPath);
+    return this.mapToSummary(raw);
+  }
+  async readRaw(reportPath) {
+    let content;
+    try {
+      content = await (0, import_promises.readFile)(reportPath, "utf-8");
+    } catch (err) {
+      throw new Error(
+        `BrunoJsonReportParser: cannot read report at "${reportPath}": ${String(err)}`,
+        { cause: err }
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (err) {
+      throw new Error(
+        `BrunoJsonReportParser: invalid JSON in report at "${reportPath}": ${String(err)}`,
+        { cause: err }
+      );
+    }
+    if (Array.isArray(parsed)) {
+      return parsed;
+    }
+    if (parsed !== null && typeof parsed === "object") {
+      const obj = parsed;
+      const results = Array.isArray(obj.results) ? obj.results : [];
+      const summary = obj.summary !== null && typeof obj.summary === "object" ? obj.summary : void 0;
+      const iteration = {
+        iterationIndex: typeof obj.iterationIndex === "number" ? obj.iterationIndex : 0,
+        results,
+        ...summary !== void 0 ? { summary } : {}
+      };
+      return [iteration];
+    }
+    return [];
+  }
+  mapToSummary(raw) {
+    const requests = raw.flatMap((iter) => (iter.results ?? []).map((r) => this.mapRequest(r)));
+    const summary = raw[0]?.summary ?? {};
+    const totalRequests = summary.totalRequests ?? requests.length;
+    const passedRequests = summary.passedRequests ?? requests.filter((r) => r.status === "finished").length;
+    const failedRequests = summary.failedRequests ?? requests.filter((r) => r.status === "failed").length;
+    const skippedRequests = summary.skippedRequests ?? requests.filter((r) => r.status === "skipped").length;
+    const allTests = requests.flatMap((r) => r.tests);
+    const totalTests = summary.totalTests ?? allTests.length;
+    const passedTests = summary.passedTests ?? allTests.filter((t) => t.status === "passed").length;
+    const failedTests = summary.failedTests ?? allTests.filter((t) => t.status === "failed").length;
+    const allAssertions = requests.flatMap((r) => r.assertions);
+    const totalAssertions = summary.totalAssertions ?? allAssertions.length;
+    const passedAssertions = summary.passedAssertions ?? allAssertions.filter((a) => a.passed).length;
+    const failedAssertions = summary.failedAssertions ?? allAssertions.filter((a) => !a.passed).length;
+    const now = nowIso();
+    return {
+      runId: "",
+      collectionPath: "",
+      startedAt: now,
+      finishedAt: now,
+      durationMs: 0,
+      exitCode: 0,
+      status: failedRequests > 0 ? "failed" : "finished",
+      totalRequests,
+      passedRequests,
+      failedRequests,
+      skippedRequests,
+      totalTests,
+      passedTests,
+      failedTests,
+      totalAssertions,
+      passedAssertions,
+      failedAssertions,
+      requests
+    };
+  }
+  mapRequest(raw) {
+    const tests = (raw.testResults ?? []).map((t) => this.mapTest(t));
+    const assertions = (raw.assertionResults ?? []).map((a) => this.mapAssertion(a));
+    const responseStatus = typeof raw.response?.status === "number" ? raw.response.status : void 0;
+    return {
+      requestName: raw.name ?? raw.test?.filename ?? "unknown",
+      requestFile: raw.test?.filename ?? "",
+      status: this.mapRequestStatus(raw.status),
+      ...responseStatus !== void 0 ? { responseStatus } : {},
+      ...raw.response?.responseTime !== void 0 ? { durationMs: raw.response.responseTime } : {},
+      ...raw.error ? { error: this.makeError(String(raw.error)) } : {},
+      tests,
+      assertions
+    };
+  }
+  mapTest(raw) {
+    return {
+      testName: raw.description ?? "unknown",
+      status: this.mapTestStatus(raw.status),
+      ...raw.error ? { error: this.makeError(String(raw.error)) } : {}
+    };
+  }
+  mapAssertion(raw) {
+    const passed = raw.status === "pass" || raw.status === "passed";
+    const assertion = raw.lhsExpr !== void 0 && raw.rhsExpr !== void 0 ? `${raw.lhsExpr} ${raw.rhsExpr}` : "unknown";
+    return {
+      assertion,
+      passed,
+      ...raw.error ? { error: this.makeError(String(raw.error)) } : {}
+    };
+  }
+  mapRequestStatus(status) {
+    switch (status?.toLowerCase()) {
+      case "pass":
+      case "passed":
+      case "success":
+        return "finished";
+      case "fail":
+      case "failed":
+      case "error":
+        return "failed";
+      case "skip":
+      case "skipped":
+        return "skipped";
+      default:
+        return "finished";
+    }
+  }
+  mapTestStatus(status) {
+    switch (status?.toLowerCase()) {
+      case "pass":
+      case "passed":
+        return "passed";
+      case "fail":
+      case "failed":
+        return "failed";
+      case "skip":
+      case "skipped":
+        return "skipped";
+      default:
+        return "failed";
+    }
+  }
+  makeError(message) {
+    return { message };
+  }
+};
+
+// src/infrastructure/BruFileScanner.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+var BruFileScanner = class {
+  /**
+   * Returns all HTTP request files found under `rootDir`.
+   *
+   * @param rootDir  Absolute path to the collection root (the directory
+   *                 passed to `bru run`).
+   * @param recursive  When `true`, descends into sub-directories. Mirrors
+   *                   the `-r` flag behaviour of `bru run`.
+   */
+  async scan(rootDir, recursive) {
+    const found = await this.collectBruFiles(rootDir, rootDir, recursive);
+    found.sort((a, b) => a.requestFile.localeCompare(b.requestFile));
+    return found;
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async collectBruFiles(rootDir, dir, recursive) {
+    let entries;
+    try {
+      entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "environments") continue;
+        if (recursive) {
+          const nested = await this.collectBruFiles(rootDir, fullPath, true);
+          results.push(...nested);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".bru")) {
+        const discovered = await this.parseRequestFile(rootDir, fullPath);
+        if (discovered !== null) {
+          results.push(discovered);
+        }
+      }
+    }
+    return results;
+  }
+  async parseRequestFile(rootDir, filePath) {
+    let content;
+    try {
+      content = await (0, import_promises2.readFile)(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+    const meta = this.parseMetaBlock(content);
+    if (!meta.type || meta.type !== "http") {
+      return null;
+    }
+    const requestName = meta.name ?? this.nameFromPath(filePath);
+    const requestFile = (0, import_node_path.relative)(rootDir, filePath).replace(/\\/g, "/");
+    return { requestName, requestFile };
+  }
+  parseMetaBlock(content) {
+    const metaMatch = content.match(/meta\s*\{([^}]*)\}/s);
+    if (!metaMatch) return { name: void 0, type: void 0 };
+    const block = metaMatch[1];
+    const nameMatch = block.match(/\bname:\s*([^\n]+)/);
+    const typeMatch = block.match(/\btype:\s*([^\n]+)/);
+    return {
+      name: nameMatch?.[1]?.trim(),
+      type: typeMatch?.[1]?.trim()
+    };
+  }
+  nameFromPath(filePath) {
+    const parts = filePath.replace(/\\/g, "/").split("/");
+    return parts.at(-1)?.replace(/\.bru$/, "") ?? "unknown";
+  }
+};
+
+// src/infrastructure/TypedEventBus.ts
+var TypedEventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    this.getOrCreate(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  once(event, handler) {
+    const wrapper = (payload) => {
+      this.off(event, wrapper);
+      handler(payload);
+    };
+    return this.on(event, wrapper);
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  emit(event, payload) {
+    const set = this.handlers.get(event);
+    if (!set) return;
+    for (const handler of set) {
+      handler(payload);
+    }
+  }
+  removeAllListeners(event) {
+    if (event !== void 0) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+  getOrCreate(event) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    return set;
+  }
+};
+
+// src/application/BrunoLifecycleAdapter.ts
+var BrunoLifecycleAdapter = class {
+  bus = new TypedEventBus();
+  parser;
+  scanner;
+  constructor(parser, scanner) {
+    this.parser = parser ?? new BrunoJsonReportParser();
+    this.scanner = scanner ?? new BruFileScanner();
+  }
+  on(event, handler) {
+    return this.bus.on(event, handler);
+  }
+  once(event, handler) {
+    return this.bus.once(event, handler);
+  }
+  off(event, handler) {
+    this.bus.off(event, handler);
+  }
+  async run(config) {
+    const runId = generateRunId();
+    const startedAt = nowIso();
+    this.emit("run:starting", {
+      event: "run:starting",
+      runId,
+      timestamp: startedAt,
+      reliability: "native",
+      cwd: config.cwd,
+      collectionPath: config.collectionPath
+    });
+    const resolvedCollection = (0, import_node_path2.resolve)(config.cwd, config.collectionPath);
+    const collectionRoot = resolvedCollection.endsWith(".bru") ? (0, import_node_path2.dirname)(resolvedCollection) : resolvedCollection;
+    const discoveryPromise = this.scanner.scan(collectionRoot, config.recursive ?? false).catch(() => []);
+    const args = this.buildArgs(config);
+    const bin = config.bruBin ?? "bru";
+    return new Promise((resolveRun, rejectRun) => {
+      let timedOut = false;
+      let timeoutHandle;
+      const child = (0, import_node_child_process.spawn)(bin, args, {
+        cwd: config.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false
+      });
+      if (child.pid === void 0) {
+        const err = new Error(`Failed to spawn "${bin}". Is Bruno CLI installed?`);
+        const finishedAt = nowIso();
+        const durationMs = elapsedMs(startedAt);
+        const detail = { message: err.message };
+        const summary = this.buildEmptySummary({
+          runId,
+          collectionPath: config.collectionPath,
+          startedAt,
+          finishedAt,
+          durationMs,
+          exitCode: -1,
+          status: "failed",
+          error: detail
+        });
+        this.emit("run:failed", {
+          event: "run:failed",
+          runId,
+          timestamp: finishedAt,
+          reliability: "native",
+          exitCode: -1,
+          durationMs,
+          error: detail,
+          summary
+        });
+        rejectRun(err);
+        return;
+      }
+      this.emit("run:started", {
+        event: "run:started",
+        runId,
+        timestamp: nowIso(),
+        reliability: "native",
+        cwd: config.cwd,
+        collectionPath: config.collectionPath,
+        pid: child.pid
+      });
+      if (config.timeoutMs && config.timeoutMs > 0) {
+        timeoutHandle = setTimeout(() => {
+          timedOut = true;
+          child.kill("SIGTERM");
+        }, config.timeoutMs);
+      }
+      child.stdout.setEncoding("utf-8");
+      child.stderr.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        this.emit("stdout", {
+          event: "stdout",
+          runId,
+          timestamp: nowIso(),
+          reliability: "native",
+          chunk
+        });
+      });
+      child.stderr.on("data", (chunk) => {
+        this.emit("stderr", {
+          event: "stderr",
+          runId,
+          timestamp: nowIso(),
+          reliability: "native",
+          chunk
+        });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeoutHandle);
+        const detail = { message: err.message, stack: err.stack };
+        const finishedAt = nowIso();
+        const durationMs = elapsedMs(startedAt);
+        const summary = this.buildEmptySummary({
+          runId,
+          collectionPath: config.collectionPath,
+          startedAt,
+          finishedAt,
+          durationMs,
+          exitCode: -1,
+          status: "failed",
+          error: detail
+        });
+        this.emit("run:failed", {
+          event: "run:failed",
+          runId,
+          timestamp: finishedAt,
+          reliability: "native",
+          exitCode: -1,
+          durationMs,
+          error: detail,
+          summary
+        });
+        rejectRun(err);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeoutHandle);
+        void (async () => {
+          const exitCode = code ?? -1;
+          const finishedAt = nowIso();
+          const durationMs = elapsedMs(startedAt);
+          const runStatus = timedOut || exitCode !== 0 ? "failed" : "finished";
+          const discovered = await discoveryPromise;
+          for (const req of discovered) {
+            this.emit("request:discovered", {
+              event: "request:discovered",
+              runId,
+              timestamp: finishedAt,
+              reliability: "inferred",
+              requestName: req.requestName,
+              requestFile: req.requestFile
+            });
+          }
+          let summary;
+          let reportParsedSuccessfully = false;
+          if (config.reporterJsonPath) {
+            try {
+              summary = await this.parser.parse(config.reporterJsonPath);
+              reportParsedSuccessfully = true;
+            } catch {
+              summary = this.buildEmptySummary({
+                runId,
+                collectionPath: config.collectionPath,
+                startedAt,
+                finishedAt,
+                durationMs,
+                exitCode,
+                status: runStatus
+              });
+            }
+          } else {
+            summary = this.buildEmptySummary({
+              runId,
+              collectionPath: config.collectionPath,
+              startedAt,
+              finishedAt,
+              durationMs,
+              exitCode,
+              status: runStatus
+            });
+          }
+          const enriched = {
+            ...summary,
+            runId,
+            collectionPath: config.collectionPath,
+            startedAt,
+            finishedAt,
+            durationMs,
+            exitCode,
+            status: runStatus
+          };
+          this.emitReportEvents(enriched, runId, finishedAt);
+          if (config.reporterJsonPath && reportParsedSuccessfully) {
+            this.emit("report:json:ready", {
+              event: "report:json:ready",
+              runId,
+              timestamp: finishedAt,
+              reliability: "derived",
+              path: config.reporterJsonPath,
+              summary: enriched
+            });
+          }
+          if (runStatus === "finished") {
+            this.emit("run:finished", {
+              event: "run:finished",
+              runId,
+              timestamp: finishedAt,
+              reliability: "native",
+              exitCode,
+              durationMs,
+              summary: enriched
+            });
+          } else {
+            const error = timedOut ? { message: `Run timed out after ${config.timeoutMs ?? 0}ms` } : { message: `Run exited with code ${exitCode}` };
+            this.emit("run:failed", {
+              event: "run:failed",
+              runId,
+              timestamp: finishedAt,
+              reliability: "native",
+              exitCode,
+              durationMs,
+              error,
+              summary: enriched
+            });
+          }
+          resolveRun(enriched);
+        })().catch((err) => {
+          rejectRun(err instanceof Error ? err : new Error(String(err)));
+        });
+      });
+    });
+  }
+  emitReportEvents(summary, runId, timestamp) {
+    for (const req of summary.requests) {
+      const reqStarted = {
+        event: "request:started",
+        runId,
+        timestamp,
+        reliability: "derived",
+        requestName: req.requestName,
+        requestFile: req.requestFile
+      };
+      this.emit("request:started", reqStarted);
+      if (req.status === "skipped") {
+        const skipped = {
+          event: "request:skipped",
+          runId,
+          timestamp,
+          reliability: "derived",
+          requestName: req.requestName,
+          requestFile: req.requestFile
+        };
+        this.emit("request:skipped", skipped);
+      } else {
+        const finished = {
+          event: "request:finished",
+          runId,
+          timestamp,
+          reliability: "derived",
+          requestName: req.requestName,
+          requestFile: req.requestFile,
+          status: req.status,
+          ...req.responseStatus !== void 0 ? { responseStatus: req.responseStatus } : {},
+          ...req.durationMs !== void 0 ? { durationMs: req.durationMs } : {},
+          ...req.error !== void 0 ? { error: req.error } : {}
+        };
+        this.emit("request:finished", finished);
+      }
+      for (const test of req.tests) {
+        const testStarted = {
+          event: "test:started",
+          runId,
+          timestamp,
+          reliability: "derived",
+          requestName: req.requestName,
+          testName: test.testName
+        };
+        this.emit("test:started", testStarted);
+        const testFinished = {
+          event: "test:finished",
+          runId,
+          timestamp,
+          reliability: "derived",
+          requestName: req.requestName,
+          testName: test.testName,
+          status: test.status,
+          ...test.error !== void 0 ? { error: test.error } : {}
+        };
+        this.emit("test:finished", testFinished);
+      }
+      for (const a of req.assertions) {
+        const assertionResult = {
+          event: "assertion:result",
+          runId,
+          timestamp,
+          reliability: "derived",
+          requestName: req.requestName,
+          assertion: a.assertion,
+          passed: a.passed,
+          ...a.actual !== void 0 ? { actual: a.actual } : {},
+          ...a.expected !== void 0 ? { expected: a.expected } : {},
+          ...a.error !== void 0 ? { error: a.error } : {}
+        };
+        this.emit("assertion:result", assertionResult);
+      }
+    }
+  }
+  buildArgs(config) {
+    const args = ["run", config.collectionPath];
+    if (config.recursive) {
+      args.push("-r");
+    }
+    if (config.env) {
+      args.push("--env", config.env);
+    }
+    if (config.reporterJsonPath) {
+      args.push("--reporter-json", config.reporterJsonPath);
+    }
+    if (config.extraArgs) {
+      args.push(...config.extraArgs);
+    }
+    return args;
+  }
+  buildEmptySummary(opts) {
+    const requests = opts.requests ?? [];
+    return {
+      runId: opts.runId,
+      collectionPath: opts.collectionPath,
+      startedAt: opts.startedAt,
+      finishedAt: opts.finishedAt,
+      durationMs: opts.durationMs,
+      exitCode: opts.exitCode,
+      status: opts.status,
+      totalRequests: requests.length,
+      passedRequests: requests.filter((r) => r.status === "finished").length,
+      failedRequests: requests.filter((r) => r.status === "failed").length,
+      skippedRequests: requests.filter((r) => r.status === "skipped").length,
+      totalTests: 0,
+      passedTests: 0,
+      failedTests: 0,
+      totalAssertions: 0,
+      passedAssertions: 0,
+      failedAssertions: 0,
+      requests,
+      ...opts.error !== void 0 ? { error: opts.error } : {}
+    };
+  }
+  emit(event, payload) {
+    this.bus.emit(event, payload);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BruFileScanner,
+  BrunoJsonReportParser,
+  BrunoLifecycleAdapter,
+  TypedEventBus
+});
+//# sourceMappingURL=index.js.map