@intentius/chant-lexicon-grafana 0.99.0 → 0.100.0

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]))"]);
+  });
+});

package/src/query.ts

@@ -1,7 +1,11 @@
 /**
- * Typed queries, one class per datasource plugin: `PromQuery` (PromQL),
- * `TempoQuery` (TraceQL) and `LokiQuery` (LogQL), each typed from that
- * plugin's query schema at `GRAFANA_SCHEMA_PIN`.
+ * Typed queries, one class per datasource plugin. `PromQuery` (PromQL),
+ * `TempoQuery` (TraceQL), `LokiQuery` (LogQL), `ElasticsearchQuery`,
+ * `CloudWatchQuery`, `AzureMonitorQuery`, `CloudMonitoringQuery`,
+ * `BigQueryQuery` and `PyroscopeQuery` are typed from that plugin's query
+ * schema at `GRAFANA_SCHEMA_PIN`. `PostgresQuery`, `MySQLQuery` and
+ * `MSSQLQuery` have no schema upstream and are typed by hand from Grafana's
+ * source (`./query-models.ts`).
  *
  * The expression is a string. What the lexicon checks is where the query
  * goes: `datasource` only accepts a datasource of the query's own plugin
@@ -21,6 +25,13 @@ import type { SchemaName } from "./pin";
 import type { Dataquery as PrometheusDataquery } from "./schema/prometheus.gen";
 import type { Dataquery as TempoDataquery } from "./schema/tempo.gen";
 import type { Dataquery as LokiDataquery } from "./schema/loki.gen";
+import type { Dataquery as ElasticsearchDataquery } from "./schema/elasticsearch.gen";
+import type { Request as CloudWatchRequest } from "./schema/cloudwatch.gen";
+import type { MonitorQuery as AzureMonitorDataquery } from "./schema/azuremonitor.gen";
+import type { CloudMonitoringQuery as CloudMonitoringDataquery } from "./schema/googlecloudmonitoring.gen";
+import type { Dataquery as BigQueryDataquery } from "./schema/bigquery.gen";
+import type { Dataquery as PyroscopeDataquery } from "./schema/grafanapyroscope.gen";
+import type { SqlQueryModel } from "./query-models";
 
 /** Where a query or panel sends its request: a declared or external datasource, a datasource variable, or the ref of one declared elsewhere. */
 export type DatasourceInput<T extends string = string> =
@@ -29,8 +40,26 @@ export type DatasourceInput<T extends string = string> =
   | DatasourceVariableEntity<T>
   | DatasourceRef<T>;
 
