alchemy 2.0.0-beta.17 → 2.0.0-beta.19

package/src/Axiom/Dataset.ts

@@ -0,0 +1,291 @@
+import { Credentials } from "@distilled.cloud/axiom/Credentials";
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AdoptPolicy } from "../AdoptPolicy.ts";
+import { isResolved } from "../Diff.ts";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import { Stack } from "../Stack.ts";
+import { Stage } from "../Stage.ts";
+import type { Providers } from "./Providers.ts";
+
+export type DatasetKind =
+  | "otel:metrics:v1"
+  | "otel:traces:v1"
+  | "otel:logs:v1"
+  | "axiom:events:v1";
+
+export type DatasetProps = {
+  /**
+   * Dataset name. Used as the dataset's stable identifier in Axiom — changing
+   * this triggers a replacement.
+   */
+  name: string;
+  /** Free-form description shown in the Axiom UI. */
+  description?: string;
+  /**
+   * Dataset kind. Defaults to `axiom:events:v1`.
+   *
+   * For OTEL pipelines, choose:
+   * - `otel:traces:v1` for traces
+   * - `otel:logs:v1` for logs
+   * - `otel:metrics:v1` for metrics
+   *
+   * Cannot be changed after creation — triggers a replacement.
+   */
+  kind?: DatasetKind;
+  /** Retention in days. Plan-dependent — see Axiom docs. */
+  retentionDays?: number;
+  /** Whether to enforce the configured retention period. */
+  useRetentionPeriod?: boolean;
+};
+
+export type Dataset = Resource<
+  "Axiom.Dataset",
+  DatasetProps,
+  {
+    id: string;
+    name: string;
+    kind: DatasetKind;
+    description: string;
+    created: string;
+    apiBaseUrl: string;
+    /** Root OTLP endpoint (`${apiBaseUrl}`). Most exporters auto-append the signal path. */
+    otelEndpoint: string;
+    /** OTLP/HTTP traces endpoint. */
+    otelTracesEndpoint: string;
+    /** OTLP/HTTP logs endpoint. */
+    otelLogsEndpoint: string;
+    /** OTLP/HTTP metrics endpoint. */
+    otelMetricsEndpoint: string;
+    /**
+     * Headers required for OTLP shipping aside from the bearer token.
+     * Add `Authorization: Bearer <AXIOM_TOKEN>` separately at runtime so the
+     * secret is never persisted in resource state.
+     */
+    otelHeaders: Record<string, string>;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom dataset — the top-level container that stores events, logs,
+ * traces, or metrics. Pick a `kind` up-front: it determines schema and how
+ * the data is shown in the UI, and **cannot be changed** after creation
+ * (changing it triggers a replacement, which deletes the data).
+ *
+ * Datasets expose Axiom's OTLP/HTTP endpoints (`otelTracesEndpoint`,
+ * `otelLogsEndpoint`, `otelMetricsEndpoint`) as output attributes so you can
+ * inject them into a Worker / Lambda's env vars for OpenTelemetry shipping.
+ * The bearer token is **not** stored in resource state — supply
+ * `Authorization: Bearer <AXIOM_TOKEN>` separately at runtime.
+ *
+ * @see https://axiom.co/docs/reference/datasets
+ * @see https://axiom.co/docs/send-data/opentelemetry — OTLP endpoint reference
+ *
+ * @section Creating a Dataset
+ * @example Logs dataset with 30-day retention
+ * ```typescript
+ * const logs = yield* Axiom.Dataset("app-logs", {
+ *   name: "my-app-logs",
+ *   kind: "otel:logs:v1",
+ *   description: "Application logs from prod workers",
+ *   retentionDays: 30,
+ *   useRetentionPeriod: true,
+ * });
+ * ```
+ *
+ * @example Separate datasets per OTEL signal
+ * ```typescript
+ * const traces  = yield* Axiom.Dataset("traces",  { name: "app-traces",  kind: "otel:traces:v1"  });
+ * const logs    = yield* Axiom.Dataset("logs",    { name: "app-logs",    kind: "otel:logs:v1"    });
+ * const metrics = yield* Axiom.Dataset("metrics", { name: "app-metrics", kind: "otel:metrics:v1" });
+ * ```
+ *
+ * @section Shipping OTEL data
+ * @example Wire OTEL env vars into a Cloudflare Worker
+ * ```typescript
+ * yield* Cloudflare.Worker("api", {
+ *   vars: {
+ *     OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: traces.otelTracesEndpoint,
+ *     OTEL_EXPORTER_OTLP_LOGS_ENDPOINT:   logs.otelLogsEndpoint,
+ *     // Bearer token must come from a secret store, not the dataset state.
+ *     OTEL_EXPORTER_OTLP_HEADERS:
+ *       `Authorization=Bearer ${env.AXIOM_TOKEN},X-Axiom-Dataset=${traces.name}`,
+ *   },
+ * });
+ * ```
+ */
+export const Dataset = Resource<Dataset>("Axiom.Dataset");
+
+/**
+ * Axiom has no tags/labels API. The only writable field we can use to mark
+ * ownership is `description`. We append a deterministic marker on create so
+ * that on a re-apply (e.g. state was wiped) we can safely identify a dataset
+ * that **we** previously created and adopt it idempotently — without
+ * accidentally hijacking a dataset created by someone else with the same name.
+ */
+const MARKER_RE = /\s*\[alchemy:stack=([^;]+);stage=([^;]+);id=([^\]]+)\]\s*$/;
+
+const buildMarker = (stack: string, stage: string, id: string) =>
+  `[alchemy:stack=${stack};stage=${stage};id=${id}]`;
+
+const augmentDescription = (
+  description: string | undefined,
+  marker: string,
+) => {
+  const base = stripMarker(description ?? "");
+  return base.length > 0 ? `${base}\n${marker}` : marker;
+};
+
+const stripMarker = (description: string): string =>
+  description.replace(MARKER_RE, "").trimEnd();
+
+const parseMarker = (
+  description: string | undefined,
+): { stack: string; stage: string; id: string } | undefined => {
+  if (!description) return undefined;
+  const m = description.match(MARKER_RE);
+  if (!m) return undefined;
+  return { stack: m[1], stage: m[2], id: m[3] };
+};
+
+const buildOtelAttrs = (apiBaseUrl: string, name: string) => {
+  const root = apiBaseUrl.replace(/\/$/, "");
+  return {
+    apiBaseUrl: root,
+    otelEndpoint: root,
+    otelTracesEndpoint: `${root}/v1/traces`,
+    otelLogsEndpoint: `${root}/v1/logs`,
+    otelMetricsEndpoint: `${root}/v1/metrics`,
+    otelHeaders: { "X-Axiom-Dataset": name } as Record<string, string>,
+  };
+};
+
+export const DatasetProvider = () =>
+  Provider.effect(
+    Dataset,
+    Effect.gen(function* () {
+      const { apiBaseUrl } = yield* Credentials;
+      const create = yield* Operations.createDataset;
+      const update = yield* Operations.updateDataset;
+      const get = yield* Operations.getDataset;
+      const del = yield* Operations.deleteDataset;
+
+      const toAttrs = (
+        dataset: Operations.CreateDatasetOutput,
+      ) => ({
+        id: dataset.id,
+        name: dataset.name,
+        kind: dataset.kind,
+        description: stripMarker(dataset.description),
+        created: dataset.created,
+        ...buildOtelAttrs(apiBaseUrl, dataset.name),
+      });
+
+      return {
+        stables: ["id", "name", "kind"],
+        diff: Effect.fn(function* ({ olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.name !== output.name) {
+            return { action: "replace" } as const;
+          }
+          if (news.kind && output && news.kind !== output.kind) {
+            return { action: "replace" } as const;
+          }
+          if (
+            news.description !== olds?.description ||
+            news.retentionDays !== olds?.retentionDays ||
+            news.useRetentionPeriod !== olds?.useRetentionPeriod
+          ) {
+            return { action: "update" } as const;
+          }
+          return undefined;
+        }),
+        create: Effect.fn(function* ({ id, news }) {
+          const stack = yield* Stack;
+          const stage = yield* Stage;
+          const adoptPolicy = yield* Effect.serviceOption(AdoptPolicy).pipe(
+            Effect.map(Option.getOrElse(() => false)),
+          );
+          const marker = buildMarker(stack.name, stage, id);
+          const dataset = yield* (
+            create({
+              name: news.name,
+              description: augmentDescription(news.description, marker),
+              kind: news.kind,
+              retentionDays: news.retentionDays,
+              useRetentionPeriod: news.useRetentionPeriod,
+            }) as Effect.Effect<
+              Operations.CreateDatasetOutput,
+              { readonly _tag: string },
+              never
+            >
+          ).pipe(
+            Effect.catchIf(
+              (
+                e,
+              ): e is { readonly _tag: "Conflict" | "UnprocessableEntity" } =>
+                e._tag === "Conflict" || e._tag === "UnprocessableEntity",
+              () =>
+                Effect.gen(function* () {
+                  const existing = yield* get({ dataset_id: news.name });
+                  const ownership = parseMarker(existing.description);
+                  const isOurs =
+                    ownership !== undefined &&
+                    ownership.stack === stack.name &&
+                    ownership.stage === stage &&
+                    ownership.id === id;
+                  if (isOurs || adoptPolicy) {
+                    // Re-apply the user's desired props (and re-stamp marker)
+                    // so adoption is idempotent and Axiom-side state matches
+                    // the resource spec.
+                    return yield* update({
+                      dataset_id: existing.id,
+                      description: augmentDescription(news.description, marker),
+                      retentionDays: news.retentionDays,
+                      useRetentionPeriod: news.useRetentionPeriod,
+                    });
+                  }
+                  return yield* Effect.die(
+                    new Error(
+                      `Axiom dataset "${news.name}" already exists and was ` +
+                        `not created by this stack (${stack.name}/${stage}/${id}). ` +
+                        `Pipe the resource through \`adopt()\` from "alchemy/AdoptPolicy" ` +
+                        `to take ownership, or delete the dataset in Axiom and retry.`,
+                    ),
+                  );
+                }),
+            ),
+          );
+          return toAttrs(dataset);
+        }),
+        update: Effect.fn(function* ({ id, news, output }) {
+          const stack = yield* Stack;
+          const stage = yield* Stage;
+          const marker = buildMarker(stack.name, stage, id);
+          const dataset = yield* update({
+            dataset_id: output.id,
+            description: augmentDescription(news.description, marker),
+            retentionDays: news.retentionDays,
+            useRetentionPeriod: news.useRetentionPeriod,
+          });
+          return toAttrs(dataset);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ dataset_id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.id) return undefined;
+          return yield* get({ dataset_id: output.id }).pipe(
+            Effect.map(toAttrs),
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Axiom/Monitor.ts

@@ -0,0 +1,122 @@
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import { isResolved } from "../Diff.ts";
+import type { Providers } from "./Providers.ts";
+
+export type MonitorProps = Operations.CreateMonitorInput;
+
+export type Monitor = Resource<
+  "Axiom.Monitor",
+  MonitorProps,
+  Operations.CreateMonitorOutput,
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom monitor — a scheduled APL/MPL query that evaluates on a fixed
+ * cadence and fires alerts via {@link Notifier notifiers} when its
+ * condition is met.
+ *
+ * Three monitor `type`s are supported:
+ *
+ * - **`Threshold`** — fires when an aggregate result crosses a static
+ *   `threshold` (compared with `operator`).
+ * - **`MatchEvent`** — fires for every event matching the query.
+ * - **`AnomalyDetection`** — fires when results deviate from a learned
+ *   baseline by more than `tolerance` over `compareDays`.
+ *
+ * Changing `type` triggers a replacement; everything else updates in place.
+ *
+ * @see https://axiom.co/docs/monitor-data/monitors
+ *
+ * @section Creating a Monitor
+ * @example Threshold: alert on >100 errors per 5m
+ * ```typescript
+ * yield* Axiom.Monitor("error-rate", {
+ *   name: "High error rate",
+ *   description: "Fires when error count exceeds 100/5m",
+ *   type: "Threshold",
+ *   aplQuery: `
+ *     ['my-app-traces']
+ *     | where status >= 500
+ *     | summarize count() by bin_auto(_time)
+ *   `,
+ *   operator: "Above",
+ *   threshold: 100,
+ *   intervalMinutes: 5,
+ *   rangeMinutes: 5,
+ *   alertOnNoData: false,
+ *   resolvable: true,
+ *   notifierIds: [slack.id, pagerduty.id],
+ * });
+ * ```
+ *
+ * @example MatchEvent: alert on every panic
+ * ```typescript
+ * yield* Axiom.Monitor("panics", {
+ *   name: "Service panic",
+ *   type: "MatchEvent",
+ *   aplQuery: `['my-app-logs'] | where message contains "panic:"`,
+ *   intervalMinutes: 1,
+ *   rangeMinutes: 1,
+ *   notifierIds: [pagerduty.id],
+ * });
+ * ```
+ *
+ * @example AnomalyDetection: deviation vs. last 7 days
+ * ```typescript
+ * yield* Axiom.Monitor("traffic-anomaly", {
+ *   name: "Traffic anomaly",
+ *   type: "AnomalyDetection",
+ *   aplQuery: `['my-app-traces'] | summarize count() by bin_auto(_time)`,
+ *   compareDays: 7,
+ *   tolerance: 25,             // %
+ *   intervalMinutes: 15,
+ *   rangeMinutes: 15,
+ *   notifierIds: [slack.id],
+ * });
+ * ```
+ */
+export const Monitor = Resource<Monitor>("Axiom.Monitor");
+
+export const MonitorProvider = () =>
+  Provider.effect(
+    Monitor,
+    Effect.gen(function* () {
+      const create = yield* Operations.createMonitor;
+      const update = yield* Operations.updateMonitor;
+      const get = yield* Operations.getMonitor;
+      const del = yield* Operations.deleteMonitor;
+
+      return {
+        stables: ["id"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.type !== output.type) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        create: Effect.fn(function* ({ news }) {
+          return yield* create(news);
+        }),
+        update: Effect.fn(function* ({ news, output }) {
+          return yield* update({ ...news, id: output.id });
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.id) return undefined;
+          return yield* get({ id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Axiom/Notifier.ts

@@ -0,0 +1,104 @@
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import type { Providers } from "./Providers.ts";
+
+export type NotifierProps = Operations.CreateNotifierInput;
+
+export type Notifier = Resource<
+  "Axiom.Notifier",
+  NotifierProps,
+  Operations.CreateNotifierOutput & { id: string },
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom notifier — an alert destination (Slack, email, PagerDuty,
+ * Opsgenie, Discord, Microsoft Teams, generic webhook, or a fully custom
+ * webhook with templated body/headers) that {@link Monitor monitors} target
+ * via `notifierIds`. Exactly one channel under `properties` should be set.
+ *
+ * @see https://axiom.co/docs/monitor-data/notifiers
+ *
+ * @section Creating a Notifier
+ * @example Slack incoming webhook
+ * ```typescript
+ * const slack = yield* Axiom.Notifier("ops-slack", {
+ *   name: "ops-channel",
+ *   properties: {
+ *     slack: { slackUrl: process.env.SLACK_WEBHOOK_URL! },
+ *   },
+ * });
+ * ```
+ *
+ * @example Email distribution list
+ * ```typescript
+ * yield* Axiom.Notifier("ops-email", {
+ *   name: "ops-team",
+ *   properties: { email: { emails: ["sre@example.com", "oncall@example.com"] } },
+ * });
+ * ```
+ *
+ * @example PagerDuty integration
+ * ```typescript
+ * yield* Axiom.Notifier("pagerduty", {
+ *   name: "primary-oncall",
+ *   properties: {
+ *     pagerduty: { routingKey: process.env.PAGERDUTY_ROUTING_KEY!, token: "" },
+ *   },
+ * });
+ * ```
+ *
+ * @example Custom webhook with templated body
+ * ```typescript
+ * yield* Axiom.Notifier("incident-webhook", {
+ *   name: "incident.io",
+ *   properties: {
+ *     customWebhook: {
+ *       url: "https://api.incident.io/v2/alert_events",
+ *       headers: { "Content-Type": "application/json" },
+ *       secretHeaders: { Authorization: `Bearer ${process.env.INCIDENT_TOKEN}` },
+ *       body: '{"title": "{{.Monitor.Name}}", "status": "firing"}',
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export const Notifier = Resource<Notifier>("Axiom.Notifier");
+
+export const NotifierProvider = () =>
+  Provider.effect(
+    Notifier,
+    Effect.gen(function* () {
+      const create = yield* Operations.createNotifier;
+      const update = yield* Operations.updateNotifier;
+      const get = yield* Operations.getNotifier;
+      const del = yield* Operations.deleteNotifier;
+
+      return {
+        stables: ["id"],
+        create: Effect.fn(function* ({ news }) {
+          const result = yield* create(news);
+          return { ...result, id: result.id ?? "" };
+        }),
+        update: Effect.fn(function* ({ news, output }) {
+          const result = yield* update({ ...news, id: output.id });
+          return { ...result, id: result.id ?? output.id };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.id) return undefined;
+          return yield* get({ id: output.id }).pipe(
+            Effect.map((current) => ({ ...current, id: current.id ?? output.id })),
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Axiom/Providers.ts

@@ -0,0 +1,58 @@
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import * as Provider from "../Provider.ts";
+import { Annotation, AnnotationProvider } from "./Annotation.ts";
+import { ApiToken, ApiTokenProvider } from "./ApiToken.ts";
+import { AxiomAuth } from "./AuthProvider.ts";
+import * as Credentials from "./Credentials.ts";
+import { Dashboard, DashboardProvider } from "./Dashboard.ts";
+import { Dataset, DatasetProvider } from "./Dataset.ts";
+import { Monitor, MonitorProvider } from "./Monitor.ts";
+import { Notifier, NotifierProvider } from "./Notifier.ts";
+import { View, ViewProvider } from "./View.ts";
+import { VirtualField, VirtualFieldProvider } from "./VirtualField.ts";
+
+export { Credentials } from "@distilled.cloud/axiom/Credentials";
+
+export class Providers extends Provider.ProviderCollection<Providers>()(
+  "Axiom",
+) {}
+
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+
+/**
+ * Axiom providers and credentials. Wires up Dataset, ApiToken, Notifier,
+ * Monitor, Dashboard, VirtualField, View and Annotation resources, and
+ * registers the Axiom AuthProvider so `alchemy login` can configure it.
+ */
+export const providers = () =>
+  Layer.effect(
+    Providers,
+    Provider.collection([
+      Annotation,
+      ApiToken,
+      Dashboard,
+      Dataset,
+      Monitor,
+      Notifier,
+      View,
+      VirtualField,
+    ]),
+  ).pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        AnnotationProvider(),
+        ApiTokenProvider(),
+        DashboardProvider(),
+        DatasetProvider(),
+        MonitorProvider(),
+        NotifierProvider(),
+        ViewProvider(),
+        VirtualFieldProvider(),
+      ),
+    ),
+    Layer.provideMerge(Credentials.fromAuthProvider()),
+    Layer.provideMerge(FetchHttpClient.layer),
+    Layer.provideMerge(AxiomAuth),
+    Layer.orDie,
+  );

package/src/Axiom/View.ts

@@ -0,0 +1,106 @@
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../Diff.ts";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import type { Providers } from "./Providers.ts";
+
+export type ViewProps = Operations.CreateViewInput;
+
+export type View = Resource<
+  "Axiom.View",
+  ViewProps,
+  Operations.CreateViewOutput & {
+    /**
+     * Path identifier used by `updateView` / `getView` / `deleteView`.
+     * Currently derived from `name` because Axiom's view list/get responses
+     * don't expose a separate id field.
+     */
+    id: string;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom saved view — a named, shareable APL query. Useful for building
+ * starter dashboards, providing canned "open in Axiom" links from your app,
+ * or pinning common investigations the team revisits.
+ *
+ * The path identifier is `name`. Renaming a view triggers a replacement
+ * (the old one is deleted, a new one is created).
+ *
+ * @see https://axiom.co/docs/query-data/datasets — APL query reference
+ *
+ * @section Creating a View
+ * @example Recent errors across one dataset
+ * ```typescript
+ * yield* Axiom.View("recent-errors", {
+ *   name: "recent-errors",
+ *   description: "Last 100 5xx responses",
+ *   datasets: ["my-app-traces"],
+ *   aplQuery: `
+ *     ['my-app-traces']
+ *     | where status >= 500
+ *     | order by _time desc
+ *     | take 100
+ *   `,
+ * });
+ * ```
+ *
+ * @example Cross-dataset join (logs + traces by trace_id)
+ * ```typescript
+ * yield* Axiom.View("trace-with-logs", {
+ *   name: "trace-with-logs",
+ *   datasets: ["my-app-traces", "my-app-logs"],
+ *   aplQuery: `
+ *     ['my-app-traces']
+ *     | where duration_ms > 1000
+ *     | join kind=leftouter (['my-app-logs']) on trace_id
+ *   `,
+ * });
+ * ```
+ */
+export const View = Resource<View>("Axiom.View");
+
+export const ViewProvider = () =>
+  Provider.effect(
+    View,
+    Effect.gen(function* () {
+      const create = yield* Operations.createView;
+      const update = yield* Operations.updateView;
+      const get = yield* Operations.getView;
+      const del = yield* Operations.deleteView;
+
+      return {
+        stables: ["id"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.name !== output.name) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        create: Effect.fn(function* ({ news }) {
+          const result = yield* create(news);
+          return { ...result, id: news.name };
+        }),
+        update: Effect.fn(function* ({ news, output }) {
+          const result = yield* update({ ...news, id: output.id });
+          return { ...result, id: output.id };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.id) return undefined;
+          return yield* get({ id: output.id }).pipe(
+            Effect.map((current) => ({ ...current, id: output.id })),
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );