@intentius/chant-lexicon-grafana 0.96.0

package/src/generated/lexicon-grafana.json

@@ -0,0 +1,107 @@
+{
+  "ConstantVariable": {
+    "resourceType": "Grafana::Variable::constant",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "CustomVariable": {
+    "resourceType": "Grafana::Variable::custom",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "Dashboard": {
+    "resourceType": "Grafana::Dashboard",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "DashboardProvider": {
+    "resourceType": "Grafana::DashboardProvider",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "Datasource": {
+    "resourceType": "Grafana::Datasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "DatasourceVariable": {
+    "resourceType": "Grafana::Variable::datasource",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "GaugePanel": {
+    "resourceType": "Grafana::Panel::gauge",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "HeatmapPanel": {
+    "resourceType": "Grafana::Panel::heatmap",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "IntervalVariable": {
+    "resourceType": "Grafana::Variable::interval",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "LogsPanel": {
+    "resourceType": "Grafana::Panel::logs",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "LokiQuery": {
+    "resourceType": "Grafana::Query::loki",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "PromQuery": {
+    "resourceType": "Grafana::Query::prometheus",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "QueryVariable": {
+    "resourceType": "Grafana::Variable::query",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "Row": {
+    "resourceType": "Grafana::Row",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "StatPanel": {
+    "resourceType": "Grafana::Panel::stat",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "TablePanel": {
+    "resourceType": "Grafana::Panel::table",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "TempoQuery": {
+    "resourceType": "Grafana::Query::tempo",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "TextboxVariable": {
+    "resourceType": "Grafana::Variable::textbox",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "TextPanel": {
+    "resourceType": "Grafana::Panel::text",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "TimeSeriesPanel": {
+    "resourceType": "Grafana::Panel::timeseries",
+    "kind": "resource",
+    "lexicon": "grafana"
+  },
+  "TracesPanel": {
+    "resourceType": "Grafana::Panel::traces",
+    "kind": "resource",
+    "lexicon": "grafana"
+  }
+}

package/src/import.e2e.test.ts

@@ -0,0 +1,147 @@
+/**
+ * "A dashboard builds to JSON that Grafana imports without edits", against
+ * Grafana itself.
+ *
+ * Builds each example (getting-started, and dashboards-from-declarations,
+ * whose dashboards the RED, SLO and agent composites build), mounts its
+ * provisioning files and dashboards into a pinned `grafana/grafana`
+ * container, and asserts that
+ * Grafana provisioned every datasource and dashboard and hands each
+ * dashboard back with the panels that were built. It then imports the same
+ * JSON a second time through `POST /api/dashboards/db`, the path the UI's
+ * import uses, under another uid.
+ *
+ * Skipped, with the reason in the test name, when Docker is not running.
+ * On demand: `npx vitest run --project e2e lexicons/grafana`.
+ */
+import { execSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterAll, describe, expect, it } from "vitest";
+import { build } from "@intentius/chant/build";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import type { Serializer } from "@intentius/chant/serializer";
+import { otelSerializer } from "@intentius/chant-lexicon-otel/serializer";
+import { prometheusSerializer } from "@intentius/chant-lexicon-prometheus/serializer";
+import { grafanaSerializer } from "./serializer";
+
+/** The Grafana release the import test runs against; `CHANT_GRAFANA_IMAGE` overrides it. */
+export const GRAFANA_IMAGE = process.env.CHANT_GRAFANA_IMAGE ?? "grafana/grafana:12.4.11";
+
+function available(cmd: string): boolean {
+  try {
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const hasDocker = available("docker info");
+const skipReason = hasDocker ? "" : "Docker is not running";
+const AUTH = `Basic ${Buffer.from("admin:admin").toString("base64")}`;
+const examples = join(dirname(dirname(fileURLToPath(import.meta.url))), "examples");
+
+/** Each example, and the serializers its build root needs. */
+const EXAMPLES: Array<{ name: string; serializers: Serializer[] }> = [
+  { name: "getting-started", serializers: [grafanaSerializer] },
+  { name: "dashboards-from-declarations", serializers: [otelSerializer, prometheusSerializer, grafanaSerializer] },
+];
+
+async function waitFor<T>(what: string, fn: () => Promise<T | undefined>, timeoutMs = 120_000): Promise<T> {
+  const deadline = Date.now() + timeoutMs;
+  let last: unknown;
+  while (Date.now() < deadline) {
+    try {
+      const v = await fn();
+      if (v !== undefined) return v;
+    } catch (err) {
+      last = err;
+    }
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+  throw new Error(`timed out waiting for ${what}${last ? `: ${String(last)}` : ""}`);
+}
+
+describe.skipIf(!hasDocker).each(EXAMPLES)(`Grafana imports the $name dashboards without edits${skipReason ? ` (skipped: ${skipReason})` : ""}`, ({ name, serializers }) => {
+  const CONTAINER = `chant-grafana-import-${name}-${process.pid}`;
+  const dir = mkdtempSync(join(tmpdir(), "chant-grafana-import-"));
+
+  afterAll(() => {
+    try {
+      execSync(`docker rm -f ${CONTAINER}`, { stdio: "ignore" });
+    } catch {
+      // already gone
+    }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("provisions every datasource and dashboard, and accepts the JSON through the import API", { timeout: 300_000 }, async () => {
+    const result = await build(join(examples, name, "src"), serializers);
+    expect(result.errors).toEqual([]);
+    const out = result.outputs.get("grafana") as SerializerResult;
+    for (const [file, content] of Object.entries(out.files ?? {})) {
+      mkdirSync(dirname(join(dir, file)), { recursive: true });
+      writeFileSync(join(dir, file), content);
+    }
+    const index = JSON.parse(out.primary) as { dashboards: Array<{ uid: string; title: string; folder?: string; file: string }>; datasources: Array<{ uid: string; type: string; name: string }> };
+
+    execSync(
+      [
+        "docker run -d",
+        `--name ${CONTAINER}`,
+        "-p 127.0.0.1::3000",
+        "-e GF_SECURITY_ADMIN_PASSWORD=admin",
+        "-e GF_ANALYTICS_REPORTING_ENABLED=false",
+        "-e GF_ANALYTICS_CHECK_FOR_UPDATES=false",
+        `-v ${join(dir, "provisioning")}:/etc/grafana/provisioning:ro`,
+        `-v ${join(dir, "dashboards")}:/var/lib/grafana/dashboards:ro`,
+        GRAFANA_IMAGE,
+      ].join(" "),
+      { stdio: "ignore" },
+    );
+    const port = execSync(`docker port ${CONTAINER} 3000/tcp`).toString().trim().split("\n")[0].split(":").pop();
+    const base = `http://127.0.0.1:${port}`;
+    const api = async (path: string, init?: RequestInit) => {
+      const res = await fetch(`${base}${path}`, { ...init, headers: { authorization: AUTH, "content-type": "application/json", ...(init?.headers ?? {}) } });
+      return { status: res.status, body: (await res.json()) as Record<string, unknown> & unknown[] };
+    };
+
+    await waitFor("Grafana to answer", async () => ((await fetch(`${base}/api/health`)).ok ? true : undefined));
+
+    // Datasources: every declared one, with the uid and type chant gave it.
+    const datasources = await waitFor("datasources", async () => {
+      const { status, body } = await api("/api/datasources");
+      return status === 200 && (body as unknown[]).length >= index.datasources.length ? (body as unknown as Array<{ uid: string; type: string; name: string }>) : undefined;
+    });
+    expect(datasources.map((d) => [d.uid, d.type, d.name]).sort()).toEqual(index.datasources.map((d) => [d.uid, d.type, d.name]).sort());
+
+    // Dashboards: provisioned, in their folder, with every panel as built.
+    for (const d of index.dashboards) {
+      const { body } = await waitFor(`dashboard ${d.uid}`, async () => {
+        const r = await api(`/api/dashboards/uid/${d.uid}`);
+        return r.status === 200 ? r : undefined;
+      });
+      const meta = body.meta as { provisioned: boolean; folderTitle?: string };
+      const stored = body.dashboard as { title: string; panels: Array<Record<string, unknown>>; templating: { list: unknown[] } };
+      const built = JSON.parse(out.files![d.file]) as typeof stored;
+      expect(meta.provisioned).toBe(true);
+      if (d.folder) expect(meta.folderTitle).toBe(d.folder);
+      expect(stored.title).toBe(d.title);
+      const shape = (panels: Array<Record<string, unknown>>) => panels.map((p) => [p.id, p.type, p.title, p.gridPos]);
+      expect(shape(stored.panels)).toEqual(shape(built.panels));
+      expect(stored.templating.list.length).toBe(built.templating.list.length);
+    }
+
+    // The same JSON through the import API, under a new uid.
+    const first = index.dashboards[0];
+    const copy = { ...JSON.parse(out.files![first.file]), uid: `${first.uid}-api`, title: `${first.title} (API import)` };
+    const imported = await api("/api/dashboards/db", { method: "POST", body: JSON.stringify({ dashboard: copy, overwrite: false }) });
+    expect(imported.status).toBe(200);
+    expect(imported.body.status).toBe("success");
+    const back = await api(`/api/dashboards/uid/${first.uid}-api`);
+    expect((back.body.dashboard as { panels: unknown[] }).panels.length).toBe(copy.panels.length);
+  });
+});

package/src/import.test.ts

@@ -0,0 +1,45 @@
+/**
+ * "A dashboard builds to JSON that Grafana imports without edits", offline.
+ *
+ * Builds every example and validates each dashboard against Grafana's
+ * dashboard schema at `GRAFANA_SCHEMA_PIN`, each panel's options and each
+ * query against their plugin's schema, and runs GRAF101-GRAF107 over the
+ * output. `import.e2e.test.ts` does the same against a real Grafana when
+ * Docker is available.
+ */
+import { describe, expect, test } from "vitest";
+import { readdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { build } from "@intentius/chant/build";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { load } from "js-yaml";
+import { grafanaSerializer } from "./serializer";
+import { validateDashboardSchema } from "./schema-validate";
+import { validateGrafanaOutput } from "./validate-output";
+import type { ProvisionedDatasource } from "./build";
+
+const examplesDir = join(dirname(dirname(fileURLToPath(import.meta.url))), "examples");
+const examples = readdirSync(examplesDir).filter((e) => {
+  try {
+    return statSync(join(examplesDir, e, "src")).isDirectory();
+  } catch {
+    return false;
+  }
+});
+
+describe.each(examples)("example %s", (example) => {
+  test("every dashboard matches the pinned Grafana schemas, and every check passes", { timeout: 30_000 }, async () => {
+    const result = await build(join(examplesDir, example, "src"), [grafanaSerializer]);
+    expect(result.errors).toEqual([]);
+    const out = result.outputs.get("grafana") as SerializerResult;
+    const dashboards = Object.entries(out.files ?? {}).filter(([f]) => f.startsWith("dashboards/"));
+    expect(dashboards.length).toBeGreaterThan(0);
+    for (const [file, text] of dashboards) {
+      expect({ file, problems: validateDashboardSchema(JSON.parse(text)) }).toEqual({ file, problems: [] });
+    }
+    const ds = load(out.files?.["provisioning/datasources/chant.yaml"] ?? "datasources: []") as { datasources: ProvisionedDatasource[] };
+    const issues = validateGrafanaOutput({ dashboards: dashboards.map(([source, t]) => ({ source, json: JSON.parse(t) })), datasources: ds.datasources });
+    expect(issues).toEqual([]);
+  });
+});

package/src/index.ts

@@ -0,0 +1,178 @@
+// Grafana lexicon.
+
+// Plugin and serializer
+export { grafanaPlugin } from "./plugin";
+export { grafanaSerializer } from "./serializer";
+
+// Datasources
+export {
+  Datasource,
+  DATASOURCE_TYPE,
+  BUILTIN_DATASOURCE_UIDS,
+  isDatasourceEntity,
+  type DatasourceProps,
+  type DatasourceEntity,
+  type DatasourceConstructor,
+  type DatasourceRef,
+  type DatasourceAccess,
+  type KnownDatasourceType,
+} from "./datasource";
+
+// Dashboards and provisioning
+export {
+  Dashboard,
+  DashboardProvider,
+  DASHBOARD_TYPE,
+  DASHBOARD_PROVIDER_TYPE,
+  DEFAULT_DASHBOARDS_PATH,
+  isDashboardEntity,
+  isDashboardProviderEntity,
+  type DashboardProps,
+  type DashboardEntity,
+  type DashboardLinkInput,
+  type DashboardProviderProps,
+  type DashboardProviderEntity,
+} from "./dashboard";
+
+// Panels and rows, and the extension point for other panel plugins
+export {
+  TimeSeriesPanel,
+  StatPanel,
+  GaugePanel,
+  TablePanel,
+  LogsPanel,
+  TracesPanel,
+  HeatmapPanel,
+  TextPanel,
+  Row,
+  definePanel,
+  registeredPanels,
+  panelDefinitionFor,
+  isPanelEntity,
+  isRowEntity,
+  PANEL_TYPE_PREFIX,
+  ROW_TYPE,
+  type PanelProps,
+  type PanelFieldConfig,
+  type PanelLink,
+  type PanelDefinition,
+  type PanelEntity,
+  type PanelClass,
+  type RowProps,
+  type RowEntity,
+} from "./panels";
+
+// Queries, and the extension point for other datasource plugins
+export {
+  PromQuery,
+  TempoQuery,
+  LokiQuery,
+  defineQuery,
+  registeredQueries,
+  queryDefinitionFor,
+  isQueryEntity,
+  QUERY_TYPE_PREFIX,
+  type DatasourceInput,
+  type QueryModel,
+  type QueryProps,
+  type QueryDefinition,
+  type QueryEntity,
+  type QueryClass,
+  type PromQueryEntity,
+  type TempoQueryEntity,
+  type LokiQueryEntity,
+} from "./query";
+
+// Variables
+export {
+  QueryVariable,
+  CustomVariable,
+  IntervalVariable,
+  DatasourceVariable,
+  ConstantVariable,
+  TextboxVariable,
+  isVariableEntity,
+  isDatasourceVariable,
+  isBuiltinVariable,
+  VARIABLE_NAME,
+  VARIABLE_TYPE_PREFIX,
+  type VariableKind,
+  type VariableHide,
+  type VariableEntity,
+  type VariableDatasource,
+  type DatasourceVariableEntity,
+  type QueryVariableProps,
+  type CustomVariableProps,
+  type IntervalVariableProps,
+  type DatasourceVariableProps,
+  type ConstantVariableProps,
+  type TextboxVariableProps,
+} from "./variables";
+
+// The generated schema types and their pin
+export * as schema from "./schema";
+export { DASHBOARD_SCHEMA_VERSION } from "./schema";
+export { GRAFANA_SCHEMA_PIN, SCHEMA_NAMES, type GrafanaSchemaPin, type SchemaName } from "./pin";
+
+// Plain-data API: render, check and detect without a build
+export {
+  buildGrafana,
+  grafanaFiles,
+  renderDashboard,
+  dashboardJson,
+  dashboardUid,
+  panelsJson,
+  targetJson,
+  variableModel,
+  datasourceRef,
+  provisionedDatasource,
+  provisionedProvider,
+  datasourcesYaml,
+  dashboardProvidersYaml,
+  GRID_COLUMNS,
+  DATASOURCES_FILE,
+  DASHBOARD_PROVIDERS_FILE,
+  DASHBOARDS_DIR,
+  type BuiltGrafana,
+  type BuiltDashboard,
+  type GrafanaIndex,
+  type ProvisionedDatasource,
+  type ProvisionedProvider,
+  type DashboardJson,
+  type PanelJson,
+  type RowPanelJson,
+  type VariableModel,
+  type DataSourceRef,
+} from "./build";
+export {
+  validateGrafanaOutput,
+  issuesFor,
+  variableReferences,
+  type GrafanaIssue,
+  type GrafanaIssueCode,
+  type GrafanaArtifacts,
+  type DashboardDoc,
+} from "./validate-output";
+export { validateDashboardSchema, type SchemaProblem } from "./schema-validate";
+export { looksLikeDashboard, looksLikeDatasourceProvisioning, looksLikeDashboardProvisioning } from "./detect";
+export { slugUid, isValidUid, UID_PATTERN, type DeepPartial } from "./util";
+
+// Composites: dashboards built from a spanmetrics connector, an Slo and the GenAI preset
+export {
+  RedDashboard,
+  redQueries,
+  SloDashboard,
+  sloQueries,
+  AgentDashboard,
+  agentQueries,
+  type RedDashboardProps,
+  type RedDashboardMembers,
+  type RedDashboardInstance,
+  type SloDashboardProps,
+  type SloDashboardMembers,
+  type SloDashboardInstance,
+  type AgentDashboardProps,
+  type AgentDashboardMembers,
+  type AgentDashboardInstance,
+  type DashboardOptions,
+} from "./composites";

package/src/lint/audit-catalog.ts

@@ -0,0 +1,87 @@
+/**
+ * The grafana lexicon's chant audit catalog, contributed via
+ * `grafanaPlugin.auditCatalog()` (#687, #1346).
+ *
+ * GRAF101-GRAF107 read the emitted dashboard JSON and provisioning files, so
+ * they fire on an audit of files chant didn't build too, and are
+ * `yamlBased`. GRAF001 and GRAF002 read TypeScript source, so they are
+ * constructed with `yamlBased: false`; they are listed for a reader who
+ * meets them in a lint report.
+ */
+
+import { auditRule, type RuleMeta } from "@intentius/chant/audit/catalog";
+
+function sourceRule(id: string, category: RuleMeta["category"], title: string, remediation: string): RuleMeta {
+  return { id, tier: "merge-worthy", fixKind: "guidance", category, title, remediation, yamlBased: false };
+}
+
+export const grafanaAuditCatalog: Record<string, RuleMeta> = {
+  GRAF001: sourceRule(
+    "GRAF001",
+    "correctness",
+    "Grafana uid or variable name is not valid syntax",
+    'Use 1-40 letters, digits, "-" and "_" for uids, and letters, digits and "_" for variable names.',
+  ),
+  GRAF002: sourceRule(
+    "GRAF002",
+    "security",
+    "Datasource secret declared as a literal",
+    "Replace the value with `$__env{NAME}` or `$__file{/path}` so Grafana reads it when it loads the provisioning file.",
+  ),
+  GRAF101: auditRule(
+    "GRAF101",
+    "merge-worthy",
+    "guidance",
+    "Panel uses an undeclared datasource",
+    "Point the panel or query at a declared Datasource, or declare the datasource it names in the same build root.",
+    { category: "correctness" },
+  ),
+  GRAF102: auditRule(
+    "GRAF102",
+    "merge-worthy",
+    "guidance",
+    "Query sent to a datasource of another type",
+    "Use the query class that matches the datasource (PromQuery for prometheus, TempoQuery for tempo, LokiQuery for loki), or point the query at a datasource of its own type.",
+    { category: "correctness" },
+  ),
+  GRAF103: auditRule(
+    "GRAF103",
+    "merge-worthy",
+    "guidance",
+    "Query uses an undeclared dashboard variable",
+    "Declare the variable and list it in the dashboard's variables, or remove the reference.",
+    { category: "correctness" },
+  ),
+  GRAF104: auditRule(
+    "GRAF104",
+    "merge-worthy",
+    "guidance",
+    "Duplicate dashboard uid, datasource, panel id, variable or refId",
+    "Give each dashboard and datasource its own uid and name, and each panel, variable and query its own id within its dashboard or panel.",
+    { category: "correctness" },
+  ),
+  GRAF105: auditRule(
+    "GRAF105",
+    "report-only",
+    "guidance",
+    "Panel outside the grid or overlapping another",
+    "Keep x + w within 24 columns, and move or resize overlapping panels, or leave x and y out so the dashboard places them.",
+    { category: "best-practice" },
+  ),
+  GRAF106: auditRule(
+    "GRAF106",
+    "merge-worthy",
+    "guidance",
+    "Dashboard or datasource uid Grafana rejects, or an untitled dashboard",
+    'Use 1-40 letters, digits, "-" and "_" for uids, and give every dashboard a title.',
+    { category: "correctness" },
+  ),
+  GRAF107: auditRule(
+    "GRAF107",
+    "merge-worthy",
+    "guidance",
+    "Dashboard does not match the Grafana schema",
+    "Fix the key or value the message names; the panel option types generated from the same schema show what is allowed.",
+    { category: "correctness" },
+  ),
+};

package/src/lint/post-synth/graf101.ts

@@ -0,0 +1,17 @@
+/**
+ * GRAF101: A panel, query or variable uses a datasource no Datasource in the build declares
+ *
+ * Grafana shows "datasource not found" on the panel. Typed references cannot go wrong this way, so it mostly catches a { type, uid } ref or a hand-edited dashboard. A panel with queries and no datasource at all is a warning: Grafana sends them to its default datasource. This check joins dashboards against the Datasource declarations of the same build root, so it goes silent across build roots (chant #1939): with no Datasource declared in the build it reports nothing, and a datasource declared in another build root looks undeclared. Keep datasources and the dashboards that use them in one build root.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { grafanaDiagnostics } from "./grafana-helpers";
+
+export const graf101: PostSynthCheck = {
+  id: "GRAF101",
+  description: "A panel, query or variable uses a datasource no Datasource in the build declares",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return grafanaDiagnostics(ctx, "GRAF101");
+  },
+};

package/src/lint/post-synth/graf102.ts

@@ -0,0 +1,17 @@
+/**
+ * GRAF102: A query is sent to a datasource of another plugin type
+ *
+ * A PromQL query sent to Tempo fails at query time. The typed classes prevent this at compile time; the check catches refs, datasource variables of the wrong plugin type and hand-edited dashboards. Like GRAF101 it joins against the Datasource declarations of the same build root and goes silent across build roots (chant #1939).
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { grafanaDiagnostics } from "./grafana-helpers";
+
+export const graf102: PostSynthCheck = {
+  id: "GRAF102",
+  description: "A query is sent to a datasource of another plugin type",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return grafanaDiagnostics(ctx, "GRAF102");
+  },
+};

package/src/lint/post-synth/graf103.ts

@@ -0,0 +1,17 @@
+/**
+ * GRAF103: A query, title, datasource or repeat uses a variable the dashboard does not declare
+ *
+ * Grafana leaves an undeclared $name in the query as text, so the query fails or matches nothing. Names Grafana defines itself ($__interval, $__rate_interval, $__range and the rest of $__*) need no declaration.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { grafanaDiagnostics } from "./grafana-helpers";
+
+export const graf103: PostSynthCheck = {
+  id: "GRAF103",
+  description: "A query, title, datasource or repeat uses a variable the dashboard does not declare",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return grafanaDiagnostics(ctx, "GRAF103");
+  },
+};

package/src/lint/post-synth/graf104.ts

@@ -0,0 +1,17 @@
+/**
+ * GRAF104: Two dashboards, datasources, panels, variables or queries share an id
+ *
+ * Dashboard uids and datasource uids and names must be unique across the build, panel ids and variable names within a dashboard, and refIds within a panel. Grafana keeps one of two dashboards with the same uid and silently drops the other.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { grafanaDiagnostics } from "./grafana-helpers";
+
+export const graf104: PostSynthCheck = {
+  id: "GRAF104",
+  description: "Two dashboards, datasources, panels, variables or queries share an id",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return grafanaDiagnostics(ctx, "GRAF104");
+  },
+};

package/src/lint/post-synth/graf105.ts

@@ -0,0 +1,17 @@
+/**
+ * GRAF105: A panel does not fit the 24-column grid, or overlaps another panel
+ *
+ * A panel wider than the grid is an error. An overlap is a warning: Grafana moves one of the panels on load, so the dashboard does not look the way it was declared. Panels without x and y are placed by the dashboard and cannot overlap each other.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { grafanaDiagnostics } from "./grafana-helpers";
+
+export const graf105: PostSynthCheck = {
+  id: "GRAF105",
+  description: "A panel does not fit the 24-column grid, or overlaps another panel",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return grafanaDiagnostics(ctx, "GRAF105");
+  },
+};

package/src/lint/post-synth/graf106.ts

@@ -0,0 +1,17 @@
+/**
+ * GRAF106: A dashboard or datasource uid Grafana rejects, or a dashboard with no title
+ *
+ * Grafana accepts uids of 1-40 letters, digits, - and _, and refuses to save a dashboard without a title.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { grafanaDiagnostics } from "./grafana-helpers";
+
+export const graf106: PostSynthCheck = {
+  id: "GRAF106",
+  description: "A dashboard or datasource uid Grafana rejects, or a dashboard with no title",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return grafanaDiagnostics(ctx, "GRAF106");
+  },
+};