alchemy 2.0.0-beta.18 → 2.0.0-beta.19

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)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Axiom/VirtualField.ts

@@ -0,0 +1,90 @@
+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 VirtualFieldProps = Operations.CreateVirtualFieldInput;
+
+export type VirtualField = Resource<
+  "Axiom.VirtualField",
+  VirtualFieldProps,
+  Operations.CreateVirtualFieldOutput,
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom virtual field — a saved APL expression that appears as a derived
+ * column on a dataset at query time. Use these to standardise common
+ * computations (status classes, latency buckets, parsed JSON paths) so
+ * dashboards and monitors don't have to redefine them.
+ *
+ * Bound to a single `dataset`; changing the dataset triggers a replacement.
+ *
+ * @see https://axiom.co/docs/query-data/virtual-fields
+ *
+ * @section Creating a Virtual Field
+ * @example HTTP status class (e.g. 200 → "2xx")
+ * ```typescript
+ * yield* Axiom.VirtualField("status-class", {
+ *   dataset: "my-app-traces",
+ *   name: "status_class",
+ *   description: "HTTP response class bucket",
+ *   expression: 'strcat(tostring(toint(status / 100)), "xx")',
+ *   type: "string",
+ * });
+ * ```
+ *
+ * @example Latency bucket in seconds
+ * ```typescript
+ * yield* Axiom.VirtualField("latency-bucket", {
+ *   dataset: "my-app-traces",
+ *   name: "latency_bucket_s",
+ *   expression: "bin(duration_ms / 1000.0, 0.5)",
+ *   type: "number",
+ *   unit: "s",
+ * });
+ * ```
+ */
+export const VirtualField = Resource<VirtualField>("Axiom.VirtualField");
+
+export const VirtualFieldProvider = () =>
+  Provider.effect(
+    VirtualField,
+    Effect.gen(function* () {
+      const create = yield* Operations.createVirtualField;
+      const update = yield* Operations.updateVirtualField;
+      const get = yield* Operations.getVirtualField;
+      const del = yield* Operations.deleteVirtualField;
+
+      return {
+        stables: ["id"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.dataset !== output.dataset) {
+            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/index.ts

@@ -0,0 +1,12 @@
+export * from "./Annotation.ts";
+export * from "./ApiToken.ts";
+export * from "./AuthProvider.ts";
+export * from "./Chart.ts";
+export * from "./Credentials.ts";
+export * from "./Dashboard.ts";
+export * from "./Dataset.ts";
+export * from "./Monitor.ts";
+export * from "./Notifier.ts";
+export * from "./Providers.ts";
+export * from "./View.ts";
+export * from "./VirtualField.ts";

package/src/Bundle/Bundle.ts

@@ -7,6 +7,25 @@ import * as Stream from "effect/Stream";
 import assert from "node:assert";
 import * as rolldown from "rolldown";
 import { sha256, sha256Object } from "../Util/sha256.ts";
+import { purePlugin, type PurePluginOptions } from "./PurePlugin.ts";
+
+/**
+ * Extra options accepted by {@link build} / {@link watch} on top of the
+ * standard rolldown input/output options.
+ */
+export interface BundleExtraOptions {
+  /**
+   * Configures the {@link purePlugin} which annotates top-level
+   * call/new expressions in matching packages with `/*#__PURE__*\/`
+   * so rolldown can tree-shake them.
+   *
+   * - `undefined` (default): plugin is enabled with default packages
+   *   (`effect`, `@effect/*`).
+   * - `PurePluginOptions`: plugin is enabled with the provided options.
+   * - `false`: plugin is disabled.
+   */
+  readonly pure?: PurePluginOptions | false;
+}
 
 export interface BundleOutput {
   /**
@@ -40,11 +59,13 @@ export class BundleError extends Data.TaggedError("BundleError")<{
 export const build = (
   inputOptions: rolldown.InputOptions,
   outputOptions?: rolldown.OutputOptions,
+  extra?: BundleExtraOptions,
 ): Effect.Effect<BundleOutput, BundleError> =>
   Effect.tryPromise({
     try: async () => {
       const bundle = await rolldown.rolldown({
         ...inputOptions,
+        plugins: withPurePlugin(inputOptions.plugins, extra?.pure),
         optimization: inputOptions.optimization ?? {
           inlineConst: {
             mode: "smart",
@@ -71,6 +92,7 @@ export const build = (
 export const watch = (
   inputOptions: rolldown.InputOptions,
   outputOptions?: rolldown.OutputOptions,
+  extra?: BundleExtraOptions,
 ): Stream.Stream<Result.Result<BundleOutput, BundleError>> =>
   Stream.callback<Result.Result<rolldown.OutputBundle, BundleError>>((queue) =>
     Effect.acquireRelease(
@@ -78,7 +100,7 @@ export const watch = (
         const watcher = rolldown.watch({
           ...inputOptions,
           plugins: [
-            inputOptions.plugins,
+            withPurePlugin(inputOptions.plugins, extra?.pure),
             // The watcher event listener does not receive the bundle output, so we grab it using a plugin.
             {
               name: "alchemy:watch-bundle",
@@ -179,6 +201,22 @@ export function bundleOutputFromRolldownOutputBundle(
   ).pipe(Effect.flatMap(bundleOutputFromFiles));
 }
 
+/**
+ * Composes the user-provided plugin chain with the default
+ * {@link purePlugin} according to the `pure` option.
+ *
+ * The pure plugin is appended LAST so it sees module ids that have already
+ * been resolved into `node_modules/<pkg>/...` by upstream resolver plugins
+ * such as `@distilled.cloud/cloudflare-rolldown-plugin`.
+ */
+function withPurePlugin(
+  plugins: rolldown.RolldownPluginOption,
+  pure: PurePluginOptions | false | undefined,
+): rolldown.RolldownPluginOption {
+  if (pure === false) return plugins;
+  return [plugins, purePlugin(pure ?? {})];
+}
+
 function bundleErrorFromUnknown(error: unknown): BundleError {
   const message = error instanceof Error ? error.message : String(error);
   return new BundleError({