alchemy-effect 0.3.0 → 0.4.0

package/lib/apply.d.ts

@@ -1,12 +1,12 @@
 import * as Effect from "effect/Effect";
 import type { Simplify } from "effect/Types";
+import { App } from "./app.ts";
+import { CLI } from "./cli/service.ts";
 import { type Delete, type DerivePlan, type IPlan, type Providers } from "./plan.ts";
 import type { Instance } from "./policy.ts";
 import type { AnyResource, Resource } from "./resource.ts";
 import type { AnyService } from "./service.ts";
-import { State } from "./state.ts";
-import { App } from "./app.ts";
-import { CLI } from "./cli/service.ts";
+import { State, StateStoreError } from "./state.ts";
 export type ApplyEffect<P extends IPlan, Err = never, Req = never> = Effect.Effect<{
     [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k];
 }, Err, Req>;
@@ -14,5 +14,5 @@ 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 declare const apply: <const Resources extends (AnyService | AnyResource)[] = never>(...resources: Resources) => ApplyEffect<DerivePlan<Instance<Resources[number]>>, never, State | Providers<Instance<Resources[number]>>>;
-export declare const applyPlan: <P extends IPlan>(plan: P) => Effect.Effect<{ [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k]; } | undefined, never, State | App | CLI>;
+export declare const applyPlan: <P extends IPlan>(plan: P) => Effect.Effect<{ [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k]; } | undefined, StateStoreError, State | App | CLI>;
 //# sourceMappingURL=apply.d.ts.map

package/lib/apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../src/apply.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI7C,OAAO,EAKL,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,SAAS,EAEf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B,OAAO,EAAgC,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAErE,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,KAAK,EACf,GAAG,GAAG,KAAK,EACX,GAAG,GAAG,KAAK,IACT,MAAM,CAAC,MAAM,CACf;KACG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C,EACD,GAAG,EACH,GAAG,CACJ,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK,IAAI;KACxC,EAAE,IAAI,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,SAC5C,MAAM,CAAC,QAAQ,CAAC,GAChB,SAAS,GACT,KAAK,GACL,KAAK,GACL,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;CACrD,CAAC;AAEF,eAAO,MAAM,KAAK,GAChB,KAAK,CAAC,SAAS,SAAS,CAAC,UAAU,GAAG,WAAW,CAAC,EAAE,GAAG,KAAK,EAE5D,GAAG,WAAW,SAAS,KACtB,WAAW,CACZ,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EACvC,KAAK,EACL,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAEc,CAAC;AAE/D,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,KAAK,EAAE,MAAM,CAAC,sBAoZ3C,CAAC,sFAEJ,CAAC"}
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../src/apply.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B,OAAO,EAEL,GAAG,EAEJ,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAIL,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EASL,KAAK,EACL,eAAe,EAChB,MAAM,YAAY,CAAC;AAIpB,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,KAAK,EACf,GAAG,GAAG,KAAK,EACX,GAAG,GAAG,KAAK,IACT,MAAM,CAAC,MAAM,CACf;KACG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C,EACD,GAAG,EACH,GAAG,CACJ,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK,IAAI;KACxC,EAAE,IAAI,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,SAC5C,MAAM,CAAC,QAAQ,CAAC,GAChB,SAAS,GACT,KAAK,GACL,KAAK,GACL,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;CACrD,CAAC;AAEF,eAAO,MAAM,KAAK,GAChB,KAAK,CAAC,SAAS,SAAS,CAAC,UAAU,GAAG,WAAW,CAAC,EAAE,GAAG,KAAK,EAE5D,GAAG,WAAW,SAAS,KACtB,WAAW,CACZ,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EACvC,KAAK,EACL,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAKtC,CAAC;AAEX,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,KAAK,EAAE,MAAM,CAAC,sBAqB3C,CAAC,gGAEJ,CAAC"}

package/lib/apply.js

@@ -1,20 +1,35 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import { App } from "./app.js";
+import { CLI, } from "./cli/service.js";
+import { generateInstanceId } from "./instance-id.js";
 import * as Output from "./output.js";
 import { plan, } from "./plan.js";
-import { State } from "./state.js";
-import { App } from "./app.js";
+import { State, StateStoreError, } from "./state.js";
 import { asEffect } from "./util.js";
