alchemy 2.0.0-beta.55 → 2.0.0-beta.56

package/src/AWS/StateStore/State.ts

@@ -0,0 +1,399 @@
+import type { Credentials } from "@distilled.cloud/aws/Credentials";
+import type { Region } from "@distilled.cloud/aws/Region";
+import * as s3 from "@distilled.cloud/aws/s3";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+import { CredentialsStoreLive } from "../../Auth/Credentials.ts";
+import { decodeFqn, encodeFqn } from "../../FQN.ts";
+import { STATE_STORE_VERSION } from "../../State/HttpStateApi.ts";
+import {
+  State,
+  StateStoreError,
+  type PersistedState,
+  type StateService,
+} from "../../State/State.ts";
+import { encodeState, reviveState } from "../../State/StateEncoding.ts";
+import { recordStateStoreInit } from "../../Telemetry/Metrics.ts";
+import { AwsAuth } from "../AuthProvider.ts";
+import * as AwsCredentials from "../Credentials.ts";
+import * as Endpoint from "../Endpoint.ts";
+import {
+  AWSEnvironment,
+  Default as DefaultEnvironment,
+} from "../Environment.ts";
+import * as AwsRegion from "../Region.ts";
+
+/**
+ * The bookkeeping object that stores a stack's resolved output. Lives
+ * alongside the resource objects under the same stage prefix, so it
+ * must be filtered out of `list` results before FQN decoding.
+ */
+const OUTPUT_FILE = "__stack_output__.json";
+
+/** Maximum number of keys S3 accepts in a single DeleteObjects call. */
+const DELETE_BATCH_SIZE = 1000;
+
+export interface S3StateOptions {
+  /**
+   * Name of the S3 bucket that holds the state objects. The bucket is
+   * created on first use if it does not exist.
+   *
+   * The bucket is created in the account-regional namespace, so custom
+   * names must follow the `<prefix>-<accountId>-<region>-an` convention.
+   *
+   * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/gpbucketnamespaces.html#account-regional-gp-buckets
+   * @default `alchemy-state-{accountId}-{region}-an`
+   */
+  bucketName?: string;
+  /**
+   * Key prefix within the bucket under which all state objects are
+   * stored, e.g. `"alchemy"`. A trailing `/` is appended automatically.
+   *
+   * @default "" (bucket root)
+   */
+  prefix?: string;
+}
+
+/** Context required by the distilled S3 operations. */
+type S3Deps = Credentials | HttpClient | Region;
+
+/**
+ * State store backed by an AWS S3 bucket.
+ *
+ * Stack state is persisted as JSON objects in an account-regional S3
+ * bucket, laid out exactly like the local state store's file tree with
+ * the bucket (plus optional `prefix`) taking the place of the
+ * `.alchemy/state` directory:
+ *
+ * ```
+ * s3://{bucket}/{prefix}{stack}/{stage}/{fqn}.json
+ * s3://{bucket}/{prefix}{stack}/{stage}/__stack_output__.json
+ * ```
+ *
+ * The bucket is created lazily on the first state operation if it does
+ * not already exist — nothing touches AWS credentials at layer
+ * construction time.
+ *
+ * @resource
+ *
+ * @section Using the S3 State Store
+ * Pass `AWS.state()` as the `state` option of a Stack. By default the
+ * state is stored in an account-regional bucket named
+ * `alchemy-state-{accountId}-{region}-an`.
+ *
+ * @example Default bucket
+ * ```typescript
+ * import * as Alchemy from "alchemy";
+ * import * as AWS from "alchemy/AWS";
+ *
+ * const Stack = Alchemy.Stack(
+ *   "my-stack",
+ *   { providers: AWS.providers(), state: AWS.state() },
+ *   Effect.gen(function* () {
+ *     // ...
+ *   }),
+ * );
+ * ```
+ *
+ * @example Custom bucket and key prefix
+ * ```typescript
+ * const Stack = Alchemy.Stack(
+ *   "my-stack",
+ *   {
+ *     providers: AWS.providers(),
+ *     state: AWS.state({
+ *       bucketName: "my-company-state",
+ *       prefix: "alchemy",
+ *     }),
+ *   },
+ *   Effect.gen(function* () {
+ *     // ...
+ *   }),
+ * );
+ * ```
+ */
+export const state = (options: S3StateOptions = {}) =>
+  Layer.effect(
+    State,
+    Effect.gen(function* () {
+      const context = yield* Effect.context<S3Deps | AWSEnvironment>();
+
+      const make = makeS3State(options).pipe(
+        recordStateStoreInit,
+        Effect.orDie,
+        Effect.provideContext(context),
+      );
+
+      return yield* Effect.cached(make);
+    }),
+  ).pipe(
+    Layer.provideMerge(AwsRegion.fromEnvironment),
+    Layer.provideMerge(AwsCredentials.fromEnvironment),
+    Layer.provideMerge(Endpoint.fromEnvironment),
+    Layer.provideMerge(DefaultEnvironment),
+    Layer.provideMerge(AwsAuth),
+    Layer.provideMerge(CredentialsStoreLive),
+    Layer.orDie,
+  );
+
+/**
+ * Construct an S3-backed {@link StateService}.
+ *
+ * Construction itself never touches AWS — environment resolution and
+ * the ensure-bucket-exists check are deferred into a cached Effect
+ * that runs once, on the first state operation.
+ */
+export const makeS3State = (options: S3StateOptions = {}) =>
+  Effect.gen(function* () {
+    const context = yield* Effect.context<S3Deps | AWSEnvironment>();
+
+    const prefix = options.prefix
+      ? `${options.prefix.replace(/\/+$/, "")}/`
+      : "";
+
+    const toError = (cause: unknown) =>
+      new StateStoreError({
+        message:
+          cause instanceof Error
+            ? cause.message
+            : `S3 state store error: ${String(cause)}`,
+        cause: cause instanceof Error ? cause : undefined,
+      });
+
+    // Anything that touches AWS credentials must NOT run at layer
+    // construction time. Resolving the environment (account/region),
+    // deriving the bucket name, and ensuring the bucket exists are all
+    // deferred into this cached Effect: `Effect.cached` memoizes the
+    // result and locks concurrent first callers onto a single in-flight
+    // run, so the bucket is ensured exactly once — lazily, on first use
+    // of the state store.
+    const bucket = yield* Effect.cached(
+      Effect.gen(function* () {
+        const { accountId, region } = yield* AWSEnvironment.current;
+        const bucketName =
+          options.bucketName ?? createStateBucketName(accountId, region);
+        yield* ensureStateBucket(bucketName, region);
+        return bucketName;
+      }).pipe(Effect.provideContext(context), Effect.mapError(toError)),
+    );
+
+    // Close over the captured context so every StateService method is
+    // self-contained (`R = never`), matching the StateService contract.
+    const run = <A, E>(
+      f: (bucket: string) => Effect.Effect<A, E, S3Deps>,
+    ): Effect.Effect<A, StateStoreError> =>
+      bucket.pipe(
+        Effect.flatMap((bucket) =>
+          f(bucket).pipe(
+            Effect.provideContext(context),
+            Effect.mapError(toError),
+          ),
+        ),
+      );
+
+    const stagePrefix = ({ stack, stage }: { stack: string; stage: string }) =>
+      `${prefix}${stack}/${stage}/`;
+
+    const resourceKey = (request: {
+      stack: string;
+      stage: string;
+      fqn: string;
+    }) => `${stagePrefix(request)}${encodeFqn(request.fqn)}.json`;
+
+    const outputKey = (request: { stack: string; stage: string }) =>
+      `${stagePrefix(request)}${OUTPUT_FILE}`;
+
+    /** All object keys under `keyPrefix`, across pagination. */
+    const listKeys = (bucket: string, keyPrefix: string) =>
+      s3.listObjectsV2.pages({ Bucket: bucket, Prefix: keyPrefix }).pipe(
+        Stream.flatMap((page) => Stream.fromIterable(page.Contents ?? [])),
+        Stream.map((object) => object.Key),
+        Stream.filter((key): key is string => key !== undefined),
+        Stream.runCollect,
+        Effect.map((keys) => Array.from(keys)),
+      );
+
+    /**
+     * Immediate "subdirectory" names under `keyPrefix`, derived from
+     * S3 CommonPrefixes (delimiter `/`), across pagination.
+     */
+    const listChildren = (bucket: string, keyPrefix: string) =>
+      s3.listObjectsV2
+        .pages({ Bucket: bucket, Prefix: keyPrefix, Delimiter: "/" })
+        .pipe(
+          Stream.flatMap((page) =>
+            Stream.fromIterable(page.CommonPrefixes ?? []),
+          ),
+          // `{keyPrefix}{name}/` -> `{name}`
+          Stream.map((common) => common.Prefix),
+          Stream.filter((p): p is string => p !== undefined),
+          Stream.map((p) => p.slice(keyPrefix.length, -1)),
+          Stream.runCollect,
+          Effect.map((names) => Array.from(names)),
+        );
+
+    /** Read and revive a JSON object; `undefined` when the key is absent. */
+    const readJson = <T>(bucket: string, key: string) =>
+      s3.getObject({ Bucket: bucket, Key: key }).pipe(
+        Effect.flatMap((result) =>
+          result.Body === undefined
+            ? Effect.succeed(undefined)
+            : Stream.mkString(Stream.decodeText(result.Body)).pipe(
+                Effect.flatMap((text) =>
+                  Effect.try({
+                    try: () => JSON.parse(text, reviveState) as T,
+                    catch: (cause) =>
+                      new StateStoreError({
+                        message: `Failed to parse state object '${key}'`,
+                        cause: cause instanceof Error ? cause : undefined,
+                      }),
+                  }),
+                ),
+              ),
+        ),
+        Effect.catchTag("NoSuchKey", () => Effect.succeed(undefined)),
+      );
+
+    const writeJson = (bucket: string, key: string, value: unknown) =>
+      s3.putObject({
+        Bucket: bucket,
+        Key: key,
+        Body: JSON.stringify(encodeState(value), null, 2),
+        ContentType: "application/json",
+      });
+
+    /** Delete every object under `keyPrefix` in batches. Idempotent. */
+    const deleteAll = (bucket: string, keyPrefix: string) =>
+      Effect.gen(function* () {
+        const keys = yield* listKeys(bucket, keyPrefix);
+        for (let i = 0; i < keys.length; i += DELETE_BATCH_SIZE) {
+          yield* s3.deleteObjects({
+            Bucket: bucket,
+            Delete: {
+              Objects: keys
+                .slice(i, i + DELETE_BATCH_SIZE)
+                .map((Key) => ({ Key })),
+              Quiet: true,
+            },
+          });
+        }
+      });
+
+    const state: StateService = {
+      id: "s3",
+      getVersion: () => Effect.succeed(STATE_STORE_VERSION),
+      listStacks: () => run((bucket) => listChildren(bucket, prefix)),
+      listStages: (stack: string) =>
+        run((bucket) => listChildren(bucket, `${prefix}${stack}/`)),
+      get: (request) =>
+        run((bucket) => readJson<PersistedState>(bucket, resourceKey(request))),
+      getReplacedResources: Effect.fnUntraced(function* (request) {
+        return (yield* Effect.all(
+          (yield* state.list(request)).map((fqn) =>
+            state.get({
+              stack: request.stack,
+              stage: request.stage,
+              fqn,
+            }),
+          ),
+        )).filter((r) => r?.status === "replaced");
+      }),
+      set: (request) =>
+        run((bucket) =>
+          writeJson(bucket, resourceKey(request), request.value),
+        ).pipe(Effect.map(() => request.value)),
+      delete: (request) =>
+        run((bucket) =>
+          s3.deleteObject({ Bucket: bucket, Key: resourceKey(request) }),
+        ).pipe(Effect.asVoid),
+      deleteStack: ({ stack, stage }) =>
+        run((bucket) =>
+          deleteAll(
+            bucket,
+            stage === undefined
+              ? `${prefix}${stack}/`
+              : stagePrefix({ stack, stage }),
+          ),
+        ),
+      list: (request) =>
+        run((bucket) => listKeys(bucket, stagePrefix(request))).pipe(
+          Effect.map((keys) =>
+            keys
+              .map((key) => key.slice(stagePrefix(request).length))
+              // Filter the bookkeeping file before decoding — `decodeFqn`
+              // replaces `__` with `/`, which would turn the literal name
+              // `__stack_output__` into `/stack_output/` and slip past
+              // the filter, leaving the engine to look up a non-existent
+              // resource.
+              .filter((file) => file !== OUTPUT_FILE && file.endsWith(".json"))
+              .map((file) => decodeFqn(file.replace(/\.json$/, ""))),
+          ),
+        ),
+      getOutput: (request) =>
+        run((bucket) => readJson(bucket, outputKey(request))),
+      setOutput: (request) =>
+        run((bucket) =>
+          writeJson(bucket, outputKey(request), request.value),
+        ).pipe(Effect.map(() => request.value)),
+    };
+    return state;
+  });
+
+/**
+ * Build the default account-regional state bucket name.
+ *
+ * Account-regional buckets must follow the naming convention:
+ *   `<prefix>-<accountId>-<region>-an`
+ *
+ * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/gpbucketnamespaces.html#account-regional-gp-buckets
+ */
+export const createStateBucketName = (accountId: string, region: string) =>
+  `alchemy-state-${accountId}-${region}-an`.toLowerCase();
+
+/**
+ * Observe-then-ensure the state bucket: head it, create it if missing
+ * (tolerating create races), and wait for it to become available.
+ */
+const ensureStateBucket = (bucket: string, region: string) =>
+  Effect.gen(function* () {
+    const exists = yield* s3.headBucket({ Bucket: bucket }).pipe(
+      Effect.map(() => true),
+      Effect.catchTag("NotFound", () => Effect.succeed(false)),
+    );
+    if (exists) {
+      return;
+    }
+
+    yield* Effect.logInfo(
+      `S3 state store: creating bucket ${bucket} in ${region}`,
+    );
+    yield* s3
+      .createBucket({
+        Bucket: bucket,
+        // account-regional namespace: the bucket name only needs to be
+        // unique within this account+region, so deterministic default
+        // names can't collide with other AWS customers.
+        BucketNamespace: "account-regional",
+        // us-east-1 rejects an explicit LocationConstraint
+        ...(region === "us-east-1"
+          ? {}
+          : {
+              CreateBucketConfiguration: {
+                LocationConstraint: region as s3.BucketLocationConstraint,
+              },
+            }),
+      })
+      .pipe(
+        // a concurrent deploy may have created it between head and create
+        Effect.catchTag("BucketAlreadyOwnedByYou", () => Effect.void),
+      );
+
+    // wait for the bucket to become available (eventual consistency)
+    yield* Effect.retry(
+      s3.headBucket({ Bucket: bucket }),
+      Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(10))),
+    );
+  });

