@intentius/chant-lexicon-grafana 0.98.0 → 0.100.0

package/src/promql-check.test.ts

@@ -0,0 +1,108 @@
+/**
+ * GRAF108's pieces: template-variable substitution, the PromQL inside a
+ * Prometheus query variable, and which queries of a dashboard get parsed.
+ * The check itself, over built and hand-written dashboards, is in
+ * lint/post-synth/post-synth.test.ts.
+ */
+import { describe, expect, test } from "vitest";
+import { checkGrafanaPromql, prometheusQueries, substituteTemplateVariables, variablePromql } from "./promql-check";
+import { knownDatasources } from "./datasource-refs";
+
+describe("substituteTemplateVariables", () => {
+  test.each([
+    ['sum(rate(x{a=~"$a"}[$__rate_interval]))', 'sum(rate(x{a=~"$a"}[5m]))'],
+    ["rate(x[$__interval:$__interval])", "rate(x[5m:5m])"],
+    ["rate(x[${window}]) offset $shift", "rate(x[5m]) offset 5m"],
+    ["rate(x[${minutes}m])", "rate(x[1m])"],
+    ['$metric{job="a"} / $__range_s', 'grafana_var{job="a"} / 1'],
+    ["sum by ($group) (x) * $__interval_ms", "sum by (grafana_var) (x) * 1"],
+    ["x @ ${__to:date:seconds}", "x @ 1"],
+    ["rate([[metric]][[[w]]])", "rate(grafana_var[5m])"],
+    ["topk(${n:raw}, x)", "topk(grafana_var, x)"],
+    ["x{a='$a', b=`$b`}", "x{a='$a', b=`$b`}"],
+    ['x{a="\\"$a"}[$__range]', 'x{a="\\"$a"}[5m]'],
+  ])("%s", (query, text) => {
+    expect(substituteTemplateVariables(query).text).toBe(text);
+  });
+
+  test("maps offsets in the substituted text back to the query", () => {
+    const s = substituteTemplateVariables("rate(x[$__rate_interval]) +");
+    expect(s.text).toBe("rate(x[5m]) +");
+    expect(s.originalOffset(7)).toBe(7);
+    expect(s.originalOffset(8)).toBe(7);
+    expect(s.originalOffset(11)).toBe(25);
+  });
+});
+
+describe("checkGrafanaPromql", () => {
+  test("passes the queries Grafana's own dashboards use", () => {
+    for (const q of [
+      'histogram_quantile(0.99, sum by (le) (rate(http_request_duration_seconds_bucket{route=~"$route"}[$__rate_interval])))',
+      'sum by (route) (rate(http_requests_total{job=~"$job", env=~"$env"}[$window]))',
+      "sum(increase(x[$__range])) / ($__range_s)",
+      'up{instance=~"[[instance]]"}',
+    ]) {
+      expect({ q, r: checkGrafanaPromql(q) }).toEqual({ q, r: { ok: true } });
+    }
+  });
+
+  test("reports an unbalanced expression against the original text", () => {
+    const r = checkGrafanaPromql('sum(x{cluster="$cluster"}');
+    expect(r).toEqual({ ok: false, message: expect.stringContaining('ends early (after "sum(x{cluster="$cluster"}")') });
+  });
+
+  test("reports the offset in the query as written, not as substituted", () => {
+    const r = checkGrafanaPromql("rate(x[$__rate_interval]) by");
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.message).toMatch(/offset 2\d: "rate\(x\[\$__rate_interval\]\) ?" >>> /);
+  });
+});
+
+describe("variablePromql", () => {
+  test.each([
+    ["label_names()", []],
+    ['label_names(up{job="a"})', ['up{job="a"}']],
+    ["label_values(job)", []],
+    ['label_values(up{env="$env"}, job)', ['up{env="$env"}']],
+    ["metrics(^http_.*)", []],
+    ["query_result(topk(5, sum by (job) (up)))", ["topk(5, sum by (job) (up))"]],
+    ['up{job="a"}', ['up{job="a"}']],
+    ["  ", []],
+  ])("%s", (query, promql) => {
+    expect(variablePromql(query)).toEqual(promql);
+  });
+});
+
+describe("prometheusQueries", () => {
+  const known = knownDatasources([
+    { name: "Prometheus", type: "prometheus", uid: "prom" },
+    { name: "Loki", type: "loki", uid: "loki" },
+  ]);
+  const dashboard = {
+    templating: {
+      list: [
+        { type: "datasource", name: "ds", query: "prometheus" },
+        { type: "query", name: "job", datasource: { type: "prometheus", uid: "prom" }, query: { query: "label_values(up, job)", refId: "V" } },
+        { type: "query", name: "stream", datasource: { type: "loki", uid: "loki" }, query: "label_values(app)" },
+      ],
+    },
+    panels: [
+      { id: 1, title: "a", type: "stat", datasource: { type: "prometheus", uid: "prom" }, targets: [{ refId: "A", expr: "up" }, { refId: "B", expr: "" }] },
+      { id: 2, title: "b", type: "logs", datasource: { type: "loki", uid: "loki" }, targets: [{ refId: "A", expr: '{app="x"} |= "error"' }] },
+      { id: 3, title: "c", type: "stat", datasource: { type: "prometheus", uid: "${ds}" }, targets: [{ refId: "A", expr: "sum(up)" }] },
+      { id: 4, title: "d", type: "stat", targets: [{ refId: "A", expr: "no datasource" }] },
+      { id: 5, title: "e", type: "stat", datasource: { type: "datasource", uid: "-- Mixed --" }, targets: [{ refId: "A", expr: "x", datasource: { type: "loki", uid: "loki" } }, { refId: "B", expr: "y", datasource: { type: "prometheus", uid: "prom" } }] },
+    ],
+    __elements: { lib: { name: "lib", kind: 1, model: { type: "stat", datasource: { type: "prometheus", uid: "prom" }, targets: [{ refId: "A", expr: "rate(x[5m])" }] } } },
+  };
+
+  test("takes only the queries that reach a Prometheus, including library panels", () => {
+    expect(prometheusQueries(dashboard, known)).toEqual([
+      { where: 'panel "a" (id 1) query A', expr: "up" },
+      { where: 'panel "c" (id 3) query A', expr: "sum(up)" },
+      { where: 'panel "e" (id 5) query B', expr: "y" },
+      { where: 'variable "job" query', expr: "up" },
+      { where: 'library panel "lib" query A', expr: "rate(x[5m])" },
+    ]);
+  });
+});

