@intentius/chant-lexicon-grafana 0.98.0 → 0.100.0

package/src/export-resources.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Live export (#2946) against an in-memory Grafana: the IR goes through the
+ * importer's generator unchanged, and a dashboard exported from Grafana
+ * generates the same source as the same JSON given to `chant import`.
+ */
+
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { exportResources } from "./export-resources";
+import { fakeGrafana, liveDatasource, type FakeGrafanaState } from "./api/fake-grafana";
+import { GrafanaGenerator } from "./import/generator";
+import { parseGrafana } from "./import/parser";
+import { grafanaPlugin } from "./plugin";
+import { datasourceProps } from "./import/live-export";
+
+const CONFIG = { grafana: { profiles: { prod: { url: "http://grafana.test" } } } };
+
+const board = {
+  title: "Checkout",
+  tags: ["shop"],
+  graphTooltip: 1,
+  schemaVersion: 41,
+  panels: [
+    {
+      type: "timeseries",
+      id: 1,
+      title: "Requests",
+      gridPos: { h: 8, w: 12, x: 0, y: 0 },
+      datasource: { type: "prometheus", uid: "prom" },
+      targets: [{ refId: "A", expr: "sum(rate(http_requests_total[5m]))", datasource: { type: "prometheus", uid: "prom" } }],
+    },
+  ],
+};
+
+function state(overrides: Partial<FakeGrafanaState> = {}): FakeGrafanaState {
+  return {
+    api: "v1",
+    dashboards: {
+      checkout: { spec: board, annotations: { "grafana.app/managedBy": "classic-file-provisioning", "grafana.app/managerId": "chant" } },
+      "hand-made": { spec: { title: "Hand made", panels: [] } },
+    },
+    datasources: {
+      prom: liveDatasource({ name: "Prom", type: "prometheus", uid: "prom", url: "http://prometheus:9090", isDefault: true, secure: ["basicAuthPassword"] }),
+    },
+    ...overrides,
+  };
+}
+
+const exportFrom = (s: FakeGrafanaState, opts: Partial<Parameters<typeof exportResources>[0]> = {}) =>
+  exportResources({ environment: "prod", config: CONFIG, env: {}, http: fakeGrafana(s), ...opts });
+
+describe("exportResources", () => {
+  it("is wired on the plugin", () => {
+    expect(typeof grafanaPlugin.exportResources).toBe("function");
+  });
+
+  it("feeds the importer's generator unchanged, and generates what chant import writes for the same JSON", async () => {
+    const ir = await exportFrom(state(), { selector: { type: "Grafana::Dashboard", name: "checkout" } });
+    const exported = new GrafanaGenerator().generate(ir);
+    const imported = new GrafanaGenerator().generate(parseGrafana(JSON.stringify({ ...board, uid: "checkout" })));
+    expect(exported).toEqual(imported);
+    expect(exported.map((f) => f.path)).toEqual(expect.arrayContaining([expect.stringMatching(/^checkout\/dashboard\.ts$/)]));
+  });
+
+  it("exports every dashboard and datasource, secrets as key names only", async () => {
+    const ir = await exportFrom(state());
+    expect(ir.resources.map((r) => `${r.type}:${r.logicalId}`).sort()).toEqual(["Grafana::Dashboard:checkout", "Grafana::Dashboard:handMade", "Grafana::Provisioning:datasources"]);
+    const files = new GrafanaGenerator().generate(ir);
+    const ds = files.find((f) => f.path === "datasources.ts")!.content;
+    expect(ds).toContain('basicAuthPassword: "[REDACTED]"');
+    expect(ir.warnings?.join("\n")).toMatch(/\[REDACTED\]/);
+  });
+
+  it("a dashboard refers to a datasource exported beside it by uid, rather than declaring it again", async () => {
+    const files = new GrafanaGenerator().generate(await exportFrom(state()));
+    const dashboardDatasources = files.find((f) => f.path === "checkout/datasources.ts")!.content;
+    expect(dashboardDatasources).not.toContain("ExternalDatasource");
+    expect(dashboardDatasources).toMatch(/const prom: DatasourceRef<"prometheus"> = \{ type: "prometheus", uid: "prom" \}/);
+    expect(files.find((f) => f.path === "datasources.ts")!.content).toContain("new Datasource(");
+  });
+
+  it("owned keeps only chant's dashboards and no datasources", async () => {
+    const ir = await exportFrom(state(), { owned: true });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["checkout"]);
+    expect(ir.warnings?.join("\n")).toMatch(/datasources are not exported with --owned/);
+  });
+
+  it("reads the legacy API on a server without dashboard.grafana.app", async () => {
+    const ir = await exportFrom(state({ api: "legacy" }), { selector: { name: "checkout" } });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["checkout"]);
+  });
+
+  it("leaves out a v2-stored dashboard the server does not serve at v2, and says so", async () => {
+    const s = state();
+    s.dashboards.checkout.storedVersion = "v2beta1";
+    const ir = await exportFrom(s, { selector: { type: "Grafana::Dashboard" } });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["handMade"]);
+    expect(ir.warnings?.join("\n")).toMatch(/checkout is not exported: it is stored as a v2beta1 dashboard .* lossy down-conversion/);
+  });
+
+  it("exports a v2-stored dashboard through its v2 read, as chant import of the same v2 JSON does (#2947)", async () => {
+    const fixture = JSON.parse(readFileSync(join(import.meta.dirname, "..", "test", "fixtures", "exports", "grafana-13.2.2", "tabs.v2-resource.json"), "utf-8")) as { spec: Record<string, unknown> };
+    const s = state();
+    s.dashboards.checkout = { ...s.dashboards.checkout, storedVersion: "v2", v2: fixture.spec };
+    const ir = await exportFrom(s, { selector: { type: "Grafana::Dashboard", name: "checkout" } });
+    expect(ir.resources.map((r) => r.logicalId)).toEqual(["checkoutTabs"]);
+    expect(ir.warnings).toContainEqual(expect.stringMatching(/^dashboard checkout is stored as v2 and exported in the classic model: layout: the dashboard's tabs "Overview" and "Details" become expanded rows/));
+    const exported = new GrafanaGenerator().generate(ir);
+    const imported = new GrafanaGenerator().generate(parseGrafana(JSON.stringify({ ...fixture, metadata: { name: "checkout" } })));
+    expect(exported).toEqual(imported);
+  });
+
+  it("fails loudly when there is no Grafana to read", async () => {
+    await expect(exportResources({ environment: "staging", config: CONFIG, env: {} })).rejects.toThrow(/GRAFANA_URL/);
+  });
+});
+
+describe("datasourceProps", () => {
+  const live = liveDatasource({ name: "Prom", type: "prometheus", uid: "prom", url: "http://p:9090", secure: ["password"] });
+
+  it("keeps what somebody set, and names secrets without their values", () => {
+    expect(datasourceProps(live)).toEqual({ name: "Prom", type: "prometheus", uid: "prom", url: "http://p:9090", secureJsonData: { password: "[REDACTED]" } });
+  });
+
+  it("keeps the API's defaults under verbatim, and editable from readOnly", () => {
+    expect(datasourceProps({ ...live, readOnly: false }, { keepDefaults: true })).toMatchObject({ access: "proxy", isDefault: false, editable: true });
+  });
+});

