@homeflare/alchemy 0.32.0 → 0.34.0

package/src/grafana/folder.ts

@@ -0,0 +1,161 @@
+/**
+ * `Grafana.Folder` — one Grafana folder, keyed by `uid`. Mirrors `datasource.ts`'s shape and
+ * doctrine (uid required, not generated — same reasoning, `getFolderByUID`/`updateFolder`/
+ * `deleteFolder` are all UID-keyed and `getFolders` (list) has no per-uid filter).
+ *
+ * ⛔ `description` IS WRITE-ONLY — MEASURED against `@distilled.cloud/grafana`'s generated types
+ *   (`Folder` in services/grafana.ts has no `description` field at all, though
+ *   `CreateFolderRequest`/`UpdateFolderRequest` both accept one). Grafana's classic folder GET
+ *   never returns it, not even as an is-it-set flag the way `DataSource.secureJsonFields` reports
+ *   for a datasource's secure fields. So `description` is sent on every create/update that
+ *   declares it but is NEVER part of `matches` — this resource cannot detect drift in a value it
+ *   is never shown, the same treatment `datasource.ts` gives `secureJsonDataRefs`.
+ *
+ * ⚠️ NESTING (`parentUid`) IS CREATE-ONLY — MEASURED against the same generated types.
+ *   `CreateFolderRequest.parentUid` exists; `UpdateFolderRequest` has no `parentUid` field at all
+ *   (`folder_uid`, `description`, `overwrite`, `title`, `version` — reparenting is simply not a
+ *   thing `PUT /folders/{uid}` can do). A declaration whose `parentUid` no longer matches the live
+ *   folder therefore REFUSES with `GrafanaFolderReparentError` rather than either silently doing
+ *   nothing (which would lie about the declaration taking effect) or deleting and recreating the
+ *   folder under the new parent (which — see the ⛔ below — takes every dashboard and alert rule in
+ *   it with it). Move a folder by hand in Grafana, then adjust the declaration to match.
+ *
+ * ⛔ DELETE DEFAULTS TO `retain` — DELETING A FOLDER DELETES ITS DASHBOARDS AND ALERT RULES IN
+ *   GRAFANA, per `deleteFolder`'s own operation description ("along with all dashboards (and their
+ *   alerts) stored in the folder... cannot be reverted... also deletes all the subfolders"). That
+ *   is the same class of multi-object cascade `openbao/mount.ts` guards with
+ *   `defaultRemovalPolicy: 'retain'` ("disabling a mount destroys every secret under it") — VERIFIED
+ *   there against Alchemy's own `Apply.ts` (not re-verified here; same engine, same option). A
+ *   stack that explicitly wants the cascade opts in with `.pipe(RemovalPolicy.destroy())` on the
+ *   declared instance; `destroy` below still implements the real DELETE in full either way (S11).
+ *   `Grafana.Dashboard` does NOT default to retain — deleting one dashboard is the same
+ *   single-object blast radius `Grafana.Datasource` already accepts without a retain guard, not
+ *   this family's multi-object cascade.
+ *
+ * ⛔ A PROVISIONED FOLDER (`managedBy` set — see provisioned.ts) REFUSES EVERY UPDATE AND DESTROY.
+ *   `matches` still compares structurally either way, so a mismatched declaration against a
+ *   provisioned folder shows `update` in a plan (never a silent, permanently-hidden noop) and then
+ *   fails loudly, by design, when reconcile actually tries to write.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import * as grafana from '@distilled.cloud/grafana';
+import * as Data from 'effect/Data';
+import * as Effect from 'effect/Effect';
+import { type GrafanaProvisionedObjectError, refuseIfProvisioned } from './provisioned.ts';
+import { type GrafanaSpec, grafanaHandlers } from './resource.ts';
+
+export interface FolderProps {
+  uid: string;
+  title: string;
+  /** Write-only — see the file header. Sent on every create/update that declares it; never diffed. */
+  description?: string;
+  /** Parent folder UID, for nested folders. Create-only — see the file header. */
+  parentUid?: string;
+}
+
+export interface FolderAttributes {
+  uid: string;
+  id: number;
+  title: string;
+  parentUid: string;
+  /** Non-empty when Grafana reports this folder as externally managed (e.g. provisioning). */
+  managedBy: string;
+  url: string;
+  version: number;
+}
+
+export interface GrafanaFolder extends Resource<
+  'Grafana.Folder',
+  FolderProps,
+  FolderAttributes,
+  never
+> {}
+
+export const GrafanaFolder = Resource<GrafanaFolder>('Grafana.Folder', {
+  defaultRemovalPolicy: 'retain',
+});
+
+/** A declared `parentUid` disagrees with the live folder's — `updateFolder` cannot reparent. */
+export class GrafanaFolderReparentError extends Data.TaggedError('GrafanaFolderReparentError')<{
+  readonly message: string;
+}> {}
+
+export const spec: GrafanaSpec<
+  FolderProps,
+  grafana.Folder,
+  FolderAttributes,
+  | grafana.CreateFolderError
+  | grafana.GetFolderByUIDError
+  | grafana.UpdateFolderError
+  | grafana.DeleteFolderError
+  | GrafanaProvisionedObjectError
+  | GrafanaFolderReparentError
+> = {
+  attributes: (live) => ({
+    id: live.id ?? 0,
+    managedBy: live.managedBy ?? '',
+    parentUid: live.parentUid ?? '',
+    title: live.title ?? '',
+    uid: live.uid ?? '',
+    url: live.url ?? '',
+    version: live.version ?? 0,
+  }),
+  create: (props) =>
+    grafana.createFolder({
+      uid: props.uid,
+      title: props.title,
+      ...(props.description === undefined ? {} : { description: props.description }),
+      ...(props.parentUid === undefined ? {} : { parentUid: props.parentUid }),
+    }),
+  destroy: (props, live) =>
+    Effect.gen(function* () {
+      if (live.managedBy) {
+        return yield* refuseIfProvisioned('Grafana.Folder', props.uid, live.managedBy);
+      }
+      yield* grafana.deleteFolder({ folder_uid: props.uid });
+    }),
+  fetchLive: (props) =>
+    grafana
+      .getFolderByUID({ folder_uid: props.uid })
+      .pipe(Effect.catchTag('NotFound', () => Effect.succeed(undefined))),
+  matches: (attributes, props) =>
+    attributes.title === props.title &&
+    (props.parentUid === undefined || attributes.parentUid === props.parentUid),
+  update: (props, live) =>
+    Effect.gen(function* () {
+      if (live.managedBy) {
+        return yield* refuseIfProvisioned('Grafana.Folder', props.uid, live.managedBy);
+      }
+      if (props.parentUid !== undefined && props.parentUid !== (live.parentUid ?? undefined)) {
+        return yield* Effect.fail(
+          new GrafanaFolderReparentError({
+            message:
+              `Grafana.Folder '${props.uid}' declares parentUid '${props.parentUid}' but is ` +
+              `live under '${live.parentUid ?? '(root)'}'. PUT /folders/{uid} cannot reparent a ` +
+              `folder — move it by hand in Grafana, then update the declaration to match.`,
+          }),
+        );
+      }
+      // ⚠️ UNLIKE DASHBOARD.TS's 412, THIS HAS NO VERIFIED CONFLICT SIGNAL. `version` is sent
+      //   optimistically, but the SDK's own doc comment on `UpdateFolderRequest.version` says
+      //   "only used by the legacy folder implementation" — on Grafana's newer unified-storage
+      //   folder backend it is plausibly ignored outright, meaning two concurrent title/description
+      //   writes could silently last-write-win with no error, unlike a dashboard save. NOT
+      //   MEASURED against a live instance either way (no live calls in this PR; flagged by an
+      //   adversarial review) — sending it is harmless (a no-op field on a backend that ignores it)
+      //   and correct on one that still honors it, so it stays, but do not read its PRESENCE here
+      //   as proof this resource detects folder update conflicts the way dashboard.ts does.
+      return yield* grafana.updateFolder({
+        folder_uid: props.uid,
+        title: props.title,
+        ...(props.description === undefined ? {} : { description: props.description }),
+        ...(live.version === undefined ? {} : { version: live.version }),
+      });
+    }),
+};
+
+export const handlers = grafanaHandlers(spec);
+
+export const GrafanaFolderProvider = () =>
+  Provider.effect(GrafanaFolder, Effect.succeed(GrafanaFolder.Provider.of(handlers)));

