@intentius/chant-lexicon-grafana 0.124.31 → 0.124.32

package/dist/api/dashboards.js

@@ -0,0 +1,210 @@
+/**
+ * Reading dashboards (#2946).
+ *
+ * Grafana 12 and 13 serve dashboards as Kubernetes-style resources under
+ * `/apis/dashboard.grafana.app/<version>/namespaces/<ns>/dashboards/<uid>`:
+ * the classic dashboard JSON in `spec`, and who manages it in
+ * `metadata.annotations` and `metadata.labels` (./../ownership.ts). The
+ * version is discovered once per client from the API group, preferring the
+ * newest classic (v1-family) version the server serves: `v1` on 13.x,
+ * `v1beta1` on 12.x. A server without the group (Grafana 11) is read over
+ * `GET /api/dashboards/uid/<uid>`, which has the same JSON and no metadata
+ * channel.
+ *
+ * ## The version branch is one place
+ *
+ * {@link classicDashboardOf} decides how a stored dashboard is read as
+ * classic JSON. Everything downstream (observe, deep observe, export) only
+ * ever sees its answer. A dashboard Grafana stores as v2 (the layout-and-
+ * elements schema) is not read through Grafana's own v2-to-v1 conversion,
+ * which drops what v1 cannot hold with nothing to show it (the importer
+ * refuses that read too, `lossyV1Read`). Instead {@link readDashboard} and
+ * {@link listDashboards} read it again at the newest v2 version the server
+ * serves (`v2` on 13.x, `v2beta1` on 12.x), and `classicDashboardOf`
+ * converts that with the importer's v2 reader (./../import/v2.ts), which
+ * names everything v2 holds that the classic model cannot (#2947). Only a
+ * v2-stored dashboard the server cannot serve at v2, or whose conversion
+ * failed, is reported as not readable.
+ */
+import { looksLikeV2Dashboard } from "../detect.js";
+import { lossyV1Read, readV2Dashboard } from "../import/v2.js";
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function stringMap(v) {
+    if (!isObject(v))
+        return {};
+    return Object.fromEntries(Object.entries(v).filter(([, x]) => typeof x === "string"));
+}
+export const DASHBOARD_GROUP = "dashboard.grafana.app";
+/** Classic-schema versions of the dashboard API, newest first. */
+export const CLASSIC_DASHBOARD_VERSIONS = ["v1", "v1beta1", "v0alpha1"];
+/** v2-schema versions of the dashboard API the v2 reader understands, newest first. */
+export const V2_DASHBOARD_VERSIONS = ["v2", "v2beta1"];
+/** The dashboard API the server behind `client` serves, discovered once per client. */
+export function dashboardApi(client) {
+    return client.once("dashboard-api", async () => {
+        const group = await client.get(`/apis/${DASHBOARD_GROUP}`);
+        const served = new Set((group?.versions ?? []).map((v) => v.version).filter((v) => typeof v === "string"));
+        const version = CLASSIC_DASHBOARD_VERSIONS.find((v) => served.has(v));
+        const v2Version = V2_DASHBOARD_VERSIONS.find((v) => served.has(v));
+        return version ? { kind: "apis", version, ...(v2Version ? { v2Version } : {}) } : { kind: "legacy" };
+    });
+}
+/** The request path for one dashboard on this API (at `version` instead of the classic one, when given). */
+export function dashboardPath(api, namespace, uid, version) {
+    const id = encodeURIComponent(uid);
+    return api.kind === "apis"
+        ? `/apis/${DASHBOARD_GROUP}/${version ?? api.version}/namespaces/${encodeURIComponent(namespace)}/dashboards/${id}`
+        : `/api/dashboards/uid/${id}`;
+}
+/**
+ * A classic read of a dashboard Grafana stores as v2 is a lossy
+ * down-conversion: read it again at v2, where it is whole. Anything else,
+ * and a v2-stored dashboard on a server with no v2 version the reader knows,
+ * comes back as it was (and `classicDashboardOf` says why it cannot be read).
+ */
+async function atStoredVersion(client, api, live) {
+    if (api.kind !== "apis" || !api.v2Version)
+        return live;
+    const lossy = lossyV1Read(live.raw);
+    if (!lossy || lossy.failed || !lossy.storedVersion.startsWith("v2"))
+        return live;
+    const address = dashboardPath(api, client.namespace, live.uid, api.v2Version);
+    const body = await client.get(address);
+    return body === undefined ? live : fromResource(body, address);
+}
+function fromResource(resource, address) {
+    const metadata = isObject(resource.metadata) ? resource.metadata : {};
+    const annotations = stringMap(metadata.annotations);
+    const folderUid = annotations["grafana.app/folder"];
+    return {
+        uid: typeof metadata.name === "string" ? metadata.name : "",
+        raw: resource,
+        via: "apis",
+        labels: stringMap(metadata.labels),
+        annotations,
+        ...(folderUid ? { folderUid } : {}),
+        address,
+    };
+}
+function fromLegacy(body, address) {
+    const dashboard = isObject(body.dashboard) ? body.dashboard : {};
+    const meta = isObject(body.meta) ? body.meta : {};
+    return {
+        uid: typeof dashboard.uid === "string" ? dashboard.uid : "",
+        raw: body,
+        via: "legacy",
+        labels: {},
+        annotations: {},
+        ...(typeof meta.folderUid === "string" && meta.folderUid !== "" ? { folderUid: meta.folderUid } : {}),
+        ...(typeof meta.folderTitle === "string" && meta.folderTitle !== "" && meta.folderUid ? { folderTitle: meta.folderTitle } : {}),
+        address,
+    };
+}
+/** Read one dashboard by uid. Throws `GrafanaApiError` for anything but a 2xx or a 404. */
+export async function readDashboard(client, uid) {
+    const api = await dashboardApi(client);
+    const address = dashboardPath(api, client.namespace, uid);
+    const body = await client.get(address);
+    if (body === undefined)
+        return { absent: true, address };
+    if (api.kind !== "apis")
+        return { present: fromLegacy(body, address) };
+    return { present: await atStoredVersion(client, api, fromResource(body, address)) };
+}
+/** Every dashboard in the organisation, paged. */
+export async function listDashboards(client) {
+    const api = await dashboardApi(client);
+    const out = [];
+    if (api.kind === "apis") {
+        const base = `/apis/${DASHBOARD_GROUP}/${api.version}/namespaces/${encodeURIComponent(client.namespace)}/dashboards`;
+        let next;
+        do {
+            const page = await client.get(`${base}?limit=500${next ? `&continue=${encodeURIComponent(next)}` : ""}`);
+            for (const item of page?.items ?? []) {
+                if (!isObject(item))
+                    continue;
+                const d = fromResource(item, `${base}/${encodeURIComponent(String(item.metadata?.name ?? ""))}`);
+                if (d.uid)
+                    out.push(await atStoredVersion(client, api, d));
+            }
+            next = page?.metadata?.continue || undefined;
+        } while (next);
+        return out;
+    }
+    for (let page = 1;; page++) {
+        const hits = (await client.get(`/api/search?type=dash-db&limit=1000&page=${page}`)) ?? [];
+        for (const hit of hits) {
+            if (typeof hit.uid !== "string")
+                continue;
+            const read = await readDashboard(client, hit.uid);
+            if ("present" in read)
+                out.push(read.present);
+        }
+        if (hits.length < 1000)
+            break;
+    }
+    return out;
+}
+/** A v2 dashboard (a resource, or a bare v2 spec) as classic JSON with the uid, and what the classic form cannot hold. */
+function fromV2(v2, uid) {
+    try {
+        const { dashboard, warnings } = readV2Dashboard(v2);
+        return { json: { ...dashboard, uid: uid || dashboard.uid }, warnings };
+    }
+    catch (err) {
+        return { unsupported: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * The stored dashboard as classic JSON, with its uid, or why it cannot be
+ * read as one. The only place the dashboard schema version branches. A v2
+ * dashboard is converted by the importer's v2 reader; `warnings` then names
+ * what v2 holds that the classic JSON does not (tabs, auto grids,
+ * conditional rendering), and is absent for a classic dashboard.
+ */
+export function classicDashboardOf(dashboard) {
+    if (dashboard.via === "legacy") {
+        const json = isObject(dashboard.raw.dashboard) ? dashboard.raw.dashboard : {};
+        if (looksLikeV2Dashboard(json))
+            return fromV2(json, dashboard.uid);
+        return { json };
+    }
+    if (looksLikeV2Dashboard(dashboard.raw))
+        return fromV2(dashboard.raw, dashboard.uid);
+    // The importer's own test for a v1 read of a v2-stored dashboard, so import
+    // and observe refuse the same lossy down-conversion. readDashboard has
+    // already tried the v2 read; this is a server that could not give it.
+    const lossy = lossyV1Read(dashboard.raw);
+    if (lossy?.failed)
+        return { unsupported: `Grafana could not convert it from ${lossy.storedVersion || "the version it is stored at"} to the classic schema` };
+    if (lossy) {
+        return {
+            unsupported: `it is stored as a ${lossy.storedVersion} dashboard and the server did not serve it at ${V2_DASHBOARD_VERSIONS.join(" or ")}; ` +
+                `its ${lossy.apiVersion} copy is a lossy down-conversion, so it is not read`,
+        };
+    }
+    const spec = isObject(dashboard.raw.spec) ? dashboard.raw.spec : undefined;
+    if (!spec)
+        return { unsupported: "the resource has no spec" };
+    if (looksLikeV2Dashboard(spec))
+        return fromV2(spec, dashboard.uid);
+    // The resource's name is the dashboard's uid; the spec does not repeat it.
+    return { json: { ...spec, uid: dashboard.uid } };
+}
+/**
+ * The title of the folder a dashboard is in, or undefined for the General
+ * folder. One `GET /api/folders/<uid>` per folder per client.
+ */
+export async function folderTitleOf(client, dashboard) {
+    if (!dashboard.folderUid)
+        return undefined;
+    if (dashboard.folderTitle)
+        return dashboard.folderTitle;
+    const uid = dashboard.folderUid;
+    return client.once(`folder:${uid}`, async () => {
+        const folder = await client.get(`/api/folders/${encodeURIComponent(uid)}`);
+        return typeof folder?.title === "string" ? folder.title : undefined;
+    });
+}

package/dist/api/datasources.js

@@ -0,0 +1,24 @@
+/**
+ * Reading datasources (#2946), over `GET /api/datasources/uid/<uid>` and
+ * `GET /api/datasources`. Grafana 12.4 and 13.2 serve no general
+ * datasource resource under `/apis`, so this is the one datasource API both
+ * have, and it carries no labels or annotations: a datasource's ownership
+ * cannot be read (see ../ownership.ts).
+ *
+ * The API never returns secret values. `secureJsonFields` says which
+ * secrets are set, and that is all this reads of them.
+ */
+export function datasourcePath(uid) {
+    return `/api/datasources/uid/${encodeURIComponent(uid)}`;
+}
+/** Read one datasource by uid. Throws `GrafanaApiError` for anything but a 2xx or a 404. */
+export async function readDatasource(client, uid) {
+    const address = datasourcePath(uid);
+    const body = await client.get(address);
+    return body === undefined ? { absent: true, address } : { present: body, address };
+}
+/** Every datasource in the organisation. */
+export async function listDatasources(client) {
+    const list = await client.get("/api/datasources");
+    return (list ?? []).filter((d) => typeof d === "object" && d !== null && !Array.isArray(d));
+}

package/dist/api/fake-grafana-writes.js

@@ -0,0 +1,185 @@
+/**
+ * A Grafana that remembers writes, in memory, for the applier's tests
+ * (#2948). The read-only fake (./fake-grafana.ts) serves a fixed state for
+ * observe and export; this one serves the routes the applier writes to and
+ * keeps what it was sent, so a second apply sees the first one's result.
+ *
+ * It behaves as Grafana 12.4.11 and 13.2.2 did when the applier was checked
+ * against them (../op/activities/grafana-apply.e2e.test.ts): `POST` to an
+ * existing name is a 409, `PUT` needs no `resourceVersion`, a stored
+ * dashboard gets the built-in annotation and Grafana's defaults
+ * (`storedDashboard`), a folder with anything in it cannot be deleted over
+ * `/apis`, and a library element update needs its `version`. With
+ * `api: "legacy"` it is a Grafana 11: no `/apis` groups, dashboards over
+ * `/api/dashboards/db` and `/api/dashboards/uid`, folders over `/api/folders`.
+ */
+import { storedDashboard } from "./fake-grafana.js";
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+export function emptyGrafana(api) {
+    return { api, dashboards: {}, folders: {}, libraryElements: {} };
+}
+/** What Grafana fills in on a dashboard it stores, beyond `storedDashboard`. */
+const DASHBOARD_DEFAULTS = { editable: true, fiscalYearStartMonth: 0, graphTooltip: 0, links: [], templating: { list: [] }, timepicker: {}, timezone: "", weekStart: "" };
+function store(spec) {
+    return { ...DASHBOARD_DEFAULTS, ...storedDashboard(spec) };
+}
+const ok = (json, status = 200) => ({ status, json });
+const notFound = { status: 404, json: { message: "not found" } };
+/**
+ * A {@link GrafanaHttp} over `state`, which it changes as it is written to.
+ * Every request is recorded in `calls` as `METHOD path`.
+ */
+export function writableGrafana(state, calls = []) {
+    const ns = state.namespace ?? "default";
+    const apis = state.api !== "legacy";
+    const dashRoute = new RegExp(`^/apis/dashboard\\.grafana\\.app/${state.api}/namespaces/${ns}/dashboards(?:/([^/]+))?$`);
+    const folderRoute = new RegExp(`^/apis/folder\\.grafana\\.app/${state.api}/namespaces/${ns}/folders(?:/([^/]+))?$`);
+    const resource = (kind, group, uid, r) => ({
+        apiVersion: `${group}/${state.api}`,
+        kind,
+        metadata: { name: uid, namespace: ns, resourceVersion: "1", labels: { "grafana.app/deprecatedInternalID": "1", ...r.labels }, annotations: r.annotations },
+        spec: r.spec,
+        ...(kind === "Dashboard" ? { status: { conversion: { failed: false, storedVersion: "v0alpha1" } } } : {}),
+    });
+    const metadataOf = (body) => {
+        const m = isObject(body) && isObject(body.metadata) ? body.metadata : {};
+        const strings = (v) => (isObject(v) ? Object.fromEntries(Object.entries(v).filter(([, x]) => typeof x === "string")) : {});
+        const labels = strings(m.labels);
+        delete labels["grafana.app/deprecatedInternalID"];
+        return { name: typeof m.name === "string" ? m.name : "", labels, annotations: strings(m.annotations) };
+    };
+    const parentOf = (r) => r.annotations["grafana.app/folder"] ?? "";
+    const counts = (uid) => ({
+        dashboards: Object.values(state.dashboards).filter((d) => parentOf(d) === uid).length,
+        folders: Object.values(state.folders).filter((f) => parentOf(f) === uid).length,
+        librarypanels: Object.values(state.libraryElements).filter((e) => e.folderUid === uid).length,
+        alertrules: 0,
+    });
+    return async (method, path, body) => {
+        calls.push(`${method} ${path}`);
+        if (state.status !== undefined)
+            return { status: state.status, json: { message: "refused" } };
+        const [route] = path.split("?");
+        if (route === "/apis/dashboard.grafana.app") {
+            if (!apis)
+                return notFound;
+            const versions = state.api === "v1" ? ["v2", "v0alpha1", "v1", "v1beta1"] : ["v1beta1", "v0alpha1", "v2beta1"];
+            return ok({ kind: "APIGroup", versions: versions.map((version) => ({ version })) });
+        }
+        if (route === "/apis/folder.grafana.app") {
+            if (!apis)
+                return notFound;
+            return ok({ kind: "APIGroup", versions: (state.api === "v1" ? ["v1", "v1beta1"] : ["v1beta1"]).map((version) => ({ version })) });
+        }
+        for (const [re, kind, group, table] of [
+            [dashRoute, "Dashboard", "dashboard.grafana.app", state.dashboards],
+            [folderRoute, "Folder", "folder.grafana.app", state.folders],
+        ]) {
+            const m = apis ? re.exec(route) : null;
+            if (!m)
+                continue;
+            const uid = m[1] ? decodeURIComponent(m[1]) : undefined;
+            if (!uid) {
+                if (method === "GET")
+                    return ok({ items: Object.entries(table).map(([u, r]) => resource(kind, group, u, r)), metadata: {} });
+                if (method === "POST") {
+                    const meta = metadataOf(body);
+                    if (table[meta.name])
+                        return { status: 409, json: { message: "already exists" } };
+                    const spec = isObject(body) && isObject(body.spec) ? body.spec : {};
+                    table[meta.name] = { spec: kind === "Dashboard" ? store(spec) : spec, labels: meta.labels, annotations: meta.annotations };
+                    return ok(resource(kind, group, meta.name, table[meta.name]), 201);
+                }
+                return { status: 405, json: {} };
+            }
+            const r = table[uid];
+            if (method === "GET")
+                return r ? ok(resource(kind, group, uid, r)) : notFound;
+            if (method === "PUT") {
+                const meta = metadataOf(body);
+                const spec = isObject(body) && isObject(body.spec) ? body.spec : {};
+                table[uid] = { spec: kind === "Dashboard" ? store(spec) : spec, labels: meta.labels, annotations: meta.annotations };
+                return ok(resource(kind, group, uid, table[uid]), r ? 200 : 201);
+            }
+            if (method === "DELETE") {
+                if (!r)
+                    return notFound;
+                if (kind === "Folder" && Object.values(counts(uid)).some((n) => n > 0))
+                    return { status: 400, json: { message: "Folder cannot be deleted: folder is not empty" } };
+                delete table[uid];
+                return ok({ status: "Success" });
+            }
+        }
+        const counted = /^\/api\/folders\/([^/]+)\/counts$/.exec(route);
+        if (counted)
+            return state.folders[decodeURIComponent(counted[1])] ? ok(counts(decodeURIComponent(counted[1]))) : notFound;
+        // Legacy dashboards and folders (Grafana 11; 12.4 and 13.2 still serve them).
+        const legacyDash = /^\/api\/dashboards\/uid\/([^/]+)$/.exec(route);
+        if (legacyDash && method === "GET") {
+            const uid = decodeURIComponent(legacyDash[1]);
+            const d = state.dashboards[uid];
+            if (!d)
+                return notFound;
+            return ok({ dashboard: { ...d.spec, uid, id: 7, version: 3 }, meta: { folderUid: parentOf(d), provisioned: false } });
+        }
+        if (route === "/api/dashboards/db" && method === "POST" && isObject(body) && isObject(body.dashboard)) {
+            const { uid, id: _id, version: _v, ...spec } = body.dashboard;
+            const folderUid = typeof body.folderUid === "string" ? body.folderUid : "";
+            const prior = state.dashboards[String(uid)];
+            state.dashboards[String(uid)] = { spec, labels: prior?.labels ?? {}, annotations: folderUid ? { "grafana.app/folder": folderUid } : {} };
+            return ok({ status: "success", uid, version: 1 });
+        }
+        if (route === "/api/search")
+            return ok(Object.keys(state.dashboards).map((uid) => ({ uid, type: "dash-db" })));
+        const legacyFolder = /^\/api\/folders\/([^/]+)(\/move)?$/.exec(route);
+        if (legacyFolder) {
+            const uid = decodeURIComponent(legacyFolder[1]);
+            const f = state.folders[uid];
+            if (!f)
+                return notFound;
+            if (legacyFolder[2] && method === "POST" && isObject(body)) {
+                f.annotations = typeof body.parentUid === "string" && body.parentUid ? { "grafana.app/folder": body.parentUid } : {};
+                return ok({ uid });
+            }
+            if (method === "GET")
+                return ok({ uid, title: f.spec.title, version: 1, ...(parentOf(f) ? { parentUid: parentOf(f) } : {}) });
+            if (method === "PUT" && isObject(body)) {
+                f.spec = { title: body.title };
+                return ok({ uid, title: body.title });
+            }
+        }
+        if (route === "/api/folders" && method === "POST" && isObject(body)) {
+            const uid = String(body.uid);
+            if (state.folders[uid])
+                return { status: 409, json: { message: "a folder with that uid already exists" } };
+            state.folders[uid] = { spec: { title: body.title }, labels: {}, annotations: typeof body.parentUid === "string" && body.parentUid ? { "grafana.app/folder": body.parentUid } : {} };
+            return ok({ uid, title: body.title });
+        }
+        // Library elements: the same on every version.
+        if (route === "/api/library-elements" && method === "POST" && isObject(body)) {
+            const uid = String(body.uid);
+            if (state.libraryElements[uid])
+                return { status: 400, json: { message: "library element with that name or UID already exists" } };
+            state.libraryElements[uid] = { uid, name: body.name, kind: body.kind, model: body.model, folderUid: body.folderUid ?? "", version: 1 };
+            return ok({ result: state.libraryElements[uid] });
+        }
+        const lib = /^\/api\/library-elements\/([^/]+)$/.exec(route);
+        if (lib) {
+            const uid = decodeURIComponent(lib[1]);
+            const el = state.libraryElements[uid];
+            if (!el)
+                return notFound;
+            if (method === "GET")
+                return ok({ result: el });
+            if (method === "PATCH" && isObject(body)) {
+                if (body.version !== el.version)
+                    return { status: 400, json: { message: "bad request data" } };
+                state.libraryElements[uid] = { ...el, name: body.name, model: body.model, folderUid: body.folderUid ?? "", version: el.version + 1 };
+                return ok({ result: state.libraryElements[uid] });
+            }
+        }
+        return notFound;
+    };
+}

package/dist/api/fake-grafana.js

@@ -0,0 +1,161 @@
+/**
+ * A Grafana API in memory, for the observe and export tests (#2946).
+ *
+ * Serves the routes the readers use, from a state the test sets up, in the
+ * shapes Grafana 12.4.11 and 13.2.2 return (checked against both with the
+ * e2e in ../observe.e2e.test.ts): the API group discovery, dashboard
+ * resources under `/apis`, the legacy `/api/dashboards/uid` and
+ * `/api/search`, folders, and datasources. `storedDashboard` does to a built
+ * dashboard what Grafana does when it stores one.
+ */
+const BUILTIN_ANNOTATION = {
+    builtIn: 1,
+    datasource: { type: "grafana", uid: "-- Grafana --" },
+    enable: true,
+    hide: true,
+    iconColor: "rgba(0, 211, 255, 1)",
+    name: "Annotations & Alerts",
+    type: "dashboard",
+};
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function dropNulls(v) {
+    if (Array.isArray(v))
+        return v.map(dropNulls);
+    if (isObject(v))
+        return Object.fromEntries(Object.entries(v).filter(([, x]) => x !== null).map(([k, x]) => [k, dropNulls(x)]));
+    return v;
+}
+function storePanel(p) {
+    const out = { ...p };
+    if (isObject(out.options) && Object.keys(out.options).length === 0)
+        delete out.options;
+    const fc = out.fieldConfig;
+    if (isObject(fc) && isObject(fc.defaults) && Object.keys(fc.defaults).length === 0 && Array.isArray(fc.overrides) && fc.overrides.length === 0)
+        delete out.fieldConfig;
+    if (Array.isArray(out.panels))
+        out.panels = out.panels.map((c) => (isObject(c) ? storePanel(c) : c));
+    return out;
+}
+/**
+ * A built dashboard as Grafana hands it back through `/apis` (measured on
+ * 12.4.11 and 13.2.2): the built-in annotation added, empty `options` and
+ * `fieldConfig` dropped, `null` values dropped, and the uid moved to the
+ * resource's name. The legacy route (`/api/dashboards/uid`) serves the
+ * built JSON plus `id` and `version`; the fake serves this model on both,
+ * which is the harder case for the legacy path.
+ */
+export function storedDashboard(built) {
+    const out = dropNulls(built);
+    const annotations = isObject(out.annotations) && Array.isArray(out.annotations.list) ? out.annotations.list : [];
+    out.annotations = { list: [BUILTIN_ANNOTATION, ...annotations] };
+    if (Array.isArray(out.panels))
+        out.panels = out.panels.map((p) => (isObject(p) ? storePanel(p) : p));
+    delete out.uid;
+    return out;
+}
+const ok = (json) => ({ status: 200, json });
+const notFound = { status: 404, json: { message: "not found" } };
+/** A {@link GrafanaHttp} over `state`, recording every request path in `calls`. */
+export function fakeGrafana(state, calls = []) {
+    const ns = state.namespace ?? "default";
+    const resource = (uid, d) => ({
+        apiVersion: `dashboard.grafana.app/${state.api}`,
+        kind: "Dashboard",
+        metadata: {
+            name: uid,
+            namespace: ns,
+            resourceVersion: "1",
+            generation: 1,
+            labels: { "grafana.app/deprecatedInternalID": "1", ...(d.labels ?? {}) },
+            annotations: { ...(d.folderUid ? { "grafana.app/folder": d.folderUid } : {}), ...(d.annotations ?? {}) },
+        },
+        spec: d.spec,
+        status: { conversion: { failed: false, storedVersion: d.storedVersion ?? "v0alpha1" } },
+    });
+    return async (method, path) => {
+        calls.push(`${method} ${path}`);
+        if (state.status !== undefined)
+            return { status: state.status, json: { message: "refused" } };
+        const [route, query] = path.split("?");
+        if (route === "/apis/dashboard.grafana.app") {
+            if (state.api === "legacy")
+                return notFound;
+            const versions = state.api === "v1" ? ["v2", "v2beta1", "v2alpha1", "v0alpha1", "v1", "v1beta1"] : ["v1beta1", "v0alpha1", "v2beta1", "v2alpha1"];
+            return ok({ kind: "APIGroup", name: "dashboard.grafana.app", versions: versions.map((version) => ({ groupVersion: `dashboard.grafana.app/${version}`, version })) });
+        }
+        const list = new RegExp(`^/apis/dashboard\\.grafana\\.app/${state.api}/namespaces/${ns}/dashboards$`).exec(route);
+        if (list && state.api !== "legacy")
+            return ok({ items: Object.entries(state.dashboards).map(([uid, d]) => resource(uid, d)), metadata: {} });
+        const v2 = new RegExp(`^/apis/dashboard\\.grafana\\.app/(v2|v2beta1)/namespaces/${ns}/dashboards/([^/]+)$`).exec(route);
+        if (v2 && state.api !== "legacy" && (state.api === "v1" || v2[1] === "v2beta1")) {
+            const uid = decodeURIComponent(v2[2]);
+            const d = state.dashboards[uid];
+            if (!d?.v2)
+                return notFound;
+            const r = resource(uid, d);
+            return ok({ ...r, apiVersion: `dashboard.grafana.app/${v2[1]}`, spec: d.v2, status: {} });
+        }
+        const one = new RegExp(`^/apis/dashboard\\.grafana\\.app/${state.api}/namespaces/${ns}/dashboards/([^/]+)$`).exec(route);
+        if (one && state.api !== "legacy") {
+            const d = state.dashboards[decodeURIComponent(one[1])];
+            return d ? ok(resource(decodeURIComponent(one[1]), d)) : notFound;
+        }
+        const legacy = /^\/api\/dashboards\/uid\/([^/]+)$/.exec(route);
+        if (legacy) {
+            const uid = decodeURIComponent(legacy[1]);
+            const d = state.dashboards[uid];
+            if (!d)
+                return notFound;
+            const folderTitle = d.folderUid ? state.folders?.[d.folderUid] : undefined;
+            return ok({
+                dashboard: { ...d.spec, uid, id: 7, version: 3 },
+                meta: { provisioned: true, folderUid: d.folderUid ?? "", folderTitle: folderTitle ?? "Dashboards", version: 3 },
+            });
+        }
+        if (route === "/api/search") {
+            const page = Number(new URLSearchParams(query ?? "").get("page") ?? "1");
+            return ok(page === 1 ? Object.keys(state.dashboards).map((uid) => ({ uid, type: "dash-db" })) : []);
+        }
+        const folder = /^\/api\/folders\/([^/]+)$/.exec(route);
+        if (folder) {
+            const uid = decodeURIComponent(folder[1]);
+            const title = state.folders?.[uid];
+            const parentUid = state.folderParents?.[uid];
+            return title ? ok({ uid, title, ...(parentUid ? { parentUid } : {}) }) : notFound;
+        }
+        if (route === "/api/datasources")
+            return ok(Object.values(state.datasources ?? {}).map(({ secureJsonFields: _s, ...rest }) => rest));
+        const ds = /^\/api\/datasources\/uid\/([^/]+)$/.exec(route);
+        if (ds) {
+            const d = state.datasources?.[decodeURIComponent(ds[1])];
+            return d ? ok(d) : notFound;
+        }
+        return notFound;
+    };
+}
+/** A datasource as `GET /api/datasources/uid/<uid>` returns one provisioned from a file. */
+export function liveDatasource(ds) {
+    return {
+        id: 2,
+        uid: ds.uid,
+        orgId: 1,
+        name: ds.name,
+        type: ds.type,
+        typeLogoUrl: `public/plugins/${ds.type}/img/logo.svg`,
+        access: "proxy",
+        url: ds.url ?? "",
+        user: "",
+        database: "",
+        basicAuth: false,
+        basicAuthUser: "",
+        withCredentials: false,
+        isDefault: ds.isDefault ?? false,
+        jsonData: ds.jsonData ?? {},
+        secureJsonFields: Object.fromEntries((ds.secure ?? []).map((k) => [k, true])),
+        version: 1,
+        readOnly: ds.readOnly ?? true,
+        apiVersion: "",
+    };
+}