bitfab 0.11.5 → 0.12.0

package/dist/index.cjs

@@ -35,7 +35,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.11.5";
+    __version__ = "0.12.0";
   }
 });
 
@@ -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,16 +460,51 @@ 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);
+    }
+  }
+  for (const child of rootNode.children) {
+    walk(child);
+  }
+  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 {
     const maybePromise = runWithReplayContext(
-      { testRunId, inputSourceSpanId: span.id },
+      {
+        testRunId,
+        inputSourceSpanId: span.id,
+        inputSourceTraceId: span.externalTraceId,
+        mockTree,
+        callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
+        mockStrategy
+      },
       () => fn(...inputs)
     );
     result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
@@ -479,9 +550,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();
@@ -2555,6 +2627,9 @@ var Bitfab = class {
           contexts: [],
           ...replayCtxAtRoot?.testRunId && {
             testRunId: replayCtxAtRoot.testRunId
+          },
+          ...replayCtxAtRoot?.inputSourceTraceId && {
+            inputSourceTraceId: replayCtxAtRoot.inputSourceTraceId
           }
         });
         pendingSpanPromises.set(traceId, []);
@@ -2603,7 +2678,8 @@ var Bitfab = class {
               sessionId: traceState?.sessionId,
               metadata: traceState?.metadata,
               contexts: traceState?.contexts ?? [],
-              testRunId: traceState?.testRunId
+              testRunId: traceState?.testRunId,
+              inputSourceTraceId: traceState?.inputSourceTraceId
             });
             activeTraceStates.delete(traceId);
           } else {
@@ -2617,6 +2693,28 @@ 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 });
+            return output;
+          }
+        }
+      }
       const executeWithContext = () => {
         const result = fn(...args);
         if (result instanceof Promise) {
@@ -2680,6 +2778,9 @@ var Bitfab = class {
     if (params.contexts && params.contexts.length > 0) {
       rawTrace.contexts = params.contexts;
     }
+    if (params.inputSourceTraceId) {
+      rawTrace.input_source_trace_id = params.inputSourceTraceId;
+    }
     this.httpClient.sendExternalTrace({
       type: "sdk-function",
       source: "typescript-sdk-function",