package/src/grafana/index.ts

@@ -2,22 +2,55 @@
  * Grafana providers for Alchemy.
  *
  * ⛔ THIS BARREL IS THE PUBLIC API, AND IT IS DELIBERATELY SMALLER THAN THE DIRECTORY. These are
- *   the symbols a real stack consumes; the rest of the files (resource.ts's engine, fake-grafana.ts)
- *   are internals a provider needs but a consumer should not depend on.
+ *   the symbols a real stack consumes; the rest of the files (resource.ts's engine, provisioned.ts,
+ *   dashboard-model.ts, fake-grafana.ts) are internals a provider needs but a consumer should not
+ *   depend on.
  *
- * ⛔ ONLY `Grafana.Datasource` SHIPS HERE. `@distilled.cloud/grafana` (aliased onto
- *   `@homeflare/distilled-grafana` — see docs/distilled-interim.md) now HAS folder, dashboard and
- *   alerting-provisioning CRUD operations — the SDK-level gap docs/grafana.md and
- *   docs/upstream-conformance.md recorded is fixed. Building `Grafana.Folder`, `Grafana.Dashboard`,
- *   `Grafana.AlertRule` etc. on top of them is follow-up work this PR deliberately does not do —
- *   see docs/grafana.md for what changed and what is still open.
+ * `Grafana.Datasource`, `Grafana.Folder`, `Grafana.Dashboard`, `Grafana.ContactPoint`,
+ * `Grafana.MuteTiming` and `Grafana.MessageTemplate` ship here. `Grafana.AlertRuleGroup` and
+ * `Grafana.NotificationPolicy` are stacked follow-up PRs on the same SDK operations — see
+ * docs/grafana.md, docs/grafana-folder-dashboard.md and docs/grafana-alerting.md for what shipped
+ * and what is still open.
  */
 export {
   type DatasourceAttributes,
   type DatasourceProps,
   GrafanaDatasource,
   GrafanaDatasourceProvider,
-  GrafanaSecretRefUnsetError,
 } from './datasource.ts';
+export {
+  type DashboardAttributes,
+  type DashboardModel,
+  type DashboardProps,
+  GrafanaDashboard,
+  GrafanaDashboardProvider,
+} from './dashboard.ts';
+export {
+  type FolderAttributes,
+  type FolderProps,
+  GrafanaFolder,
+  GrafanaFolderProvider,
+  GrafanaFolderReparentError,
+} from './folder.ts';
+export {
+  type ContactPointAttributes,
+  type ContactPointProps,
+  GrafanaContactPoint,
+  GrafanaContactPointProvider,
+} from './contact-point.ts';
+export {
+  type MessageTemplateAttributes,
+  type MessageTemplateProps,
+  GrafanaMessageTemplate,
+  GrafanaMessageTemplateProvider,
+} from './message-template.ts';
+export {
+  type MuteTimingAttributes,
+  type MuteTimingProps,
+  GrafanaMuteTiming,
+  GrafanaMuteTimingProvider,
+} from './mute-timing.ts';
+export { GrafanaProvisionedObjectError } from './provisioned.ts';
+export { GrafanaSecretRefUnsetError } from './secret-refs.ts';
 export { type GrafanaTarget, grafanaCredentials } from './credentials.ts';
 export { grafanaProviders } from './providers.ts';

package/src/grafana/message-template.test.ts

@@ -0,0 +1,212 @@
+/**
+ * `Grafana.MessageTemplate` against a fake Grafana — the PUT-is-both-create-and-update route (no
+ * `routePostTemplate` exists), the foreign-provenance refusal, and version-carrying updates.
+ * Mirrors `message-template.ts`'s own file header.
+ */
+import { describe, expect, test } from 'bun:test';
+import * as Effect from 'effect/Effect';
+import { GrafanaProvisionedObjectError } from './alerting-provenance.ts';
+import { fakeFailure, fakeGrafana, fakeGrafanaLayer } from './fake-grafana.ts';
+import { spec } from './message-template.ts';
+import { grafanaOperations } from './resource.ts';
+
+const PATH = '/api/v1/provisioning/templates/slack-body';
+
+const liveJson = {
+  name: 'slack-body',
+  provenance: 'api',
+  template: '{{ define "slack-body" }}…{{ end }}',
+  version: '3',
+};
+const props = { name: 'slack-body', template: '{{ define "slack-body" }}…{{ end }}' };
+
+describe('spec.fetchLive', () => {
+  test('a live template decodes into typed attributes', async () => {
+    const fake = fakeGrafana((method, url) =>
+      method === 'GET' && url.pathname === PATH ? Response.json(liveJson) : fakeFailure(404, 'x'),
+    );
+    const live = await Effect.runPromise(
+      spec.fetchLive(props).pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+    );
+    expect(live !== undefined && spec.attributes(live, props)).toEqual({
+      name: 'slack-body',
+      provenance: 'api',
+      template: '{{ define "slack-body" }}…{{ end }}',
+    });
+    expect(fake.bodies[0]).toBeUndefined();
+  });
+
+  test('a 404 folds to undefined', async () => {
+    const fake = fakeGrafana(() => fakeFailure(404, 'template not found'));
+    const result = await Effect.runPromise(
+      spec.fetchLive(props).pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+    );
+    expect(result).toBeUndefined();
+  });
+
+  test('a 401 propagates — never folded to absent', async () => {
+    const fake = fakeGrafana(() => fakeFailure(401, 'bad token'));
+    const failure = await Effect.runPromise(
+      Effect.flip(spec.fetchLive(props).pipe(Effect.provide(fakeGrafanaLayer(fake.fetch)))),
+    );
+    expect(failure._tag).toBe('Unauthorized');
+  });
+});
+
+describe('create and update — the same PUT route', () => {
+  test('create sends no version — nothing has been read yet', async () => {
+    const fake = fakeGrafana((method, url) =>
+      method === 'PUT' && url.pathname === PATH ? Response.json(liveJson) : fakeFailure(404, 'x'),
+    );
+    await Effect.runPromise(spec.create(props).pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))));
+    // ⛔ `name` is a URL path label (`/templates/{name}`), never part of the body — only
+    //   `template` (and, on update, `version`) travel in the JSON payload.
+    expect(fake.bodies[0]).toEqual({ template: props.template });
+  });
+
+  test('an api-provenance template updates and sends the live version for concurrency', async () => {
+    const changed = { name: 'slack-body', template: 'v2' };
+    const fake = fakeGrafana((method, url) => {
+      if (method === 'GET' && url.pathname === PATH) return Response.json(liveJson);
+      if (method === 'PUT' && url.pathname === PATH)
+        return Response.json({ ...liveJson, template: 'v2' });
+      return fakeFailure(500, 'unexpected request');
+    });
+    await Effect.runPromise(
+      grafanaOperations(spec)
+        .reconcile(changed)
+        .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+    );
+    const put = fake.seen.findIndex((s) => s.method === 'PUT');
+    expect(fake.bodies[put]).toEqual({ template: 'v2', version: '3' });
+  });
+
+  test('reconcile is a noop when the declared template already matches what is live', async () => {
+    const fake = fakeGrafana((method, url) =>
+      method === 'GET' && url.pathname === PATH
+        ? Response.json(liveJson)
+        : fakeFailure(500, 'reconcile should not write when nothing changed'),
+    );
+    const after = await Effect.runPromise(
+      grafanaOperations(spec)
+        .reconcile(props)
+        .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+    );
+    expect(after.name).toBe('slack-body');
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+});
+
+describe('foreign provenance refuses update and destroy', () => {
+  test('a file-provisioned template refuses update and sends no PUT', async () => {
+    const fileProvisioned = { ...liveJson, provenance: 'file' };
+    const fake = fakeGrafana((method, url) =>
+      method === 'GET' && url.pathname === PATH
+        ? Response.json(fileProvisioned)
+        : fakeFailure(500, 'no write should be attempted'),
+    );
+    const failure = await Effect.runPromise(
+      Effect.flip(
+        grafanaOperations(spec)
+          .reconcile({ name: 'slack-body', template: 'v2' })
+          .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+      ),
+    );
+    expect(failure).toBeInstanceOf(GrafanaProvisionedObjectError);
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+
+  test('a file-provisioned template refuses destroy and sends no DELETE', async () => {
+    const fileProvisioned = { ...liveJson, provenance: 'file' };
+    const fake = fakeGrafana((method, url) =>
+      method === 'GET' && url.pathname === PATH
+        ? Response.json(fileProvisioned)
+        : fakeFailure(500, 'no DELETE should be attempted'),
+    );
+    const failure = await Effect.runPromise(
+      Effect.flip(
+        grafanaOperations(spec)
+          .destroy(props)
+          .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+      ),
+    );
+    expect(failure).toBeInstanceOf(GrafanaProvisionedObjectError);
+    expect(fake.seen).toEqual([{ method: 'GET', path: PATH }]);
+  });
+
+  test('deletes a live, api-provenance template', async () => {
+    const fake = fakeGrafana((method, url) => {
+      if (method === 'GET' && url.pathname === PATH) return Response.json(liveJson);
+      if (method === 'DELETE' && url.pathname === PATH) return Response.json({});
+      return fakeFailure(500, 'unexpected request');
+    });
+    await Effect.runPromise(
+      grafanaOperations(spec)
+        .destroy(props)
+        .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+    );
+    expect(fake.seen).toEqual([
+      { method: 'GET', path: PATH },
+      { method: 'DELETE', path: PATH },
+    ]);
+  });
+});
+
+describe('missing provenance fails closed', () => {
+  // ⛔ THE REGRESSION AN ADVERSARIAL REVIEW OF THIS PR FOUND — see contact-point.test.ts's own
+  //   copy of this block for the full account.
+  const noProvenanceField: Record<string, unknown> = { ...liveJson };
+  delete noProvenanceField.provenance;
+
+  test('a response with no provenance field at all refuses update', async () => {
+    const fake = fakeGrafana((method, url) =>
+      method === 'GET' && url.pathname === PATH
+        ? Response.json(noProvenanceField)
+        : fakeFailure(500, 'no write should be attempted'),
+    );
+    const failure = await Effect.runPromise(
+      Effect.flip(
+        grafanaOperations(spec)
+          .reconcile({ name: 'slack-body', template: 'v2' })
+          .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+      ),
+    );
+    expect(failure).toBeInstanceOf(GrafanaProvisionedObjectError);
+    expect(failure.message).toContain('did not report a provenance');
+    expect(fake.seen.every((s) => s.method === 'GET')).toBe(true);
+  });
+
+  test('a response with no provenance field at all refuses destroy', async () => {
+    const fake = fakeGrafana((method, url) =>
+      method === 'GET' && url.pathname === PATH
+        ? Response.json(noProvenanceField)
+        : fakeFailure(500, 'no DELETE should be attempted'),
+    );
+    const failure = await Effect.runPromise(
+      Effect.flip(
+        grafanaOperations(spec)
+          .destroy(props)
+          .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+      ),
+    );
+    expect(failure).toBeInstanceOf(GrafanaProvisionedObjectError);
+    expect(fake.seen).toEqual([{ method: 'GET', path: PATH }]);
+  });
+
+  test('an EXPLICIT empty-string provenance (ProvenanceNone) is writable', async () => {
+    const explicitlyNone = { ...liveJson, provenance: '' };
+    const fake = fakeGrafana((method, url) => {
+      if (method === 'GET' && url.pathname === PATH) return Response.json(explicitlyNone);
+      if (method === 'PUT' && url.pathname === PATH) {
+        return Response.json({ ...explicitlyNone, template: 'v2' });
+      }
+      return fakeFailure(500, 'unexpected request');
+    });
+    await Effect.runPromise(
+      grafanaOperations(spec)
+        .reconcile({ name: 'slack-body', template: 'v2' })
+        .pipe(Effect.provide(fakeGrafanaLayer(fake.fetch))),
+    );
+    expect(fake.seen.some((s) => s.method === 'PUT')).toBe(true);
+  });
+});

package/src/grafana/message-template.ts

@@ -0,0 +1,114 @@
+/**
+ * `Grafana.MessageTemplate` — one Grafana notification-template group, keyed by `name`.
+ *
+ * ⚠️ CREATE AND UPDATE ARE THE SAME WIRE CALL — MEASURED: `services/grafana.ts` has no
+ *   `routePostTemplate` at all, only `routePutTemplate` (`PUT /v1/provisioning/templates/{name}`,
+ *   upsert by name), `routeGetTemplate`/`routeGetTemplates` and `routeDeleteTemplate`. `spec.create`
+ *   and `spec.update` both call it — kept as two separate functions anyway (rather than omitting
+ *   `update` and letting them collapse into one) so the shared engine's `diff` reports a content
+ *   change as `update`, not the `replace` it would show for any resource whose `spec.update` is
+ *   undefined (`resource.ts`).
+ *
+ * ⛔ A FOREIGN-PROVENANCE TEMPLATE REFUSES EVERY UPDATE AND DESTROY — `alerting-provenance.ts`,
+ *   shared with `Grafana.ContactPoint`/`AlertRuleGroup`/`NotificationPolicy`; see that file's
+ *   header. `create` is never at risk: it only runs when `fetchLive` already found nothing.
+ *
+ * ⚠️ `version` IS SENT FOR OPTIMISTIC CONCURRENCY WHEN GRAFANA REPORTS ONE — `RoutePutTemplateRequest.
+ *   version`'s own doc comment: "Version of template to use for optimistic concurrency. Leave empty
+ *   to disable validation." Unlike `Grafana.Dashboard`'s 412, no live call confirms what error this
+ *   produces on a genuine mismatch (no live calls in this PR) — whatever typed error the SDK
+ *   declares for `routePutTemplate` is left uncaught either way, per the house rule against
+ *   folding a non-not-found error into absent.
+ *
+ * ⚠️ `X-Disable-Provenance` IS NEVER SET — same reasoning as `contact-point.ts`'s file header.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import * as grafana from '@distilled.cloud/grafana';
+import * as Effect from 'effect/Effect';
+import {
+  type GrafanaProvisionedObjectError,
+  isForeignProvenance,
+  refuseIfForeignProvenance,
+} from './alerting-provenance.ts';
+import { type GrafanaSpec, grafanaHandlers } from './resource.ts';
+
+export interface MessageTemplateProps {
+  name: string;
+  /** The Go-template body, e.g. Grafana's own "Export as JSON/YAML" template text. */
+  template: string;
+}
+
+export interface MessageTemplateAttributes {
+  name: string;
+  template: string;
+  /** `""`/`"api"` (this family may write); anything else, INCLUDING `undefined` (Grafana didn't
+   *  report the field), refuses — see alerting-provenance.ts's "fails open" note. */
+  provenance: string | undefined;
+}
+
+export interface GrafanaMessageTemplate extends Resource<
+  'Grafana.MessageTemplate',
+  MessageTemplateProps,
+  MessageTemplateAttributes,
+  never
+> {}
+
+export const GrafanaMessageTemplate = Resource<GrafanaMessageTemplate>('Grafana.MessageTemplate');
+
+export const spec: GrafanaSpec<
+  MessageTemplateProps,
+  grafana.NotificationTemplate,
+  MessageTemplateAttributes,
+  | grafana.RouteGetTemplateError
+  | grafana.RoutePutTemplateError
+  | grafana.RouteDeleteTemplateError
+  | GrafanaProvisionedObjectError
+> = {
+  attributes: (live) => ({
+    name: live.name ?? '',
+    // ⛔ NEVER `?? ''` — see alerting-provenance.ts's "fails open" note.
+    provenance: live.provenance,
+    template: live.template ?? '',
+  }),
+  create: (props) => grafana.routePutTemplate({ name: props.name, template: props.template }),
+  destroy: (props, live) =>
+    Effect.gen(function* () {
+      if (isForeignProvenance(live.provenance)) {
+        return yield* refuseIfForeignProvenance(
+          'Grafana.MessageTemplate',
+          props.name,
+          live.provenance,
+        );
+      }
+      yield* grafana.routeDeleteTemplate({ name: props.name });
+    }),
+  fetchLive: (props) =>
+    grafana
+      .routeGetTemplate({ name: props.name })
+      .pipe(Effect.catchTag('NotFound', () => Effect.succeed(undefined))),
+  matches: (attributes, props) => attributes.template === props.template,
+  update: (props, live) =>
+    Effect.gen(function* () {
+      if (isForeignProvenance(live.provenance)) {
+        return yield* refuseIfForeignProvenance(
+          'Grafana.MessageTemplate',
+          props.name,
+          live.provenance,
+        );
+      }
+      yield* grafana.routePutTemplate({
+        name: props.name,
+        template: props.template,
+        ...(live.version === undefined ? {} : { version: live.version }),
+      });
+    }),
+};
+
+export const handlers = grafanaHandlers(spec);
+
+export const GrafanaMessageTemplateProvider = () =>
+  Provider.effect(
+    GrafanaMessageTemplate,
+    Effect.succeed(GrafanaMessageTemplate.Provider.of(handlers)),
+  );