package/src/export-resources.ts

@@ -0,0 +1,84 @@
+/**
+ * Live export for grafana (#2946): `chant import --from <env>` writes the
+ * environment's dashboards and datasources as chant TypeScript.
+ *
+ * All I/O is here; the mapping is pure in ./import/live-export.ts, and the
+ * IR it builds is the importer's own (#2945), so a dashboard exported from
+ * Grafana and the same dashboard's JSON given to `chant import` generate the
+ * same source through the same `GrafanaGenerator`.
+ *
+ * - Every dashboard in the organisation is listed over the API the thin
+ *   read uses (`/apis/dashboard.grafana.app`, or `/api/search` plus
+ *   `/api/dashboards/uid` on Grafana 11). A dashboard stored as v2 is read at
+ *   v2 and exported through its classic form, with a warning for each thing
+ *   the classic form cannot hold (#2947).
+ * - Every datasource is read by uid, for `secureJsonFields`; secrets come
+ *   back as key names only (see `datasourceProps`).
+ * - `selector.type` is `Grafana::Dashboard` or `Grafana::Datasource`;
+ *   `selector.name` is a uid.
+ * - `owned` keeps only dashboards that are chant's (./ownership.ts), and
+ *   leaves datasources out, since their ownership cannot be read. There is no
+ *   project here to name its providers, so a file-provisioned dashboard is
+ *   chant's when its provider is the default one, `chant`.
+ * - `verbatim` keeps datasource keys at the API's "not set" values. A
+ *   dashboard is always planned by the importer, which leaves out keys at
+ *   Grafana's defaults either way.
+ */
+
+import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
+import { bindGrafana, type BindOptions } from "./api/bind";
+import { classicDashboardOf, listDashboards } from "./api/dashboards";
+import { listDatasources, readDatasource } from "./api/datasources";
+import { DASHBOARD_TYPE } from "./dashboard";
+import { DATASOURCE_TYPE } from "./datasource";
+import { exportTemplate } from "./import/live-export";
+import { DEFAULT_PROVIDER_NAME, dashboardOwnership } from "./ownership";
+
+type Json = Record<string, unknown>;
+
+export interface GrafanaExportOptions extends Omit<BindOptions, "environment"> {
+  environment: string;
+  stack?: string;
+  region?: string;
+  selector?: ResourceSelector;
+  owned?: boolean;
+  verbatim?: boolean;
+}
+
+export async function exportResources(options: GrafanaExportOptions): Promise<ExportedTemplate> {
+  const client = await bindGrafana({ ...options });
+  const type = options.selector?.type;
+  const name = options.selector?.name;
+  const warnings: string[] = [];
+
+  const dashboards: Array<{ json: Json }> = [];
+  if (type === undefined || type === DASHBOARD_TYPE) {
+    const providers = new Set([DEFAULT_PROVIDER_NAME]);
+    for (const live of await listDashboards(client)) {
+      if (name !== undefined && live.uid !== name) continue;
+      if (options.owned && dashboardOwnership(live, providers).ownership !== "owned") continue;
+      const classic = classicDashboardOf(live);
+      if ("unsupported" in classic) {
+        warnings.push(`dashboard ${live.uid} is not exported: ${classic.unsupported}`);
+        continue;
+      }
+      for (const w of classic.warnings ?? []) warnings.push(`dashboard ${live.uid} is stored as v2 and exported in the classic model: ${w}`);
+      dashboards.push({ json: classic.json });
+    }
+  }
+
+  const datasources: Json[] = [];
+  if ((type === undefined || type === DATASOURCE_TYPE) && !options.owned) {
+    for (const summary of await listDatasources(client)) {
+      const uid = typeof summary.uid === "string" ? summary.uid : undefined;
+      if (!uid || (name !== undefined && uid !== name)) continue;
+      const read = await readDatasource(client, uid);
+      if ("present" in read) datasources.push(read.present);
+    }
+  } else if (options.owned && (type === undefined || type === DATASOURCE_TYPE)) {
+    warnings.push("datasources are not exported with --owned: Grafana's datasource API carries no ownership marker");
+  }
+
+  const ir = exportTemplate({ dashboards, datasources, keepDefaults: options.verbatim });
+  return { ...ir, warnings: [...warnings, ...(ir.warnings ?? [])] };
+}

