alchemy-effect 0.2.0 → 0.4.0

package/src/apply.ts

@@ -1,476 +1,848 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
 import type { Simplify } from "effect/Types";
-import { PlanReviewer, type PlanRejected } from "./approve.ts";
+import { App } from "./app.ts";
 import type { AnyBinding, BindingService } from "./binding.ts";
-import type { ApplyEvent, ApplyStatus } from "./event.ts";
 import {
+  type PlanStatusSession,
+  CLI,
+  type ScopedPlanStatusSession,
+} from "./cli/service.ts";
+import type { ApplyStatus } from "./event.ts";
+import { generateInstanceId } from "./instance-id.ts";
+import * as Output from "./output.ts";
+import {
+  type Apply,
   plan,
   type BindNode,
-  type Create,
-  type CRUD,
   type Delete,
-  type Plan,
-  type Update,
+  type DerivePlan,
+  type IPlan,
+  type Providers,
 } from "./plan.ts";
-import type { Resource } from "./resource.ts";
-import type { Service } from "./service.ts";
-import { State } from "./state.ts";
-
-export interface PlanStatusSession {
-  emit: (event: ApplyEvent) => Effect.Effect<void>;
-  done: () => Effect.Effect<void>;
-}
-
-export interface ScopedPlanStatusSession extends PlanStatusSession {
-  note: (note: string) => Effect.Effect<void>;
-}
-
-export class PlanStatusReporter extends Context.Tag("PlanStatusReporter")<
-  PlanStatusReporter,
+import type { Instance } from "./policy.ts";
+import type { AnyResource, Resource } from "./resource.ts";
+import type { AnyService } from "./service.ts";
+import {
+  type CreatedResourceState,
+  type CreatingResourceState,
+  type DeletingResourceState,
+  type ReplacedResourceState,
+  type ReplacingResourceState,
+  type ResourceState,
+  type UpdatedResourceState,
+  type UpdatingReourceState,
+  State,
+  StateStoreError,
+} from "./state.ts";
+import { asEffect } from "./util.ts";
+import { getProviderByType } from "./provider.ts";
+
+export type ApplyEffect<
+  P extends IPlan,
+  Err = never,
+  Req = never,
+> = Effect.Effect<
   {
-    start(plan: Plan): Effect.Effect<PlanStatusSession, never>;
-  }
->() {}
-
-export const apply: typeof applyPlan &
-  typeof applyResources &
-  typeof applyResourcesPhase = (...args: any[]): any =>
-  Effect.isEffect(args[0])
-    ? applyPlan(args[0] as any)
-    : args.length === 1 && "phase" in args[0]
-      ? applyResourcesPhase(args[0])
-      : applyResources(...args);
-
-export const applyResourcesPhase = <
-  const Phase extends "update" | "destroy",
-  const Resources extends (Service | Resource)[],
->(props: {
-  resources: Resources;
-  phase: Phase;
-}) => applyPlan(plan(props));
-
-export const applyResources = <const Resources extends (Service | Resource)[]>(
+    [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k];
+  },
+  Err,
+  Req
+>;
+
+export type AppliedPlan<P extends IPlan> = {
+  [id in keyof P["resources"]]: P["resources"][id] extends
+    | Delete<Resource>
+    | undefined
+    | never
+    ? never
+    : Simplify<P["resources"][id]["resource"]["attr"]>;
+};
+
+export const apply = <
+  const Resources extends (AnyService | AnyResource)[] = never,
+>(
   ...resources: Resources
-) =>
-  applyPlan(
-    plan({
-      phase: "update",
-      resources,
-    }),
-  );
-
-export const applyPlan = <P extends Plan, Err, Req>(
-  plan: Effect.Effect<P, Err, Req>,
-) =>
-  plan.pipe(
-    Effect.flatMap((plan) =>
-      Effect.gen(function* () {
-        const state = yield* State;
-        const outputs = {} as Record<string, Effect.Effect<any, any>>;
-        const reviewer = yield* Effect.serviceOption(PlanReviewer);
-
-        if (Option.isSome(reviewer)) {
-          yield* reviewer.value.approve(plan);
-        }
-
-        const events = yield* Effect.serviceOption(PlanStatusReporter);
-
-        const session = Option.isSome(events)
-          ? yield* events.value.start(plan)
-          : ({
-              emit: () => Effect.void,
-              done: () => Effect.void,
-            } satisfies PlanStatusSession);
-        const { emit, done } = session;
-
-        const constOrEffect = <T, Err = never, Req = never>(
-          effect: T | Effect.Effect<T>,
-        ): Effect.Effect<T, Err, Req> =>
-          Effect.isEffect(effect) ? effect : Effect.succeed(effect);
-
-        const resolveBindingUpstream = Effect.fn(function* ({
-          node,
-          resource,
-        }: {
-          node: BindNode;
-          resource: Resource;
-        }) {
-          const binding = node.binding as AnyBinding & {
-            // smuggled property (because it interacts poorly with inference)
-            Tag: Context.Tag<never, BindingService>;
-          };
-          const provider = yield* binding.Tag;
-
-          const resourceId: string = node.binding.capability.resource.id;
-          const upstreamNode = plan.resources[resourceId];
-          const upstreamAttr = resource
-            ? yield* apply(upstreamNode)
-            : yield* Effect.dieMessage(`Resource ${resourceId} not found`);
-
-          return {
-            resourceId,
-            upstreamAttr,
-            upstreamNode,
-            provider,
-          };
+): ApplyEffect<
+  DerivePlan<Instance<Resources[number]>>,
+  never,
+  State | Providers<Instance<Resources[number]>>
+  // TODO(sam): don't cast to any
+> =>
+  plan(...resources).pipe(
+    Effect.flatMap((p) => applyPlan(p as any as IPlan)),
+  ) as any;
+
+export const applyPlan = <P extends IPlan>(plan: P) =>
+  Effect.gen(function* () {
+    const cli = yield* CLI;
+    const session = yield* cli.startApplySession(plan);
+
+    // 1. expand the graph (create new resources, update existing and create replacements)
+    const resources = yield* expandAndPivot(plan, session);
+    // TODO(sam): support roll back to previous state if errors occur during expansion
+    // -> RISK: some UPDATEs may not be reverisble (i.e. trigger replacements)
+    // TODO(sam): should pivot be done separately? E.g shift traffic?
+
+    // 2. delete orphans and replaced resources
+    yield* collectGarbage(plan, session);
+
+    yield* session.done();
+
+    if (Object.keys(plan.resources).length === 0) {
+      // all resources are deleted, return undefined
+      return undefined;
+    }
+    return resources as {
+      [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k];
+    };
+  });
+
+const expandAndPivot = Effect.fnUntraced(function* (
+  plan: IPlan,
+  session: PlanStatusSession,
+) {
+  const state = yield* State;
+  const app = yield* App;
+
+  const outputs = {} as Record<string, Effect.Effect<any, any, State>>;
+  const resolveUpstream = Effect.fn(function* (resourceId: string) {
+    const upstreamNode = plan.resources[resourceId];
+    const upstreamAttr = upstreamNode
+      ? yield* apply(upstreamNode)
+      : yield* Effect.dieMessage(`Resource ${resourceId} not found`);
+    return {
+      resourceId,
+      upstreamAttr,
+      upstreamNode,
+    };
+  });
+
+  const resolveBindingUpstream = Effect.fn(function* ({
+    node,
+  }: {
+    node: BindNode;
+    resource: Resource;
+  }) {
+    const binding = node.binding as AnyBinding & {
+      // smuggled property (because it interacts poorly with inference)
+      Tag: Context.Tag<never, BindingService>;
+    };
+    const provider = yield* binding.Tag;
+    const resourceId: string = node.binding.capability.resource.id;
+    const { upstreamAttr, upstreamNode } = yield* resolveUpstream(resourceId);
+
+    return {
+      resourceId,
+      upstreamAttr,
+      upstreamNode,
+      provider,
+    };
+  });
+
+  const attachBindings = ({
+    resource,
+    bindings,
+    target,
+  }: {
+    resource: Resource;
+    bindings: BindNode[];
+    target: {
+      id: string;
+      props: any;
+      attr: any;
+    };
+  }) =>
+    Effect.all(
+      bindings.map(
+        Effect.fn(function* (node) {
+          const { resourceId, upstreamAttr, upstreamNode, provider } =
+            yield* resolveBindingUpstream({ node, resource });
+
+          const input = {
+            source: {
+              id: resourceId,
+              attr: upstreamAttr,
+              props: upstreamNode.resource.props,
+            },
+            props: node.binding.props,
+            attr: node.attr,
+            target,
+          } as const;
+          if (node.action === "attach") {
+            return yield* asEffect(provider.attach(input));
+          } else if (node.action === "reattach") {
+            // reattach is optional, we fall back to attach if it's not available
+            return yield* asEffect(
+              (provider.reattach ? provider.reattach : provider.attach)(input),
+            );
+          } else if (node.action === "detach" && provider.detach) {
+            return yield* asEffect(
+              provider.detach({
+                ...input,
+                target,
+              }),
+            );
+          }
+          return node.attr;
+        }),
+      ),
+    );
+
+  const postAttachBindings = ({
+    bindings,
+    bindingOutputs,
+    resource,
+    target,
+  }: {
+    bindings: BindNode[];
+    bindingOutputs: any[];
+    resource: Resource;
+    target: {
+      id: string;
+      props: any;
+      attr: any;
+    };
+  }) =>
+    Effect.all(
+      bindings.map(
+        Effect.fn(function* (node, i) {
+          const { resourceId, upstreamAttr, upstreamNode, provider } =
+            yield* resolveBindingUpstream({ node, resource });
+
+          const oldBindingOutput = bindingOutputs[i];
+
+          if (
+            provider.postattach &&
+            (node.action === "attach" || node.action === "reattach")
+          ) {
+            const bindingOutput = yield* asEffect(
+              provider.postattach({
+                source: {
+                  id: resourceId,
+                  attr: upstreamAttr,
+                  props: upstreamNode.resource.props,
+                },
+                props: node.binding.props,
+                attr: oldBindingOutput,
+                target,
+              } as const),
+            );
+            return {
+              ...oldBindingOutput,
+              ...bindingOutput,
+            };
+          }
+          return oldBindingOutput;
+        }),
+      ),
+    );
+
+  const apply: (node: Apply) => Effect.Effect<any, never, never> = (node) =>
+    Effect.gen(function* () {
+      const commit = <State extends ResourceState>(value: State) =>
+        state.set({
+          stack: app.name,
+          stage: app.stage,
+          resourceId: node.resource.id,
+          value,
         });
 
-        const attachBindings = ({
-          resource,
-          bindings,
-          target,
-        }: {
-          resource: Resource;
-          bindings: BindNode[];
-          target: {
-            id: string;
-            props: any;
-            attr: any;
-          };
-        }) =>
-          Effect.all(
-            bindings.map(
-              Effect.fn(function* (node) {
-                const { resourceId, upstreamAttr, upstreamNode, provider } =
-                  yield* resolveBindingUpstream({ node, resource });
-
-                const input = {
-                  source: {
-                    id: resourceId,
-                    attr: upstreamAttr,
-                    props: upstreamNode.resource.props,
-                  },
-                  props: node.binding.props,
-                  attr: node.attr,
-                  target,
-                } as const;
-                if (node.action === "attach") {
-                  return yield* constOrEffect(provider.attach(input));
-                } else if (node.action === "reattach") {
-                  // reattach is optional, we fall back to attach if it's not available
-                  return yield* constOrEffect(
-                    (provider.reattach ? provider.reattach : provider.attach)(
-                      input,
-                    ),
-                  );
-                } else if (node.action === "detach" && provider.detach) {
-                  return yield* constOrEffect(
-                    provider.detach({
-                      ...input,
-                      target,
-                    }),
-                  );
-                }
-                return node.attr;
-              }),
+      const id = node.resource.id;
+      const resource = node.resource;
+
+      const scopedSession = {
+        ...session,
+        note: (note: string) =>
+          session.emit({
+            id,
+            kind: "annotate",
+            message: note,
+          }),
+      } satisfies ScopedPlanStatusSession;
+
+      return yield* (outputs[id] ??= yield* Effect.cached(
+        Effect.gen(function* () {
+          const report = (status: ApplyStatus) =>
+            session.emit({
+              kind: "status-change",
+              id,
+              type: node.resource.type,
+              status,
+            });
+
+          if (node.action === "noop") {
+            return node.state.attr;
+          }
+
+          // resolve upstream dependencies before committing any changes to state
+          const upstream = Object.fromEntries(
+            yield* Effect.all(
+              Object.entries(Output.resolveUpstream(node.props)).map(([id]) =>
+                resolveUpstream(id).pipe(
+                  Effect.map(({ upstreamAttr }) => [id, upstreamAttr]),
+                ),
+              ),
             ),
           );
 
-        const postAttachBindings = ({
-          bindings,
-          bindingOutputs,
-          resource,
-          target,
-        }: {
-          bindings: BindNode[];
-          bindingOutputs: any[];
-          resource: Resource;
-          target: {
-            id: string;
-            props: any;
-            attr: any;
-          };
-        }) =>
-          Effect.all(
-            bindings.map(
-              Effect.fn(function* (node, i) {
-                const { resourceId, upstreamAttr, upstreamNode, provider } =
-                  yield* resolveBindingUpstream({ node, resource });
-
-                const oldBindingOutput = bindingOutputs[i];
-
-                if (
-                  provider.postattach &&
-                  (node.action === "attach" || node.action === "reattach")
-                ) {
-                  const bindingOutput = yield* constOrEffect(
-                    provider.postattach({
-                      source: {
-                        id: resourceId,
-                        attr: upstreamAttr,
-                        props: upstreamNode.resource.props,
-                      },
-                      props: node.binding.props,
-                      attr: oldBindingOutput,
-                      target,
-                    } as const),
-                  );
-                  return {
-                    ...oldBindingOutput,
-                    ...bindingOutput,
-                  };
-                }
-                return oldBindingOutput;
-              }),
-            ),
-          );
+          const instanceId = yield* Effect.gen(function* () {
+            if (node.action === "create" && !node.state?.instanceId) {
+              const instanceId = yield* generateInstanceId();
+              yield* commit<CreatingResourceState>({
+                status: "creating",
+                instanceId,
+                logicalId: id,
+                downstream: node.downstream,
+                props: node.props,
+                providerVersion: node.provider.version ?? 0,
+                resourceType: node.resource.type,
+                bindings: node.bindings,
+              });
+              return instanceId;
+            } else if (node.action === "replace") {
+              if (
+                node.state.status === "replaced" ||
+                node.state.status === "replacing"
+              ) {
+                // replace has already begun and we have the new instanceId, do not re-create it
+                return node.state.instanceId;
+              }
+              const instanceId = yield* generateInstanceId();
+              yield* commit<ReplacingResourceState>({
+                status: "replacing",
+                instanceId,
+                logicalId: id,
+                downstream: node.downstream,
+                props: node.props,
+                providerVersion: node.provider.version ?? 0,
+                resourceType: node.resource.type,
+                bindings: node.bindings,
+                old: node.state,
+                deleteFirst: node.deleteFirst,
+              });
+              return instanceId;
+            } else if (node.state?.instanceId) {
+              // we're in a create, update or delete state with a stable instanceId, use it
+              return node.state.instanceId;
+            }
+            // this should never happen
+            return yield* Effect.dieMessage(
+              `Instance ID not found for resource '${id}' and action is '${node.action}'`,
+            );
+          });
+
+          if (node.action === "create") {
+            const news = (yield* Output.evaluate(
+              node.props,
+              upstream,
+            )) as Record<string, any>;
+
+            const checkpoint = (attr: any) =>
+              commit<CreatingResourceState>({
+                status: "creating",
+                logicalId: id,
+                instanceId,
+                resourceType: node.resource.type,
+                props: news,
+                attr,
+                providerVersion: node.provider.version ?? 0,
+                bindings: node.bindings,
+                downstream: node.downstream,
+              });
+
+            if (!node.state) {
+              yield* checkpoint(undefined);
+            }
 
-        const apply: (node: CRUD) => Effect.Effect<any, never, never> = (
-          node,
-        ) =>
-          Effect.gen(function* () {
-            const checkpoint = <Out, Err>(
-              effect: Effect.Effect<Out, Err, never>,
-            ) => effect.pipe(Effect.flatMap((output) => saveState({ output })));
-
-            const saveState = <Output>({
-              output,
-              bindings = node.bindings,
-            }: {
-              output: Output;
-              bindings?: BindNode[];
-            }) =>
-              state
-                .set(node.resource.id, {
-                  id: node.resource.id,
-                  type: node.resource.type,
-                  status: node.action === "create" ? "created" : "updated",
-                  props: node.resource.props,
-                  output,
-                  bindings,
-                })
-                .pipe(Effect.map(() => output));
-
-            const id = node.resource.id;
-            const resource = node.resource;
-
-            const scopedSession = {
-              ...session,
-              note: (note: string) =>
-                session.emit({
-                  id,
-                  kind: "annotate",
-                  message: note,
-                }),
-            } satisfies ScopedPlanStatusSession;
-
-            return yield* (outputs[id] ??= yield* Effect.cached(
-              Effect.gen(function* () {
-                const report = (status: ApplyStatus) =>
-                  emit({
-                    kind: "status-change",
-                    id,
-                    type: node.resource.type,
-                    status,
-                  });
-
-                const createOrUpdate = Effect.fn(function* ({
-                  node,
+            let attr: any;
+            if (
+              node.action === "create" &&
+              node.provider.precreate &&
+              // pre-create is only designed to ensure the resource exists, if we have state.attr, then it already exists and should be skipped
+              node.state?.attr === undefined
+            ) {
+              yield* report("pre-creating");
+
+              // stub the resource prior to resolving upstream resources or bindings if a stub is available
+              attr = yield* node.provider.precreate({
+                id,
+                news: node.props,
+                session: scopedSession,
+                instanceId,
+              });
+
+              yield* checkpoint(attr);
+            }
+
+            yield* report("attaching");
+
+            let bindingOutputs = yield* attachBindings({
+              resource,
+              bindings: node.bindings,
+              target: {
+                id,
+                props: news,
+                attr,
+              },
+            });
+
+            yield* report("creating");
+
+            attr = yield* node.provider.create({
+              id,
+              news,
+              instanceId,
+              bindings: bindingOutputs,
+              session: scopedSession,
+            });
+
+            yield* checkpoint(attr);
+
+            yield* report("post-attach");
+            bindingOutputs = yield* postAttachBindings({
+              resource,
+              bindings: node.bindings,
+              bindingOutputs,
+              target: {
+                id,
+                props: news,
+                attr,
+              },
+            });
+
+            yield* commit<CreatedResourceState>({
+              status: "created",
+              logicalId: id,
+              instanceId,
+              resourceType: node.resource.type,
+              props: news,
+              attr,
+              bindings: node.bindings.map((binding, i) => ({
+                ...binding,
+                attr: bindingOutputs[i],
+              })),
+              providerVersion: node.provider.version ?? 0,
+              downstream: node.downstream,
+            });
+
+            yield* report("created");
+
+            return attr;
+          } else if (node.action === "update") {
+            const upstream = Object.fromEntries(
+              yield* Effect.all(
+                Object.entries(Output.resolveUpstream(node.props)).map(([id]) =>
+                  resolveUpstream(id).pipe(
+                    Effect.map(({ upstreamAttr }) => [id, upstreamAttr]),
+                  ),
+                ),
+              ),
+            );
+            const news = (yield* Output.evaluate(
+              node.props,
+              upstream,
+            )) as Record<string, any>;
+
+            const checkpoint = (attr: any) => {
+              if (node.state.status === "replaced") {
+                return commit<ReplacedResourceState>({
+                  ...node.state,
+                  attr,
+                  props: news,
+                });
+              } else {
+                return commit<UpdatingReourceState>({
+                  status: "updating",
+                  logicalId: id,
+                  instanceId,
+                  resourceType: node.resource.type,
+                  props: news,
                   attr,
-                  phase,
-                }: {
-                  node: Create<Resource> | Update<Resource>;
-                  attr: any;
-                  phase: "create" | "update";
-                }) {
-                  yield* report(phase === "create" ? "creating" : "updating");
-
-                  let bindingOutputs = yield* attachBindings({
-                    resource,
-                    bindings: node.bindings,
-                    target: {
-                      id,
-                      props: node.news,
-                      attr,
-                    },
-                  });
-
-                  const output: any = yield* (
-                    phase === "create"
-                      ? node.provider.create
-                      : node.provider.update
-                  )({
-                    id,
-                    news: node.news,
-                    bindings: bindingOutputs,
-                    session: scopedSession,
-                    ...(node.action === "update"
-                      ? {
-                          output: node.output,
-                          olds: node.olds,
-                        }
-                      : {}),
-                  }).pipe(
-                    // TODO(sam): partial checkpoints
-                    // checkpoint,
-                    Effect.tap(() =>
-                      report(phase === "create" ? "created" : "updated"),
-                    ),
-                  );
-
-                  bindingOutputs = yield* postAttachBindings({
-                    resource,
-                    bindings: node.bindings,
-                    bindingOutputs,
-                    target: {
-                      id,
-                      props: node.news,
-                      attr,
-                    },
-                  });
-
-                  yield* saveState({
-                    output,
-                    bindings: node.bindings.map((binding, i) => ({
-                      ...binding,
-                      attr: bindingOutputs[i],
-                    })),
-                  });
-
-                  return output;
+                  providerVersion: node.provider.version ?? 0,
+                  bindings: node.bindings,
+                  downstream: node.downstream,
+                  old:
+                    node.state.status === "updating"
+                      ? node.state.old
+                      : node.state,
                 });
+              }
+            };
+
+            yield* checkpoint(node.state.attr);
+
+            yield* report("attaching");
+
+            let bindingOutputs = yield* attachBindings({
+              resource,
+              bindings: node.bindings,
+              target: {
+                id,
+                props: news,
+                attr: node.state.attr,
+              },
+            });
+
+            yield* report("updating");
+
+            const attr = yield* node.provider.update({
+              id,
+              news,
+              instanceId,
+              bindings: bindingOutputs,
+              session: scopedSession,
+              olds:
+                node.state.status === "created" ||
+                node.state.status === "updated" ||
+                node.state.status === "replaced"
+                  ? node.state.props
+                  : node.state.old.props,
+              output: node.state.attr,
+            });
+
+            yield* checkpoint(attr);
+
+            yield* report("post-attach");
+
+            bindingOutputs = yield* postAttachBindings({
+              resource,
+              bindings: node.bindings,
+              bindingOutputs,
+              target: {
+                id,
+                props: news,
+                attr,
+              },
+            });
+
+            if (node.state.status === "replaced") {
+              yield* commit<ReplacedResourceState>({
+                ...node.state,
+                attr,
+                props: news,
+              });
+            } else {
+              yield* commit<UpdatedResourceState>({
+                status: "updated",
+                logicalId: id,
+                instanceId,
+                resourceType: node.resource.type,
+                props: news,
+                attr,
+                bindings: node.bindings.map((binding, i) => ({
+                  ...binding,
+                  attr: bindingOutputs[i],
+                })),
+                providerVersion: node.provider.version ?? 0,
+                downstream: node.downstream,
+              });
+            }
 
-                if (node.action === "noop") {
-                  return (yield* state.get(id))?.output;
-                } else if (node.action === "create") {
-                  let attr: any;
-                  if (node.provider.precreate) {
-                    yield* Effect.logDebug("precreate", id);
-                    // stub the resource prior to resolving upstream resources or bindings if a stub is available
-                    attr = yield* node.provider.precreate({
-                      id,
-                      news: node.news,
-                      session: scopedSession,
-                    });
-                  }
-
-                  yield* Effect.logDebug("create", id);
-                  return yield* createOrUpdate({
-                    node,
-                    attr,
-                    phase: "create",
-                  });
-                } else if (node.action === "update") {
-                  yield* Effect.logDebug("update", id);
-                  return yield* createOrUpdate({
-                    node,
-                    attr: node.attributes,
-                    phase: "update",
-                  });
-                } else if (node.action === "delete") {
-                  yield* Effect.logDebug("delete", id);
-                  yield* Effect.all(
-                    node.downstream.map((dep) =>
-                      dep in plan.resources
-                        ? apply(
-                            plan.resources[
-                              dep
-                            ] as P["resources"][keyof P["resources"]],
-                          )
-                        : Effect.void,
-                    ),
-                  );
-                  yield* report("deleting");
-
-                  return yield* node.provider
-                    .delete({
-                      id,
-                      olds: node.olds,
-                      output: node.output,
-                      session: scopedSession,
-                      bindings: [],
-                    })
-                    .pipe(
-                      Effect.flatMap(() => state.delete(id)),
-                      Effect.tap(() => report("deleted")),
-                    );
-                } else if (node.action === "replace") {
-                  const destroy = Effect.gen(function* () {
-                    yield* report("deleting");
-                    return yield* node.provider.delete({
-                      id,
-                      olds: node.olds,
-                      output: node.output,
-                      session: scopedSession,
-                      bindings: [],
-                    });
-                  });
-                  const create = Effect.gen(function* () {
-                    yield* report("creating");
-                    return yield* (
-                      node.provider
-                        .create({
-                          id,
-                          news: node.news,
-                          // TODO(sam): these need to only include attach actions
-                          bindings: yield* attachBindings({
-                            resource,
-                            bindings: node.bindings,
-                            target: {
-                              id,
-                              props: node.news,
-                              attr: node.attributes,
-                            },
-                          }),
-                          session: scopedSession,
-                        })
-                        // TODO(sam): delete and create will conflict here, we need to extend the state store for replace
-                        .pipe(
-                          checkpoint,
-                          Effect.tap(() => report("created")),
-                        )
-                    );
-                  });
-                  if (!node.deleteFirst) {
-                    yield* destroy;
-                    return outputs;
-                  } else {
-                    yield* destroy;
-                    return yield* create;
-                  }
-                }
-              }),
-            ));
-          }) as Effect.Effect<any, never, never>;
+            yield* report("updated");
+
+            return attr;
+          } else if (node.action === "replace") {
+            if (node.state.status === "replaced") {
+              // we've already created the replacement resource, return the output
+              return node.state.attr;
+            }
+            let state: ReplacingResourceState;
+            if (node.state.status !== "replacing") {
+              yield* commit<ReplacingResourceState>(
+                (state = {
+                  status: "replacing",
+                  logicalId: id,
+                  instanceId,
+                  resourceType: node.resource.type,
+                  props: node.props,
+                  attr: node.state.attr,
+                  providerVersion: node.provider.version ?? 0,
+                  deleteFirst: node.deleteFirst,
+                  old: node.state,
+                  downstream: node.downstream,
+                }),
+              );
+            } else {
+              state = node.state;
+            }
+            const upstream = Object.fromEntries(
+              yield* Effect.all(
+                Object.entries(Output.resolveUpstream(node.props)).map(([id]) =>
+                  resolveUpstream(id).pipe(
+                    Effect.map(({ upstreamAttr }) => [id, upstreamAttr]),
+                  ),
+                ),
+              ),
+            );
+            const news = (yield* Output.evaluate(
+              node.props,
+              upstream,
+            )) as Record<string, any>;
+
+            const checkpoint = <
+              S extends ReplacingResourceState | ReplacedResourceState,
+            >({
+              status,
+              attr,
+              bindings,
+            }: Pick<S, "status" | "attr" | "bindings">) =>
+              commit<S>({
+                status,
+                logicalId: id,
+                instanceId,
+                resourceType: node.resource.type,
+                props: news,
+                attr,
+                providerVersion: node.provider.version ?? 0,
+                bindings: bindings ?? node.bindings,
+                downstream: node.downstream,
+                old: state.old,
+                deleteFirst: node.deleteFirst,
+              } as S);
+
+            let attr: any;
+            if (
+              node.provider.precreate &&
+              // pre-create is only designed to ensure the resource exists, if we have state.attr, then it already exists and should be skipped
+              node.state?.attr === undefined
+            ) {
+              yield* report("pre-creating");
+
+              // stub the resource prior to resolving upstream resources or bindings if a stub is available
+              attr = yield* node.provider.precreate({
+                id,
+                news: node.props,
+                session: scopedSession,
+                instanceId,
+              });
+
+              yield* checkpoint({
+                status: "replacing",
+                attr,
+              });
+            }
 
-        const nodes = [
-          ...Object.entries(plan.resources),
-          ...Object.entries(plan.deletions),
-        ];
+            yield* report("attaching");
+
+            let bindingOutputs = yield* attachBindings({
+              resource,
+              bindings: node.bindings,
+              target: {
+                id,
+                props: news,
+                attr,
+              },
+            });
+
+            yield* report("creating replacement");
+
+            attr = yield* node.provider.create({
+              id,
+              news,
+              instanceId,
+              bindings: bindingOutputs,
+              session: scopedSession,
+            });
+
+            yield* checkpoint({
+              status: "replacing",
+              attr,
+            });
+
+            yield* report("post-attach");
+
+            bindingOutputs = yield* postAttachBindings({
+              resource,
+              bindings: node.bindings,
+              bindingOutputs,
+              target: {
+                id,
+                props: news,
+                attr,
+              },
+            });
+
+            yield* checkpoint<ReplacedResourceState>({
+              status: "replaced",
+              attr,
+              bindings: node.bindings.map((binding, i) => ({
+                ...binding,
+                attr: bindingOutputs[i],
+              })),
+            });
+
+            yield* report("created");
+            return attr;
+          }
+          // @ts-expect-error
+          return yield* Effect.dieMessage(`Unknown action: ${node.action}`);
+        }),
+      ));
+    }) as Effect.Effect<any, never, never>;
+
+  return Object.fromEntries(
+    yield* Effect.all(
+      Object.entries(plan.resources).map(
+        Effect.fn(function* ([id, node]) {
+          return [id, yield* apply(node)];
+        }),
+      ),
+    ),
+  );
+});
+
+const collectGarbage = Effect.fnUntraced(function* (
+  plan: IPlan,
+  session: PlanStatusSession,
+) {
+  const state = yield* State;
+  const app = yield* App;
+
+  const deletions: {
+    [logicalId in string]: Effect.Effect<void, StateStoreError, never>;
+  } = {};
+
+  // delete all replaced resources
+  const replacedResources = yield* state.getReplacedResources({
+    stack: app.name,
+    stage: app.stage,
+  });
+
+  const deletionGraph = {
+    ...plan.deletions,
+    ...Object.fromEntries(
+      replacedResources.map((replaced) => [replaced.logicalId, replaced]),
+    ),
+  };
+
+  const deleteResource: (
+    node: Delete<Resource> | ReplacedResourceState,
+  ) => Effect.Effect<void, StateStoreError, never> = Effect.fnUntraced(
+    function* (node: Delete<Resource> | ReplacedResourceState) {
+      const isDeleteNode = (
+        node: Delete<Resource> | ReplacedResourceState,
+      ): node is Delete<Resource> => "action" in node;
+
+      const {
+        logicalId,
+        resourceType,
+        instanceId,
+        downstream,
+        props,
+        attr,
+        provider,
+      } = isDeleteNode(node)
+        ? {
+            logicalId: node.resource.id,
+            resourceType: node.resource.type,
+            instanceId: node.state.instanceId,
+            downstream: node.downstream,
+            props: node.state.props,
+            attr: node.state.attr,
+            provider: node.provider,
+          }
+        : {
+            logicalId: node.logicalId,
+            resourceType: node.old.resourceType,
+            instanceId: node.old.instanceId,
+            downstream: node.old.downstream,
+            props: node.old.props,
+            attr: node.old.attr,
+            provider: yield* getProviderByType(node.old.resourceType),
+          };
 
-        const resources: any = Object.fromEntries(
+      const commit = <State extends ResourceState>(value: State) =>
+        state.set({
+          stack: app.name,
+          stage: app.stage,
+          resourceId: logicalId,
+          value,
+        });
+
+      const report = (status: ApplyStatus) =>
+        session.emit({
+          kind: "status-change",
+          id: logicalId,
+          type: resourceType,
+          status,
+        });
+
+      const scopedSession = {
+        ...session,
+        note: (note: string) =>
+          session.emit({
+            id: logicalId,
+            kind: "annotate",
+            message: note,
+          }),
+      } satisfies ScopedPlanStatusSession;
+
+      return yield* (deletions[logicalId] ??= yield* Effect.cached(
+        Effect.gen(function* () {
           yield* Effect.all(
-            nodes.map(
-              Effect.fn(function* ([id, node]) {
-                return [id, yield* apply(node as CRUD)];
-              }),
+            downstream.map((dep) =>
+              dep in deletionGraph
+                ? deleteResource(deletionGraph[dep] as Delete<Resource>)
+                : Effect.void,
             ),
-          ),
-        );
-        yield* done();
-        if (Object.keys(plan.resources).length === 0) {
-          // all resources are deleted, return undefined
-          return undefined;
-        }
-        return resources;
-      }),
-    ),
-  ) as Effect.Effect<
-    "update" extends P["phase"]
-      ?
-          | {
-              [id in keyof P["resources"]]: P["resources"][id] extends
-                | Delete<Resource>
-                | undefined
-                | never
-                ? never
-                : Simplify<P["resources"][id]["resource"]["attr"]>;
-            }
-          // union distribution isn't happening, so we gotta add this additional void here just in case
-          | ("destroy" extends P["phase"] ? void : never)
-      : void,
-    Err | PlanRejected,
-    Req
-  >;
+          );
+
+          yield* report("deleting");
+
+          if (isDeleteNode(node)) {
+            yield* commit<DeletingResourceState>({
+              status: "deleting",
+              logicalId,
+              instanceId,
+              resourceType,
+              props,
+              attr,
+              downstream,
+              providerVersion: provider.version ?? 0,
+              bindings: node.bindings,
+            });
+          }
+
+          yield* provider.delete({
+            id: logicalId,
+            instanceId,
+            olds: props as never,
+            output: attr,
+            session: scopedSession,
+            bindings: [],
+          });
+
+          if (isDeleteNode(node)) {
+            // TODO(sam): should we commit a tombstone instead? and then clean up tombstones after all deletions are complete?
+            yield* state.delete({
+              stack: app.name,
+              stage: app.stage,
+              resourceId: logicalId,
+            });
+            yield* report("deleted");
+          } else {
+            yield* commit<CreatedResourceState>({
+              status: "created",
+              logicalId,
+              instanceId,
+              resourceType,
+              props: node.props,
+              attr: node.attr,
+              providerVersion: provider.version ?? 0,
+              downstream: node.downstream,
+              bindings: node.bindings,
+            });
+            yield* report("replaced");
+          }
+        }),
+      ));
+    },
+  );
+
+  yield* Effect.all(
+    Object.values(deletionGraph)
+      .filter((node) => node !== undefined)
+      .map(deleteResource),
+  );
+});