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

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({