package/src/folder.ts

@@ -0,0 +1,118 @@
+/**
+ * `Folder`: a Grafana folder with a stable uid, nested with `parent`.
+ *
+ * A dashboard names its folder either as a path string
+ * (`folder: "Platform/Kubernetes"`) or as a `Folder`. Both give the same
+ * folders: one per level, each with the uid `folderUidFor` makes from its
+ * path unless a `Folder` sets one. A `Folder` is needed only to pin a uid
+ * (for links, alert rules, permissions set elsewhere) or to declare a folder
+ * that holds no dashboard yet.
+ *
+ * How each delivery carries it:
+ *
+ * - File provisioning writes the dashboard under `dashboards/<level>/...`,
+ *   and a provider with `foldersFromFilesStructure` makes one folder per
+ *   level (nested on Grafana 13.1 and later; GRAF109 says what earlier
+ *   versions do). Grafana finds each level's folder by title under its
+ *   parent and creates it when missing, with a uid of its own: file
+ *   provisioning has no field for a nested folder's uid. A folder the API
+ *   applier made first keeps the uid it was given. A `DashboardProvider`
+ *   whose `folder` is a root-level `Folder` writes its `folderUid`.
+ * - The API applier (./api/apply.ts) creates every folder with its uid and
+ *   parent, parents first.
+ * - Observation reads a dashboard's folder back as its path, and a `Folder`
+ *   by its uid.
+ *
+ * The rules for turning folders into uids and parents are in one place,
+ * `resolveFolders` in ./api/folders.ts, which the build, the applier and
+ * observation all call.
+ */
+
+import { createResource } from "@intentius/chant/runtime";
+import type { Declarable } from "@intentius/chant/declarable";
+import { slugUid } from "./util";
+
+export interface FolderProps {
+  /** The title Grafana shows. A single level: nest with `parent`, not with `/`. */
+  title: string;
+  /**
+   * Stable id: letters, digits, `-` and `_`, at most 40 characters, and not
+   * `general`, which Grafana keeps for its root. Defaults to the folder's
+   * path as a uid (`Platform/Kubernetes` becomes `platform-kubernetes`), the
+   * same uid a dashboard's `folder: "Platform/Kubernetes"` gives it.
+   */
+  uid?: string;
+  /** The folder this one is in. Leave it out for a folder at the root. */
+  parent?: FolderEntity;
+}
+
+export interface FolderEntity extends Declarable {
+  readonly props: FolderProps;
+  /** The uid Grafana gives the folder: its own, else one made from its path. */
+  readonly uid: string;
+  /** Its titles from the root, joined with `/`: the directory the build writes it to. */
+  readonly path: string;
+}
+
+export const FOLDER_TYPE = "Grafana::Folder";
+
+/**
+ * The levels of a folder path, as the build writes them to directories:
+ * split on `/`, a backslash made `-`, leading dots and surrounding blanks
+ * dropped, so no level names a directory outside `dashboards/`. Empty levels
+ * are dropped; no levels at all is the General folder.
+ */
+export function folderLevels(path: string): string[] {
+  return path
+    .split("/")
+    .map((level) => level.replace(/\\+/g, "-").trim().replace(/^\.+/, "").trim())
+    .filter((level) => level !== "");
+}
+
+/** The uid chant gives a folder it only knows by path. Stable, so a second apply finds the folder the first one made. */
+export function folderUidFor(path: string): string {
+  return slugUid(folderLevels(path).join("/"));
+}
+
+const Base = createResource(FOLDER_TYPE, "grafana", {}) as unknown as (this: object, props: Record<string, unknown>) => void;
+
+/** A Grafana folder. */
+export const Folder = function (this: object, props: FolderProps) {
+  const title = props.title;
+  if (typeof title !== "string" || folderLevels(title).length !== 1 || folderLevels(title)[0] !== title) {
+    throw new Error(
+      `grafana: Folder title ${JSON.stringify(title)} is not one folder level: use parent to nest folders, and leave out "/", "\\", leading dots and surrounding blanks, which file provisioning cannot write as a directory`,
+    );
+  }
+  if (props.parent !== undefined && !isFolderEntity(props.parent)) throw new Error(`grafana: Folder "${title}" has a parent that is not a Folder`);
+  Base.call(this, props as unknown as Record<string, unknown>);
+  const path = props.parent ? `${props.parent.path}/${title}` : title;
+  Object.defineProperty(this, "path", { value: path, enumerable: false });
+  Object.defineProperty(this, "uid", { value: props.uid ?? folderUidFor(path), enumerable: false });
+} as unknown as new (props: FolderProps) => FolderEntity;
+Object.defineProperty(Folder, "name", { value: "Folder" });
+
+export function isFolderEntity(value: unknown): value is FolderEntity {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as Declarable).entityType === FOLDER_TYPE &&
+    (value as Declarable).lexicon === "grafana"
+  );
+}
+
+/** A folder's uid from its props, as observation sees them (the props of a `Folder`, parents included). */
+export function folderUidOf(props: Record<string, unknown>): string | undefined {
+  if (typeof props.uid === "string" && props.uid !== "") return props.uid;
+  const path = folderPathOf(props);
+  return path ? folderUidFor(path) : undefined;
+}
+
+/** A folder's path from its props, walking `parent`. */
+export function folderPathOf(props: Record<string, unknown>): string | undefined {
+  if (typeof props.title !== "string") return undefined;
+  const parent = props.parent as { props?: Record<string, unknown> } | undefined;
+  if (!parent) return props.title;
+  const up = parent.props ? folderPathOf(parent.props) : undefined;
+  return up === undefined ? undefined : `${up}/${props.title}`;
+}

