alchemy-effect 0.2.0 → 0.4.0

package/lib/plan.js

@@ -2,9 +2,12 @@ import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import { omit } from "effect/Struct";
-import {} from "./provider.js";
+import { App } from "./app.js";
+import * as Output from "./output.js";
+import { getProviderByType } from "./provider.js";
 import { isService } from "./service.js";
-import { State, StateStoreError } from "./state.js";
+import { State, StateStoreError, } from "./state.js";
+import { asEffect } from "./util.js";
 export const isBindNode = (node) => {
     return (node &&
         typeof node === "object" &&
@@ -20,187 +23,443 @@ export const isCRUD = (node) => {
             node.action === "replace" ||
             node.action === "noop"));
 };
-const Node = (node) => ({
-    ...node,
-    toString() {
-        return `${this.action.charAt(0).toUpperCase()}${this.action.slice(1)}(${this.resource})`;
-    },
-    [Symbol.toStringTag]() {
-        return this.toString();
-    },
-});
-export const plan = ({ phase, resources, }) => {
-    return Effect.gen(function* () {
-        const state = yield* State;
-        const resourceIds = yield* state.list();
-        const resourcesState = yield* Effect.all(resourceIds.map((id) => state.get(id)));
-        // map of resource ID -> its downstream dependencies (resources that depend on it)
-        const downstream = resourcesState
-            .filter((resource) => !!resource?.bindings)
-            .flatMap((resource) => resource.bindings.flatMap(({ binding }) => [
-            [binding.capability.resource.id, binding.capability.resource],
-        ]))
-            .reduce((acc, [id, resourceId]) => ({
-            ...acc,
-            [id]: [...(acc[id] ?? []), resourceId],
-        }), {});
-        const resourceGraph = phase === "update"
-            ? Object.fromEntries((yield* Effect.all(resources
-                .flatMap((resource) => [
-                ...(isService(resource)
-                    ? resource.props.bindings.capabilities.map((cap) => cap.resource)
-                    : []),
-                resource,
-            ])
-                .filter((node, i, arr) => arr.findIndex((n) => n.id === node.id) === i)
-                .map(Effect.fn(function* (node) {
-                const id = node.id;
-                const resource = node;
-                const news = resource.props;
-                const oldState = yield* state.get(id);
+export const plan = (..._resources) => Effect.gen(function* () {
+    const state = yield* State;
+    const findResources = (resource, visited) => {
+        if (visited.has(resource.id)) {
+            return [];
+        }
+        visited.add(resource.id);
+        const upstream = Object.values(Output.upstreamAny(resource.props));
+        return [
+            resource,
+            ...upstream,
+            ...upstream.flatMap((r) => findResources(r, visited)),
+        ];
+    };
+    const resources = _resources
+        .flatMap((r) => findResources(r, new Set()))
+        .filter((r, i, arr) => arr.findIndex((r2) => r2.id === r.id) === i);
+    // TODO(sam): rename terminology to Stack
+    const app = yield* App;
+    const resourceIds = yield* state.list({
+        stack: app.name,
+        stage: app.stage,
+    });
+    const oldResources = yield* Effect.all(resourceIds.map((id) => state.get({ stack: app.name, stage: app.stage, resourceId: id })));
+    const resolvedResources = {};
+    const resolveResource = (resourceExpr) => Effect.gen(function* () {
+        return yield* (resolvedResources[resourceExpr.src.id] ??=
+            yield* Effect.cached(Effect.gen(function* () {
+                const resource = resourceExpr.src;
                 const provider = yield* resource.provider.tag;
-                const bindings = isService(node)
-                    ? yield* diffBindings({
-                        oldState,
-                        bindings: node.props.bindings.bindings,
-                        target: {
-                            id: node.id,
-                            props: node.props,
-                            oldAttr: oldState?.output,
-                            oldProps: oldState?.props,
-                        },
-                    })
-                    : []; // TODO(sam): return undefined instead of empty array
-                if (oldState === undefined ||
-                    oldState.status === "creating") {
-                    return Node({
-                        action: "create",
-                        news,
-                        provider,
-                        resource,
-                        bindings,
-                        // phantom
-                        attributes: undefined,
-                    });
+                const props = yield* resolveInput(resource.props);
+                const oldState = yield* state.get({
+                    stack: app.name,
+                    stage: app.stage,
+                    resourceId: resource.id,
+                });
+                if (!oldState || oldState.status === "creating") {
+                    return resourceExpr;
                 }
-                const diff = provider.diff
-                    ? yield* provider.diff({
-                        id,
-                        olds: oldState.props,
-                        news,
-                        output: oldState.output,
+                const oldProps = oldState.status === "created" ||
+                    oldState.status === "updated" ||
+                    oldState.status === "replaced"
+                    ? // if we're in a stable state, then just use the props
+                        oldState.props
+                    : // if we failed to update or replace, compare with the last known stable props
+                        oldState.status === "updating" ||
+                            oldState.status === "replacing"
+                            ? oldState.old.props
+                            : // TODO(sam): it kinda doesn't make sense to diff with a "deleting" state
+                                oldState.props;
+                const diff = yield* provider.diff
+                    ? provider.diff({
+                        id: resource.id,
+                        olds: oldProps,
+                        instanceId: oldState.instanceId,
+                        news: props,
+                        output: oldState.attr,
                     })
-                    : undefined;
-                if (!diff && arePropsChanged(oldState, resource.props)) {
-                    return Node({
-                        action: "update",
-                        olds: oldState.props,
-                        news,
-                        output: oldState.output,
-                        provider,
-                        resource,
-                        bindings,
-                        // phantom
-                        attributes: undefined,
-                    });
+                    : Effect.succeed(undefined);
+                const stables = [
+                    ...(provider.stables ?? []),
+                    ...(diff?.stables ?? []),
+                ];
+                const withStables = (output) => stables.length > 0
+                    ? new Output.ResourceExpr(resourceExpr.src, Object.fromEntries(stables.map((stable) => [stable, output?.[stable]])))
+                    : // if there are no stable properties, treat every property as changed
+                        resourceExpr;
+                if (diff == null) {
+                    if (arePropsChanged(oldProps, props)) {
+                        // the props have changed but the provider did not provide any hints as to what is stable
+                        // so we must assume everything has changed
+                        return withStables(oldState?.attr);
+                    }
                 }
-                else if (diff?.action === "replace") {
-                    return Node({
-                        action: "replace",
-                        olds: oldState.props,
-                        news,
-                        output: oldState.output,
-                        provider,
-                        resource,
-                        bindings,
-                        // phantom
-                        attributes: undefined,
-                    });
+                else if (diff.action === "update") {
+                    return withStables(oldState?.attr);
                 }
-                else if (diff?.action === "update") {
-                    return Node({
-                        action: "update",
-                        olds: oldState.props,
-                        news,
-                        output: oldState.output,
-                        provider,
-                        resource,
-                        bindings,
-                        // phantom
-                        attributes: undefined,
-                    });
+                else if (diff.action === "replace") {
+                    return resourceExpr;
+                }
+                if (oldState.status === "created" ||
+                    oldState.status === "updated" ||
+                    oldState.status === "replaced") {
+                    // we can safely return the attributes if we know they have stabilized
+                    return oldState?.attr;
                 }
                 else {
-                    return Node({
-                        action: "noop",
-                        resource,
-                        bindings,
-                        // phantom
-                        attributes: undefined,
-                    });
+                    // we must assume the resource doesn't exist if it hasn't stabilized
+                    return resourceExpr;
                 }
-            })))).map((update) => [update.resource.id, update]))
-            : {};
-        const deletions = Object.fromEntries((yield* Effect.all((yield* state.list()).map(Effect.fn(function* (id) {
-            if (id in resourceGraph) {
-                return;
+            })));
+    });
+    const resolveInput = (input) => Effect.gen(function* () {
+        if (!input) {
+            return input;
+        }
+        else if (Output.isExpr(input)) {
+            return yield* resolveOutput(input);
+        }
+        else if (Array.isArray(input)) {
+            return yield* Effect.all(input.map(resolveInput));
+        }
+        else if (typeof input === "object") {
+            return Object.fromEntries(yield* Effect.all(Object.entries(input).map(([key, value]) => resolveInput(value).pipe(Effect.map((value) => [key, value])))));
+        }
+        return input;
+    });
+    const resolveOutput = (expr) => Effect.gen(function* () {
+        if (Output.isResourceExpr(expr)) {
+            return yield* resolveResource(expr);
+        }
+        else if (Output.isPropExpr(expr)) {
+            const upstream = yield* resolveOutput(expr.expr);
+            return upstream?.[expr.identifier];
+        }
+        else if (Output.isApplyExpr(expr)) {
+            const upstream = yield* resolveOutput(expr.expr);
+            return Output.hasOutputs(upstream) ? expr : expr.f(upstream);
+        }
+        else if (Output.isEffectExpr(expr)) {
+            const upstream = yield* resolveOutput(expr.expr);
+            return Output.hasOutputs(upstream) ? expr : yield* expr.f(upstream);
+        }
+        else if (Output.isAllExpr(expr)) {
+            return yield* Effect.all(expr.outs.map(resolveOutput));
+        }
+        return yield* Effect.die(new Error("Not implemented yet"));
+    });
+    // map of resource ID -> its downstream dependencies (resources that depend on it)
+    const oldDownstreamDependencies = Object.fromEntries(oldResources
+        .filter((resource) => !!resource)
+        .map((resource) => [resource.logicalId, resource.downstream]));
+    const newUpstreamDependencies = Object.fromEntries(resources.map((resource) => [
+        resource.id,
+        [
+            ...Object.values(Output.upstreamAny(resource.props)).map((r) => r.id),
+            ...(isService(resource)
+                ? resource.props.bindings.capabilities.map((cap) => cap.resource.id)
+                : []),
+        ],
+    ]));
+    const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => [
+        resource.id,
+        Object.entries(newUpstreamDependencies)
+            .filter(([_, downstream]) => downstream.includes(resource.id))
+            .map(([id]) => id),
+    ]));
+    const resourceGraph = Object.fromEntries((yield* Effect.all(resources
+        .flatMap((resource) => [
+        ...(isService(resource)
+            ? resource.props.bindings.capabilities.map((cap) => cap.resource)
+            : []),
+        ...Object.values(Output.upstreamAny(resource.props)),
+        resource,
+    ])
+        .filter((node, i, arr) => arr.findIndex((n) => n.id === node.id) === i)
+        .map(Effect.fn(function* (node) {
+        const id = node.id;
+        const resource = node;
+        const news = yield* resolveInput(resource.props);
+        const oldState = yield* state.get({
+            stack: app.name,
+            stage: app.stage,
+            resourceId: id,
+        });
+        const provider = yield* resource.provider.tag;
+        const downstream = newDownstreamDependencies[id] ?? [];
+        const bindings = isService(node)
+            ? yield* diffBindings({
+                oldState,
+                bindings: node.props.bindings.bindings,
+                target: {
+                    id: node.id,
+                    props: node.props,
+                    // TODO(sam): pick the right ones based on old status
+                    oldAttr: oldState?.attr,
+                    oldProps: oldState?.props,
+                },
+            })
+            : []; // TODO(sam): return undefined instead of empty array
+        const Node = (node) => ({
+            ...node,
+            provider,
+            resource,
+            bindings,
+            downstream,
+        });
+        // handle empty and intermediate (non-final) states:
+        if (oldState === undefined) {
+            return Node({
+                action: "create",
+                props: news,
+                state: oldState,
+            });
+        }
+        // TODO(sam): is this correct for all possible states a resource can be in?
+        const oldProps = oldState.props;
+        const diff = yield* asEffect(provider.diff
+            ? provider.diff({
+                id,
+                olds: oldProps,
+                instanceId: oldState.instanceId,
+                output: oldState.attr,
+                news,
+            })
+            : undefined).pipe(Effect.map((diff) => diff ??
+            {
+                action: arePropsChanged(oldProps, news)
+                    ? "update"
+                    : "noop",
+            }));
+        if (oldState.status === "creating") {
+            if (diff.action === "noop") {
+                // we're in the creating state and props are un-changed
+                // let's just continue where we left off
+                return Node({
+                    action: "create",
+                    props: news,
+                    state: oldState,
+                });
             }
-            const oldState = yield* state.get(id);
-            const context = yield* Effect.context();
-            if (oldState) {
-                const provider = context.unsafeMap.get(oldState?.type);
-                if (!provider) {
-                    yield* Effect.die(new Error(`Provider not found for ${oldState?.type}`));
-                }
-                return [
-                    id,
-                    {
-                        action: "delete",
-                        olds: oldState.props,
-                        output: oldState.output,
-                        provider,
-                        attributes: oldState?.output,
-                        // TODO(sam): Support Detach Bindings
-                        bindings: [],
-                        resource: {
-                            id: id,
-                            parent: undefined,
-                            type: oldState.type,
-                            attr: oldState.output,
-                            props: oldState.props,
-                        },
-                        downstream: downstream[id] ?? [],
+            else if (diff.action === "update") {
+                // props have changed in a way that is updatable
+                // again, just continue with the create
+                // TODO(sam): should we maybe try an update instead?
+                return Node({
+                    action: "create",
+                    props: news,
+                    state: oldState,
+                });
+            }
+            else {
+                // props have changed in an incompatible way
+                // because it's possible that an un-updatable resource has already been created
+                // we must use a replace step to create a new one and delete the potential old one
+                return Node({
+                    action: "replace",
+                    props: news,
+                    deleteFirst: diff.deleteFirst ?? false,
+                    state: oldState,
+                });
+            }
+        }
+        else if (oldState.status === "updating") {
+            // we started to update a resource but did not complete
+            if (diff.action === "update" || diff.action === "noop") {
+                return Node({
+                    action: "update",
+                    props: news,
+                    state: oldState,
+                });
+            }
+            else {
+                // we started to update a resource but now believe we should replace it
+                return Node({
+                    action: "replace",
+                    deleteFirst: diff.deleteFirst ?? false,
+                    props: news,
+                    // TODO(sam): can Apply handle replacements when the oldState is UpdatingResourceState?
+                    // -> or is there we do a provider.read to try and reconcile back to UpdatedResourceState?
+                    state: oldState,
+                });
+            }
+        }
+        else if (oldState.status === "replacing") {
+            // resource replacement started, but the replacement may or may not have been created
+            if (diff.action === "noop") {
+                // this is the stable case - noop means just continue with the replacement
+                return Node({
+                    action: "replace",
+                    deleteFirst: oldState.deleteFirst,
+                    props: news,
+                    state: oldState,
+                });
+            }
+            else if (diff.action === "update") {
+                // potential problem here - the props have changed since we tried to replace,
+                // but not enough to trigger another replacement. the resource provider should
+                // be designed as idempotent to converge to the right state when creating the new resource
+                // the newly generated instanceId is intended to assist with this
+                return Node({
+                    action: "replace",
+                    deleteFirst: oldState.deleteFirst,
+                    props: news,
+                    state: oldState,
+                });
+            }
+            else {
+                // ah shit, so we tried to replace the resource and then crashed
+                // now the props have changed again in such a way that the (maybe, maybe not)
+                // created resource should also be replaced
+                // TODO(sam): what should we do?
+                // 1. trigger a deletion of the potentially created resource
+                // 2. expect the resource provider to handle it idempotently?
+                // -> i don't think this case is fair to put on the resource provider
+                //    because if the resource was created, it's in a state that can't be updated
+                return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
+            }
+        }
+        else if (oldState.status === "replaced") {
+            // replacement has been created but we're not done cleaning up the old state
+            if (diff.action === "noop") {
+                // this is the stable case - noop means just continue cleaning up the replacement
+                return Node({
+                    action: "replace",
+                    deleteFirst: oldState.deleteFirst,
+                    props: news,
+                    state: oldState,
+                });
+            }
+            else if (diff.action === "update") {
+                // the replacement has been created but now also needs to be updated
+                // the resource provider should:
+                // 1. Update the newly created replacement resource
+                // 2. Then proceed as normal to delete the replaced resources (after all downstream references are updated)
+                return Node({
+                    action: "update",
+                    props: news,
+                    state: oldState,
+                });
+            }
+            else {
+                // the replacement has been created but now it needs to be replaced
+                // this is the worst-case scenario because downstream resources
+                // could have been been updated to point to the replaced resources
+                return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
+            }
+        }
+        else if (oldState.status === "deleting") {
+            if (diff.action === "noop" || diff.action === "update") {
+                // we're in a partially deleted state, it is unclear whether it was or was not deleted
+                // it should be safe to re-create it with the same instanceId?
+                return Node({
+                    action: "create",
+                    props: news,
+                    state: {
+                        ...oldState,
+                        status: "creating",
+                        props: news,
                     },
-                ];
+                });
             }
-        })))).filter((v) => !!v));
-        for (const [resourceId, deletion] of Object.entries(deletions)) {
-            const dependencies = deletion.downstream.filter((d) => d in resourceGraph);
-            if (dependencies.length > 0) {
-                return yield* Effect.fail(new DeleteResourceHasDownstreamDependencies({
-                    message: `Resource ${resourceId} has downstream dependencies`,
-                    resourceId,
-                    dependencies,
-                }));
+            else {
+                return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
             }
         }
-        return {
-            phase,
-            resources: resourceGraph,
-            deletions,
-        };
-    });
-};
-class DeleteResourceHasDownstreamDependencies extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {
+        else if (diff.action === "update") {
+            return Node({
+                action: "update",
+                props: news,
+                state: oldState,
+            });
+        }
+        else if (diff.action === "replace") {
+            return Node({
+                action: "replace",
+                props: news,
+                state: oldState,
+                deleteFirst: diff?.deleteFirst ?? false,
+            });
+        }
+        else {
+            return Node({
+                action: "noop",
+                state: oldState,
+            });
+        }
+    })))).map((update) => [update.resource.id, update]));
+    const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({ stack: app.name, stage: app.stage })).map(Effect.fn(function* (id) {
+        if (id in resourceGraph) {
+            return;
+        }
+        const oldState = yield* state.get({
+            stack: app.name,
+            stage: app.stage,
+            resourceId: id,
+        });
+        if (oldState) {
+            const provider = yield* getProviderByType(oldState.resourceType);
+            return [
+                id,
+                {
+                    action: "delete",
+                    state: oldState,
+                    // // TODO(sam): Support Detach Bindings
+                    bindings: [],
+                    provider,
+                    resource: {
+                        id: id,
+                        type: oldState.resourceType,
+                        attr: oldState.attr,
+                        props: oldState.props,
+                    },
+                    // TODO(sam): is it enough to just pass through oldState?
+                    downstream: oldDownstreamDependencies[id] ?? [],
+                },
+            ];
+        }
+    })))).filter((v) => !!v));
+    for (const [resourceId, deletion] of Object.entries(deletions)) {
+        const dependencies = deletion.state.downstream.filter((d) => d in resourceGraph);
+        if (dependencies.length > 0) {
+            return yield* Effect.fail(new DeleteResourceHasDownstreamDependencies({
+                message: `Resource ${resourceId} has downstream dependencies`,
+                resourceId,
+                dependencies,
+            }));
+        }
+    }
+    return {
+        resources: resourceGraph,
+        deletions,
+    };
+});
+export class CannotReplacePartiallyReplacedResource extends Data.TaggedError("CannotReplacePartiallyReplacedResource") {
+    constructor(logicalId) {
+        super({
+            message: `Resource '${logicalId}' did not finish being replaced in a previous deployment ` +
+                `and is expected to be replaced again in this deployment. ` +
+                `You should revert its properties and try again after a successful deployment.`,
+            logicalId,
+        });
+    }
 }
-const arePropsChanged = (oldState, newProps) => {
-    return (JSON.stringify(omit(oldState?.props ?? {}, "bindings")) !==
-        JSON.stringify(omit((newProps ?? {}), "bindings")));
+export class DeleteResourceHasDownstreamDependencies extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {
+}
+const arePropsChanged = (oldProps, newProps) => {
+    return (Output.hasOutputs(newProps) ||
+        JSON.stringify(omit((oldProps ?? {}), "bindings")) !==
+            JSON.stringify(omit((newProps ?? {}), "bindings")));
 };
 const diffBindings = Effect.fn(function* ({ oldState, bindings, target, }) {
     // const actions: BindNode[] = [];
     const oldBindings = oldState?.bindings;
-    const oldSids = new Set(oldBindings?.map(({ binding }) => binding.capability.sid));
+    // const oldSids = new Set(
+    //   oldBindings?.map(({ binding }) => binding.capability.sid),
+    // );
     const diffBinding = Effect.fn(function* (binding) {
         const cap = binding.capability;
         const sid = cap.sid ?? `${cap.action}:${cap.resource.ID}`;
@@ -277,7 +536,7 @@ const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldB
                 id: oldCap.resource.id,
                 props: newCap.resource.props,
                 oldProps: oldState?.props,
-                oldAttr: oldState?.output,
+                oldAttr: oldState?.attr,
             },
             props: newBinding.props,
             attr: oldBinding.attr,
@@ -297,4 +556,83 @@ const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldB
 });
 // TODO(sam): compare props
 // oldBinding.props !== newBinding.props;
+/**
+ * Print a plan in a human-readable format that shows the graph topology.
+ */
+export const printPlan = (plan) => {
+    const lines = [];
+    const allNodes = { ...plan.resources, ...plan.deletions };
+    // Build reverse mapping: upstream -> downstream
+    const upstreamMap = {};
+    for (const [id] of Object.entries(allNodes)) {
+        upstreamMap[id] = [];
+    }
+    for (const [id, node] of Object.entries(allNodes)) {
+        if (!node)
+            continue;
+        for (const downstreamId of node.state?.downstream ?? []) {
+            if (upstreamMap[downstreamId]) {
+                upstreamMap[downstreamId].push(id);
+            }
+        }
+    }
+    // Action symbols
+    const actionSymbol = (action) => {
+        switch (action) {
+            case "create":
+                return "+";
+            case "update":
+                return "~";
+            case "delete":
+                return "-";
+            case "replace":
+                return "±";
+            case "noop":
+                return "=";
+            default:
+                return "?";
+        }
+    };
+    // Print header
+    lines.push("╔════════════════════════════════════════════════════════════════╗");
+    lines.push("║                           PLAN                                 ║");
+    lines.push("╠════════════════════════════════════════════════════════════════╣");
+    lines.push("║ Legend: + create, ~ update, - delete, ± replace, = noop        ║");
+    lines.push("╚════════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // Print resources section
+    lines.push("┌─ Resources ────────────────────────────────────────────────────┐");
+    const resourceIds = Object.keys(plan.resources).sort();
+    for (const id of resourceIds) {
+        const node = plan.resources[id];
+        const symbol = actionSymbol(node.action);
+        const type = node.resource?.type ?? "unknown";
+        const downstream = node.state?.downstream?.length
+            ? ` → [${node.state?.downstream.join(", ")}]`
+            : "";
+        lines.push(`│ [${symbol}] ${id} (${type})${downstream}`);
+    }
+    if (resourceIds.length === 0) {
+        lines.push("│ (none)");
+    }
+    lines.push("└────────────────────────────────────────────────────────────────┘");
+    lines.push("");
+    // Print deletions section
+    lines.push("┌─ Deletions ────────────────────────────────────────────────────┐");
+    const deletionIds = Object.keys(plan.deletions).sort();
+    for (const id of deletionIds) {
+        const node = plan.deletions[id];
+        const type = node.resource?.type ?? "unknown";
+        const downstream = node.state.downstream?.length
+            ? ` → [${node.state.downstream.join(", ")}]`
+            : "";
+        lines.push(`│ [-] ${id} (${type})${downstream}`);
+    }
+    if (deletionIds.length === 0) {
+        lines.push("│ (none)");
+    }
+    lines.push("└────────────────────────────────────────────────────────────────┘");
+    lines.push("");
+    return lines.join("\n");
+};
 //# sourceMappingURL=plan.js.map