alchemy-effect 0.5.0 → 0.6.2

package/lib/plan.js

@@ -1,686 +0,0 @@
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { omit } from "effect/Struct";
-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 { asEffect } from "./util.js";
-import { InstanceId } from "./instance-id.js";
-export const isBindNode = (node) => {
-    return (node &&
-        typeof node === "object" &&
-        (node.action === "attach" ||
-            node.action === "detach" ||
-            node.action === "noop"));
-};
-export const isCRUD = (node) => {
-    return (node &&
-        typeof node === "object" &&
-        (node.action === "create" ||
-            node.action === "update" ||
-            node.action === "replace" ||
-            node.action === "noop"));
-};
-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 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 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,
-                    })
-                        .pipe(Effect.provide(Layer.succeed(InstanceId, oldState.instanceId)))
-                    : 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 === "update") {
-                    return withStables(oldState?.attr);
-                }
-                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 {
-                    // we must assume the resource doesn't exist if it hasn't stabilized
-                    return resourceExpr;
-                }
-            })));
-    });
-    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,
-            });
-        }
-        else if (oldState.status === "creating" &&
-            oldState.attr === undefined) {
-            if (provider.read) {
-                const attr = yield* provider.read({
-                    id,
-                    instanceId: oldState.instanceId,
-                    olds: oldState.props,
-                    output: oldState.attr,
-                    bindings,
-                });
-                if (attr) {
-                    return Node({
-                        action: "create",
-                        props: news,
-                        state: { ...oldState, attr },
-                    });
-                }
-            }
-        }
-        // 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,
-            })
-                .pipe(Effect.provide(Layer.succeed(InstanceId, oldState.instanceId)))
-            : 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,
-                });
-            }
-            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,
-                    },
-                });
-            }
-            else {
-                return yield* Effect.fail(new CannotReplacePartiallyReplacedResource(id));
-            }
-        }
-        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,
-        });
-        let attr = oldState?.attr;
-        if (oldState) {
-            const provider = yield* getProviderByType(oldState.resourceType);
-            if (oldState.attr === undefined) {
-                if (provider.read) {
-                    attr = yield* provider
-                        .read({
-                        id,
-                        instanceId: oldState.instanceId,
-                        olds: oldState.props,
-                        output: oldState.attr,
-                        bindings: oldState.bindings ?? [],
-                    })
-                        .pipe(Effect.provide(Layer.succeed(InstanceId, oldState.instanceId)));
-                }
-                if (attr === undefined) {
-                    // skip deletion if we have no record of any attributes
-                    // TODO(sam): should we open up provider.delete to accept undefined and let it try and generate a physical name and delete?
-                    return undefined;
-                }
-            }
-            return [
-                id,
-                {
-                    action: "delete",
-                    state: { ...oldState, attr },
-                    // // TODO(sam): Support Detach Bindings
-                    bindings: [],
-                    provider,
-                    resource: {
-                        id: id,
-                        type: oldState.resourceType,
-                        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,
-        });
-    }
-}
-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 diffBinding = Effect.fn(function* (binding) {
-        const cap = binding.capability;
-        const sid = cap.sid ?? `${cap.action}:${cap.resource.ID}`;
-        // Find potential oldBinding for this sid
-        const oldBinding = oldBindings?.find(({ binding }) => binding.capability.sid === sid);
-        if (!oldBinding) {
-            return {
-                action: "attach",
-                binding,
-                attr: undefined,
-                olds: undefined,
-            };
-        }
-        const diff = yield* isBindingDiff({
-            target,
-            oldBinding,
-            newBinding: binding,
-        });
-        // if (diff === false) {
-        // } else if (diff === true) {
-        //   return {
-        //     action: "attach",
-        //     binding,
-        //     olds: oldBinding,
-        //   } satisfies Attach<AnyBinding>;
-        // }
-        if (diff.action === "replace") {
-            return yield* Effect.die(new Error("Replace binding not yet supported"));
-            // TODO(sam): implement support for replacing bindings
-            // return {
-            //   action: "replace",
-            //   binding,
-            //   olds: oldBinding,
-            // };
-        }
-        else if (diff?.action === "update") {
-            return {
-                action: "reattach",
-                binding,
-                olds: oldBinding,
-                attr: oldBinding.attr,
-            };
-        }
-        return {
-            action: "noop",
-            binding,
-            attr: oldBinding.attr,
-        };
-    });
-    return (yield* Effect.all(bindings.map(diffBinding))).filter((action) => action !== null);
-});
-const isBindingDiff = Effect.fn(function* ({ target, oldBinding: { binding: oldBinding }, newBinding, }) {
-    const oldCap = oldBinding.capability;
-    const newCap = newBinding.capability;
-    if (
-    // if the binding provider has changed
-    oldBinding.tag !== newBinding.tag ||
-        // if it points to a totally different resource, we should replace
-        oldCap?.resource?.id !== newCap?.resource?.id ||
-        // if it is a different action
-        oldCap.action !== newCap.action) {
-        // then we must replace (we need to detach and attach with different bindings or to different resources)
-        return {
-            action: "replace",
-        };
-    }
-    const binding = newBinding;
-    const provider = yield* binding.Tag;
-    if (provider.diff) {
-        const state = yield* State;
-        const oldState = yield* state.get(oldCap.resource.id);
-        if (oldState) {
-            const diff = yield* provider
-                .diff({
-                source: {
-                    id: oldCap.resource.id,
-                    props: newCap.resource.props,
-                    oldProps: oldState?.props,
-                    oldAttr: oldState?.attr,
-                },
-                props: newBinding.props,
-                attr: oldBinding.attr,
-                target,
-            })
-                .pipe(Effect.provide(Layer.succeed(InstanceId, oldState.instanceId)));
-            if (diff?.action === "update" || diff?.action === "replace") {
-                return diff;
-            }
-        }
-    }
-    return {
-        action: oldBinding.capability.action !== newBinding.capability.action ||
-            oldBinding.capability?.resource?.id !==
-                newBinding.capability?.resource?.id
-            ? "update"
-            : "noop",
-    };
-});
-// 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