package/src/promql-check.ts

@@ -0,0 +1,193 @@
+/**
+ * GRAF108: the PromQL a dashboard sends to Prometheus, syntax-checked with
+ * the prometheus lexicon's `checkPromql` (the grammar behind the Prometheus
+ * web UI's editor, `@prometheus-io/lezer-promql`).
+ *
+ * Only queries that reach a Prometheus datasource are parsed, as
+ * `datasourceUses()` resolves them: a query's own ref, else its panel's, a
+ * datasource variable's plugin type, or an undeclared ref's own `type`. A
+ * query whose datasource can't be told (no ref at all, a `-- Mixed --` panel
+ * query with none of its own) is left alone.
+ *
+ * Grafana interpolates template variables before Prometheus sees the query,
+ * so `$var`, `${var}`, `${var:format}`, `[[var]]` and the `$__` macros are
+ * replaced with a placeholder that parses where they stand: a duration
+ * inside `[...]` or after `offset`, a number for the `_ms`/`_s` macros and
+ * `$__from`/`$__to`, an identifier anywhere else. Inside a string literal
+ * they are left as they are.
+ */
+
+import { checkPromql } from "@intentius/chant-lexicon-prometheus/promql";
+import { datasourceUses, variablesOf, type KnownDatasource } from "./datasource-refs";
+
+type Json = Record<string, unknown>;
+
+const DURATION = "5m";
+const NUMBER = "1";
+const IDENTIFIER = "grafana_var";
+
+/** A template variable reference starting at the regex's lastIndex. */
+const VARIABLE = /\$\{([^}]*)\}|\[\[([A-Za-z_][^\]]*)\]\]|\$([A-Za-z_][A-Za-z0-9_]*)/y;
+
+function isNumericMacro(name: string): boolean {
+  if (name === "__from" || name === "__to") return true;
+  return (name.startsWith("__") || name === "interval_ms") && /_(ms|s)$/.test(name);
+}
+
+/** A span of substituted text and the original text it replaced. */
+interface Span {
+  at: number;
+  length: number;
+  original: number;
+  originalLength: number;
+}
+
+export interface Substituted {
+  text: string;
+  /** Maps an offset in `text` back to one in the original query. */
+  originalOffset(at: number): number;
+}
+
+/** Replace every template variable outside a string literal with a placeholder that parses in its place. */
+export function substituteTemplateVariables(query: string): Substituted {
+  let out = "";
+  const spans: Span[] = [];
+  let quote: string | undefined;
+  let depth = 0;
+  let i = 0;
+  while (i < query.length) {
+    const c = query[i];
+    if (quote) {
+      out += c;
+      if (c === "\\" && quote !== "`" && i + 1 < query.length) {
+        out += query[i + 1];
+        i += 2;
+        continue;
+      }
+      if (c === quote) quote = undefined;
+      i++;
+      continue;
+    }
+    if (c === "$" || (c === "[" && query[i + 1] === "[")) {
+      VARIABLE.lastIndex = i;
+      const m = VARIABLE.exec(query);
+      if (m) {
+        const name = (m[1] ?? m[2] ?? m[3]).split(/[:.]/)[0].trim();
+        const before = out.trimEnd();
+        let value: string;
+        if (depth > 0 || /\boffset$/i.test(before)) {
+          // `[${n}m]`: the unit follows, so only the number is substituted.
+          value = /[a-z]/i.test(query[i + m[0].length] ?? "") ? NUMBER : DURATION;
+        } else if (isNumericMacro(name) || before.endsWith("@")) {
+          value = NUMBER;
+        } else {
+          value = IDENTIFIER;
+        }
+        spans.push({ at: out.length, length: value.length, original: i, originalLength: m[0].length });
+        out += value;
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (c === '"' || c === "'" || c === "`") quote = c;
+    else if (c === "[") depth++;
+    else if (c === "]" && depth > 0) depth--;
+    out += c;
+    i++;
+  }
+  return {
+    text: out,
+    originalOffset(at: number): number {
+      let shift = 0;
+      for (const s of spans) {
+        if (at < s.at) break;
+        if (at < s.at + s.length) return s.original;
+        shift = s.original + s.originalLength - (s.at + s.length);
+      }
+      return at + shift;
+    },
+  };
+}
+
+export type PromqlSyntax = { ok: true } | { ok: false; message: string };
+
+/** Check one query's PromQL syntax after substituting its template variables. */
+export function checkGrafanaPromql(query: string): PromqlSyntax {
+  const substituted = substituteTemplateVariables(query);
+  const checked = checkPromql(substituted.text);
+  if (checked.ok) return { ok: true };
+  const at = Math.min(substituted.originalOffset(checked.position), query.length);
+  if (at >= query.length) return { ok: false, message: `the expression ends early (after "${query.slice(Math.max(0, at - 30)).trim()}")` };
+  const before = query.slice(Math.max(0, at - 30), at);
+  const after = query.slice(at, at + 30);
+  return { ok: false, message: `syntax error at offset ${at}: "${before}" >>> "${after}"` };
+}
+
+/**
+ * The PromQL inside a Prometheus query variable's query. Grafana handles
+ * `label_names()`, `label_values(selector, label)`, `metrics(regex)` and
+ * `query_result(expr)` itself and sends only the selector or expression; any
+ * other text is a series selector (`/api/v1/series?match[]=`).
+ */
+export function variablePromql(query: string): string[] {
+  const q = query.trim();
+  if (q === "" || /^label_names\(\s*\)$/.test(q)) return [];
+  let m = /^label_names\((.+)\)$/.exec(q);
+  if (m) return [m[1]];
+  m = /^label_values\((?:(.+),\s*)?([a-zA-Z_$][a-zA-Z0-9_]*)\)$/.exec(q);
+  if (m) return m[1] ? [m[1]] : [];
+  if (/^metrics\((.+)\)$/.test(q)) return [];
+  m = /^query_result\((.+)\)$/.exec(q);
+  if (m) return [m[1]];
+  return [q];
+}
+
+function variableQueryText(variable: Json): string | undefined {
+  const q = variable.query;
+  if (typeof q === "string") return q;
+  if (q && typeof q === "object" && typeof (q as Json).query === "string") return (q as Json).query as string;
+  return undefined;
+}
+
+/** One piece of PromQL a dashboard sends to Prometheus, and where it is written. */
+export interface PromqlUse {
+  where: string;
+  expr: string;
+}
+
+/** The PromQL of one dashboard (or, for a library panel, a one-panel stand-in); `library` names the `__elements` key. */
+function usesOf(dashboard: Json, known: ReadonlyMap<string, KnownDatasource>, library?: string): PromqlUse[] {
+  const out: PromqlUse[] = [];
+  for (const use of datasourceUses(dashboard, known)) {
+    if (use.resolved.type !== "prometheus") continue;
+    if (use.kind === "query") {
+      const expr = use.target?.expr;
+      if (typeof expr !== "string" || expr.trim() === "") continue;
+      out.push({ where: library ? `library panel "${library}" query ${String(use.target?.refId ?? "?")}` : use.where, expr });
+    } else if (use.kind === "annotation" && use.annotation) {
+      // A Prometheus annotation keeps its query in `target.expr`, or at the top level when saved before Grafana 10.
+      const expr = use.target?.expr ?? use.annotation.expr;
+      if (typeof expr === "string" && expr.trim() !== "") out.push({ where: `${use.where} query`, expr });
+    } else if (use.kind === "variable" && use.variable?.type === "query" && !library) {
+      const text = variableQueryText(use.variable);
+      if (text) for (const expr of variablePromql(text)) out.push({ where: `${use.where} query`, expr });
+    }
+  }
+  return out;
+}
+
+/** Every PromQL query a dashboard sends to Prometheus: panel queries, query variables and the library panels an export embeds in `__elements`. */
+export function prometheusQueries(dashboard: Json, known: ReadonlyMap<string, KnownDatasource>): PromqlUse[] {
+  const out = usesOf(dashboard, known);
+  const elements = dashboard.__elements;
+  if (elements && typeof elements === "object" && !Array.isArray(elements)) {
+    // The dashboard's variables, so a library panel's `${DS_...}` ref resolves as the dashboard's would.
+    const templating = { list: variablesOf(dashboard) };
+    for (const [key, element] of Object.entries(elements as Json)) {
+      const model = element && typeof element === "object" ? (element as Json).model : undefined;
+      if (!model || typeof model !== "object" || Array.isArray(model)) continue;
+      out.push(...usesOf({ templating, panels: [model] }, known, key));
+    }
+  }
+  return out;
+}

package/src/query-models.ts

@@ -0,0 +1,94 @@
+/**
+ * Hand-written query models for the datasources that have no schema.
+ *
+ * PostgreSQL, MySQL and Microsoft SQL Server share one query model, defined
+ * in TypeScript in Grafana's `@grafana/sql` package with no CUE kind, so
+ * foundation-sdk publishes no JSON Schema for it and `npm run generate` has
+ * nothing to read. The types here follow `packages/grafana-sql/src` at
+ * Grafana v13.2.2, cited per type. The three plugins bundled with
+ * grafana/grafana:13.2.2 (grafana-postgresql-datasource 13.0.3, mysql 13.1.2,
+ * mssql 13.0.5) use this model unchanged. GRAF107 does not check these
+ * queries' fields; the dashboard schema's `Panel` still checks the panel.
+ */
+
+/** `QueryEditorExpressionType`, packages/grafana-sql/src/expressions.ts:34-42. */
+export type SqlExpressionType = "property" | "operator" | "or" | "and" | "groupBy" | "function" | "functionParameter";
+
+/** `QueryEditorProperty`, packages/grafana-sql/src/expressions.ts:5-8 (its type is the one-member `QueryEditorPropertyType`). */
+export interface SqlProperty {
+  type: "string";
+  name?: string;
+}
+
+/** `QueryEditorFunctionParameterExpression`, packages/grafana-sql/src/expressions.ts:64-67. */
+export interface SqlFunctionParameterExpression {
+  type: "functionParameter";
+  name?: string;
+}
+
+/** `QueryEditorFunctionExpression`, packages/grafana-sql/src/expressions.ts:57-62: a selected column, optionally wrapped in an aggregation. */
+export interface SqlFunctionExpression {
+  type: "function";
+  name?: string;
+  alias?: string;
+  parameters?: SqlFunctionParameterExpression[];
+}
+
+/** `QueryEditorGroupByExpression`, packages/grafana-sql/src/expressions.ts:52-55. */
+export interface SqlGroupByExpression {
+  type: "groupBy";
+  property: SqlProperty;
+}
+
+/** `QueryEditorPropertyExpression`, packages/grafana-sql/src/expressions.ts:29-32. */
+export interface SqlPropertyExpression {
+  type: "property";
+  property: SqlProperty;
+}
+
+/**
+ * The visual builder's query: `SQLExpression`, packages/grafana-sql/src/types.ts:67-77.
+ * `whereJsonTree` is react-awesome-query-builder's `JsonTree`, carried as data.
+ */
+export interface SqlBuilderQuery {
+  columns?: SqlFunctionExpression[];
+  whereJsonTree?: Record<string, unknown>;
+  whereString?: string;
+  filters?: Array<{ name: string; value: string }>;
+  groupBy?: SqlGroupByExpression[];
+  orderBy?: SqlPropertyExpression;
+  orderByDirection?: "ASC" | "DESC";
+  limit?: number;
+  offset?: number;
+}
+
+/** `QueryFormat`, packages/grafana-sql/src/types.ts:39-42. */
+export type SqlQueryFormat = "time_series" | "table";
+
+/**
+ * A PostgreSQL, MySQL or MSSQL query: `SQLQuery`, packages/grafana-sql/src/types.ts:46-56,
+ * over `DataQuery` from @grafana/schema (refId, hide, key, queryType, datasource).
+ *
+ * In code mode (`editorMode: "code"`, `rawQuery: true`) `rawSql` is the
+ * query; in builder mode `dataset`, `table` and `sql` describe it and Grafana
+ * writes the generated SQL to `rawSql`.
+ */
+export interface SqlQueryModel {
+  refId?: string;
+  hide?: boolean;
+  key?: string;
+  queryType?: string;
+  datasource?: { type?: string; uid?: string };
+  /** The SQL, with Grafana's `$__timeFilter()` and other macros. */
+  rawSql?: string;
+  format?: SqlQueryFormat;
+  alias?: string;
+  dataset?: string;
+  table?: string;
+  sql?: SqlBuilderQuery;
+  /** `EditorMode` from @grafana/plugin-ui: the raw SQL editor or the visual builder. */
+  editorMode?: "code" | "builder";
+  rawQuery?: boolean;
+  /** `SQLQueryMeta`, packages/grafana-sql/src/types.ts:44: which columns a variable query takes its values and texts from. */
+  meta?: { valueField?: string; textField?: string };
+}

package/src/query.test.ts

@@ -0,0 +1,166 @@
+/**
+ * The query classes beyond Prometheus, Tempo and Loki (#2951): each renders
+ * as a target of its plugin, GRAF107 checks the schema-typed ones, the
+ * PostgreSQL class answers to the plugin's old id, and GRAF108 still parses
+ * only what reaches a Prometheus.
+ */
+import { describe, expect, test } from "vitest";
+import { Dashboard } from "./dashboard";
+import { Datasource } from "./datasource";
+import { TablePanel, TimeSeriesPanel } from "./panels";
+import {
+  AzureMonitorQuery,
+  BigQueryQuery,
+  CloudMonitoringQuery,
+  CloudWatchQuery,
+  ElasticsearchQuery,
+  LokiQuery,
+  MSSQLQuery,
+  MySQLQuery,
+  PostgresQuery,
+  PromQuery,
+  PyroscopeQuery,
+  queryDefinitionFor,
+  registeredQueries,
+} from "./query";
+import { renderDashboard } from "./build";
+import { validateDashboardSchema } from "./schema-validate";
+import { prometheusQueries } from "./promql-check";
+import { knownDatasources } from "./datasource-refs";
+import { SCHEMA_NAMES } from "./pin";
+
+type Json = Record<string, unknown>;
+
+const es = new Datasource({ name: "Logs", type: "elasticsearch" });
+const cw = new Datasource({ name: "CloudWatch", type: "cloudwatch" });
+const az = new Datasource({ name: "Azure", type: "grafana-azure-monitor-datasource" });
+const gcm = new Datasource({ name: "GCM", type: "stackdriver" });
+const bq = new Datasource({ name: "BigQuery", type: "grafana-bigquery-datasource" });
+const py = new Datasource({ name: "Pyroscope", type: "grafana-pyroscope-datasource" });
+const pg = new Datasource({ name: "Postgres", type: "grafana-postgresql-datasource" });
+const pgOld = new Datasource({ name: "Postgres old", type: "postgres" });
+const my = new Datasource({ name: "MySQL", type: "mysql" });
+const ms = new Datasource({ name: "MSSQL", type: "mssql" });
+const prom = new Datasource({ name: "Prometheus", type: "prometheus" });
+const loki = new Datasource({ name: "Loki", type: "loki" });
+
+function render(panels: unknown[]): Json {
+  return renderDashboard(new Dashboard({ title: "Q", uid: "q", panels: panels as never })) as unknown as Json;
+}
+
+const targetsOf = (json: Json, i = 0) => ((json.panels as Json[])[i].targets as Json[]);
+
+describe("query classes", () => {
+  test("every query schema at the pin has a class, and every class names a schema or is hand-typed", () => {
+    const schemas = registeredQueries().filter((d) => d.builtin).flatMap((d) => (d.schema ? [d.schema] : []));
+    expect(schemas.sort()).toEqual(
+      ["prometheus", "tempo", "loki", "elasticsearch", "cloudwatch", "azuremonitor", "googlecloudmonitoring", "bigquery", "grafanapyroscope"].sort(),
+    );
+    expect(schemas.every((s) => (SCHEMA_NAMES as readonly string[]).includes(s))).toBe(true);
+    expect(registeredQueries().filter((d) => d.builtin && !d.schema).map((d) => d.className).sort()).toEqual(["MSSQLQuery", "MySQLQuery", "PostgresQuery"]);
+  });
+
+  test("each renders as a target of its plugin and passes GRAF107", () => {
+    const json = render([
+      new TimeSeriesPanel({
+        datasource: es,
+        targets: [
+          new ElasticsearchQuery({
+            query: "level:error",
+            timeField: "@timestamp",
+            metrics: [{ id: "1", type: "count" }],
+            bucketAggs: [{ id: "2", type: "date_histogram", field: "@timestamp", settings: { interval: "auto" } }],
+          }),
+        ],
+      }),
+      new TimeSeriesPanel({
+        datasource: cw,
+        targets: [
+          new CloudWatchQuery({ queryMode: "Metrics", namespace: "AWS/Lambda", metricName: "Errors", statistic: "Sum", dimensions: { FunctionName: "checkout" } }),
+          new CloudWatchQuery({ queryMode: "Logs", expression: "fields @message | limit 20", logGroups: [{ arn: "arn:aws:logs:x", name: "/x" }] }),
+        ],
+      }),
+      new TablePanel({
+        datasource: az,
+        targets: [new AzureMonitorQuery({ queryType: "Azure Log Analytics", azureLogAnalytics: { query: "AppRequests | take 10", resources: ["/subscriptions/x"] } })],
+      }),
+      new TimeSeriesPanel({
+        datasource: gcm,
+        targets: [new CloudMonitoringQuery({ queryType: "promQL", promQLQuery: { projectName: "p", expr: "up", step: "10s" } })],
+      }),
+      new TablePanel({ datasource: bq, targets: [new BigQueryQuery({ rawSql: "SELECT 1", project: "p" })] }),
+      new TimeSeriesPanel({ datasource: py, targets: [new PyroscopeQuery({ profileTypeId: "process_cpu:cpu:nanoseconds:cpu:nanoseconds", queryType: "metrics" })] }),
+      new TablePanel({ datasource: pg, targets: [new PostgresQuery({ rawSql: "SELECT now()", format: "table", editorMode: "code", rawQuery: true })] }),
+      new TablePanel({ datasource: my, targets: [new MySQLQuery({ rawSql: "SELECT 1" })] }),
+      new TablePanel({ datasource: ms, targets: [new MSSQLQuery({ rawSql: "SELECT TOP 1 1" })] }),
+    ]);
+    const types = (json.panels as Json[]).map((p) => (targetsOf({ panels: [p] })[0].datasource as Json).type);
+    expect(types).toEqual([
+      "elasticsearch",
+      "cloudwatch",
+      "grafana-azure-monitor-datasource",
+      "stackdriver",
+      "grafana-bigquery-datasource",
+      "grafana-pyroscope-datasource",
+      "grafana-postgresql-datasource",
+      "mysql",
+      "mssql",
+    ]);
+    expect(targetsOf(json, 1).map((t) => t.refId)).toEqual(["A", "B"]);
+    expect(validateDashboardSchema(json)).toEqual([]);
+  });
+
+  test("GRAF107 checks the schema-typed models: a wrong value is an error, an unknown key a warning", () => {
+    const json = render([
+      new TimeSeriesPanel({
+        datasource: es,
+        // @ts-expect-error a bucket aggregation type the schema does not list
+        targets: [new ElasticsearchQuery({ query: "*", bucketAggs: [{ id: "2", type: "histogramz" }] })],
+      }),
+      new TimeSeriesPanel({
+        datasource: cw,
+        // @ts-expect-error queryMode is Metrics, Logs or Annotations
+        targets: [new CloudWatchQuery({ queryMode: "Traces", namespace: "x" })],
+      }),
+      new TablePanel({
+        datasource: bq,
+        // @ts-expect-error BigQuery's query has no expr
+        targets: [new BigQueryQuery({ rawSql: "SELECT 1", expr: "x" })],
+      }),
+    ]);
+    const problems = validateDashboardSchema(json);
+    expect(problems.filter((p) => p.path.startsWith("/panels/0/targets/0/bucketAggs")).some((p) => p.severity === "error")).toBe(true);
+    expect(problems.some((p) => p.path.startsWith("/panels/1/targets/0") && p.severity === "error")).toBe(true);
+    expect(problems).toContainEqual({ path: "/panels/2/targets/0", message: 'unknown key "expr" (not in the pinned schema)', severity: "warning" });
+  });
+
+  test("a query only takes a datasource of its own plugin type", () => {
+    // @ts-expect-error a MySQL query cannot go to a Postgres datasource
+    new MySQLQuery({ rawSql: "SELECT 1", datasource: pg });
+    // @ts-expect-error nor an Elasticsearch query to Loki
+    new ElasticsearchQuery({ query: "*", datasource: loki });
+    expect(new PostgresQuery({ rawSql: "SELECT 1", datasource: pgOld }).props.datasource).toBe(pgOld);
+  });
+
+  test("the PostgreSQL class answers to the plugin's old id, postgres", () => {
+    expect(queryDefinitionFor("postgres")?.className).toBe("PostgresQuery");
+    expect(queryDefinitionFor("grafana-postgresql-datasource")?.className).toBe("PostgresQuery");
+    expect(registeredQueries().filter((d) => d.className === "PostgresQuery")).toHaveLength(1);
+  });
+});
+
+describe("GRAF108 routing with the new query types", () => {
+  test("only queries that reach a Prometheus are parsed, whatever field holds PromQL-looking text", () => {
+    const json = render([
+      new TimeSeriesPanel({ datasource: prom, targets: [new PromQuery({ expr: "sum(rate(x[5m]))" })] }),
+      new TimeSeriesPanel({ datasource: gcm, targets: [new CloudMonitoringQuery({ queryType: "promQL", promQLQuery: { projectName: "p", expr: "sum(", step: "1m" } })] }),
+      new TimeSeriesPanel({ datasource: loki, targets: [new LokiQuery({ expr: 'sum(rate({job="x"}[5m]' })] }),
+      new TablePanel({ datasource: pg, targets: [new PostgresQuery({ rawSql: "SELECT sum(" })] }),
+      new TimeSeriesPanel({ datasource: cw, targets: [new CloudWatchQuery({ queryMode: "Metrics", namespace: "", expression: "SUM(METRICS(" })] }),
+    ]);
+    const known = knownDatasources(
+      [prom, gcm, loki, pg, cw].map((d) => ({ name: d.props.name, type: d.datasourceType, uid: d.uid })),
+    );
+    expect(prometheusQueries(json, known).map((q) => q.expr)).toEqual(["sum(rate(x[5m]))"]);
+  });
+});