-/** A query model's fields, less what chant fills in (`datasource`, `refId` stays optional). */
-export type QueryModel<M> = Omit<M, "datasource">;
+/**
+ * A query model's fields, less what chant fills in (`datasource`, `refId`
+ * stays optional). A model that is a union (CloudWatch's metrics, logs and
+ * annotation queries) stays one, member by member.
+ */
+export type QueryModel<M> = M extends unknown ? Omit<M, "datasource"> : never;
+
+/** `M` with the fields `K` optional, member by member: for fields a schema requires that Grafana fills in when they are missing. */
+export type Loosen<M, K extends PropertyKey> = M extends unknown ? Omit<M, K> & Partial<Pick<M, K & keyof M>> : never;
+
+type KeysOfUnion<U> = U extends unknown ? keyof U : never;
+
+/**
+ * A union of models as one object type: every member's fields, each
+ * optional, typed as the union of what the members allow there. A class
+ * whose props are a union could not have a single prop named by
+ * `PropsOf<typeof Class>["key"]`, which is how imported source types its
+ * lifted consts.
+ */
+export type MergedModel<U> = { [K in KeysOfUnion<U>]?: U extends unknown ? (K extends keyof U ? U[K] : never) : never };
 
 export type QueryProps<M, T extends string> = QueryModel<M> & {
   /** Overrides the panel's datasource for this query. */
@@ -51,6 +80,12 @@ export interface QueryDefinition<T extends string = string, M = Record<string, u
   defaults?: Partial<M>;
   /** True only for the queries this package ships. */
   builtin: boolean;
+  /**
+   * Other plugin ids Grafana accepts for the same plugin (`aliasIDs` in its
+   * plugin.json), e.g. `postgres` for `grafana-postgresql-datasource`. The
+   * class is registered under each, so imports and GRAF107 find it by either.
+   */
+  aliases?: readonly string[];
 }
 
 export interface QueryEntity<T extends string = string, M = Record<string, unknown>> extends Declarable {
@@ -71,9 +106,9 @@ function registry(): Map<string, QueryDefinition> {
   return (g[REGISTRY_KEY] ??= new Map());
 }
 
-/** Every registered query definition, keyed by datasource type. */
+/** Every registered query definition, once each (a definition with aliases is registered under several types). */
 export function registeredQueries(): QueryDefinition[] {
-  return [...registry().values()];
+  return [...new Set(registry().values())];
 }
 
 export function queryDefinitionFor(datasourceType: string): QueryDefinition | undefined {
@@ -85,7 +120,7 @@ function makeQueryClass<T extends string, M>(def: QueryDefinition<T, M>): QueryC
   if (existing?.builtin && !def.builtin) {
     throw new Error(`grafana: queries for "${def.datasourceType}" are built in (${existing.className}); use that class.`);
   }
-  registry().set(def.datasourceType, def as unknown as QueryDefinition);
+  for (const type of [def.datasourceType, ...(def.aliases ?? [])]) registry().set(type, def as unknown as QueryDefinition);
   const Base = createProperty(`${QUERY_TYPE_PREFIX}${def.datasourceType}`, "grafana") as unknown as (
     this: object,
     props: Record<string, unknown>,
@@ -104,11 +139,11 @@ function makeQueryClass<T extends string, M>(def: QueryDefinition<T, M>): QueryC
  *
  * @example
  * ```ts
- * interface ElasticQueryModel { query: string; metrics?: Array<{ type: string; id: string }>; refId?: string }
+ * interface OpenSearchQueryModel { query: string; queryType?: "lucene" | "PPL"; refId?: string }
  *
- * export const ElasticQuery = defineQuery<ElasticQueryModel>()({
- *   datasourceType: "elasticsearch",
- *   className: "ElasticQuery",
+ * export const OpenSearchQuery = defineQuery<OpenSearchQueryModel>()({
+ *   datasourceType: "grafana-opensearch-datasource",
+ *   className: "OpenSearchQuery",
  *   expressionField: "query",
  * });
  * ```
@@ -160,6 +195,136 @@ export const LokiQuery = makeQueryClass<"loki", LokiDataquery>({
   builtin: true,
 });
 
+/**
+ * An Elasticsearch query: `query` is Lucene (or the query string of a raw
+ * data, raw document or logs query), `metrics` and `bucketAggs` the
+ * aggregations.
+ */
+export const ElasticsearchQuery = makeQueryClass<"elasticsearch", ElasticsearchDataquery>({
+  datasourceType: "elasticsearch",
+  className: "ElasticsearchQuery",
+  description: "An Elasticsearch query; query is Lucene, metrics and bucketAggs the aggregations",
+  schema: "elasticsearch",
+  expressionField: "query",
+  builtin: true,
+});
+
+/**
+ * A CloudWatch query: a metrics query (`queryMode: "Metrics"`), a Logs
+ * Insights query (`queryMode: "Logs"`, `expression` in `queryLanguage`) or an
+ * annotation query. The three schema definitions are merged into one type
+ * with every field but `queryMode` optional, so each field is one prop;
+ * GRAF107 checks the fields against the three definitions. Grafana's editor
+ * starts `id` and `region` at `""` and `"default"`
+ * (public/app/plugins/datasource/cloudwatch/defaultQueries.ts:12-27 and
+ * 41-52 at v13.2.2), and the backend reads a missing region as the
+ * datasource's default (pkg/tsdb/cloudwatch/cloudwatch.go:65).
+ */
+export const CloudWatchQuery = makeQueryClass<"cloudwatch", MergedModel<CloudWatchRequest> & Pick<CloudWatchRequest, "queryMode">>({
+  datasourceType: "cloudwatch",
+  className: "CloudWatchQuery",
+  description: "A CloudWatch metrics, Logs Insights or annotation query, by queryMode",
+  schema: "cloudwatch",
+  expressionField: "expression",
+  builtin: true,
+});
+
+/**
+ * An Azure Monitor query: `queryType` picks which of `azureMonitor`,
+ * `azureLogAnalytics` (KQL), `azureResourceGraph` or `azureTraces` holds it.
+ */
+export const AzureMonitorQuery = makeQueryClass<"grafana-azure-monitor-datasource", AzureMonitorDataquery>({
+  datasourceType: "grafana-azure-monitor-datasource",
+  className: "AzureMonitorQuery",
+  description: "An Azure Monitor metrics, Log Analytics (KQL), Resource Graph or traces query, by queryType",
+  schema: "azuremonitor",
+  builtin: true,
+});
+
+/**
+ * A Google Cloud Monitoring query (plugin id `stackdriver`): `queryType`
+ * picks which of `timeSeriesList`, `timeSeriesQuery` (MQL), `sloQuery` or
+ * `promQLQuery` holds it.
+ */
+export const CloudMonitoringQuery = makeQueryClass<"stackdriver", CloudMonitoringDataquery>({
+  datasourceType: "stackdriver",
+  className: "CloudMonitoringQuery",
+  description: "A Google Cloud Monitoring time series, MQL, SLO or PromQL query, by queryType",
+  schema: "googlecloudmonitoring",
+  builtin: true,
+});
+
+/**
+ * A BigQuery query: `rawSql` is GoogleSQL. `format` and `rawSql` may be left
+ * out: the plugin fills in `table` and `""` (src/utils.ts:147-160 in
+ * grafana/google-bigquery-datasource v3.4.2).
+ */
+export const BigQueryQuery = makeQueryClass<"grafana-bigquery-datasource", Loosen<BigQueryDataquery, "format" | "rawSql">>({
+  datasourceType: "grafana-bigquery-datasource",
+  className: "BigQueryQuery",
+  description: "A BigQuery query; rawSql is GoogleSQL",
+  schema: "bigquery",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
+/**
+ * A Grafana Pyroscope query: `labelSelector` selects the profiles of
+ * `profileTypeId`. `labelSelector` and `groupBy` may be left out: the plugin
+ * starts them at `{}` and none (dataquery.ts:67-75 and datasource.ts:156-164
+ * in grafana-pyroscope-datasource 13.0.4, the version bundled with
+ * grafana/grafana:13.2.2).
+ */
+export const PyroscopeQuery = makeQueryClass<"grafana-pyroscope-datasource", Loosen<PyroscopeDataquery, "labelSelector" | "groupBy">>({
+  datasourceType: "grafana-pyroscope-datasource",
+  className: "PyroscopeQuery",
+  description: "A Grafana Pyroscope profile or metrics query; labelSelector selects the profiles",
+  schema: "grafanapyroscope",
+  expressionField: "labelSelector",
+  builtin: true,
+});
+
+/**
+ * A PostgreSQL query: `rawSql` is SQL with Grafana's macros. Also used for
+ * the plugin's old id, `postgres` (an `aliasIDs` entry in the plugin.json of
+ * grafana-postgresql-datasource 13.0.3, bundled with grafana/grafana:13.2.2).
+ */
+export const PostgresQuery = makeQueryClass<"grafana-postgresql-datasource" | "postgres", SqlQueryModel>({
+  datasourceType: "grafana-postgresql-datasource",
+  aliases: ["postgres"],
+  className: "PostgresQuery",
+  description: "A PostgreSQL query; rawSql is SQL with Grafana's macros",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
+/** A MySQL query: `rawSql` is SQL with Grafana's macros. */
+export const MySQLQuery = makeQueryClass<"mysql", SqlQueryModel>({
+  datasourceType: "mysql",
+  className: "MySQLQuery",
+  description: "A MySQL query; rawSql is SQL with Grafana's macros",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
+/** A Microsoft SQL Server query: `rawSql` is T-SQL with Grafana's macros. */
+export const MSSQLQuery = makeQueryClass<"mssql", SqlQueryModel>({
+  datasourceType: "mssql",
+  className: "MSSQLQuery",
+  description: "A Microsoft SQL Server query; rawSql is T-SQL with Grafana's macros",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
 export type PromQueryEntity = InstanceType<typeof PromQuery>;
 export type TempoQueryEntity = InstanceType<typeof TempoQuery>;
 export type LokiQueryEntity = InstanceType<typeof LokiQuery>;
+export type ElasticsearchQueryEntity = InstanceType<typeof ElasticsearchQuery>;
+export type CloudWatchQueryEntity = InstanceType<typeof CloudWatchQuery>;
+export type AzureMonitorQueryEntity = InstanceType<typeof AzureMonitorQuery>;
+export type CloudMonitoringQueryEntity = InstanceType<typeof CloudMonitoringQuery>;
+export type BigQueryQueryEntity = InstanceType<typeof BigQueryQuery>;
+export type PyroscopeQueryEntity = InstanceType<typeof PyroscopeQuery>;
+export type PostgresQueryEntity = InstanceType<typeof PostgresQuery>;
+export type MySQLQueryEntity = InstanceType<typeof MySQLQuery>;
+export type MSSQLQueryEntity = InstanceType<typeof MSSQLQuery>;