@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/dist/esm/variables/variants/TestVariable.js

@@ -0,0 +1,117 @@
+import { Subject, Observable } from 'rxjs';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { queryMetricTree } from '../../utils/metricTree.js';
+import { VariableDependencyConfig } from '../VariableDependencyConfig.js';
+import { renderSelectForVariable } from '../components/VariableValueSelect.js';
+import { MultiValueVariable } from './MultiValueVariable.js';
+import { VariableRefresh } from '@grafana/data';
+import { getClosest } from '../../core/sceneGraph/utils.js';
+import { SceneVariableSet } from '../sets/SceneVariableSet.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class TestVariable extends MultiValueVariable {
+  constructor(initialState, isLazy = false) {
+    super(__spreadValues({
+      type: "custom",
+      name: "Test",
+      value: "Value",
+      text: "Text",
+      query: "Query",
+      options: [],
+      refresh: VariableRefresh.onDashboardLoad,
+      updateOptions: true
+    }, initialState));
+    this.completeUpdate = new Subject();
+    this.isGettingValues = true;
+    this.getValueOptionsCount = 0;
+    this.isLazy = false;
+    this._variableDependency = new VariableDependencyConfig(this, {
+      statePaths: ["query"]
+    });
+    this.isLazy = isLazy;
+  }
+  getValueOptions(args) {
+    const { delayMs } = this.state;
+    this.getValueOptionsCount += 1;
+    const queryController = sceneGraph.getQueryController(this);
+    return new Observable((observer) => {
+      const queryEntry = {
+        type: "variable",
+        origin: this,
+        cancel: () => observer.complete()
+      };
+      if (queryController) {
+        queryController.queryStarted(queryEntry);
+      }
+      this.setState({ loading: true });
+      if (this.state.throwError) {
+        throw new Error(this.state.throwError);
+      }
+      const interpolatedQuery = sceneGraph.interpolate(this, this.state.query);
+      const options = this.getOptions(interpolatedQuery);
+      const sub = this.completeUpdate.subscribe({
+        next: () => {
+          const newState = { issuedQuery: interpolatedQuery, loading: false };
+          if (this.state.updateOptions) {
+            newState.options = options;
+          }
+          this.setState(newState);
+          observer.next(options);
+          observer.complete();
+        }
+      });
+      let timeout;
+      if (delayMs) {
+        timeout = window.setTimeout(() => this.signalUpdateCompleted(), delayMs);
+      } else if (delayMs === 0) {
+        this.signalUpdateCompleted();
+      }
+      this.isGettingValues = true;
+      return () => {
+        sub.unsubscribe();
+        window.clearTimeout(timeout);
+        this.isGettingValues = false;
+        if (this.state.loading) {
+          this.setState({ loading: false });
+        }
+        if (queryController) {
+          queryController.queryCompleted(queryEntry);
+        }
+      };
+    });
+  }
+  cancel() {
+    const sceneVarSet = getClosest(this, (s) => s instanceof SceneVariableSet ? s : void 0);
+    sceneVarSet == null ? void 0 : sceneVarSet.cancel(this);
+  }
+  getOptions(interpolatedQuery) {
+    if (this.state.optionsToReturn) {
+      return this.state.optionsToReturn;
+    }
+    return queryMetricTree(interpolatedQuery).map((x) => ({ label: x.name, value: x.name }));
+  }
+  signalUpdateCompleted() {
+    this.completeUpdate.next(1);
+  }
+}
+TestVariable.Component = ({ model }) => {
+  return renderSelectForVariable(model);
+};
+
+export { TestVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"TestVariable.js","sources":["../../../../variables/variants/TestVariable.js"],"sourcesContent":["import { Subject, Observable } from 'rxjs';\nimport { sceneGraph } from '../../core/sceneGraph/index.js';\nimport { queryMetricTree } from '../../utils/metricTree.js';\nimport { VariableDependencyConfig } from '../VariableDependencyConfig.js';\nimport { renderSelectForVariable } from '../components/VariableValueSelect.js';\nimport { MultiValueVariable } from './MultiValueVariable.js';\nimport { VariableRefresh } from '@grafana/data';\nimport { getClosest } from '../../core/sceneGraph/utils.js';\nimport { SceneVariableSet } from '../sets/SceneVariableSet.js';\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nclass TestVariable extends MultiValueVariable {\n  constructor(initialState, isLazy = false) {\n    super(__spreadValues({\n      type: \"custom\",\n      name: \"Test\",\n      value: \"Value\",\n      text: \"Text\",\n      query: \"Query\",\n      options: [],\n      refresh: VariableRefresh.onDashboardLoad,\n      updateOptions: true\n    }, initialState));\n    this.completeUpdate = new Subject();\n    this.isGettingValues = true;\n    this.getValueOptionsCount = 0;\n    this.isLazy = false;\n    this._variableDependency = new VariableDependencyConfig(this, {\n      statePaths: [\"query\"]\n    });\n    this.isLazy = isLazy;\n  }\n  getValueOptions(args) {\n    const { delayMs } = this.state;\n    this.getValueOptionsCount += 1;\n    const queryController = sceneGraph.getQueryController(this);\n    return new Observable((observer) => {\n      const queryEntry = {\n        type: \"variable\",\n        origin: this,\n        cancel: () => observer.complete()\n      };\n      if (queryController) {\n        queryController.queryStarted(queryEntry);\n      }\n      this.setState({ loading: true });\n      if (this.state.throwError) {\n        throw new Error(this.state.throwError);\n      }\n      const interpolatedQuery = sceneGraph.interpolate(this, this.state.query);\n      const options = this.getOptions(interpolatedQuery);\n      const sub = this.completeUpdate.subscribe({\n        next: () => {\n          const newState = { issuedQuery: interpolatedQuery, loading: false };\n          if (this.state.updateOptions) {\n            newState.options = options;\n          }\n          this.setState(newState);\n          observer.next(options);\n          observer.complete();\n        }\n      });\n      let timeout;\n      if (delayMs) {\n        timeout = window.setTimeout(() => this.signalUpdateCompleted(), delayMs);\n      } else if (delayMs === 0) {\n        this.signalUpdateCompleted();\n      }\n      this.isGettingValues = true;\n      return () => {\n        sub.unsubscribe();\n        window.clearTimeout(timeout);\n        this.isGettingValues = false;\n        if (this.state.loading) {\n          this.setState({ loading: false });\n        }\n        if (queryController) {\n          queryController.queryCompleted(queryEntry);\n        }\n      };\n    });\n  }\n  cancel() {\n    const sceneVarSet = getClosest(this, (s) => s instanceof SceneVariableSet ? s : void 0);\n    sceneVarSet == null ? void 0 : sceneVarSet.cancel(this);\n  }\n  getOptions(interpolatedQuery) {\n    if (this.state.optionsToReturn) {\n      return this.state.optionsToReturn;\n    }\n    return queryMetricTree(interpolatedQuery).map((x) => ({ label: x.name, value: x.name }));\n  }\n  signalUpdateCompleted() {\n    this.completeUpdate.next(1);\n  }\n}\nTestVariable.Component = ({ model }) => {\n  return renderSelectForVariable(model);\n};\n\nexport { TestVariable };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"TestVariable.js","sources":["../../../../src/variables/variants/TestVariable.tsx"],"sourcesContent":["import { Observable, Subject } from 'rxjs';\n\nimport { sceneGraph } from '../../core/sceneGraph';\nimport { SceneComponentProps } from '../../core/types';\nimport { queryMetricTree } from '../../utils/metricTree';\nimport { VariableDependencyConfig } from '../VariableDependencyConfig';\nimport { renderSelectForVariable } from '../components/VariableValueSelect';\nimport { VariableValueOption } from '../types';\n\nimport { MultiValueVariable, MultiValueVariableState, VariableGetOptionsArgs } from './MultiValueVariable';\nimport { VariableRefresh } from '@grafana/data';\nimport { getClosest } from '../../core/sceneGraph/utils';\nimport { SceneVariableSet } from '../sets/SceneVariableSet';\nimport { SceneQueryControllerEntry } from '../../behaviors/SceneQueryController';\n\nexport interface TestVariableState extends MultiValueVariableState {\n  query: string;\n  delayMs?: number;\n  issuedQuery?: string;\n  refresh?: VariableRefresh;\n  throwError?: string;\n  optionsToReturn?: VariableValueOption[];\n  updateOptions?: boolean;\n}\n\n/**\n * This variable is only designed for unit tests and potentially e2e tests.\n */\nexport class TestVariable extends MultiValueVariable<TestVariableState> {\n  private completeUpdate = new Subject<number>();\n  public isGettingValues = true;\n  public getValueOptionsCount = 0;\n  isLazy = false;\n\n  protected _variableDependency = new VariableDependencyConfig(this, {\n    statePaths: ['query'],\n  });\n\n  public constructor(initialState: Partial<TestVariableState>, isLazy = false) {\n    super({\n      type: 'custom',\n      name: 'Test',\n      value: 'Value',\n      text: 'Text',\n      query: 'Query',\n      options: [],\n      refresh: VariableRefresh.onDashboardLoad,\n      updateOptions: true,\n      ...initialState,\n    });\n    this.isLazy = isLazy;\n  }\n\n  public getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]> {\n    const { delayMs } = this.state;\n\n    this.getValueOptionsCount += 1;\n\n    const queryController = sceneGraph.getQueryController(this);\n\n    return new Observable<VariableValueOption[]>((observer) => {\n      const queryEntry: SceneQueryControllerEntry = {\n        type: 'variable',\n        origin: this,\n        cancel: () => observer.complete(),\n      };\n\n      if (queryController) {\n        queryController.queryStarted(queryEntry);\n      }\n\n      this.setState({ loading: true });\n\n      if (this.state.throwError) {\n        throw new Error(this.state.throwError);\n      }\n\n      const interpolatedQuery = sceneGraph.interpolate(this, this.state.query);\n      const options = this.getOptions(interpolatedQuery);\n\n      const sub = this.completeUpdate.subscribe({\n        next: () => {\n          const newState: Partial<TestVariableState> = { issuedQuery: interpolatedQuery, loading: false };\n\n          if (this.state.updateOptions) {\n            newState.options = options;\n          }\n\n          this.setState(newState);\n          observer.next(options);\n          observer.complete();\n        },\n      });\n\n      let timeout: number | undefined;\n      if (delayMs) {\n        timeout = window.setTimeout(() => this.signalUpdateCompleted(), delayMs);\n      } else if (delayMs === 0) {\n        this.signalUpdateCompleted();\n      }\n\n      this.isGettingValues = true;\n\n      return () => {\n        sub.unsubscribe();\n        window.clearTimeout(timeout);\n        this.isGettingValues = false;\n\n        if (this.state.loading) {\n          this.setState({ loading: false });\n        }\n\n        if (queryController) {\n          queryController.queryCompleted(queryEntry);\n        }\n      };\n    });\n  }\n\n  public cancel() {\n    const sceneVarSet = getClosest(this, (s) => (s instanceof SceneVariableSet ? s : undefined));\n    sceneVarSet?.cancel(this);\n  }\n\n  private getOptions(interpolatedQuery: string) {\n    if (this.state.optionsToReturn) {\n      return this.state.optionsToReturn;\n    }\n\n    return queryMetricTree(interpolatedQuery).map((x) => ({ label: x.name, value: x.name }));\n  }\n\n  /** Useful from tests */\n  public signalUpdateCompleted() {\n    this.completeUpdate.next(1);\n  }\n\n  public static Component = ({ model }: SceneComponentProps<MultiValueVariable>) => {\n    return renderSelectForVariable(model);\n  };\n}\n"],"names":[],"mappings":"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"}\n"],"names":[],"mappings":"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"}

