@alchemy.run/axiom 0.0.0 → 2.0.0-beta.84

package/src/Dataset.ts

@@ -0,0 +1,326 @@
+import * as Axiom from "@distilled.cloud/axiom";
+import { Credentials } from "@distilled.cloud/axiom/Credentials";
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import { Stack } from "alchemy/Stack";
+import { Stage } from "alchemy/Stage";
+import * as Effect from "effect/Effect";
+import { otelDatasetHeader } from "./OtelHeaders.ts";
+import type { Providers } from "./Providers.ts";
+
+export type DatasetKind =
+  | "otel:metrics:v1"
+  | "otel:traces:v1"
+  | "otel:logs:v1"
+  | "axiom:events:v1"
+  | (string & {});
+
+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;
+  /**
+   * Edge deployment where Axiom stores and processes the dataset's data.
+   * Defaults to the organization's default edge deployment.
+   *
+   * Cannot be changed after creation — triggers a replacement.
+   */
+  edgeDeployment?: 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;
+    /** Edge deployment where the dataset's data is stored and processed. */
+    edgeDeployment: string;
+    /** Base URL for ingesting and querying data in the dataset's edge deployment. */
+    edgeDeploymentUrl: string;
+    /** Base URL for Axiom's centralized management API. */
+    apiBaseUrl: string;
+    /** Root OTLP endpoint. 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:
+     * `X-Axiom-Dataset`, or `X-Axiom-Metrics-Dataset` for an
+     * `otel:metrics:v1` dataset.
+     * 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 their edge deployment and 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
+ *
+ * ### 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" });
+ * ```
+ *
+ * ### 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}`,
+ *   },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Dataset
+ */
+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] };
+};
+
+export const DatasetProvider = () =>
+  Provider.effect(
+    Dataset,
+    Effect.gen(function* () {
+      const { apiBaseUrl } = yield* yield* Credentials;
+      const create = yield* Axiom.createDataset;
+      const update = yield* Axiom.updateDataset;
+      const get = yield* Axiom.getDataset;
+      const listDatasets = yield* Axiom.getDatasets;
+      const del = yield* Axiom.deleteDataset;
+
+      const toAttrs = Effect.fn(function* (dataset: Axiom.Dataset) {
+        if (!dataset.edgeDeployment || !dataset.edgeDeploymentUrl) {
+          return yield* Effect.fail(
+            new Error(`Axiom dataset "${dataset.name}" is missing its edge deployment metadata`),
+          );
+        }
+        const apiRoot = apiBaseUrl.replace(/\/$/, "");
+        const otelRoot = dataset.edgeDeploymentUrl.replace(/\/$/, "");
+        return {
+          id: dataset.id,
+          name: dataset.name,
+          kind: dataset.kind,
+          description: stripMarker(dataset.description),
+          created: dataset.created,
+          edgeDeployment: dataset.edgeDeployment,
+          edgeDeploymentUrl: dataset.edgeDeploymentUrl,
+          apiBaseUrl: apiRoot,
+          otelEndpoint: otelRoot,
+          otelTracesEndpoint: `${otelRoot}/v1/traces`,
+          otelLogsEndpoint: `${otelRoot}/v1/logs`,
+          otelMetricsEndpoint: `${otelRoot}/v1/metrics`,
+          otelHeaders: {
+            [otelDatasetHeader(dataset.kind === "otel:metrics:v1")]: dataset.name,
+          } as Record<string, string>,
+        };
+      });
+
+      return {
+        stables: ["id", "name", "kind", "edgeDeployment", "edgeDeploymentUrl"],
+        // Enumerate every dataset in the org. Axiom exposes a single
+        // account-wide `GET /v2/datasets` collection op (no pagination), so we
+        // fetch it once and hydrate each row into the exact `read`/`toAttrs`
+        // Attributes shape — directly usable by `delete` with no follow-up get.
+        list: () =>
+          Effect.gen(function* () {
+            const datasets = yield* listDatasets({});
+            return yield* Effect.forEach(datasets, toAttrs);
+          }),
+        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.edgeDeployment && output && news.edgeDeployment !== output.edgeDeployment) {
+            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;
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output }) {
+          const stack = yield* Stack;
+          const stage = yield* Stage;
+          const marker = buildMarker(stack.name, stage, id);
+
+          // Observe — Axiom's dataset path identifier is `name`, which is
+          // also stable input. Probe for live state by name (preferring the
+          // cached `output.id` when present). `read` upstream has already
+          // surfaced foreign datasets as `Unowned`, so by the time we land
+          // here mutation is safe.
+          const datasetId = output?.id ?? news.name;
+          const observed = yield* get({ dataset_id: datasetId }).pipe(
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+
+          // Ensure — POST creates the dataset. Tolerate Conflict/
+          // UnprocessableEntity as a race with a peer reconciler (or with
+          // upstream read↔create), falling through to the sync path.
+          let current = observed;
+          if (current === undefined) {
+            current = yield* (
+              create({
+                name: news.name,
+                description: augmentDescription(news.description, marker),
+                edgeDeployment: news.edgeDeployment,
+                kind: news.kind,
+                retentionDays: news.retentionDays,
+                useRetentionPeriod: news.useRetentionPeriod,
+              }) as Effect.Effect<Axiom.Dataset, { readonly _tag: string }, never>
+            ).pipe(
+              Effect.catchIf(
+                (e): e is { readonly _tag: "Conflict" | "UnprocessableEntity" } =>
+                  e._tag === "Conflict" || e._tag === "UnprocessableEntity",
+                () =>
+                  update({
+                    dataset_id: news.name,
+                    description: augmentDescription(news.description, marker),
+                    retentionDays: news.retentionDays,
+                    useRetentionPeriod: news.useRetentionPeriod,
+                  }),
+              ),
+            );
+            return yield* toAttrs(current);
+          }
+
+          // Sync — the dataset exists. Apply mutable aspects (description,
+          // retentionDays, useRetentionPeriod) via PATCH. `kind` and `name`
+          // are stable and replacement-only via diff above.
+          const desiredDescription = augmentDescription(news.description, marker);
+          const needsSync =
+            current.description !== desiredDescription ||
+            current.retentionDays !== news.retentionDays ||
+            current.useRetentionPeriod !== news.useRetentionPeriod;
+          if (!needsSync) {
+            return yield* toAttrs(current);
+          }
+          const updated = yield* update({
+            dataset_id: current.id,
+            description: desiredDescription,
+            retentionDays: news.retentionDays,
+            useRetentionPeriod: news.useRetentionPeriod,
+          });
+          return yield* toAttrs(updated);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ dataset_id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const stack = yield* Stack;
+          const stage = yield* Stage;
+          const datasetId = output?.id ?? olds?.name;
+          if (!datasetId) return undefined;
+          const existing = yield* get({ dataset_id: datasetId }).pipe(
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+          if (!existing) return undefined;
+          const ownership = parseMarker(existing.description);
+          const isOurs =
+            ownership !== undefined &&
+            ownership.stack === stack.name &&
+            ownership.stage === stage &&
+            ownership.id === id;
+          const attrs = yield* toAttrs(existing);
+          return isOurs ? attrs : Unowned(attrs);
+        }),
+      };
+    }),
+  );

