@grafana/scenes 8.10.2 → 8.11.0

package/dist/index.js

@@ -3363,24 +3363,53 @@ function isExtraQueryProvider(obj) {
 }
 
 const passthroughProcessor = (_, secondary) => rxjs.of(secondary);
-const extraQueryProcessingOperator = (processors) => (data) => {
+function combineLoadingStates(responseState) {
+  var _a;
+  if (responseState.some((s) => s === data.LoadingState.Error)) {
+    return data.LoadingState.Error;
+  }
+  if (responseState.some((s) => s === data.LoadingState.Loading)) {
+    return data.LoadingState.Loading;
+  }
+  if (responseState.some((s) => s === data.LoadingState.Streaming)) {
+    return data.LoadingState.Streaming;
+  }
+  return (_a = responseState[0]) != null ? _a : data.LoadingState.Done;
+}
+const extraQueryProcessingOperator = (panelDataProcessors) => (data) => {
+  const processedCache = /* @__PURE__ */ new WeakMap();
   return data.pipe(
-    rxjs.mergeMap(([primary, ...secondaries]) => {
-      const processedSecondaries = secondaries.flatMap((s) => {
+    rxjs.mergeMap(([primaryResponse, ...secondaryResponses]) => {
+      const processedSecondaries = secondaryResponses.map((s) => {
         var _a, _b;
-        return (_b = (_a = processors.get(s.request.requestId)) == null ? void 0 : _a(primary, s)) != null ? _b : rxjs.of(s);
+        const cached = processedCache.get(s);
+        if (cached) {
+          return rxjs.of(cached);
+        }
+        const processedPanelData = (_b = (_a = panelDataProcessors.get(s.request.requestId)) == null ? void 0 : _a(primaryResponse, s)) != null ? _b : rxjs.of(s);
+        return processedPanelData.pipe(rxjs.tap((out) => processedCache.set(s, out)));
       });
-      return rxjs.forkJoin([rxjs.of(primary), ...processedSecondaries]);
+      return rxjs.combineLatest([rxjs.of(primaryResponse), ...processedSecondaries]);
     }),
-    rxjs.map(([primary, ...processedSecondaries]) => {
+    rxjs.map(([processedPrimary, ...processedSecondaries]) => {
       var _a;
+      const allResponses = [processedPrimary, ...processedSecondaries];
+      const allResponseErrors = allResponses.flatMap((d) => {
+        var _a2;
+        return (_a2 = d.errors) != null ? _a2 : [];
+      });
       return {
-        ...primary,
-        series: [...primary.series, ...processedSecondaries.flatMap((s) => s.series)],
-        annotations: [...(_a = primary.annotations) != null ? _a : [], ...processedSecondaries.flatMap((s) => {
-          var _a2;
-          return (_a2 = s.annotations) != null ? _a2 : [];
-        })]
+        ...processedPrimary,
+        state: combineLoadingStates(allResponses.map((d) => d.state)),
+        series: [...processedPrimary.series, ...processedSecondaries.flatMap((s) => s.series)],
+        annotations: [
+          ...(_a = processedPrimary.annotations) != null ? _a : [],
+          ...processedSecondaries.flatMap((s) => {
+            var _a2;
+            return (_a2 = s.annotations) != null ? _a2 : [];
+          })
+        ],
+        ...allResponseErrors.length > 0 ? { errors: allResponseErrors, error: allResponseErrors[0] } : {}
       };
     })
   );
@@ -11102,6 +11131,123 @@ function shouldUseMixedRuntimeDatasource(sceneObject, datasource, queries) {
   }
   return false;
 }
+function parseRefsFromMathExpression(input) {
+  const bracket = /\$\{([A-Za-z0-9_ ]+?)\}/gm;
+  const simple = /\$([A-Za-z0-9_]+)/gm;
+  const found = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = bracket.exec(input)) !== null) {
+    found.add(match[1]);
+  }
+  while ((match = simple.exec(input)) !== null) {
+    found.add(match[1]);
+  }
+  return Array.from(found);
+}
+function getExpressionReferences(query) {
+  const { type, expression, conditions } = query;
+  if (type === "math" || type === "sql") {
+    return parseRefsFromMathExpression(expression != null ? expression : "");
+  }
+  if (type === "classic_conditions") {
+    return (conditions != null ? conditions : []).map((condition) => {
+      var _a, _b;
+      return (_b = (_a = condition.query) == null ? void 0 : _a.params) == null ? void 0 : _b[0];
+    }).filter((refId) => Boolean(refId));
+  }
+  return expression ? [expression] : [];
+}
+function rewriteExpressionReferences(query, renameMap) {
+  var _a, _b;
+  const { type } = query;
+  if (type === "math" || type === "sql") {
+    let expression = (_a = query.expression) != null ? _a : "";
+    for (const oldRef of Object.keys(renameMap)) {
+      const pattern = new RegExp("(\\$" + oldRef + "\\b)|(\\$\\{" + oldRef + "\\})", "gm");
+      expression = expression.replace(pattern, "${" + renameMap[oldRef] + "}");
+    }
+    query.expression = expression;
+  } else if (type === "classic_conditions") {
+    ((_b = query.conditions) != null ? _b : []).forEach((condition) => {
+      var _a2;
+      const params = (_a2 = condition.query) == null ? void 0 : _a2.params;
+      if (params && params[0] && renameMap[params[0]]) {
+        params[0] = renameMap[params[0]];
+      }
+    });
+  } else if (query.expression && renameMap[query.expression]) {
+    query.expression = renameMap[query.expression];
+  }
+}
+function expandExpressionFanOut(sceneObject, targets) {
+  var _a, _b, _c;
+  const isExpression = (query) => Boolean(runtime.isExpressionReference && runtime.isExpressionReference(query.datasource));
+  if (!targets.some(isExpression)) {
+    return targets;
+  }
+  let variableName;
+  let uids;
+  for (const target of targets) {
+    if (isExpression(target)) {
+      continue;
+    }
+    const candidate = getSimpleVariableNameFromDatasourceUid((_a = target.datasource) == null ? void 0 : _a.uid);
+    if (!candidate) {
+      continue;
+    }
+    const value = (_b = sceneGraph.lookupVariable(candidate, sceneObject)) == null ? void 0 : _b.getValue();
+    if (Array.isArray(value)) {
+      const selected = value.filter((item) => item !== "default").map(String);
+      if (selected.length > 1) {
+        variableName = candidate;
+        uids = selected;
+        break;
+      }
+    }
+  }
+  if (!variableName || !uids) {
+    return targets;
+  }
+  const fannedRootRefIds = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    if (!isExpression(target) && getSimpleVariableNameFromDatasourceUid((_c = target.datasource) == null ? void 0 : _c.uid) === variableName) {
+      fannedRootRefIds.add(target.refId);
+    }
+  }
+  const dependentRefIds = new Set(fannedRootRefIds);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const target of targets) {
+      if (!isExpression(target) || dependentRefIds.has(target.refId)) {
+        continue;
+      }
+      if (getExpressionReferences(target).some((refId) => dependentRefIds.has(refId))) {
+        dependentRefIds.add(target.refId);
+        changed = true;
+      }
+    }
+  }
+  const expanded = targets.filter((target) => !dependentRefIds.has(target.refId));
+  const toFanOut = targets.filter((target) => dependentRefIds.has(target.refId));
+  uids.forEach((uid, index) => {
+    const renameMap = {};
+    for (const target of toFanOut) {
+      renameMap[target.refId] = `${target.refId}_${index}`;
+    }
+    for (const target of toFanOut) {
+      const clone = lodash.cloneDeep(target);
+      clone.refId = renameMap[target.refId];
+      if (fannedRootRefIds.has(target.refId)) {
+        clone.datasource = { ...clone.datasource, uid };
+      } else {
+        rewriteExpressionReferences(clone, renameMap);
+      }
+      expanded.push(clone);
+    }
+  });
+  return expanded;
+}
 class SceneQueryRunner extends SceneObjectBase {
   constructor(initialState) {
     super(initialState);
@@ -11413,7 +11559,7 @@ class SceneQueryRunner extends SceneObjectBase {
       if (secondaries.length > 0) {
         const secondaryStreams = secondaries.map((r) => runRequest(ds, r));
         const op = extraQueryProcessingOperator(processors);
-        stream = rxjs.forkJoin([stream, ...secondaryStreams]).pipe(op);
+        stream = rxjs.combineLatest([stream, ...secondaryStreams]).pipe(op);
       }
       const panelProfiler = findPanelProfiler(this);
       stream = stream.pipe(
@@ -11496,6 +11642,7 @@ class SceneQueryRunner extends SceneObjectBase {
       }
       return query;
     });
+    request.targets = expandExpressionFanOut(this, request.targets);
     const lowerIntervalLimit = minInterval ? interpolate(this, minInterval) : ds.interval;
     const norm = data.rangeUtil.calculateInterval(timeRange.state.value, request.maxDataPoints, lowerIntervalLimit);
     request.scopedVars = Object.assign({}, request.scopedVars, {