@intentius/chant-lexicon-grafana 0.99.0 → 0.100.0

package/src/import/parser.ts

@@ -47,6 +47,7 @@ import * as jsYaml from "js-yaml";
 import type { TemplateIR, TemplateParser, ResourceIR } from "@intentius/chant/import/parser";
 import { DASHBOARD_SCHEMA_VERSION } from "../schema/dashboard.gen";
 import { BUILTIN_DATASOURCE_UIDS } from "../datasource";
+import { JSONDATA_LINKS } from "../datasource-settings";
 import {
   looksLikeDashboard,
   looksLikeAlertingProvisioning,
@@ -149,9 +150,21 @@ const PACKAGE_CLASS_NAMES = new Set([
   "DatasourceVariable",
   "ConstantVariable",
   "TextboxVariable",
+  "AdhocVariable",
+  "GroupByVariable",
+  "SwitchVariable",
   "PromQuery",
   "TempoQuery",
   "LokiQuery",
+  "ElasticsearchQuery",
+  "CloudWatchQuery",
+  "AzureMonitorQuery",
+  "CloudMonitoringQuery",
+  "BigQueryQuery",
+  "PyroscopeQuery",
+  "PostgresQuery",
+  "MySQLQuery",
+  "MSSQLQuery",
   "TimeSeriesPanel",
   "StatPanel",
   "GaugePanel",
@@ -187,6 +200,8 @@ const PACKAGE_CLASS_NAMES = new Set([
   "MuteTiming",
   "NotificationTemplate",
   "ExternalDatasource",
+  "DatasourceProvisioning",
+  "Folder",
 ]);
 
 function words(text: string): string[] {
@@ -526,6 +541,52 @@ class DashboardConverter {
     return ids;
   }
 
+  // ── annotations ─────────────────────────────────────────────────
+
+  /**
+   * `annotations.list` as `Dashboard.annotations`: every entry but the
+   * built-in one Grafana adds anyway, with its datasource resolved like a
+   * panel's and every other key as it is. `enable` and `iconColor`, which
+   * the schema requires and the build fills in, are recorded when missing.
+   */
+  annotations(): Json[] {
+    const container = this.d.annotations;
+    if (container === undefined || container === null) return [];
+    if (!isObject(container) || !Array.isArray(container.list)) {
+      this.report.drop(pointer("annotations"), "dashboard", "annotations", "(it is not an annotations.list)");
+      return [];
+    }
+    for (const key of Object.keys(container)) if (key !== "list") this.report.drop(pointer("annotations", key), "annotations", key, NO_PROP);
+    const out: Json[] = [];
+    container.list.forEach((a, i) => {
+      if (isBuiltinAnnotation(a)) return;
+      const path = (...rest: string[]) => pointer("annotations", "list", i, ...rest);
+      if (!isObject(a) || typeof a.name !== "string") {
+        this.report.drop(path(), "annotations", `entry ${i}`, "(it is not a named annotation query)");
+        return;
+      }
+      const subject = `annotation "${a.name}"`;
+      const props: Json = {};
+      for (const [key, value] of Object.entries(a)) {
+        if (value === null || value === undefined) {
+          this.report.drop(path(key), subject, key);
+          continue;
+        }
+        if (key !== "datasource") {
+          props[key] = value;
+          continue;
+        }
+        const ds = this.resolveDatasource(value, path(key), subject);
+        if (ds === "mixed") this.report.drop(path(key), subject, key, MIXED_ELSEWHERE);
+        else if (ds) props.datasource = ds.value;
+      }
+      if (typeof a.enable !== "boolean") this.report.replace(path("enable"), true, subject, "enable", "is missing, so it is written as true, which runs the query");
+      if (typeof a.iconColor !== "string") this.report.replace(path("iconColor"), "red", subject, "iconColor", "is missing, so it is written as red");
+      out.push(props);
+    });
+    return out;
+  }
+
   // ── variables ───────────────────────────────────────────────────
 
   variable(json: unknown, index: number): string | undefined {
@@ -539,7 +600,7 @@ class DashboardConverter {
     const type = String(json.type);
     const mapping = VARIABLE_MAPPINGS[type];
     if (!mapping) {
-      this.report.drop(path, subject, "", `(${type}) is not carried: chant has no ${type} variable yet (#2952), so it is left out`);
+      this.report.drop(path, subject, "", `(${type}) is not carried: chant has no ${type} variable, so it is left out`);
       return undefined;
     }
     let dropped = false;
@@ -883,6 +944,7 @@ class DashboardConverter {
     const variableRefs = [...inputIds, ...templating.map((_, i) => varIds.get(i)).filter((x): x is string => x !== undefined)].map(declRef);
 
     const panelRefs = this.items();
+    const annotations = this.annotations();
     this.settleExternals();
     if (this.legacyPanels > 0) {
       this.report.warn(
@@ -920,18 +982,7 @@ class DashboardConverter {
     if (variableRefs.length > 0) props.variables = variableRefs;
     if (panelRefs.length > 0) props.panels = panelRefs;
 
-    // Annotations: the built-in one is what Grafana adds anyway; any other is not carried yet.
-    const annotations = isObject(d.annotations) && Array.isArray(d.annotations.list) ? d.annotations.list : [];
-    const others = annotations.filter((a) => !isBuiltinAnnotation(a));
-    if (others.length > 0) {
-      const names = others.map((a) => (isObject(a) && typeof a.name === "string" ? `"${a.name}"` : "(unnamed)"));
-      this.report.drop(
-        pointer("annotations"),
-        "dashboard",
-        "",
-        `has ${others.length === 1 ? "the annotation" : "the annotations"} ${list(names)}, which ${others.length === 1 ? "is" : "are"} not carried: Dashboard has no annotations yet (#2953)`,
-      );
-    }
+    if (annotations.length > 0) props.annotations = annotations;
 
     const handled = new Set([
       ...DASHBOARD_FIELDS,
@@ -1032,10 +1083,55 @@ const DATASOURCE_FIELDS = [
   "version",
 ];
 
-/** Plan a datasource provisioning file: one `Datasource` per entry. */
+/**
+ * The `jsonData` paths of `ds` that hold another datasource's uid (see
+ * `JSONDATA_LINKS`), with the uid found there and the plugin types the
+ * field accepts.
+ */
+function jsonDataLinks(type: string, jsonData: Json): Array<{ path: Array<string | number>; uid: string; targets: readonly string[] }> {
+  const out: Array<{ path: Array<string | number>; uid: string; targets: readonly string[] }> = [];
+  const walk = (value: unknown, rest: readonly string[], at: Array<string | number>, targets: readonly string[]) => {
+    if (rest.length === 0) {
+      if (typeof value === "string" && value !== "") out.push({ path: at, uid: value, targets });
+      return;
+    }
+    const [head, ...tail] = rest;
+    if (head === "*") {
+      if (Array.isArray(value)) value.forEach((v, i) => walk(v, tail, [...at, i], targets));
+    } else if (isObject(value)) walk(value[head], tail, [...at, head], targets);
+  };
+  for (const link of JSONDATA_LINKS) if (!link.on || link.on.includes(type)) walk(jsonData, link.path, [], link.targets);
+  return out;
+}
+
+/** A copy of `value` with `replacement` at `path`. */
+function replaceAt(value: unknown, path: ReadonlyArray<string | number>, replacement: unknown): unknown {
+  if (path.length === 0) return replacement;
+  const [head, ...tail] = path;
+  if (Array.isArray(value)) return value.map((v, i) => (i === head ? replaceAt(v, tail, replacement) : v));
+  if (isObject(value)) return { ...value, [head]: replaceAt(value[head], tail, replacement) };
+  return value;
+}
+
+/**
+ * Plan a datasource provisioning file: one `Datasource` per entry, and a
+ * `DatasourceProvisioning` for the file's own settings when they differ
+ * from what the build writes by default (`prune: true`, no deletes): a file
+ * that does not prune gets `prune: false`, so the rebuilt file still does
+ * not.
+ *
+ * A uid in one entry's `jsonData` that names another entry of the file (a
+ * Tempo's `tracesToLogsV2.datasourceUid`, a Prometheus exemplar's
+ * `datasourceUid`, a Loki derived field's) becomes a reference to that
+ * entry's `Datasource`, so the link is type-checked, when the entry is of a
+ * plugin type the field accepts. Declarations are ordered so each refers
+ * only to ones before it; a link that would close a cycle (Tempo to Loki and
+ * Loki back to Tempo) stays a uid string. The build writes provisioned
+ * datasources sorted by name, so the order does not show in its output.
+ */
 export function planDatasourceProvisioning(doc: Json): { plan: Plan; warnings: string[] } {
   const report = new Report();
-  const declarations: Declaration[] = [];
+  const entries: Array<{ id: string; name: string; type: string; props: Json; uid?: string }> = [];
   const list = Array.isArray(doc.datasources) ? doc.datasources : [];
   list.forEach((ds, i) => {
     if (!isObject(ds) || typeof ds.name !== "string" || typeof ds.type !== "string") {
@@ -1047,12 +1143,67 @@ export function planDatasourceProvisioning(doc: Json): { plan: Plan; warnings: s
     for (const key of Object.keys(ds)) {
       if (!DATASOURCE_FIELDS.includes(key)) report.drop(pointer("datasources", i, key), `datasource "${ds.name}"`, key, NO_PROP);
     }
-    declarations.push({ id: `datasource:${i}`, kind: "new", className: "Datasource", props, name: ds.name, module: "datasources" });
+    entries.push({ id: `datasource:${i}`, name: ds.name, type: ds.type, props, ...(typeof ds.uid === "string" ? { uid: ds.uid } : {}) });
   });
+  const settings: Json = {};
+  if (doc.prune !== true) settings.prune = false;
+  if (doc.prune !== undefined && doc.prune !== null && typeof doc.prune !== "boolean") {
+    report.drop(pointer("prune"), "the provisioning file", "prune", `(${JSON.stringify(doc.prune)} is not true or false, so the file is written not to prune)`);
+  }
+  const deletes: Json[] = [];
+  (Array.isArray(doc.deleteDatasources) ? doc.deleteDatasources : []).forEach((d, i) => {
+    if (!isObject(d) || typeof d.name !== "string") {
+      report.drop(pointer("deleteDatasources", i), "deleteDatasources", `entry ${i}`, "(it names no datasource)");
+      return;
+    }
+    const orgId = typeof d.orgId === "number" ? d.orgId : undefined;
+    for (const key of Object.keys(d)) if (key !== "name" && key !== "orgId") report.drop(pointer("deleteDatasources", i, key), `deleteDatasources "${d.name}"`, key, NO_PROP);
+    deletes.push({ name: d.name, ...(orgId !== undefined ? { orgId } : {}) });
+  });
+  if (deletes.length > 0) settings.deleteDatasources = deletes;
+  if (doc.deleteDatasources !== undefined && !Array.isArray(doc.deleteDatasources)) report.drop(pointer("deleteDatasources"), "the provisioning file", "deleteDatasources", "(it is not a list)");
+  const settingsDeclarations: Declaration[] = [];
+  if (Object.keys(settings).length > 0) {
+    settingsDeclarations.push({ id: "datasource-provisioning", kind: "new", className: "DatasourceProvisioning", props: settings, name: "datasource provisioning", module: "datasources" });
+  }
   for (const key of Object.keys(doc)) {
-    if (key === "apiVersion" || key === "datasources") continue;
-    report.drop(pointer(key), "the provisioning file", key, "(chant writes datasources only; prune and deleteDatasources are #2953)");
+    if (key === "apiVersion" || key === "datasources" || key === "prune" || key === "deleteDatasources") continue;
+    report.drop(pointer(key), "the provisioning file", key, NO_PROP);
+  }
+
+  // Each entry's links to other entries of the file, by the uid they name.
+  const byUid = new Map(entries.filter((e) => e.uid !== undefined).map((e) => [e.uid!, e]));
+  const links = new Map(
+    entries.map((e) => {
+      const jsonData = e.props.jsonData;
+      const found = isObject(jsonData) ? jsonDataLinks(e.type, jsonData) : [];
+      return [e.id, found.flatMap((l) => {
+        const target = byUid.get(l.uid);
+        return target && target !== e && l.targets.includes(target.type) ? [{ path: l.path, target: target.id }] : [];
+      })];
+    }),
+  );
+  // File order, except that an entry waits for the entries it links to; a cycle is broken at the first entry left.
+  const declared = new Set<string>();
+  const declarations: Declaration[] = [];
+  while (declared.size < entries.length) {
+    const remaining = entries.filter((e) => !declared.has(e.id));
+    const next = remaining.find((e) => links.get(e.id)!.every((l) => declared.has(l.target))) ?? remaining[0];
+    let jsonData = next.props.jsonData;
+    for (const l of links.get(next.id)!) if (declared.has(l.target)) jsonData = replaceAt(jsonData, l.path, declRef(l.target));
+    const props = jsonData === undefined ? next.props : { ...next.props, jsonData };
+    declarations.push({
+      id: next.id,
+      kind: "new",
+      className: "Datasource",
+      typeArguments: [JSON.stringify(next.type)],
+      props,
+      name: next.name,
+      module: "datasources",
+    });
+    declared.add(next.id);
   }
+  declarations.push(...settingsDeclarations);
   return {
     plan: {
       directory: "",

package/src/import/roundtrip.test.ts

@@ -14,7 +14,7 @@
  * the check that nothing was dropped silently.
  *
  * The generated source must lint clean (COR001, COR004 and COR009 among
- * the rules), and the rebuilt dashboards must pass GRAF101-GRAF107 without
+ * the rules), and the rebuilt dashboards must pass GRAF101-GRAF110 without
  * errors. generated-types.e2e.test.ts type-checks the generated source.
  */
 
@@ -34,7 +34,19 @@ import { GrafanaParser, type DashboardResourceMetadata } from "./parser";
 import { GrafanaGenerator } from "./generator";
 import { applyEdits } from "./edits";
 import { normalizeDashboard } from "./normalize";
-import { COMMUNITY, KUBE_PROMETHEUS, LOSSY_V1_EXPORT, UI_EXPORTS, V2_EXPORTS, exampleOutputs, projectDir, read, removeDir, writeFiles } from "./testdata/fixtures";
+import {
+  COMMUNITY,
+  KUBE_PROMETHEUS,
+  LOSSY_V1_EXPORT,
+  PROVISIONING,
+  UI_EXPORTS,
+  V2_EXPORTS,
+  exampleOutputs,
+  projectDir,
+  read,
+  removeDir,
+  writeFiles,
+} from "./testdata/fixtures";
 
 type Json = Record<string, unknown>;
 
@@ -54,7 +66,7 @@ interface Imported {
   lint: { errorCount: number; warningCount: number; output: string };
 }
 
-/** GRAF101-GRAF107 over a build's grafana entities, as the post-synth checks run them: declared and external datasources included. */
+/** GRAF101-GRAF110 over a build's grafana entities, as the post-synth checks run them: declared and external datasources included. */
 function checks(entities: Map<string, Declarable>): GrafanaIssue[] {
   const built = buildGrafana(new Map([...entities].filter(([, e]) => e.lexicon === "grafana")));
   return validateGrafanaOutput({
@@ -173,12 +185,32 @@ describe("dashboard JSON -> TypeScript -> dashboard JSON", () => {
       // GRAF101 saying it cannot check a dashboard that names its datasources only through variables.
       expect(out.issues.filter((i) => !(i.code === "GRAF101" && i.severity === "warning" && i.message.includes("cannot check")))).toEqual([]);
       expect(out.paths.every((p) => p.startsWith("chant-fx-"))).toBe(true);
-      // The ad hoc filter and the annotation are named, not dropped silently.
+      // The ad hoc filter and the deploy annotation are carried (#2952, #2953).
       if (file.includes("checkout")) {
-        expect(out.warnings).toContainEqual(expect.stringContaining('variable "Filters" (adhoc) is not carried'));
-        expect(out.warnings).toContainEqual(expect.stringContaining('the annotation "Deploys"'));
+        expect(out.source).toContain("const filters = new AdhocVariable({");
+        expect(out.warnings.join("\n")).not.toContain("Deploys");
+        expect(out.source).toContain('name: "Deploys"');
+        expect((out.rebuilt!.annotations as { list: Json[] }).list.map((a) => a.name)).toEqual(["Deploys"]);
         expect(out.source).toContain("repeat: env,");
         expect(out.source).toContain("collapsed: true,");
+      } else if (file.includes("queries")) {
+        // Every datasource with a query class is imported through it, typed; none needs a defineQuery.
+        for (const cls of [
+          "ElasticsearchQuery",
+          "CloudWatchQuery",
+          "AzureMonitorQuery",
+          "CloudMonitoringQuery",
+          "BigQueryQuery",
+          "PyroscopeQuery",
+          "PostgresQuery",
+          "MySQLQuery",
+          "MSSQLQuery",
+          "PromQuery",
+          "LokiQuery",
+        ]) {
+          expect(out.source).toContain(`new ${cls}(`);
+        }
+        expect(out.source).not.toContain("defineQuery");
       } else if (file.includes("slo")) {
         expect(out.warnings).toContainEqual(expect.stringMatching(/is a library panel \("Burn rate", uid chant-fx-burn\)/));
       }
@@ -190,7 +222,7 @@ describe("dashboard JSON -> TypeScript -> dashboard JSON", () => {
         expect(out.warnings).toContain("dashboard: __elements is not carried (the library panels exported with it; library panels are not carried yet)");
       }
       if (file.includes(".external.")) {
-        expect(out.warnings).toContainEqual(expect.stringMatching(/^__inputs: DS_PROMETHEUS \(prometheus\)/));
+        expect(out.warnings).toContainEqual(expect.stringMatching(/^__inputs: (.*, )?DS_PROMETHEUS \(prometheus\)/));
         expect(out.source).toContain("const dsPrometheus = new DatasourceVariable({");
       }
     });
@@ -205,6 +237,10 @@ describe("dashboard JSON -> TypeScript -> dashboard JSON", () => {
         // Tabs become rows, and the auto grid's panels keep the positions Grafana gives them.
         expect(out.warnings).toContainEqual(expect.stringMatching(/tabs "Overview" and "Details" become expanded rows/));
         expect((out.rebuilt!.panels as Json[]).filter((p) => p.type === "row").map((p) => p.title)).toEqual(["Overview", "Details", "Latency ($env)", "Logs"]);
+        // Its switch and group by variables come through the classic variable mappings.
+        expect(out.source).toContain('const detailed = new SwitchVariable({ name: "detailed", label: "Detailed" });');
+        expect(out.source).toContain("const groupBy = new GroupByVariable({");
+        expect(out.warnings.filter((w) => /^variable "(detailed|groupBy)"/.test(w))).toEqual([]);
       }
     });
   }
@@ -241,6 +277,23 @@ describe("dashboard JSON -> TypeScript -> dashboard JSON", () => {
     expect(out.text).not.toContain("__inputs");
   });
 
+  test("ad hoc, group by and switch variables, and object-form queries, import with no warnings", async () => {
+    const out = await expectRoundTrip(read("exports/grafana-13.2.2/drilldown.json"));
+    expect(out.warnings).toEqual([]);
+    for (const cls of ["AdhocVariable", "GroupByVariable", "SwitchVariable"]) expect(out.source).toContain(`new ${cls}({`);
+    expect(out.source).toContain("qryType: 4,");
+    expect(out.source).toContain('enabledValue: "0.99",');
+    // The rebuilt JSON keeps the object query, so Grafana's variable editor opens it in the form it was written in.
+    const namespace = (out.rebuilt!.templating as { list: Json[] }).list.find((v) => v.name === "namespace")!;
+    expect(namespace.query).toEqual({ qryType: 1, query: "label_values(kube_namespace_created, namespace)", refId: "PrometheusVariableQueryEditor-VariableQuery" });
+    // Repeated over a multi-value variable: no GRAF110.
+    expect(out.issues.filter((i) => i.code === "GRAF110")).toEqual([]);
+    for (const file of ["exports/grafana-12.4.11/drilldown.json", "exports/grafana-12.4.11/drilldown.external.json", "exports/grafana-13.2.2/drilldown.external.json"]) {
+      const warnings = (await expectRoundTrip(read(file))).warnings;
+      expect(warnings.filter((w) => !w.startsWith("__inputs:") && !w.startsWith("dashboard: __requires")), file).toEqual([]);
+    }
+  });
+
   for (const file of COMMUNITY) {
     test(`grafana.com dashboard ${file}`, async () => {
       const out = await expectRoundTrip(read(file));
@@ -343,6 +396,46 @@ describe("provisioning files", () => {
     expect(out.lint.errorCount + out.lint.warningCount, out.lint.output).toBe(0);
   });
 
+  for (const file of PROVISIONING) {
+    test(`${file}: typed Datasources, links as references, the same datasources back`, async () => {
+      const yaml = read(file);
+      const out = await importAndBuild(yaml);
+      expect(out.warnings).toEqual([]);
+      expect(out.buildErrors).toEqual([]);
+      // What the build adds: its defaults for access and editable, and a uid made from the name.
+      type Entry = Record<string, unknown> & { name: string };
+      const withDefaults = (d: Entry) => ({ access: "proxy", editable: false, ...d });
+      const sorted = (list: Entry[]) => [...list].sort((a, b) => a.name.localeCompare(b.name));
+      const source = sorted((load(yaml) as { datasources: Entry[] }).datasources.map(withDefaults));
+      expect(sorted((load(out.files[DATASOURCES_FILE]) as { datasources: Entry[] }).datasources)).toEqual(source);
+      // Settings consts are typed for their plugin, and a uid naming an earlier datasource of the file is a reference.
+      expect(out.source).toContain('PropsOf<typeof Datasource<"tempo">>["jsonData"]');
+      expect(out.source).toMatch(/serviceMap: \{ datasourceUid: (mimir|prometheus) \}/);
+      expect(out.lint.errorCount + out.lint.warningCount, out.lint.output).toBe(0);
+    });
+  }
+
+  test("a link that would close a cycle stays a uid, and one to a plugin type the field does not take is not linked", () => {
+    const ir = new GrafanaParser().parse(
+      [
+        "apiVersion: 1",
+        "datasources:",
+        "  - { name: Tempo, type: tempo, uid: tempo, jsonData: { tracesToLogsV2: { datasourceUid: loki }, serviceMap: { datasourceUid: splunk } } }",
+        "  - { name: Loki, type: loki, uid: loki, jsonData: { derivedFields: [{ name: t, matcherRegex: x, datasourceUid: tempo }] } }",
+        "  - { name: Splunk, type: grafana-splunk-datasource, uid: splunk }",
+      ].join("\n"),
+    );
+    const source = new GrafanaGenerator()
+      .generate(ir)
+      .map((f) => f.content)
+      .join("\n");
+    // Neither Tempo nor Loki can come first with both links; Tempo, first in the file, keeps its link as a uid.
+    expect(source).toContain('tracesToLogsV2: { datasourceUid: "loki" }');
+    expect(source).toContain("datasourceUid: tempo");
+    // The service map takes a Prometheus, so a Splunk uid stays a string.
+    expect(source).toContain('serviceMap: { datasourceUid: "splunk" }');
+  });
+
   test("a dashboard provisioning file becomes DashboardProviders", async () => {
     const yaml = [
       "apiVersion: 1",
@@ -382,13 +475,15 @@ describe("chant import dashboard.json", () => {
         expect(result.error).toBeUndefined();
         expect(result.success).toBe(true);
         expect(result.lexicon).toBe("grafana");
+        // Nine variables (the two __inputs datasources among them): more than COR009's eight per module.
         expect(result.generatedFiles).toEqual([
-          "chant-fx-checkout/variables.ts",
+          "chant-fx-checkout/variables-1.ts",
+          "chant-fx-checkout/variables-2.ts",
           "chant-fx-checkout/panels.ts",
           "chant-fx-checkout/row-details-for-job.ts",
           "chant-fx-checkout/dashboard.ts",
         ]);
-        expect(result.warnings).toContainEqual(expect.stringContaining('variable "Filters" (adhoc) is not carried'));
+        expect(result.warnings.join("\n")).not.toContain("is not carried: chant has no");
         const built = await build(output, [grafanaSerializer]);
         expect(built.errors).toEqual([]);
         const text = (built.outputs.get("grafana") as SerializerResult).files!["dashboards/chant-fx-checkout.json"];

package/src/import/testdata/fixtures.ts

@@ -11,6 +11,7 @@
  *   provenance and license in its README).
  * - Alerting provisioning files (test/fixtures/alerting/).
  * - What this lexicon's examples build.
+ * - Datasource provisioning files (test/fixtures/provisioning/).
  */
 import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { dirname, join, resolve } from "path";
@@ -58,6 +59,13 @@ export const KUBE_PROMETHEUS: readonly string[] = readdirSync(join(fixturesDir,
   .sort()
   .map((f) => `kube-prometheus/${f}`);
 
+/**
+ * Datasource provisioning files (test/fixtures/provisioning/, provenance in
+ * its README): one written for chant with every plugin whose settings are
+ * typed, and grafana/docker-otel-lgtm's.
+ */
+export const PROVISIONING: readonly string[] = ["provisioning/typed-plugins.datasources.yaml", "provisioning/docker-otel-lgtm.datasources.yaml"];
+
 /**
  * The alerting provisioning corpus (test/fixtures/alerting/, provenance and
  * licenses in its README): Grafana 12.4.11 and 13.2.2 exports, and files

package/src/import/v2.ts

@@ -20,9 +20,10 @@
  * pin bump that adds a v2 key fails until the key is placed in one of them.
  *
  * What the classic model can hold but chant cannot yet (library panels,
- * annotations, ad hoc, group by and switch variables) is written to the
- * classic JSON as Grafana would and reported by the classic importer
- * (`./parser.ts`), as for any classic dashboard.
+ * annotations) is written to the classic JSON as Grafana would and reported
+ * by the classic importer (`./parser.ts`), as for any classic dashboard. Ad
+ * hoc, group by and switch variables are written the same way and imported
+ * by the classic importer's variable mappings (`./mappings.ts`).
  *
  * A classic read of a dashboard Grafana stores as v2 is the lossy direction:
  * `storedAsV2` recognises it from the resource's