bitfab 0.11.6 → 0.12.1

package/dist/index.cjs

@@ -35,7 +35,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.11.6";
+    __version__ = "0.12.1";
   }
 });
 
@@ -290,6 +290,42 @@ var init_http = __esm({
           clearTimeout(timeoutId);
         }
       }
+      /**
+       * Fetch the span tree for a root span.
+       * Blocking GET request.
+       */
+      async getSpanTree(externalSpanId) {
+        const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3e4);
+        try {
+          const response = await fetch(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new BitfabError(
+              `HTTP ${response.status}: ${errorText.slice(0, 500)}`
+            );
+          }
+          return await response.json();
+        } catch (error) {
+          if (error instanceof BitfabError) {
+            throw error;
+          }
+          if (error instanceof Error) {
+            if (error.name === "AbortError") {
+              throw new BitfabError("Request timed out after 30000ms");
+            }
+            throw new BitfabError(error.message);
+          }
+          throw new BitfabError("Unknown error occurred");
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
       /**
        * Mark a replay test run as completed.
        * Blocking call.
@@ -424,11 +460,37 @@ function deserializeOutput(spanData) {
   }
   return rawOutput;
 }
-async function processItem(httpClient, serverItem, fn, testRunId) {
+function buildMockTree(rootNode) {
+  const spans = /* @__PURE__ */ new Map();
+  const counters = /* @__PURE__ */ new Map();
+  function walk(node) {
+    const key = node.traceFunctionKey;
+    if (key) {
+      const index = counters.get(key) ?? 0;
+      counters.set(key, index + 1);
+      spans.set(`${key}:${index}`, {
+        sourceSpanId: node.sourceSpanId,
+        output: node.output,
+        outputMeta: node.outputMeta
+      });
+    }
+    for (const child of node.children) {
+      walk(child);
+    }
+  }
+  walk(rootNode);
+  return { spans };
+}
+async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy) {
   const span = await httpClient.getExternalSpan(serverItem.externalSpanId);
   const spanData = span.rawData?.span_data ?? {};
   const inputs = deserializeInputs(spanData);
   const originalOutput = deserializeOutput(spanData);
+  let mockTree;
+  if (mockStrategy === "all" || mockStrategy === "marked") {
+    const treeResponse = await httpClient.getSpanTree(serverItem.externalSpanId);
+    mockTree = buildMockTree(treeResponse.root);
+  }
   let result;
   let error = null;
   try {
@@ -436,7 +498,10 @@ async function processItem(httpClient, serverItem, fn, testRunId) {
       {
         testRunId,
         inputSourceSpanId: span.id,
-        inputSourceTraceId: span.externalTraceId
+        inputSourceTraceId: span.externalTraceId,
+        mockTree,
+        callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
+        mockStrategy
       },
       () => fn(...inputs)
     );
@@ -483,9 +548,10 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options) {
     options?.codeChangeDescription,
     options?.codeChangeFiles
   );
+  const mockStrategy = options?.mock ?? "none";
   const maxConcurrency = options?.maxConcurrency ?? 10;
   const tasks = serverItems.map(
-    (serverItem) => () => processItem(httpClient, serverItem, fn, testRunId)
+    (serverItem) => () => processItem(httpClient, serverItem, fn, testRunId, mockStrategy)
   );
   const resultItems = await mapWithConcurrency(tasks, maxConcurrency);
   await flushTraces();
@@ -2625,6 +2691,31 @@ var Bitfab = class {
         } catch {
         }
       };
+      const replayCtxForMock = getReplayContext();
+      if (replayCtxForMock?.mockTree && !isRootSpan) {
+        const counters = replayCtxForMock.callCounters;
+        const callIndex = counters.get(traceFunctionKey) ?? 0;
+        counters.set(traceFunctionKey, callIndex + 1);
+        const shouldMock = replayCtxForMock.mockStrategy === "all" || replayCtxForMock.mockStrategy === "marked" && options.mockOnReplay === true;
+        if (shouldMock) {
+          const mockKey = `${traceFunctionKey}:${callIndex}`;
+          const mockSpan = replayCtxForMock.mockTree.spans.get(mockKey);
+          if (mockSpan) {
+            let output = mockSpan.output;
+            if (mockSpan.outputMeta !== void 0 && mockSpan.outputMeta !== null) {
+              output = deserializeValue({
+                json: mockSpan.output,
+                meta: mockSpan.outputMeta
+              });
+            }
+            void sendSpan({ result: output });
+            if (fn.constructor.name === "AsyncFunction") {
+              return Promise.resolve(output);
+            }
+            return output;
+          }
+        }
+      }
       const executeWithContext = () => {
         const result = fn(...args);
         if (result instanceof Promise) {