-import { CLI } from "./cli/service.js";
-export const apply = (...resources) => plan(...resources).pipe(Effect.flatMap(applyPlan));
+import { getProviderByType } from "./provider.js";
+export const apply = (...resources) => plan(...resources).pipe(Effect.flatMap((p) => applyPlan(p)));
 export const applyPlan = (plan) => 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;
+});
+const expandAndPivot = Effect.fnUntraced(function* (plan, session) {
     const state = yield* State;
-    // TODO(sam): rename terminology to Stack
     const app = yield* App;
     const outputs = {};
-    const cli = yield* CLI;
-    const session = yield* cli.startApplySession(plan);
-    const { emit, done } = session;
     const resolveUpstream = Effect.fn(function* (resourceId) {
         const upstreamNode = plan.resources[resourceId];
         const upstreamAttr = upstreamNode
@@ -88,21 +103,12 @@ export const applyPlan = (plan) => Effect.gen(function* () {
         return oldBindingOutput;
     })));
     const apply = (node) => Effect.gen(function* () {
-        const saveState = ({ output, bindings = node.bindings, news, }) => state
-            .set({
+        const commit = (value) => state.set({
             stack: app.name,
             stage: app.stage,
             resourceId: node.resource.id,
-            value: {
-                id: node.resource.id,
-                type: node.resource.type,
-                status: node.action === "create" ? "created" : "updated",
-                props: news,
-                output,
-                bindings,
-            },
-        })
-            .pipe(Effect.map(() => output));
+            value,
+        });
         const id = node.resource.id;
         const resource = node.resource;
         const scopedSession = {
@@ -114,16 +120,92 @@ export const applyPlan = (plan) => Effect.gen(function* () {
             }),
         };
         return yield* (outputs[id] ??= yield* Effect.cached(Effect.gen(function* () {
-            const report = (status) => emit({
+            const report = (status) => session.emit({
                 kind: "status-change",
                 id,
                 type: node.resource.type,
                 status,
             });
-            const createOrUpdate = Effect.fn(function* ({ node, attr, phase, }) {
-                const upstream = Object.fromEntries(yield* Effect.all(Object.entries(Output.resolveUpstream(node.news)).map(([id]) => resolveUpstream(id).pipe(Effect.map(({ upstreamAttr }) => [id, upstreamAttr])))));
-                const news = yield* Output.evaluate(node.news, upstream);
-                yield* report(phase === "create" ? "creating" : "updating");
+            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 instanceId = yield* Effect.gen(function* () {
+                if (node.action === "create" && !node.state?.instanceId) {
+                    const instanceId = yield* generateInstanceId();
+                    yield* commit({
+                        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({
+                        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));
+                const checkpoint = (attr) => commit({
+                    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);
+                }
+                let attr;
+                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,
@@ -133,21 +215,16 @@ export const applyPlan = (plan) => Effect.gen(function* () {
                         attr,
                     },
                 });
-                const output = yield* (phase === "create" ? node.provider.create : node.provider.update)({
+                yield* report("creating");
+                attr = yield* node.provider.create({
                     id,
                     news,
+                    instanceId,
                     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")));
+                });
+                yield* checkpoint(attr);
+                yield* report("post-attach");
                 bindingOutputs = yield* postAttachBindings({
                     resource,
                     bindings: node.bindings,
@@ -158,125 +235,328 @@ export const applyPlan = (plan) => Effect.gen(function* () {
                         attr,
                     },
                 });
-                yield* saveState({
-                    news,
-                    output,
+                yield* commit({
+                    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,
                 });
-                return output;
-            });
-            if (node.action === "noop") {
-                return (yield* state.get({
-                    stack: app.name,
-                    stage: app.stage,
-                    resourceId: id,
-                }))?.output;
+                yield* report("created");
+                return attr;
             }
-            else if (node.action === "create") {
+            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));
+                const checkpoint = (attr) => {
+                    if (node.state.status === "replaced") {
+                        return commit({
+                            ...node.state,
+                            attr,
+                            props: news,
+                        });
+                    }
+                    else {
+                        return commit({
+                            status: "updating",
+                            logicalId: id,
+                            instanceId,
+                            resourceType: node.resource.type,
+                            props: news,
+                            attr,
+                            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({
+                        ...node.state,
+                        attr,
+                        props: news,
+                    });
+                }
+                else {
+                    yield* commit({
+                        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,
+                    });
+                }
+                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;
+                if (node.state.status !== "replacing") {
+                    yield* commit((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));
+                const checkpoint = ({ status, attr, bindings, }) => commit({
+                    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,
+                });
                 let attr;
-                if (node.provider.precreate) {
-                    yield* Effect.logDebug("precreate", id);
+                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.news,
+                        news: node.props,
                         session: scopedSession,
+                        instanceId,
+                    });
+                    yield* checkpoint({
+                        status: "replacing",
+                        attr,
                     });
                 }
-                yield* Effect.logDebug("create", id);
-                return yield* createOrUpdate({
-                    node,
+                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({
+                    status: "replaced",
                     attr,
-                    phase: "create",
+                    bindings: node.bindings.map((binding, i) => ({
+                        ...binding,
+                        attr: bindingOutputs[i],
+                    })),
                 });
+                yield* report("created");
+                return attr;
             }
-            else if (node.action === "update") {
-                yield* Effect.logDebug("update", id);
-                return yield* createOrUpdate({
-                    node,
-                    attr: node.attributes,
-                    phase: "update",
+            // @ts-expect-error
+            return yield* Effect.dieMessage(`Unknown action: ${node.action}`);
+        })));
+    });
+    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, session) {
+    const state = yield* State;
+    const app = yield* App;
+    const deletions = {};
+    // 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 = Effect.fnUntraced(function* (node) {
+        const isDeleteNode = (node) => "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 commit = (value) => state.set({
+            stack: app.name,
+            stage: app.stage,
+            resourceId: logicalId,
+            value,
+        });
+        const report = (status) => session.emit({
+            kind: "status-change",
+            id: logicalId,
+            type: resourceType,
+            status,
+        });
+        const scopedSession = {
+            ...session,
+            note: (note) => session.emit({
+                id: logicalId,
+                kind: "annotate",
+                message: note,
+            }),
+        };
+        return yield* (deletions[logicalId] ??= yield* Effect.cached(Effect.gen(function* () {
+            yield* Effect.all(downstream.map((dep) => dep in deletionGraph
+                ? deleteResource(deletionGraph[dep])
+                : Effect.void));
+            yield* report("deleting");
+            if (isDeleteNode(node)) {
+                yield* commit({
+                    status: "deleting",
+                    logicalId,
+                    instanceId,
+                    resourceType,
+                    props,
+                    attr,
+                    downstream,
+                    providerVersion: provider.version ?? 0,
+                    bindings: node.bindings,
                 });
             }
-            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])
-                    : 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({
+            yield* provider.delete({
+                id: logicalId,
+                instanceId,
+                olds: props,
+                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: 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: [],
-                    });
+                    resourceId: logicalId,
                 });
-                const create = Effect.gen(function* () {
-                    yield* report("creating");
-                    // TODO(sam): delete and create will conflict here, we need to extend the state store for replace
-                    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,
-                                // TODO(sam): resolve the news
-                                props: node.news,
-                                attr: node.attributes,
-                            },
-                        }),
-                        session: scopedSession,
-                    })
-                        .pipe(Effect.tap((output) => saveState({ news: node.news, output })));
+                yield* report("deleted");
+            }
+            else {
+                yield* commit({
+                    status: "created",
+                    logicalId,
+                    instanceId,
+                    resourceType,
+                    props: node.props,
+                    attr: node.attr,
+                    providerVersion: provider.version ?? 0,
+                    downstream: node.downstream,
+                    bindings: node.bindings,
                 });
-                if (!node.deleteFirst) {
-                    yield* destroy;
-                    return outputs;
-                }
-                else {
-                    yield* destroy;
-                    return yield* create;
-                }
+                yield* report("replaced");
             }
         })));
     });
-    const nodes = [
-        ...Object.entries(plan.resources),
-        ...Object.entries(plan.deletions),
-    ];
-    const resources = Object.fromEntries(yield* Effect.all(nodes.map(Effect.fn(function* ([id, node]) {
-        return [id, yield* apply(node)];
-    }))));
-    yield* done();
-    if (Object.keys(plan.resources).length === 0) {
-        // all resources are deleted, return undefined
-        return undefined;
-    }
-    return resources;
+    yield* Effect.all(Object.values(deletionGraph)
+        .filter((node) => node !== undefined)
+        .map(deleteResource));
 });
 //# sourceMappingURL=apply.js.map