alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Nuke.ts

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Formatter from "effect/Formatter";
 import * as Schedule from "effect/Schedule";
 import picomatch from "picomatch";
+import { emit, type ApplyStatus } from "./Events.ts";
 import {
   isProviderCollectionService,
   isProviderService,
@@ -27,6 +28,8 @@ export interface ProviderFailure {
 
 /** One cloud object a provider's `list()` turned up, bound to its provider. */
 export interface Target {
+  /** Unique within a scan; names the target's row in progress events and views. */
+  readonly key: string;
   readonly providerId: string;
   readonly displayName: string;
   readonly attributes: Record<string, unknown>;
@@ -46,27 +49,13 @@ export interface ListOptions extends DiscoverOptions {
   readonly context: Context.Context<never>;
   readonly concurrency?: number | "unbounded";
   readonly timeoutSeconds?: number;
-  /** Called once with the selected provider count before enumeration starts. */
-  readonly onScan?: (total: number) => Effect.Effect<void>;
-  /** Called when a provider starts resolving/listing, to identify slow scans. */
-  readonly onProviderStarted?: (provider: string) => Effect.Effect<void>;
-  /**
-   * Called as each provider's listing settles (0 resources when it failed),
-   * for progress reporting — scans across many providers are the slowest
-   * part of a nuke and would otherwise be silent until the summary.
-   */
-  readonly onProvider?: (
-    provider: string,
-    resources: number,
-    error?: string,
-  ) => Effect.Effect<void>;
 }
 
 export type Strategy =
   /** Delete in dependency order, retrying a wave until it stops making progress. */
-  | { readonly _tag: "coordinated" }
+  | { readonly type: "coordinated" }
   /** Delete everything at once, retrying each object on its own. */
-  | { readonly _tag: "independent"; readonly retries: number };
+  | { readonly type: "independent"; readonly retries: number };
 
 export interface DestroyOptions {
   readonly targets: ReadonlyArray<Target>;
@@ -74,16 +63,6 @@ export interface DestroyOptions {
   readonly strategy: Strategy;
   readonly concurrency?: number | "unbounded";
   readonly timeoutSeconds?: number;
-  /** Called before each coordinated pass, or once for independent deletion. */
-  readonly onPass?: (pass: number) => Effect.Effect<void>;
-  /** Called before each deletion attempt. */
-  readonly onDeleting?: (resource: Target) => Effect.Effect<void>;
-  /** Called when dependency failures prevent a resource from being attempted. */
-  readonly onHeld?: (resource: Target, blockedBy: ReadonlyArray<string>) => Effect.Effect<void>;
-  /** Called as each object is confirmed gone, for progress reporting. */
-  readonly onDeleted?: (resource: Target) => Effect.Effect<void>;
-  /** Called as a deletion attempt fails permanently (the run keeps going). */
-  readonly onFailed?: (resource: Target, message: string) => Effect.Effect<void>;
 }
 
 export interface Result {
@@ -116,10 +95,15 @@ const failure = (
   message: typeof cause === "string" ? cause : Formatter.format(cause),
 });
 
+/**
+ * One provider's failure, typed or defect, must not abort an account-wide
+ * sweep: credential layers die on a rejected token, so collect both.
+ */
+const settle = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.result(effect.pipe(Effect.catchDefect((defect) => Effect.fail(defect))));
+
 /** Deletions here run out-of-band, so nothing reports through an apply session. */
 const silent = {
-  emit: () => Effect.void,
-  done: () => Effect.void,
   note: () => Effect.void,
 };
 
@@ -211,13 +195,13 @@ export const list = (
     const providers = yield* discover(options.context, options).pipe(
       Effect.provide(options.context),
     );
-    yield* options.onScan?.(providers.length) ?? Effect.void;
+    yield* emit({ type: "nuke.scan.started", total: providers.length });
     yield* Effect.forEach(
       providers,
       ({ id, provider }) =>
         Effect.gen(function* () {
-          yield* options.onProviderStarted?.(id) ?? Effect.void;
-          const result = yield* Effect.result(
+          yield* emit({ type: "nuke.scan.provider.started", provider: id });
+          const result = yield* settle(
             Effect.gen(function* () {
               const listed = yield* provider
                 .list()
@@ -228,19 +212,29 @@ export const list = (
           if (result._tag === "Failure") {
             const error = failure(id, "list", result.failure);
             failures.push(error);
-            yield* options.onProvider?.(id, 0, error.message) ?? Effect.void;
+            yield* emit({
+              type: "nuke.scan.provider.completed",
+              provider: id,
+              resources: 0,
+              error: error.message,
+            });
             return;
           }
           for (const raw of result.success.listed) {
             const attributes = (raw ?? {}) as Record<string, unknown>;
             resources.push({
+              key: `${id}/${resources.length}`,
               providerId: id,
               displayName: displayName(attributes),
               attributes,
               provider: result.success.provider,
             });
           }
-          yield* options.onProvider?.(id, result.success.listed.length) ?? Effect.void;
+          yield* emit({
+            type: "nuke.scan.provider.completed",
+            provider: id,
+            resources: result.success.listed.length,
+          });
         }),
       { concurrency: options.concurrency ?? 16, discard: true },
     );
@@ -254,13 +248,40 @@ export const destroy = ({
   strategy,
   concurrency = 16,
   timeoutSeconds = 120,
-  onDeleted = () => Effect.void,
-  onFailed = () => Effect.void,
-  onPass = () => Effect.void,
-  onDeleting = () => Effect.void,
-  onHeld = () => Effect.void,
 }: DestroyOptions): Effect.Effect<Result> =>
   Effect.gen(function* () {
+    // Each target reports as an apply row under its `key`.
+    const status = (resource: Target, status: ApplyStatus, message?: string) =>
+      emit({
+        type: "apply.resource.status",
+        fqn: resource.key,
+        id: resource.providerId,
+        resourceType: resource.providerId,
+        status,
+        message,
+      });
+    const onPass = (pass: number) => emit({ type: "nuke.pass.started", pass });
+    const onDeleted = (resource: Target) =>
+      status(resource, "deleted").pipe(
+        Effect.andThen(
+          emit({
+            type: "nuke.resource.deleted",
+            provider: resource.providerId,
+            resource: resource.displayName,
+          }),
+        ),
+      );
+    const onFailed = (resource: Target, message: string) =>
+      status(resource, "fail", message).pipe(
+        Effect.andThen(
+          emit({
+            type: "nuke.resource.failed",
+            provider: resource.providerId,
+            resource: resource.displayName,
+            message,
+          }),
+        ),
+      );
     const deleted: Target[] = [];
     const failed: Array<Result["failed"][number]> = [];
     const held: Array<Result["held"][number]> = [];
@@ -269,7 +290,7 @@ export const destroy = ({
     // `output` alone — `olds` just mirrors it and `instanceId` is unavailable.
     const attempt = (resource: Target) =>
       Effect.gen(function* () {
-        yield* onDeleting(resource);
+        yield* status(resource, "deleting");
         return yield* resource.provider
           .delete({
             id: resource.displayName,
@@ -284,13 +305,13 @@ export const destroy = ({
           .pipe(Effect.timeout(Duration.seconds(timeoutSeconds)), Effect.provide(context));
       });
 
-    if (strategy._tag === "independent") {
+    if (strategy.type === "independent") {
       passes = 1;
       yield* onPass(passes);
       yield* Effect.forEach(
         targets,
         (resource) =>
-          Effect.result(
+          settle(
             attempt(resource).pipe(
               Effect.retry({
                 schedule: Schedule.min([
@@ -358,7 +379,9 @@ export const destroy = ({
           );
           if (blockers.length > 0) {
             heldTypes.add(typeId);
-            yield* Effect.forEach(resources, (resource) => onHeld(resource, blockers));
+            yield* Effect.forEach(resources, (resource) =>
+              status(resource, "skipped", `Held back by ${blockers.join(", ")}`),
+            );
             held.push(
               ...resources.map((resource) => ({
                 resource,
@@ -375,7 +398,7 @@ export const destroy = ({
             remaining,
             (resource) =>
               Effect.gen(function* () {
-                const result = yield* Effect.result(attempt(resource));
+                const result = yield* settle(attempt(resource));
                 if (result._tag === "Success") {
                   deleted.push(resource);
                   yield* onDeleted(resource);

package/src/Output.ts

@@ -163,7 +163,7 @@ export type ArrayExpr<A extends any[], Req = any> = Output<A, Req> & {
 };
 
 export const isResourceExpr = <Value = any, Req = any>(
-  node: Expr<Value, Req> | any,
+  node: any,
 ): node is ResourceExpr<Value, Req> => exprKind(node) === "ResourceExpr";
 
 export class ResourceExpr<Value, Req = never> extends BaseExpr<Value, Req> {
@@ -251,6 +251,15 @@ export class ApplyExpr<A, B, Req = never> extends BaseExpr<B, Req> {
   [inspect](): string {
     return `${this.expr[inspect]()}.map(${this.f.toString()})`;
   }
+
+  // Bind the upstream and apply `f` where it is read. A binding keyed by this
+  // expression would embed `f.toString()`, which differs between the deploy
+  // and a minified runtime bundle, so the runtime would find nothing.
+  override asEffect(): any {
+    return Effect.map(this.expr.asEffect() as Effect.Effect<Accessor<A>>, (accessor) =>
+      Effect.map(accessor, this.f),
+    );
+  }
 }
 
 export const mapEffect =
@@ -374,6 +383,14 @@ export class AllExpr<Outs extends Expr[]> extends BaseExpr<Outs> {
   [inspect](): string {
     return `all(${this.outs.map((out) => out[inspect]()).join(", ")})`;
   }
+
+  // Bind each member on its own (see `ApplyExpr.asEffect`).
+  override asEffect(): any {
+    return Effect.map(
+      Effect.all(this.outs.map((out) => out.asEffect() as Effect.Effect<Accessor<unknown>>)),
+      (accessors) => Effect.all(accessors),
+    );
+  }
 }
 
 export const isRefExpr = <A = any>(node: any): node is RefExpr<A> => exprKind(node) === "RefExpr";
@@ -407,6 +424,54 @@ export class RefExpr<A> extends BaseExpr<A, never> {
   }
 }
 
+/**
+ * Refs the plan bound to a resource declared in the same program. A ref names
+ * a resource by stack, stage and id; when those are the current stack and
+ * stage and the program also declares that resource, the ref is a dependency
+ * on it, exactly like a direct reference: {@link upstream} reports the edge
+ * (create waits for the target, delete runs the dependent first) and
+ * {@link evaluate} reads the target's fresh attributes from the apply-time
+ * outputs. Unbound refs (other stacks or stages, or resources only in state)
+ * keep reading persisted state and carry no edge.
+ */
+const boundRefs = new WeakMap<object, ResourceLike>();
+
+// Keyed by the raw expression, so a ref reached through its proxy or
+// unwrapped through `ExprSymbol` finds the same binding.
+const rawExpr = (ref: object): object => (ref as any)[ExprSymbol] ?? ref;
+
+/** Bind `ref` to the declared resource it names (see {@link boundRefs}). */
+export const bindRef = (ref: RefExpr<any>, target: ResourceLike): void => {
+  boundRefs.set(rawExpr(ref), target);
+};
+
+/** The declared resource a ref was bound to, if any. */
+export const refTarget = (ref: RefExpr<any>): ResourceLike | undefined =>
+  boundRefs.get(rawExpr(ref));
+
+/**
+ * Every {@link RefExpr} reachable from `value` through the same expression and
+ * plain-data structure {@link upstream} walks. Refs a `flatMap` produces at
+ * evaluation time are not reachable, as for any upstream.
+ */
+export const collectRefs = (value: any, seen: WeakSet<object> = new WeakSet()): RefExpr<any>[] => {
+  if (isPrimitive(value) || isResource(value)) {
+    return [];
+  } else if (isExpr(value)) {
+    if (isRefExpr(value)) return [value];
+    if (isPropExpr(value)) return collectRefs(value.expr, seen);
+    if (isAllExpr(value)) return value.outs.flatMap((out: any) => collectRefs(out, seen));
+    if (isEffectExpr(value) || isApplyExpr(value) || isFlatMapExpr(value) || isNamedExpr(value)) {
+      return collectRefs(value.expr, seen);
+    }
+    return [];
+  } else if (isPlainData(value)) {
+    if (alreadySeen(value, seen)) return [];
+    return Object.values(value).flatMap((child) => collectRefs(child, seen));
+  }
+  return [];
+};
+
 export const isStackRefExpr = <A = any>(node: any): node is StackRefExpr<A> =>
   exprKind(node) === "StackRefExpr";
 
@@ -629,12 +694,16 @@ export const evaluate: <A, Req = never>(
         const value = yield* evaluate(expr.expr, upstream);
         return yield* evaluate(expr.f(value), upstream);
       } else if (isAllExpr(expr)) {
-        return yield* Effect.all(expr.outs.map((out) => evaluate(out, upstream)));
+        return yield* Effect.forEach(expr.outs, (out) => evaluate(out, upstream));
       } else if (isPropExpr(expr)) {
         return (yield* evaluate(expr.expr, upstream))?.[expr.identifier];
       } else if (isNamedExpr(expr)) {
         return yield* evaluate(expr.expr, upstream);
       } else if (isRefExpr(expr)) {
+        const target = refTarget(expr);
+        if (target !== undefined && Object.hasOwn(upstream, target.FQN)) {
+          return upstream[target.FQN as keyof typeof upstream];
+        }
         const state = yield* yield* State.State;
         const stack = expr.stack ?? (yield* StackContext).name;
         const stage = expr.stage ?? (yield* Stage);
@@ -682,13 +751,11 @@ export const evaluate: <A, Req = never>(
       }
       const nested = new Set(ancestors).add(expr);
       if (Array.isArray(expr)) {
-        return yield* Effect.all(expr.map((item) => evaluate(item, upstream, nested)));
+        return yield* Effect.forEach(expr, (item) => evaluate(item, upstream, nested));
       }
       return Object.fromEntries(
-        yield* Effect.all(
-          Object.entries(expr).map(([key, value]) =>
-            evaluate(value, upstream, nested).pipe(Effect.map((value) => [key, value])),
-          ),
+        yield* Effect.forEach(Object.entries(expr), ([key, value]) =>
+          evaluate(value, upstream, nested).pipe(Effect.map((value) => [key, value])),
         ),
       );
     }
@@ -701,6 +768,49 @@ export const evaluate: <A, Req = never>(
     return expr;
   }) as Effect.Effect<any>;
 
+/**
+ * Evaluate the parts of `expr` that `upstream` can resolve. An Output whose
+ * sources are all in `upstream` is evaluated, plain data is walked, and an
+ * Output with any other source is returned unevaluated.
+ */
+export const evaluateAvailable = (
+  expr: any,
+  upstream: {
+    [Id in string]: any;
+  },
+  ancestors: ReadonlySet<object> = new Set(),
+): Effect.Effect<
+  any,
+  InvalidReferenceError | MissingSourceError | Config.ConfigError,
+  State.State
+> =>
+  Effect.gen(function* () {
+    if (isResource(expr) || isOutput(expr)) {
+      const sources = Object.keys(upstreamAny(expr));
+      return sources.every((fqn) => Object.hasOwn(upstream, fqn))
+        ? yield* evaluate(expr, upstream)
+        : expr;
+    }
+    if (Config.isConfig(expr)) {
+      return yield* evaluate(expr, upstream);
+    }
+    if (isPlainData(expr)) {
+      if (ancestors.has(expr)) {
+        return undefined;
+      }
+      const nested = new Set(ancestors).add(expr);
+      if (Array.isArray(expr)) {
+        return yield* Effect.forEach(expr, (item) => evaluateAvailable(item, upstream, nested));
+      }
+      return Object.fromEntries(
+        yield* Effect.forEach(Object.entries(expr), ([key, value]) =>
+          evaluateAvailable(value, upstream, nested).pipe(Effect.map((value) => [key, value])),
+        ),
+      );
+    }
+    return expr;
+  });
+
 export const hasOutputs = (value: any): value is Output<any, any> =>
   Object.keys(upstreamAny(value)).length > 0;
 
@@ -756,6 +866,9 @@ export const upstream = <E extends Output<any, any>>(
     return {
       [expr.src.FQN]: expr.src,
     };
+  } else if (isRefExpr(expr)) {
+    const target = refTarget(expr);
+    return target === undefined ? {} : { [target.FQN]: target };
   } else if (isPropExpr(expr)) {
     return upstream(expr.expr, seen);
   } else if (isAllExpr(expr)) {