alchemy 2.0.0-beta.24 → 2.0.0-beta.26

package/lib/Plan.js

@@ -1,648 +0,0 @@
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Redacted from "effect/Redacted";
-import { asEffect } from ".//Util/types.js";
-import { Artifacts, ArtifactStore, createArtifactStore, ensureArtifactStore, makeScopedArtifacts, } from "./Artifacts.js";
-import { diffBindings, havePropsChanged, } from "./Diff.js";
-import { parseFqn } from "./FQN.js";
-import { InstanceId } from "./InstanceId.js";
-import * as Output from "./Output.js";
-import { findProviderByType, Provider, } from "./Provider.js";
-import { isResource, } from "./Resource.js";
-import {} from "./Stack.js";
-import { State, } from "./State/index.js";
-export const isCRUD = (node) => {
-    return (node &&
-        typeof node === "object" &&
-        (node.action === "create" ||
-            node.action === "update" ||
-            node.action === "replace" ||
-            node.action === "noop"));
-};
-export const make = (stack, options = {}) => 
-// @ts-expect-error
-Effect.gen(function* () {
-    const state = yield* State;
-    const resources = Object.values(stack.resources);
-    // TODO(sam): rename terminology to Stack
-    const stackName = stack.name;
-    const stage = stack.stage;
-    const resourceFqns = yield* state.list({
-        stack: stackName,
-        stage: stage,
-    });
-    const oldResources = yield* Effect.all(resourceFqns.map((fqn) => state.get({ stack: stackName, stage: stage, fqn })), { concurrency: "unbounded" });
-    const resolvedResources = {};
-    const resolveResource = (resourceExpr) => Effect.gen(function* () {
-        // @ts-expect-error
-        return yield* (resolvedResources[resourceExpr.src.FQN] ??=
-            yield* Effect.cached(Effect.gen(function* () {
-                const resource = resourceExpr.src;
-                const provider = yield* findProviderByType(resource.Type);
-                const props = yield* resolveInput(resource.Props);
-                const oldState = yield* state.get({
-                    stack: stackName,
-                    stage: stage,
-                    fqn: resource.FQN,
-                });
-                if (!oldState || oldState.status === "creating") {
-                    return resourceExpr;
-                }
-                const oldProps = oldState.status === "updating"
-                    ? oldState.old.props
-                    : oldState.props;
-                const oldBindings = oldState.bindings ?? [];
-                const newBindings = stack.bindings[resource.FQN] ?? [];
-                const diff = yield* provider.diff
-                    ? provider
-                        .diff({
-                        id: resource.LogicalId,
-                        olds: oldProps,
-                        instanceId: oldState.instanceId,
-                        news: props,
-                        output: oldState.attr,
-                        oldBindings,
-                        newBindings,
-                    })
-                        .pipe(providePlanScope(resource.FQN, 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 (havePropsChanged(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 (Redacted.isRedacted(input)) {
-            return input;
-        }
-        else if (Array.isArray(input)) {
-            return yield* Effect.all(input.map(resolveInput), {
-                concurrency: "unbounded",
-            });
-        }
-        else if (isResource(input)) {
-            // Resource objects have dynamic properties (path, hash, etc.) that are
-            // created on-demand by a Proxy getter and aren't enumerable via Object.entries.
-            // Resolve the ResourceExpr to get the actual resource output, then continue
-            // resolving any nested outputs in the result.
-            const resourceExpr = Output.of(input);
-            const resolved = yield* resolveOutput(resourceExpr);
-            return yield* resolveInput(resolved);
-        }
-        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]))), { concurrency: "unbounded" }));
-        }
-        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), {
-                concurrency: "unbounded",
-            });
-        }
-        else if (Output.isLiteralExpr(expr)) {
-            return expr.value;
-        }
-        return yield* Effect.die(new Error("Not implemented yet"));
-    });
-    // map of resource FQN -> its downstream dependencies (resources that depend on it)
-    const oldDownstreamDependencies = Object.fromEntries(oldResources
-        .filter((resource) => !!resource)
-        .map((resource) => [resource.fqn, resource.downstream]));
-    // Build a set of FQNs for the new resources to detect orphans
-    const newResourceFqns = new Set(resources.map((r) => r.FQN));
-    // Map FQN -> list of upstream FQNs (resources this one depends on via props)
-    const newUpstreamDependencies = Object.fromEntries(resources.map((resource) => [
-        resource.FQN,
-        Object.values(Output.upstreamAny(resource.Props)).map((r) => r.FQN),
-    ]));
-    // Map FQN -> list of upstream FQNs from bindings
-    const bindingUpstreamDependencies = Object.fromEntries(resources.map((resource) => [
-        resource.FQN,
-        Object.values(Output.upstreamAny(stack.bindings[resource.FQN] ?? [])).map((r) => r.FQN),
-    ]));
-    // Combined prop + binding upstream for the desired graph, including
-    // references to resources outside the current graph so delete validation can
-    // tell whether any surviving resource still points at an orphan.
-    const rawUpstreamDependencies = Object.fromEntries(resources.map((resource) => {
-        const fqn = resource.FQN;
-        const propDeps = newUpstreamDependencies[fqn] ?? [];
-        const bindDeps = bindingUpstreamDependencies[fqn] ?? [];
-        return [fqn, [...new Set([...propDeps, ...bindDeps])]];
-    }));
-    // Combined prop + binding upstream, filtered to resources in this graph for
-    // scheduling and cycle detection.
-    const allUpstreamDependencies = Object.fromEntries(resources.map((resource) => {
-        const fqn = resource.FQN;
-        const deps = rawUpstreamDependencies[fqn] ?? [];
-        return [fqn, deps.filter((dep) => newResourceFqns.has(dep))];
-    }));
-    // Map FQN -> list of downstream FQNs (resources that depend on this one)
-    const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => [
-        resource.FQN,
-        Object.entries(newUpstreamDependencies)
-            .filter(([_, upstream]) => upstream.includes(resource.FQN))
-            .map(([depFqn]) => depFqn),
-    ]));
-    const resourceGraph = Object.fromEntries((yield* Effect.all(resources.map(Effect.fn("plan.diff.resource")(function* (resource) {
-        const provider = yield* findProviderByType(resource.Type);
-        const id = resource.LogicalId;
-        const fqn = resource.FQN;
-        const news = yield* resolveInput(resource.Props);
-        const downstream = newDownstreamDependencies[fqn] ?? [];
-        const newBindings = yield* resolveInput(stack.bindings[fqn] ?? []);
-        const oldState = yield* state.get({
-            stack: stackName,
-            stage: stage,
-            fqn,
-        });
-        const oldBindings = oldState?.bindings ?? [];
-        const bindingDiffs = diffBindings(oldBindings, newBindings);
-        const Node = (node) => ({
-            ...node,
-            provider,
-            resource,
-            bindings: bindingDiffs,
-            downstream,
-        });
-        // Plan against the persisted state we have, not the ideal final state we
-        // hoped to reach last time. Recovery is expressed by mapping each
-        // intermediate state back onto a fresh CRUD action.
-        if (oldState === undefined) {
-            return Node({
-                action: "create",
-                props: news,
-                state: oldState,
-            });
-        }
-        else if (oldState.status === "creating" &&
-            oldState.attr === undefined) {
-            // A create may have succeeded before state persistence failed. If the
-            // provider can recover an attribute snapshot, keep driving the same
-            // create instead of starting over blindly.
-            if (provider.read) {
-                const attr = yield* provider
-                    .read({
-                    id,
-                    instanceId: oldState.instanceId,
-                    olds: oldState.props,
-                    output: oldState.attr,
-                })
-                    .pipe(providePlanScope(fqn, oldState.instanceId));
-                if (attr) {
-                    return Node({
-                        action: "create",
-                        props: news,
-                        state: { ...oldState, attr },
-                    });
-                }
-            }
-        }
-        // Diff against whatever props represent the best-known current attempt.
-        // For replacement recovery that means the top-level replacement props,
-        // not the older generations stored under `old`.
-        const oldProps = oldState.props;
-        const diff = yield* asEffect(provider
-            ?.diff?.({
-            id,
-            olds: oldProps,
-            instanceId: oldState.instanceId,
-            output: oldState.attr,
-            news,
-            oldBindings,
-            newBindings,
-        })
-            .pipe(providePlanScope(fqn, oldState.instanceId))).pipe(Effect.map((diff) => diff ??
-            {
-                action: havePropsChanged(oldProps, news) ||
-                    bindingDiffs.some((b) => b.action !== "noop")
-                    ? "update"
-                    : "noop",
-            }), Effect.map((diff) => options.force && diff.action === "noop"
-            ? {
-                action: "update",
-            }
-            : diff));
-        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") {
-            // Updating already targets the live resource, so noop/update both mean
-            // "finish the interrupted update". Only a replace diff escalates it
-            // into a fresh replacement.
-            if (diff.action === "update" || diff.action === "noop") {
-                // we can continue where we left off
-                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 should we do a provider.read to try and reconcile back to UpdatedResourceState?
-                    state: oldState,
-                });
-            }
-        }
-        else if (oldState.status === "replacing") {
-            // The replacement candidate is still being created. Noop/update keep
-            // driving the same generation; replace means that candidate itself is
-            // now obsolete and must be wrapped in a new outer generation.
-            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 {
-                // The in-flight replacement candidate itself now needs replacement.
-                // Mark this as a restart so Apply creates a fresh generation instead
-                // of resuming the old replacement instance.
-                return Node({
-                    restart: true,
-                    action: "replace",
-                    deleteFirst: diff.deleteFirst ?? oldState.deleteFirst,
-                    props: news,
-                    state: oldState,
-                });
-            }
-        }
-        else if (oldState.status === "replaced") {
-            // The new resource already exists. Noop means "just let GC finish",
-            // update means "mutate the current replacement before GC finishes",
-            // and replace means "the current replacement also became obsolete".
-            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 {
-                // Cleanup is still pending, but the current "new" resource has already
-                // become obsolete. Start another replacement generation and preserve
-                // the existing replaced node as part of the recursive old chain.
-                return Node({
-                    restart: true,
-                    action: "replace",
-                    deleteFirst: diff.deleteFirst ?? oldState.deleteFirst,
-                    props: news,
-                    state: oldState,
-                });
-            }
-        }
-        else if (oldState.status === "deleting") {
-            // we're in a partially deleted state, it is unclear whether it was or was not deleted
-            // so continue by re-creating it with the same instanceId and desired props
-            return Node({
-                action: "create",
-                props: news,
-                state: {
-                    ...oldState,
-                    status: "creating",
-                    props: news,
-                },
-            });
-        }
-        else if (diff.action === "update") {
-            // Stable created/updated resources follow the normal CRUD mapping.
-            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,
-            });
-        }
-    })), { concurrency: "unbounded" })).map((update) => [update.resource.FQN, update]));
-    // Detect unsatisfiable dependency cycles among create/replace nodes.
-    // Update/noop nodes signal their Deferred before waitForDeps so they
-    // cannot deadlock. Create/replace nodes only signal early when they
-    // have a precreate handler. Simulate the concurrent execution:
-    // precreate nodes are immediately "resolved", then iteratively resolve
-    // any node whose deps are all resolved. Remaining nodes would deadlock.
-    {
-        const createReplaceNodes = new Set(Object.entries(resourceGraph)
-            .filter(([_, node]) => node.action === "create" || node.action === "replace")
-            .map(([fqn]) => fqn));
-        if (createReplaceNodes.size > 0) {
-            const hasPrecreate = new Set([...createReplaceNodes].filter((fqn) => !!resourceGraph[fqn]?.provider?.precreate));
-            const resolved = new Set(hasPrecreate);
-            let changed = true;
-            while (changed) {
-                changed = false;
-                for (const fqn of createReplaceNodes) {
-                    if (resolved.has(fqn))
-                        continue;
-                    const deps = (allUpstreamDependencies[fqn] ?? []).filter((dep) => createReplaceNodes.has(dep));
-                    if (deps.every((dep) => resolved.has(dep))) {
-                        resolved.add(fqn);
-                        changed = true;
-                    }
-                }
-            }
-            const deadlocked = [...createReplaceNodes].filter((fqn) => !resolved.has(fqn));
-            if (deadlocked.length > 0) {
-                const missingPrecreate = deadlocked.filter((fqn) => !hasPrecreate.has(fqn));
-                return yield* Effect.die(new UnsatisfiedResourceCycle({
-                    message: `Circular dependency detected that cannot be resolved: [${deadlocked.join(", ")}]. ` +
-                        `Resources lacking a precreate handler: [${missingPrecreate.join(", ")}]. ` +
-                        `All resources in a dependency cycle must implement precreate to allow early signaling.`,
-                    cycle: deadlocked,
-                    missingPrecreate,
-                }));
-            }
-        }
-    }
-    const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({ stack: stackName, stage: stage })).map(Effect.fn("plan.diff.deletion")(function* (fqn) {
-        if (newResourceFqns.has(fqn)) {
-            return;
-        }
-        const oldState = yield* state.get({
-            stack: stackName,
-            stage: stage,
-            fqn,
-        });
-        let attr = oldState?.attr;
-        if (oldState) {
-            const { logicalId } = parseFqn(fqn);
-            const resourceType = oldState.resourceType;
-            const provider = yield* findProviderByType(resourceType);
-            if (oldState.attr === undefined) {
-                if (provider.read) {
-                    attr = yield* provider
-                        .read({
-                        id: logicalId,
-                        instanceId: oldState.instanceId,
-                        olds: oldState.props,
-                        output: oldState.attr,
-                    })
-                        .pipe(providePlanScope(fqn, oldState.instanceId));
-                }
-            }
-            return [
-                fqn,
-                {
-                    action: "delete",
-                    state: { ...oldState, attr },
-                    provider: provider,
-                    resource: {
-                        Namespace: oldState.namespace,
-                        FQN: fqn,
-                        LogicalId: logicalId,
-                        Type: oldState.resourceType,
-                        Attributes: attr,
-                        Props: oldState.props,
-                        Binding: undefined,
-                        Provider: Provider(resourceType),
-                        RemovalPolicy: oldState.removalPolicy,
-                        ExecutionContext: undefined,
-                        Providers: undefined,
-                    },
-                    downstream: oldDownstreamDependencies[fqn] ?? [],
-                    bindings: oldState.bindings.map((binding) => ({
-                        sid: binding.sid,
-                        action: "delete",
-                        data: binding.data,
-                    })),
-                },
-            ];
-        }
-    })), { concurrency: "unbounded" })).filter((v) => !!v));
-    for (const resourceFqn of Object.keys(deletions)) {
-        const dependencies = Object.entries(rawUpstreamDependencies)
-            .filter(([survivorFqn, upstream]) => survivorFqn in resourceGraph && upstream.includes(resourceFqn))
-            .map(([survivorFqn]) => survivorFqn);
-        if (dependencies.length > 0) {
-            return yield* new DeleteResourceHasDownstreamDependencies({
-                message: `Resource ${resourceFqn} has downstream dependencies`,
-                resourceId: resourceFqn,
-                dependencies,
-            });
-        }
-    }
-    return {
-        resources: resourceGraph,
-        deletions,
-        output: stack.output,
-    };
-}).pipe(ensureArtifactStore, Effect.withSpan("plan.make", {
-    attributes: {
-        "alchemy.stack": stack.name,
-        "alchemy.stage": stack.stage,
-        "alchemy.resources.count": Object.keys(stack.resources).length,
-        "alchemy.force": !!options.force,
-    },
-}));
-const providePlanScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
-export class DeleteResourceHasDownstreamDependencies extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {
-}
-export class UnsatisfiedResourceCycle extends Data.TaggedError("UnsatisfiedResourceCycle") {
-}
-// 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