package/src/AWS/StateStore/index.ts

@@ -0,0 +1 @@
+export { makeS3State, state, type S3StateOptions } from "./State.ts";

package/src/AWS/Website/AssetDeployment.ts

@@ -174,6 +174,12 @@ export const AssetDeploymentProvider = () =>
       });
 
       return {
+        // Non-listable: an AssetDeployment is an action (uploading a local
+        // directory into a bucket under a prefix), keyed by {bucketName,
+        // prefix}, not a standalone cloud resource. There is no AWS API that
+        // enumerates "asset deployments" — the uploaded objects are plain S3
+        // objects owned by their bucket — so there is nothing to enumerate.
+        list: () => Effect.succeed([]),
         read: Effect.fn(function* ({ output }) {
           return output;
         }),

package/src/AWS/Website/SsrSite.ts

@@ -110,7 +110,7 @@ const serverUrlOf = (server: SsrSiteServerOrigin): Input<string> => {
       return Output.map((url: string | undefined) => {
         if (!url) {
           throw new Error(
-            "SsrSite lambda origins require a function created with `url: true`.",
+            "SsrSite lambda origins require a function created with `url` enabled.",
           );
         }
         return url;

package/src/AWS/index.ts

@@ -3,6 +3,7 @@ export * from "./Assets.ts";
 export * from "./Bootstrap.ts";
 export * from "./Environment.ts";
 export * from "./Providers.ts";
+export * from "./StateStore/index.ts";
 
 export { Region } from "@distilled.cloud/aws/Region";
 

package/src/Auth/Lock.ts

@@ -26,8 +26,19 @@ export const withLock = <A, E, R>(
       await fs.mkdir(lockDir, { recursive: true });
       return await lock(lockPath, {
         retries: { retries: 600, minTimeout: 50, maxTimeout: 50 },
-        stale: 5_000,
+        // The holder refreshes the lockfile mtime on a timer. Under heavy
+        // load (e.g. a full test run saturating every core) that timer can
+        // be starved for several seconds, so keep the stale threshold well
+        // above any realistic starvation pause.
+        stale: 30_000,
         realpath: false,
+        // The library's default handler throws from a timer callback,
+        // which surfaces as an uncaught exception and kills the process.
+        // A compromised auth lock is benign here (worst case two refreshes
+        // race), so log and continue.
+        onCompromised: (err) => {
+          console.warn(`auth lock compromised (continuing): ${err.message}`);
+        },
       });
     }),
     () => effect,

package/src/Axiom/Annotation.ts

@@ -64,9 +64,18 @@ export const AnnotationProvider = () =>
       const update = yield* Axiom.updateAnnotation;
       const get = yield* Axiom.getAnnotation;
       const del = yield* Axiom.deleteAnnotation;
+      const listAnnotations = yield* Axiom.getAnnotations;
 
       return {
         stables: ["id"],
+        // Axiom exposes a flat, account-wide `GET /v2/annotations` list that
+        // returns every annotation's full record in one (non-paginated)
+        // response — the exact same shape `get`/`read` produce. Hand each
+        // record back directly as the resource's Attributes.
+        list: () =>
+          listAnnotations({}).pipe(
+            Effect.map((annotations) => annotations.map((a) => ({ ...a }))),
+          ),
         reconcile: Effect.fn(function* ({ news, output }) {
           // Observe — Axiom assigns the annotation id server-side, so the
           // only handle to a previously-created annotation is the cached

package/src/Axiom/ApiToken.ts

@@ -77,9 +77,25 @@ export const ApiTokenProvider = () =>
       const create = yield* Axiom.createAPIToken;
       const get = yield* Axiom.getAPIToken;
       const del = yield* Axiom.deleteAPIToken;
+      const listTokens = yield* Axiom.getAPITokens;
 
       return {
         stables: ["id", "token"],
+        // Enumerate every API token in the org. Axiom exposes a single
+        // account-wide `GET /v2/tokens` collection op (no pagination), so we
+        // fetch it once and hydrate each row into the exact `read` Attributes
+        // shape. The bearer secret is returned by Axiom only at creation and is
+        // never echoed back on enumeration, so — matching `read`, which sources
+        // the secret from cached state — we surface an empty Redacted token
+        // here rather than the real value.
+        list: () =>
+          Effect.gen(function* () {
+            const tokens = yield* listTokens({});
+            return tokens.map((token) => ({
+              ...token,
+              token: Redacted.make(""),
+            }));
+          }),
         diff: Effect.fn(function* ({ olds, news, output }) {
           if (!isResolved(news)) return undefined;
           // First create — let the engine create normally.

package/src/Axiom/Dashboard.ts

@@ -139,6 +139,7 @@ export const DashboardProvider = () =>
       const update = yield* Axiom.updateDashboard;
       const get = yield* Axiom.getDashboard;
       const del = yield* Axiom.deleteDashboard;
+      const listAll = yield* Axiom.listDashboards;
 
       const toAttrsFromCreate = (envelope: Axiom.CreateDashboardOutput) => ({
         uid: envelope.dashboard.uid,
@@ -196,6 +197,15 @@ export const DashboardProvider = () =>
             Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
           );
         }),
+        // Enumerate every dashboard visible to the caller. `GET /v2/dashboards`
+        // returns the full collection in one response (no pagination wrapper);
+        // each item carries the same shape as `getDashboard`, so we map through
+        // the shared `toAttrsFromGet` hydrator to produce the exact `read`
+        // Attributes shape.
+        list: () =>
+          listAll({}).pipe(
+            Effect.map((dashboards) => dashboards.map(toAttrsFromGet)),
+          ),
       };
     }),
   );

package/src/Axiom/Dataset.ts

@@ -171,6 +171,7 @@ export const DatasetProvider = () =>
       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 = (dataset: Axiom.CreateDatasetOutput) => ({
@@ -184,6 +185,15 @@ export const DatasetProvider = () =>
 
       return {
         stables: ["id", "name", "kind"],
+        // 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 datasets.map(toAttrs);
+          }),
         diff: Effect.fn(function* ({ olds, news, output }) {
           if (!isResolved(news)) return undefined;
           if (output && news.name !== output.name) {

package/src/Axiom/Monitor.ts

@@ -89,10 +89,21 @@ export const MonitorProvider = () =>
       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) {

package/src/Axiom/Notifier.ts

@@ -75,10 +75,21 @@ export const NotifierProvider = () =>
       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

package/src/Axiom/View.ts

@@ -70,10 +70,21 @@ export const ViewProvider = () =>
       const create = yield* Axiom.createView;
       const update = yield* Axiom.updateView;
       const get = yield* Axiom.getView;
+      const listViews = yield* Axiom.getViews;
       const del = yield* Axiom.deleteView;
 
       return {
         stables: ["id"],
+        // Enumerate every view in the org. Axiom exposes a single account-wide
+        // `GET /v2/views` collection op (no pagination) that already returns
+        // the full view objects, so we fetch it once and hydrate each row into
+        // the exact `read` Attributes shape (`id` is derived from `name`, the
+        // path identifier) — directly usable by `delete` with no follow-up get.
+        list: () =>
+          Effect.gen(function* () {
+            const views = yield* listViews({});
+            return views.map((view) => ({ ...view, id: view.name }));
+          }),
         diff: Effect.fn(function* ({ news, output }) {
           if (!isResolved(news)) return undefined;
           if (output && news.name !== output.name) {

package/src/Axiom/VirtualField.ts

@@ -58,9 +58,27 @@ export const VirtualFieldProvider = () =>
       const update = yield* Axiom.updateVirtualField;
       const get = yield* Axiom.getVirtualField;
       const del = yield* Axiom.deleteVirtualField;
+      const listVirtualFields = yield* Axiom.getVirtualFields;
+      const listDatasets = yield* Axiom.getDatasets;
 
       return {
         stables: ["id"],
+        // Axiom only exposes a per-dataset virtual-field enumeration
+        // (`GET /v2/vfields?dataset=...`); there is no account-wide list. So
+        // enumerate every dataset (`GET /v2/datasets`), fan out the per-dataset
+        // vfields list with bounded concurrency, and flatten. Each row already
+        // matches the `read` Attributes shape (`CreateVirtualFieldOutput`), so
+        // it's directly usable by `delete` with no follow-up read.
+        list: () =>
+          Effect.gen(function* () {
+            const datasets = yield* listDatasets({});
+            const perDataset = yield* Effect.forEach(
+              datasets,
+              (ds) => listVirtualFields({ dataset: ds.name }),
+              { concurrency: 10 },
+            );
+            return perDataset.flat().map((vf) => ({ ...vf }));
+          }),
         diff: Effect.fn(function* ({ news, output }) {
           if (!isResolved(news)) return undefined;
           if (output && news.dataset !== output.dataset) {

package/src/Build/Command.ts

@@ -129,6 +129,11 @@ export const CommandProvider = () =>
 
       return Command.Provider.of({
         stables: ["outdir"],
+        // Non-listable: a Build.Command is a local build/exec step whose
+        // artifact is a directory on the local filesystem keyed by the hash of
+        // its inputs. There is no remote enumeration API to discover existing
+        // build commands, so list returns an empty array.
+        list: () => Effect.succeed([]),
         diff: Effect.fnUntraced(function* ({ news, output }) {
           if (!isResolved(news)) return undefined;
           if (!output) {