package/dist/esm/dist/esm/variables/variants/TextBoxVariable.js

@@ -0,0 +1,61 @@
+import React from 'react';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { SceneObjectUrlSyncConfig } from '../../services/SceneObjectUrlSyncConfig.js';
+import { VariableValueInput } from '../components/VariableValueInput.js';
+import { SceneVariableValueChangedEvent } from '../types.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class TextBoxVariable extends SceneObjectBase {
+  constructor(initialState) {
+    super(__spreadValues({
+      type: "textbox",
+      value: "",
+      name: ""
+    }, initialState));
+    this._urlSync = new SceneObjectUrlSyncConfig(this, { keys: () => [this.getKey()] });
+  }
+  getValue() {
+    return this.state.value;
+  }
+  setValue(newValue) {
+    if (newValue !== this.state.value) {
+      this.setState({ value: newValue });
+      this.publishEvent(new SceneVariableValueChangedEvent(this), true);
+    }
+  }
+  getKey() {
+    return `var-${this.state.name}`;
+  }
+  getUrlState() {
+    return { [this.getKey()]: this.state.value };
+  }
+  updateFromUrl(values) {
+    const val = values[this.getKey()];
+    if (typeof val === "string") {
+      this.setValue(val);
+    }
+  }
+}
+TextBoxVariable.Component = ({ model }) => {
+  return /* @__PURE__ */ React.createElement(VariableValueInput, {
+    model
+  });
+};
+
+export { TextBoxVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"TextBoxVariable.js","sources":["../../../../variables/variants/TextBoxVariable.js"],"sourcesContent":["import React from 'react';\nimport { SceneObjectBase } from '../../core/SceneObjectBase.js';\nimport { SceneObjectUrlSyncConfig } from '../../services/SceneObjectUrlSyncConfig.js';\nimport { VariableValueInput } from '../components/VariableValueInput.js';\nimport { SceneVariableValueChangedEvent } from '../types.js';\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nclass TextBoxVariable extends SceneObjectBase {\n  constructor(initialState) {\n    super(__spreadValues({\n      type: \"textbox\",\n      value: \"\",\n      name: \"\"\n    }, initialState));\n    this._urlSync = new SceneObjectUrlSyncConfig(this, { keys: () => [this.getKey()] });\n  }\n  getValue() {\n    return this.state.value;\n  }\n  setValue(newValue) {\n    if (newValue !== this.state.value) {\n      this.setState({ value: newValue });\n      this.publishEvent(new SceneVariableValueChangedEvent(this), true);\n    }\n  }\n  getKey() {\n    return `var-${this.state.name}`;\n  }\n  getUrlState() {\n    return { [this.getKey()]: this.state.value };\n  }\n  updateFromUrl(values) {\n    const val = values[this.getKey()];\n    if (typeof val === \"string\") {\n      this.setValue(val);\n    }\n  }\n}\nTextBoxVariable.Component = ({ model }) => {\n  return /* @__PURE__ */ React.createElement(VariableValueInput, {\n    model\n  });\n};\n\nexport { TextBoxVariable };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAWO,MAAM,wBACH,eAEV,CAAA;AACS,EAAA,WAAA,CAAY,YAA6C,EAAA;AACxD,IAAA,KAAA,CAAA,cAAA,CAAA;MACJ,IAAM,EAAA,SAAA;MACN,KAAO,EAAA,EAAA;MACP,IAAM,EAAA,EAAA;AAAA,KAAA,EACH,YACJ,CAAA,CAAA,CAAA;AAED,IAAA,IAAA,CAAK,QAAW,GAAA,IAAI,wBAAyB,CAAA,IAAA,EAAM,EAAE,IAAA,EAAM,MAAM,CAAC,IAAK,CAAA,MAAA,EAAQ,CAAA,EAAG,CAAA,CAAA;AAAA,GAAA;EAG7E,QAA0B,GAAA;AAC/B,IAAA,OAAO,KAAK,KAAM,CAAA,KAAA,CAAA;AAAA,GAAA;AAGb,EAAA,QAAA,CAAS,QAAkB,EAAA;AAC5B,IAAA,IAAA,QAAA,KAAa,IAAK,CAAA,KAAA,CAAM,KAAO,EAAA;AACjC,MAAA,IAAA,CAAK,QAAS,CAAA,EAAE,KAAO,EAAA,QAAA,EAAU,CAAA,CAAA;AACjC,MAAA,IAAA,CAAK,YAAa,CAAA,IAAI,8BAA+B,CAAA,IAAI,GAAG,IAAI,CAAA,CAAA;AAAA,KAAA;AAClE,GAAA;EAGM,MAAiB,GAAA;AAChB,IAAA,OAAA,CAAA,IAAA,EAAO,KAAK,KAAM,CAAA,IAAA,CAAA,CAAA,CAAA;AAAA,GAAA;EAGpB,WAAc,GAAA;AACnB,IAAA,OAAO,EAAE,CAAC,IAAA,CAAK,QAAW,GAAA,IAAA,CAAK,MAAM,KAAM,EAAA,CAAA;AAAA,GAAA;AAGtC,EAAA,aAAA,CAAc,MAA8B,EAAA;AAC3C,IAAA,MAAA,GAAA,GAAM,MAAO,CAAA,IAAA,CAAK,MAAO,EAAA,CAAA,CAAA;AAE3B,IAAA,IAAA,OAAO,QAAQ,QAAU,EAAA;AAC3B,MAAA,IAAA,CAAK,SAAS,GAAG,CAAA,CAAA;AAAA,KAAA;AACnB,GAAA;AAMJ,CAAA;AA7Ca,eAAA,CA0CG,SAAY,GAAA,CAAC,EAAE,KAAA,EAAkD,KAAA;AAC7E,EAAQ,uBAAA,KAAA,CAAA,cAAA,kBAAA,EAAA;AAAmB,IAAA,KAAA;GAAc,CAAA,CAAA;AAC3C,CAAA;;;;"}

package/dist/esm/dist/esm/variables/variants/query/QueryVariable.js

@@ -0,0 +1,139 @@
+import { lastValueFrom, of, from, mergeMap, filter, take, throwError, catchError } from 'rxjs';
+import { v4 } from 'uuid';
+import { VariableRefresh, VariableSort, LoadingState, CoreApp } from '@grafana/data';
+import { sceneGraph } from '../../../core/sceneGraph/index.js';
+import { VariableDependencyConfig } from '../../VariableDependencyConfig.js';
+import { renderSelectForVariable } from '../../components/VariableValueSelect.js';
+import { MultiValueVariable } from '../MultiValueVariable.js';
+import { createQueryVariableRunner } from './createQueryVariableRunner.js';
+import { metricNamesToVariableValues } from './utils.js';
+import { toMetricFindValues } from './toMetricFindValues.js';
+import { getDataSource } from '../../../utils/getDataSource.js';
+import { safeStringifyValue } from '../../utils.js';
+import { SEARCH_FILTER_VARIABLE } from '../../constants.js';
+import { debounce } from 'lodash';
+import { registerQueryWithController } from '../../../querying/registerQueryWithController.js';
+import { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class QueryVariable extends MultiValueVariable {
+  constructor(initialState) {
+    super(__spreadValues({
+      type: "query",
+      name: "",
+      value: "",
+      text: "",
+      options: [],
+      datasource: null,
+      regex: "",
+      query: "",
+      refresh: VariableRefresh.onDashboardLoad,
+      sort: VariableSort.disabled
+    }, initialState));
+    this._variableDependency = new VariableDependencyConfig(this, {
+      statePaths: ["regex", "query", "datasource"]
+    });
+    this.onSearchChange = (searchFilter) => {
+      if (!containsSearchFilter(this.state.query)) {
+        return;
+      }
+      this._updateOptionsBasedOnSearchFilter(searchFilter);
+    };
+    this._updateOptionsBasedOnSearchFilter = debounce(async (searchFilter) => {
+      const result = await lastValueFrom(this.getValueOptions({ searchFilter }));
+      this.setState({ options: result, loading: false });
+    }, 400);
+  }
+  getValueOptions(args) {
+    if (!this.state.query) {
+      return of([]);
+    }
+    this.setState({ loading: true, error: null });
+    return from(
+      getDataSource(this.state.datasource, {
+        __sceneObject: wrapInSafeSerializableSceneObject(this)
+      })
+    ).pipe(
+      mergeMap((ds) => {
+        const runner = createQueryVariableRunner(ds);
+        const target = runner.getTarget(this);
+        const request = this.getRequest(target, args.searchFilter);
+        return runner.runRequest({ variable: this, searchFilter: args.searchFilter }, request).pipe(
+          registerQueryWithController({
+            type: "variable",
+            request,
+            origin: this
+          }),
+          filter((data) => data.state === LoadingState.Done || data.state === LoadingState.Error),
+          take(1),
+          mergeMap((data) => {
+            if (data.state === LoadingState.Error) {
+              return throwError(() => data.error);
+            }
+            return of(data);
+          }),
+          toMetricFindValues(),
+          mergeMap((values) => {
+            let regex = "";
+            if (this.state.regex) {
+              regex = sceneGraph.interpolate(this, this.state.regex, void 0, "regex");
+            }
+            return of(metricNamesToVariableValues(regex, this.state.sort, values));
+          }),
+          catchError((error) => {
+            if (error.cancelled) {
+              return of([]);
+            }
+            return throwError(() => error);
+          })
+        );
+      })
+    );
+  }
+  getRequest(target, searchFilter) {
+    const scopedVars = {
+      __sceneObject: wrapInSafeSerializableSceneObject(this)
+    };
+    if (searchFilter) {
+      scopedVars.__searchFilter = { value: searchFilter, text: searchFilter };
+    }
+    const range = sceneGraph.getTimeRange(this).state.value;
+    const request = {
+      app: CoreApp.Dashboard,
+      requestId: v4(),
+      timezone: "",
+      range,
+      interval: "",
+      intervalMs: 0,
+      targets: [target],
+      scopedVars,
+      startTime: Date.now()
+    };
+    return request;
+  }
+}
+QueryVariable.Component = ({ model }) => {
+  return renderSelectForVariable(model);
+};
+function containsSearchFilter(query) {
+  const str = safeStringifyValue(query);
+  return str.indexOf(SEARCH_FILTER_VARIABLE) > -1;
+}
+
+export { QueryVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"QueryVariable.js","sources":["../../../../../variables/variants/query/QueryVariable.js"],"sourcesContent":["import { lastValueFrom, of, from, mergeMap, filter, take, throwError, catchError } from 'rxjs';\nimport { v4 } from 'uuid';\nimport { VariableRefresh, VariableSort, LoadingState, CoreApp } from '@grafana/data';\nimport { sceneGraph } from '../../../core/sceneGraph/index.js';\nimport { VariableDependencyConfig } from '../../VariableDependencyConfig.js';\nimport { renderSelectForVariable } from '../../components/VariableValueSelect.js';\nimport { MultiValueVariable } from '../MultiValueVariable.js';\nimport { createQueryVariableRunner } from './createQueryVariableRunner.js';\nimport { metricNamesToVariableValues } from './utils.js';\nimport { toMetricFindValues } from './toMetricFindValues.js';\nimport { getDataSource } from '../../../utils/getDataSource.js';\nimport { safeStringifyValue } from '../../utils.js';\nimport { SEARCH_FILTER_VARIABLE } from '../../constants.js';\nimport { debounce } from 'lodash';\nimport { registerQueryWithController } from '../../../querying/registerQueryWithController.js';\nimport { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject.js';\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nclass QueryVariable extends MultiValueVariable {\n  constructor(initialState) {\n    super(__spreadValues({\n      type: \"query\",\n      name: \"\",\n      value: \"\",\n      text: \"\",\n      options: [],\n      datasource: null,\n      regex: \"\",\n      query: \"\",\n      refresh: VariableRefresh.onDashboardLoad,\n      sort: VariableSort.disabled\n    }, initialState));\n    this._variableDependency = new VariableDependencyConfig(this, {\n      statePaths: [\"regex\", \"query\", \"datasource\"]\n    });\n    this.onSearchChange = (searchFilter) => {\n      if (!containsSearchFilter(this.state.query)) {\n        return;\n      }\n      this._updateOptionsBasedOnSearchFilter(searchFilter);\n    };\n    this._updateOptionsBasedOnSearchFilter = debounce(async (searchFilter) => {\n      const result = await lastValueFrom(this.getValueOptions({ searchFilter }));\n      this.setState({ options: result, loading: false });\n    }, 400);\n  }\n  getValueOptions(args) {\n    if (!this.state.query) {\n      return of([]);\n    }\n    this.setState({ loading: true, error: null });\n    return from(\n      getDataSource(this.state.datasource, {\n        __sceneObject: wrapInSafeSerializableSceneObject(this)\n      })\n    ).pipe(\n      mergeMap((ds) => {\n        const runner = createQueryVariableRunner(ds);\n        const target = runner.getTarget(this);\n        const request = this.getRequest(target, args.searchFilter);\n        return runner.runRequest({ variable: this, searchFilter: args.searchFilter }, request).pipe(\n          registerQueryWithController({\n            type: \"variable\",\n            request,\n            origin: this\n          }),\n          filter((data) => data.state === LoadingState.Done || data.state === LoadingState.Error),\n          take(1),\n          mergeMap((data) => {\n            if (data.state === LoadingState.Error) {\n              return throwError(() => data.error);\n            }\n            return of(data);\n          }),\n          toMetricFindValues(),\n          mergeMap((values) => {\n            let regex = \"\";\n            if (this.state.regex) {\n              regex = sceneGraph.interpolate(this, this.state.regex, void 0, \"regex\");\n            }\n            return of(metricNamesToVariableValues(regex, this.state.sort, values));\n          }),\n          catchError((error) => {\n            if (error.cancelled) {\n              return of([]);\n            }\n            return throwError(() => error);\n          })\n        );\n      })\n    );\n  }\n  getRequest(target, searchFilter) {\n    const scopedVars = {\n      __sceneObject: wrapInSafeSerializableSceneObject(this)\n    };\n    if (searchFilter) {\n      scopedVars.__searchFilter = { value: searchFilter, text: searchFilter };\n    }\n    const range = sceneGraph.getTimeRange(this).state.value;\n    const request = {\n      app: CoreApp.Dashboard,\n      requestId: v4(),\n      timezone: \"\",\n      range,\n      interval: \"\",\n      intervalMs: 0,\n      targets: [target],\n      scopedVars,\n      startTime: Date.now()\n    };\n    return request;\n  }\n}\nQueryVariable.Component = ({ model }) => {\n  return renderSelectForVariable(model);\n};\nfunction containsSearchFilter(query) {\n  const str = safeStringifyValue(query);\n  return str.indexOf(SEARCH_FILTER_VARIABLE) > -1;\n}\n\nexport { QueryVariable };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"QueryVariable.js","sources":["../../../../../src/variables/variants/query/QueryVariable.tsx"],"sourcesContent":["import { Observable, of, filter, take, mergeMap, catchError, throwError, from, lastValueFrom } from 'rxjs';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport {\n  CoreApp,\n  DataQueryRequest,\n  LoadingState,\n  PanelData,\n  ScopedVars,\n  VariableRefresh,\n  VariableSort,\n} from '@grafana/data';\n\nimport { sceneGraph } from '../../../core/sceneGraph';\nimport { SceneComponentProps, SceneDataQuery } from '../../../core/types';\nimport { VariableDependencyConfig } from '../../VariableDependencyConfig';\nimport { renderSelectForVariable } from '../../components/VariableValueSelect';\nimport { VariableValueOption } from '../../types';\nimport { MultiValueVariable, MultiValueVariableState, VariableGetOptionsArgs } from '../MultiValueVariable';\n\nimport { createQueryVariableRunner } from './createQueryVariableRunner';\nimport { metricNamesToVariableValues } from './utils';\nimport { toMetricFindValues } from './toMetricFindValues';\nimport { getDataSource } from '../../../utils/getDataSource';\nimport { safeStringifyValue } from '../../utils';\nimport { DataQuery, DataSourceRef } from '@grafana/schema';\nimport { SEARCH_FILTER_VARIABLE } from '../../constants';\nimport { debounce } from 'lodash';\nimport { registerQueryWithController } from '../../../querying/registerQueryWithController';\nimport { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject';\n\nexport interface QueryVariableState extends MultiValueVariableState {\n  type: 'query';\n  datasource: DataSourceRef | null;\n  query: string | SceneDataQuery;\n  regex: string;\n  refresh: VariableRefresh;\n  sort: VariableSort;\n  /** @internal Only for use inside core dashboards */\n  definition?: string;\n}\n\nexport class QueryVariable extends MultiValueVariable<QueryVariableState> {\n  protected _variableDependency = new VariableDependencyConfig(this, {\n    statePaths: ['regex', 'query', 'datasource'],\n  });\n\n  public constructor(initialState: Partial<QueryVariableState>) {\n    super({\n      type: 'query',\n      name: '',\n      value: '',\n      text: '',\n      options: [],\n      datasource: null,\n      regex: '',\n      query: '',\n      refresh: VariableRefresh.onDashboardLoad,\n      sort: VariableSort.disabled,\n      ...initialState,\n    });\n  }\n\n  public getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]> {\n    if (!this.state.query) {\n      return of([]);\n    }\n\n    this.setState({ loading: true, error: null });\n\n    return from(\n      getDataSource(this.state.datasource, {\n        __sceneObject: wrapInSafeSerializableSceneObject(this),\n      })\n    ).pipe(\n      mergeMap((ds) => {\n        const runner = createQueryVariableRunner(ds);\n        const target = runner.getTarget(this);\n        const request = this.getRequest(target, args.searchFilter);\n\n        return runner.runRequest({ variable: this, searchFilter: args.searchFilter }, request).pipe(\n          registerQueryWithController({\n            type: 'variable',\n            request: request,\n            origin: this,\n          }),\n          filter((data) => data.state === LoadingState.Done || data.state === LoadingState.Error), // we only care about done or error for now\n          take(1), // take the first result, using first caused a bug where it in some situations throw an uncaught error because of no results had been received yet\n          mergeMap((data: PanelData) => {\n            if (data.state === LoadingState.Error) {\n              return throwError(() => data.error);\n            }\n            return of(data);\n          }),\n          toMetricFindValues(),\n          mergeMap((values) => {\n            let regex = '';\n            if (this.state.regex) {\n              regex = sceneGraph.interpolate(this, this.state.regex, undefined, 'regex');\n            }\n            return of(metricNamesToVariableValues(regex, this.state.sort, values));\n          }),\n          catchError((error) => {\n            if (error.cancelled) {\n              return of([]);\n            }\n            return throwError(() => error);\n          })\n        );\n      })\n    );\n  }\n\n  private getRequest(target: DataQuery | string, searchFilter?: string) {\n    const scopedVars: ScopedVars = {\n      __sceneObject: wrapInSafeSerializableSceneObject(this),\n    };\n\n    if (searchFilter) {\n      scopedVars.__searchFilter = { value: searchFilter, text: searchFilter };\n    }\n\n    const range = sceneGraph.getTimeRange(this).state.value;\n\n    const request: DataQueryRequest = {\n      app: CoreApp.Dashboard,\n      requestId: uuidv4(),\n      timezone: '',\n      range,\n      interval: '',\n      intervalMs: 0,\n      // @ts-ignore\n      targets: [target],\n      scopedVars,\n      startTime: Date.now(),\n    };\n\n    return request;\n  }\n\n  onSearchChange = (searchFilter: string) => {\n    if (!containsSearchFilter(this.state.query)) {\n      return;\n    }\n\n    this._updateOptionsBasedOnSearchFilter(searchFilter);\n  };\n\n  private _updateOptionsBasedOnSearchFilter = debounce(async (searchFilter: string) => {\n    const result = await lastValueFrom(this.getValueOptions({ searchFilter }));\n    this.setState({ options: result, loading: false });\n  }, 400);\n\n  public static Component = ({ model }: SceneComponentProps<MultiValueVariable>) => {\n    return renderSelectForVariable(model);\n  };\n}\n\nfunction containsSearchFilter(query: string | DataQuery) {\n  const str = safeStringifyValue(query);\n  return str.indexOf(SEARCH_FILTER_VARIABLE) > -1;\n}\n"],"names":["uuidv4"],"mappings":"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"}\n"],"names":["uuidv4"],"mappings":"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"}

package/dist/esm/dist/esm/variables/variants/query/createQueryVariableRunner.js

@@ -0,0 +1,129 @@
+import { from, mergeMap, of } from 'rxjs';
+import { LoadingState, getDefaultTimeRange } from '@grafana/data';
+import { getRunRequest } from '@grafana/runtime';
+import { hasStandardVariableSupport, hasLegacyVariableSupport, hasCustomVariableSupport } from './guards.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+class StandardQueryRunner {
+  constructor(datasource, _runRequest = getRunRequest()) {
+    this.datasource = datasource;
+    this._runRequest = _runRequest;
+  }
+  getTarget(variable) {
+    if (hasStandardVariableSupport(this.datasource)) {
+      return this.datasource.variables.toDataQuery(ensureVariableQueryModelIsADataQuery(variable));
+    }
+    throw new Error("Couldn't create a target with supplied arguments.");
+  }
+  runRequest(_, request) {
+    if (!hasStandardVariableSupport(this.datasource)) {
+      return getEmptyMetricFindValueObservable();
+    }
+    if (!this.datasource.variables.query) {
+      return this._runRequest(this.datasource, request);
+    }
+    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));
+  }
+}
+class LegacyQueryRunner {
+  constructor(datasource) {
+    this.datasource = datasource;
+  }
+  getTarget(variable) {
+    if (hasLegacyVariableSupport(this.datasource)) {
+      return variable.state.query;
+    }
+    throw new Error("Couldn't create a target with supplied arguments.");
+  }
+  runRequest({ variable, searchFilter }, request) {
+    if (!hasLegacyVariableSupport(this.datasource)) {
+      return getEmptyMetricFindValueObservable();
+    }
+    return from(
+      this.datasource.metricFindQuery(variable.state.query, __spreadProps(__spreadValues({}, request), {
+        variable: {
+          name: variable.state.name,
+          type: variable.state.type
+        },
+        searchFilter
+      }))
+    ).pipe(
+      mergeMap((values) => {
+        if (!values || !values.length) {
+          return getEmptyMetricFindValueObservable();
+        }
+        const series = values;
+        return of({ series, state: LoadingState.Done, timeRange: request.range });
+      })
+    );
+  }
+}
+class CustomQueryRunner {
+  constructor(datasource, _runRequest = getRunRequest()) {
+    this.datasource = datasource;
+    this._runRequest = _runRequest;
+  }
+  getTarget(variable) {
+    if (hasCustomVariableSupport(this.datasource)) {
+      return variable.state.query;
+    }
+    throw new Error("Couldn't create a target with supplied arguments.");
+  }
+  runRequest(_, request) {
+    if (!hasCustomVariableSupport(this.datasource)) {
+      return getEmptyMetricFindValueObservable();
+    }
+    if (!this.datasource.variables.query) {
+      return this._runRequest(this.datasource, request);
+    }
+    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));
+  }
+}
+function getEmptyMetricFindValueObservable() {
+  return of({ state: LoadingState.Done, series: [], timeRange: getDefaultTimeRange() });
+}
+function createQueryVariableRunnerFactory(datasource) {
+  if (hasStandardVariableSupport(datasource)) {
+    return new StandardQueryRunner(datasource, getRunRequest());
+  }
+  if (hasLegacyVariableSupport(datasource)) {
+    return new LegacyQueryRunner(datasource);
+  }
+  if (hasCustomVariableSupport(datasource)) {
+    return new CustomQueryRunner(datasource);
+  }
+  throw new Error(`Couldn't create a query runner for datasource ${datasource.type}`);
+}
+let createQueryVariableRunner = createQueryVariableRunnerFactory;
+function ensureVariableQueryModelIsADataQuery(variable) {
+  var _a;
+  const query = (_a = variable.state.query) != null ? _a : "";
+  if (typeof query === "string") {
+    return { query, refId: `variable-${variable.state.name}` };
+  }
+  if (query.refId == null) {
+    return __spreadProps(__spreadValues({}, query), { refId: `variable-${variable.state.name}` });
+  }
+  return variable.state.query;
+}
+
+export { createQueryVariableRunner };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createQueryVariableRunner.js","sources":["../../../../../variables/variants/query/createQueryVariableRunner.js"],"sourcesContent":["import { from, mergeMap, of } from 'rxjs';\nimport { LoadingState, getDefaultTimeRange } from '@grafana/data';\nimport { getRunRequest } from '@grafana/runtime';\nimport { hasStandardVariableSupport, hasLegacyVariableSupport, hasCustomVariableSupport } from './guards.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nclass StandardQueryRunner {\n  constructor(datasource, _runRequest = getRunRequest()) {\n    this.datasource = datasource;\n    this._runRequest = _runRequest;\n  }\n  getTarget(variable) {\n    if (hasStandardVariableSupport(this.datasource)) {\n      return this.datasource.variables.toDataQuery(ensureVariableQueryModelIsADataQuery(variable));\n    }\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n  runRequest(_, request) {\n    if (!hasStandardVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n    if (!this.datasource.variables.query) {\n      return this._runRequest(this.datasource, request);\n    }\n    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));\n  }\n}\nclass LegacyQueryRunner {\n  constructor(datasource) {\n    this.datasource = datasource;\n  }\n  getTarget(variable) {\n    if (hasLegacyVariableSupport(this.datasource)) {\n      return variable.state.query;\n    }\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n  runRequest({ variable, searchFilter }, request) {\n    if (!hasLegacyVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n    return from(\n      this.datasource.metricFindQuery(variable.state.query, __spreadProps(__spreadValues({}, request), {\n        variable: {\n          name: variable.state.name,\n          type: variable.state.type\n        },\n        searchFilter\n      }))\n    ).pipe(\n      mergeMap((values) => {\n        if (!values || !values.length) {\n          return getEmptyMetricFindValueObservable();\n        }\n        const series = values;\n        return of({ series, state: LoadingState.Done, timeRange: request.range });\n      })\n    );\n  }\n}\nclass CustomQueryRunner {\n  constructor(datasource, _runRequest = getRunRequest()) {\n    this.datasource = datasource;\n    this._runRequest = _runRequest;\n  }\n  getTarget(variable) {\n    if (hasCustomVariableSupport(this.datasource)) {\n      return variable.state.query;\n    }\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n  runRequest(_, request) {\n    if (!hasCustomVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n    if (!this.datasource.variables.query) {\n      return this._runRequest(this.datasource, request);\n    }\n    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));\n  }\n}\nfunction getEmptyMetricFindValueObservable() {\n  return of({ state: LoadingState.Done, series: [], timeRange: getDefaultTimeRange() });\n}\nfunction createQueryVariableRunnerFactory(datasource) {\n  if (hasStandardVariableSupport(datasource)) {\n    return new StandardQueryRunner(datasource, getRunRequest());\n  }\n  if (hasLegacyVariableSupport(datasource)) {\n    return new LegacyQueryRunner(datasource);\n  }\n  if (hasCustomVariableSupport(datasource)) {\n    return new CustomQueryRunner(datasource);\n  }\n  throw new Error(`Couldn't create a query runner for datasource ${datasource.type}`);\n}\nlet createQueryVariableRunner = createQueryVariableRunnerFactory;\nfunction ensureVariableQueryModelIsADataQuery(variable) {\n  var _a;\n  const query = (_a = variable.state.query) != null ? _a : \"\";\n  if (typeof query === \"string\") {\n    return { query, refId: `variable-${variable.state.name}` };\n  }\n  if (query.refId == null) {\n    return __spreadProps(__spreadValues({}, query), { refId: `variable-${variable.state.name}` });\n  }\n  return variable.state.query;\n}\n\nexport { createQueryVariableRunner };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createQueryVariableRunner.js","sources":["../../../../../src/variables/variants/query/createQueryVariableRunner.ts"],"sourcesContent":["import { from, mergeMap, Observable, of } from 'rxjs';\n\nimport {\n  DataQueryRequest,\n  DataSourceApi,\n  getDefaultTimeRange,\n  LoadingState,\n  PanelData,\n  StandardVariableQuery,\n} from '@grafana/data';\nimport { getRunRequest } from '@grafana/runtime';\n\nimport { hasCustomVariableSupport, hasLegacyVariableSupport, hasStandardVariableSupport } from './guards';\n\nimport { QueryVariable } from './QueryVariable';\nimport { DataQuery } from '@grafana/schema';\n\nexport interface RunnerArgs {\n  searchFilter?: string;\n  variable: QueryVariable;\n}\n\nexport interface QueryRunner {\n  getTarget: (variable: QueryVariable) => DataQuery | string;\n  runRequest: (args: RunnerArgs, request: DataQueryRequest) => Observable<PanelData>;\n}\n\nclass StandardQueryRunner implements QueryRunner {\n  public constructor(private datasource: DataSourceApi, private _runRequest = getRunRequest()) {}\n\n  public getTarget(variable: QueryVariable) {\n    if (hasStandardVariableSupport(this.datasource)) {\n      return this.datasource.variables.toDataQuery(ensureVariableQueryModelIsADataQuery(variable));\n    }\n\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n\n  public runRequest(_: RunnerArgs, request: DataQueryRequest) {\n    if (!hasStandardVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n\n    if (!this.datasource.variables.query) {\n      return this._runRequest(this.datasource, request);\n    }\n\n    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));\n  }\n}\n\nclass LegacyQueryRunner implements QueryRunner {\n  public constructor(private datasource: DataSourceApi) {}\n\n  public getTarget(variable: QueryVariable) {\n    if (hasLegacyVariableSupport(this.datasource)) {\n      return variable.state.query;\n    }\n\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n\n  public runRequest({ variable, searchFilter }: RunnerArgs, request: DataQueryRequest) {\n    if (!hasLegacyVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n\n    return from(\n      this.datasource.metricFindQuery(variable.state.query, {\n        ...request,\n        // variable is used by SQL common data source\n        variable: {\n          name: variable.state.name,\n          type: variable.state.type,\n        },\n        searchFilter,\n      })\n    ).pipe(\n      mergeMap((values) => {\n        if (!values || !values.length) {\n          return getEmptyMetricFindValueObservable();\n        }\n\n        const series: any = values;\n        return of({ series, state: LoadingState.Done, timeRange: request.range });\n      })\n    );\n  }\n}\n\nclass CustomQueryRunner implements QueryRunner {\n  public constructor(private datasource: DataSourceApi, private _runRequest = getRunRequest()) {}\n\n  public getTarget(variable: QueryVariable) {\n    if (hasCustomVariableSupport(this.datasource)) {\n      return variable.state.query;\n    }\n\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n\n  public runRequest(_: RunnerArgs, request: DataQueryRequest) {\n    if (!hasCustomVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n\n    if (!this.datasource.variables.query) {\n      return this._runRequest(this.datasource, request);\n    }\n    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));\n  }\n}\n\nfunction getEmptyMetricFindValueObservable(): Observable<PanelData> {\n  return of({ state: LoadingState.Done, series: [], timeRange: getDefaultTimeRange() });\n}\n\nfunction createQueryVariableRunnerFactory(datasource: DataSourceApi): QueryRunner {\n  if (hasStandardVariableSupport(datasource)) {\n    return new StandardQueryRunner(datasource, getRunRequest());\n  }\n\n  if (hasLegacyVariableSupport(datasource)) {\n    return new LegacyQueryRunner(datasource);\n  }\n\n  if (hasCustomVariableSupport(datasource)) {\n    return new CustomQueryRunner(datasource);\n  }\n\n  throw new Error(`Couldn't create a query runner for datasource ${datasource.type}`);\n}\n\nexport let createQueryVariableRunner = createQueryVariableRunnerFactory;\n\n/**\n * Use only in tests\n */\nexport function setCreateQueryVariableRunnerFactory(fn: (datasource: DataSourceApi) => QueryRunner) {\n  createQueryVariableRunner = fn;\n}\n\n/**\n * Fixes old legacy query string models and adds refId if missing\n */\nfunction ensureVariableQueryModelIsADataQuery(variable: QueryVariable): StandardVariableQuery {\n  const query = variable.state.query ?? '';\n\n  // Turn into query object if it's just a string\n  if (typeof query === 'string') {\n    return { query, refId: `variable-${variable.state.name}` };\n  }\n\n  // Add potentially missing refId\n  if (query.refId == null) {\n    return { ...query, refId: `variable-${variable.state.name}` } as StandardVariableQuery;\n  }\n\n  return variable.state.query as StandardVariableQuery;\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAM,mBAA2C,CAAA;AAAA,EACxC,WAAoB,CAAA,UAAA,EAAmC,WAAc,GAAA,aAAA,EAAiB,EAAA;AAAlE,IAAA,IAAA,CAAA,UAAA,GAAA,UAAA,CAAA;AAAmC,IAAA,IAAA,CAAA,WAAA,GAAA,WAAA,CAAA;AAAA,GAAgC;AAAA,EAEvF,UAAU,QAAyB,EAAA;AACxC,IAAI,IAAA,0BAAA,CAA2B,IAAK,CAAA,UAAU,CAAG,EAAA;AAC/C,MAAA,OAAO,KAAK,UAAW,CAAA,SAAA,CAAU,WAAY,CAAA,oCAAA,CAAqC,QAAQ,CAAC,CAAA,CAAA;AAAA,KAC7F;AAEA,IAAM,MAAA,IAAI,MAAM,mDAAmD,CAAA,CAAA;AAAA,GACrE;AAAA,EAEO,UAAA,CAAW,GAAe,OAA2B,EAAA;AAC1D,IAAA,IAAI,CAAC,0BAAA,CAA2B,IAAK,CAAA,UAAU,CAAG,EAAA;AAChD,MAAA,OAAO,iCAAkC,EAAA,CAAA;AAAA,KAC3C;AAEA,IAAA,IAAI,CAAC,IAAA,CAAK,UAAW,CAAA,SAAA,CAAU,KAAO,EAAA;AACpC,MAAA,OAAO,IAAK,CAAA,WAAA,CAAY,IAAK,CAAA,UAAA,EAAY,OAAO,CAAA,CAAA;AAAA,KAClD;AAEA,IAAA,OAAO,IAAK,CAAA,WAAA,CAAY,IAAK,CAAA,UAAA,EAAY,OAAS,EAAA,IAAA,CAAK,UAAW,CAAA,SAAA,CAAU,KAAM,CAAA,IAAA,CAAK,IAAK,CAAA,UAAA,CAAW,SAAS,CAAC,CAAA,CAAA;AAAA,GACnH;AACF,CAAA;AAEA,MAAM,iBAAyC,CAAA;AAAA,EACtC,YAAoB,UAA2B,EAAA;AAA3B,IAAA,IAAA,CAAA,UAAA,GAAA,UAAA,CAAA;AAAA,GAA4B;AAAA,EAEhD,UAAU,QAAyB,EAAA;AACxC,IAAI,IAAA,wBAAA,CAAyB,IAAK,CAAA,UAAU,CAAG,EAAA;AAC7C,MAAA,OAAO,SAAS,KAAM,CAAA,KAAA,CAAA;AAAA,KACxB;AAEA,IAAM,MAAA,IAAI,MAAM,mDAAmD,CAAA,CAAA;AAAA,GACrE;AAAA,EAEO,UAAW,CAAA,EAAE,QAAU,EAAA,YAAA,IAA4B,OAA2B,EAAA;AACnF,IAAA,IAAI,CAAC,wBAAA,CAAyB,IAAK,CAAA,UAAU,CAAG,EAAA;AAC9C,MAAA,OAAO,iCAAkC,EAAA,CAAA;AAAA,KAC3C;AAEA,IAAO,OAAA,IAAA;AAAA,MACL,KAAK,UAAW,CAAA,eAAA,CAAgB,SAAS,KAAM,CAAA,KAAA,EAAO,iCACjD,OADiD,CAAA,EAAA;AAAA,QAGpD,QAAU,EAAA;AAAA,UACR,IAAA,EAAM,SAAS,KAAM,CAAA,IAAA;AAAA,UACrB,IAAA,EAAM,SAAS,KAAM,CAAA,IAAA;AAAA,SACvB;AAAA,QACA,YAAA;AAAA,OACD,CAAA,CAAA;AAAA,KACD,CAAA,IAAA;AAAA,MACA,QAAA,CAAS,CAAC,MAAW,KAAA;AACnB,QAAA,IAAI,CAAC,MAAA,IAAU,CAAC,MAAA,CAAO,MAAQ,EAAA;AAC7B,UAAA,OAAO,iCAAkC,EAAA,CAAA;AAAA,SAC3C;AAEA,QAAA,MAAM,MAAc,GAAA,MAAA,CAAA;AACpB,QAAO,OAAA,EAAA,CAAG,EAAE,MAAQ,EAAA,KAAA,EAAO,aAAa,IAAM,EAAA,SAAA,EAAW,OAAQ,CAAA,KAAA,EAAO,CAAA,CAAA;AAAA,OACzE,CAAA;AAAA,KACH,CAAA;AAAA,GACF;AACF,CAAA;AAEA,MAAM,iBAAyC,CAAA;AAAA,EACtC,WAAoB,CAAA,UAAA,EAAmC,WAAc,GAAA,aAAA,EAAiB,EAAA;AAAlE,IAAA,IAAA,CAAA,UAAA,GAAA,UAAA,CAAA;AAAmC,IAAA,IAAA,CAAA,WAAA,GAAA,WAAA,CAAA;AAAA,GAAgC;AAAA,EAEvF,UAAU,QAAyB,EAAA;AACxC,IAAI,IAAA,wBAAA,CAAyB,IAAK,CAAA,UAAU,CAAG,EAAA;AAC7C,MAAA,OAAO,SAAS,KAAM,CAAA,KAAA,CAAA;AAAA,KACxB;AAEA,IAAM,MAAA,IAAI,MAAM,mDAAmD,CAAA,CAAA;AAAA,GACrE;AAAA,EAEO,UAAA,CAAW,GAAe,OAA2B,EAAA;AAC1D,IAAA,IAAI,CAAC,wBAAA,CAAyB,IAAK,CAAA,UAAU,CAAG,EAAA;AAC9C,MAAA,OAAO,iCAAkC,EAAA,CAAA;AAAA,KAC3C;AAEA,IAAA,IAAI,CAAC,IAAA,CAAK,UAAW,CAAA,SAAA,CAAU,KAAO,EAAA;AACpC,MAAA,OAAO,IAAK,CAAA,WAAA,CAAY,IAAK,CAAA,UAAA,EAAY,OAAO,CAAA,CAAA;AAAA,KAClD;AACA,IAAA,OAAO,IAAK,CAAA,WAAA,CAAY,IAAK,CAAA,UAAA,EAAY,OAAS,EAAA,IAAA,CAAK,UAAW,CAAA,SAAA,CAAU,KAAM,CAAA,IAAA,CAAK,IAAK,CAAA,UAAA,CAAW,SAAS,CAAC,CAAA,CAAA;AAAA,GACnH;AACF,CAAA;AAEA,SAAS,iCAA2D,GAAA;AAClE,EAAO,OAAA,EAAA,CAAG,EAAE,KAAA,EAAO,YAAa,CAAA,IAAA,EAAM,MAAQ,EAAA,EAAI,EAAA,SAAA,EAAW,mBAAoB,EAAA,EAAG,CAAA,CAAA;AACtF,CAAA;AAEA,SAAS,iCAAiC,UAAwC,EAAA;AAChF,EAAI,IAAA,0BAAA,CAA2B,UAAU,CAAG,EAAA;AAC1C,IAAA,OAAO,IAAI,mBAAA,CAAoB,UAAY,EAAA,aAAA,EAAe,CAAA,CAAA;AAAA,GAC5D;AAEA,EAAI,IAAA,wBAAA,CAAyB,UAAU,CAAG,EAAA;AACxC,IAAO,OAAA,IAAI,kBAAkB,UAAU,CAAA,CAAA;AAAA,GACzC;AAEA,EAAI,IAAA,wBAAA,CAAyB,UAAU,CAAG,EAAA;AACxC,IAAO,OAAA,IAAI,kBAAkB,UAAU,CAAA,CAAA;AAAA,GACzC;AAEA,EAAA,MAAM,IAAI,KAAA,CAAM,CAAiD,8CAAA,EAAA,UAAA,CAAW,IAAM,CAAA,CAAA,CAAA,CAAA;AACpF,CAAA;AAEO,IAAI,yBAA4B,GAAA,iCAAA;AAYvC,SAAS,qCAAqC,QAAgD,EAAA;AAjJ9F,EAAA,IAAA,EAAA,CAAA;AAkJE,EAAA,MAAM,KAAQ,GAAA,CAAA,EAAA,GAAA,QAAA,CAAS,KAAM,CAAA,KAAA,KAAf,IAAwB,GAAA,EAAA,GAAA,EAAA,CAAA;AAGtC,EAAI,IAAA,OAAO,UAAU,QAAU,EAAA;AAC7B,IAAA,OAAO,EAAE,KAAO,EAAA,KAAA,EAAO,CAAY,SAAA,EAAA,QAAA,CAAS,MAAM,IAAO,CAAA,CAAA,EAAA,CAAA;AAAA,GAC3D;AAGA,EAAI,IAAA,KAAA,CAAM,SAAS,IAAM,EAAA;AACvB,IAAA,OAAO,iCAAK,KAAL,CAAA,EAAA,EAAY,OAAO,CAAY,SAAA,EAAA,QAAA,CAAS,MAAM,IAAO,CAAA,CAAA,EAAA,CAAA,CAAA;AAAA,GAC9D;AAEA,EAAA,OAAO,SAAS,KAAM,CAAA,KAAA,CAAA;AACxB;;;;"}\n"],"names":[],"mappings":"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"}