package/src/generated/lexicon-grafana.json

@@ -1,9 +1,79 @@
 {
+  "AdhocVariable": {
+    "resourceType": "Grafana::Variable::adhoc",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertListPanel": {
+    "resourceType": "Grafana::Panel::alertlist",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertQuery": {
+    "resourceType": "Grafana::AlertQuery",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertRule": {
+    "resourceType": "Grafana::AlertRule",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AlertRuleGroup": {
+    "resourceType": "Grafana::AlertRuleGroup",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "AzureMonitorQuery": {
+    "resourceType": "Grafana::Query::grafana-azure-monitor-datasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "BarChartPanel": {
+    "resourceType": "Grafana::Panel::barchart",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "BarGaugePanel": {
+    "resourceType": "Grafana::Panel::bargauge",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "BigQueryQuery": {
+    "resourceType": "Grafana::Query::grafana-bigquery-datasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "CanvasPanel": {
+    "resourceType": "Grafana::Panel::canvas",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "ClassicConditionsExpression": {
+    "resourceType": "Grafana::Expression::classic_conditions",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "CloudMonitoringQuery": {
+    "resourceType": "Grafana::Query::stackdriver",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "CloudWatchQuery": {
+    "resourceType": "Grafana::Query::cloudwatch",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "ConstantVariable": {
     "resourceType": "Grafana::Variable::constant",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ContactPoint": {
+    "resourceType": "Grafana::ContactPoint",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "CustomVariable": {
     "resourceType": "Grafana::Variable::custom",
     "kind": "resource",
@@ -24,21 +94,61 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "DatasourceProvisioning": {
+    "resourceType": "Grafana::DatasourceProvisioning",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "DatasourceVariable": {
     "resourceType": "Grafana::Variable::datasource",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ElasticsearchQuery": {
+    "resourceType": "Grafana::Query::elasticsearch",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "ExternalDatasource": {
+    "resourceType": "Grafana::ExternalDatasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "FlameGraphPanel": {
+    "resourceType": "Grafana::Panel::flamegraph",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "Folder": {
+    "resourceType": "Grafana::Folder",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "GaugePanel": {
     "resourceType": "Grafana::Panel::gauge",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "GeomapPanel": {
+    "resourceType": "Grafana::Panel::geomap",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "GroupByVariable": {
+    "resourceType": "Grafana::Variable::groupby",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "HeatmapPanel": {
     "resourceType": "Grafana::Panel::heatmap",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "HistogramPanel": {
+    "resourceType": "Grafana::Panel::histogram",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "IntervalVariable": {
     "resourceType": "Grafana::Variable::interval",
     "kind": "resource",
@@ -54,26 +164,106 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "MathExpression": {
+    "resourceType": "Grafana::Expression::math",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "MSSQLQuery": {
+    "resourceType": "Grafana::Query::mssql",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "MuteTiming": {
+    "resourceType": "Grafana::MuteTiming",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "MySQLQuery": {
+    "resourceType": "Grafana::Query::mysql",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "NodeGraphPanel": {
+    "resourceType": "Grafana::Panel::nodeGraph",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "NotificationPolicy": {
+    "resourceType": "Grafana::NotificationPolicy",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "NotificationTemplate": {
+    "resourceType": "Grafana::NotificationTemplate",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "PieChartPanel": {
+    "resourceType": "Grafana::Panel::piechart",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "PostgresQuery": {
+    "resourceType": "Grafana::Query::grafana-postgresql-datasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "PromQuery": {
     "resourceType": "Grafana::Query::prometheus",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "PyroscopeQuery": {
+    "resourceType": "Grafana::Query::grafana-pyroscope-datasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "QueryVariable": {
     "resourceType": "Grafana::Variable::query",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ReduceExpression": {
+    "resourceType": "Grafana::Expression::reduce",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "ResampleExpression": {
+    "resourceType": "Grafana::Expression::resample",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "Row": {
     "resourceType": "Grafana::Row",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "SqlExpression": {
+    "resourceType": "Grafana::Expression::sql",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "StateTimelinePanel": {
+    "resourceType": "Grafana::Panel::state-timeline",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "StatPanel": {
     "resourceType": "Grafana::Panel::stat",
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "StatusHistoryPanel": {
+    "resourceType": "Grafana::Panel::status-history",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "SwitchVariable": {
+    "resourceType": "Grafana::Variable::switch",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "TablePanel": {
     "resourceType": "Grafana::Panel::table",
     "kind": "resource",
@@ -94,6 +284,11 @@
     "kind": "resource",
     "lexicon": "grafana"
   },
+  "ThresholdExpression": {
+    "resourceType": "Grafana::Expression::threshold",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
   "TimeSeriesPanel": {
     "resourceType": "Grafana::Panel::timeseries",
     "kind": "resource",
@@ -103,5 +298,15 @@
     "resourceType": "Grafana::Panel::traces",
     "kind": "resource",
     "lexicon": "grafana"
+  },
+  "TrendPanel": {
+    "resourceType": "Grafana::Panel::trend",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "XYChartPanel": {
+    "resourceType": "Grafana::Panel::xychart",
+    "kind": "resource",
+    "lexicon": "grafana"
   }
 }