package/src/Monitor.ts

@@ -0,0 +1,148 @@
+import * as Axiom from "@distilled.cloud/axiom";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import type { Providers } from "./Providers.ts";
+
+export type MonitorProps = Axiom.CreateMonitorRequest;
+
+export type Monitor = Resource<
+  "Axiom.Monitor",
+  MonitorProps,
+  Axiom.CreateMonitorResponse,
+  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
+ *
+ * ### 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],
+ * });
+ * ```
+ *
+ * @resource
+ * @product Monitor
+ */
+export const Monitor = Resource<Monitor>("Axiom.Monitor");
+
+export const MonitorProvider = () =>
+  Provider.effect(
+    Monitor,
+    Effect.gen(function* () {
+      const create = yield* Axiom.createMonitor;
+      const update = yield* Axiom.updateMonitor;
+      const get = yield* Axiom.getMonitor;
+      const list = yield* Axiom.getMonitors;
+      const del = yield* Axiom.deleteMonitor;
+
+      return {
+        stables: ["id"],
+        // Enumerate every monitor in the org. Axiom exposes a single
+        // account-wide `GET /v2/monitors` collection op (no pagination) whose
+        // item schema is identical to `getMonitor`/`createMonitor`'s output, so
+        // we fetch it once and each row already carries the exact `read`
+        // Attributes shape — directly usable by `delete` with no follow-up get.
+        list: () =>
+          Effect.gen(function* () {
+            const monitors = yield* list({});
+            return monitors.map((m) => m);
+          }),
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.type !== output.type) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          // Observe — Axiom assigns the monitor id server-side, so the only
+          // handle to a previously-created monitor is the cached
+          // `output.id`. Probe for live state with that id; treat NotFound
+          // (deleted out-of-band) as "no observed state" so we converge by
+          // re-creating.
+          const observed = output?.id
+            ? yield* get({ id: output.id }).pipe(
+                Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+              )
+            : undefined;
+
+          // Ensure — POST mints a new monitor with a fresh id.
+          if (observed === undefined) {
+            return yield* create(news);
+          }
+
+          // Sync — the monitor exists; PATCH against its id with the
+          // desired props. `type` is replacement-only (handled in diff).
+          return yield* update({ ...news, id: observed.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/Notifier.ts

@@ -0,0 +1,136 @@
+import * as Axiom from "@distilled.cloud/axiom";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import type { Providers } from "./Providers.ts";
+
+export type NotifierProps = Axiom.CreateNotifierRequest;
+
+export type Notifier = Resource<
+  "Axiom.Notifier",
+  NotifierProps,
+  Axiom.CreateNotifierResponse & { 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
+ *
+ * ### 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"}',
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @resource
+ * @product Monitor
+ */
+export const Notifier = Resource<Notifier>("Axiom.Notifier");
+
+export const NotifierProvider = () =>
+  Provider.effect(
+    Notifier,
+    Effect.gen(function* () {
+      const create = yield* Axiom.createNotifier;
+      const update = yield* Axiom.updateNotifier;
+      const get = yield* Axiom.getNotifier;
+      const listNotifiers = yield* Axiom.getNotifiers;
+      const del = yield* Axiom.deleteNotifier;
+
+      return {
+        stables: ["id"],
+        // Enumerate every notifier in the org. Axiom exposes a single
+        // account-wide `GET /v2/notifiers` collection op (no pagination), so we
+        // fetch it once and hydrate each row into the exact `read` Attributes
+        // shape (`CreateNotifierOutput & { id: string }`) — directly usable by
+        // `delete` with no follow-up get.
+        list: () =>
+          Effect.gen(function* () {
+            const notifiers = yield* listNotifiers({});
+            return notifiers.map((n) => ({ ...n, id: n.id ?? "" }));
+          }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          // Observe — Axiom assigns the notifier id server-side, so the
+          // only handle to a previously-created notifier is the cached
+          // `output.id`. Probe for live state with that id; treat NotFound
+          // (deleted out-of-band) as "no observed state" so we converge
+          // by re-creating.
+          const observed = output?.id
+            ? yield* get({ id: output.id }).pipe(
+                Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+              )
+            : undefined;
+
+          // Ensure — POST mints a new notifier. The Axiom create response
+          // sometimes omits `id` on the body; default to "" to keep the
+          // attribute shape stable until the next read populates it.
+          if (observed === undefined) {
+            const result = yield* create(news);
+            return { ...result, id: result.id ?? "" };
+          }
+
+          // Sync — the notifier exists; PATCH against its id with the
+          // desired props. Preserve the cached id if the API response
+          // omits it.
+          const result = yield* update({ ...news, id: observed.id! });
+          return { ...result, id: result.id ?? observed.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/OtelHeaders.ts

@@ -0,0 +1,9 @@
+/**
+ * Axiom routes OTLP ingest by a dataset header. Traces and logs use
+ * `X-Axiom-Dataset`; the metrics endpoint requires `X-Axiom-Metrics-Dataset`
+ * instead (https://axiom.co/docs/send-data/opentelemetry).
+ *
+ * @internal
+ */
+export const otelDatasetHeader = (metrics: boolean): string =>
+  metrics ? "X-Axiom-Metrics-Dataset" : "X-Axiom-Dataset";

package/src/Providers.ts

@@ -0,0 +1,60 @@
+import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
+import { ProfileStoreLive } from "alchemy/Auth/Profile";
+import * as Provider from "alchemy/Provider";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+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 profile edit` 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.provideMerge(ProfileStoreLive),
+    Layer.provideMerge(CredentialsStoreLive),
+    Layer.orDie,
+  );