First pass at including action invocations within stacks proto

internal/plans/planfile/tfplan.go

@@ -26,8 +26,10 @@ import (
 	"github.com/hashicorp/terraform/version"
 )
 
-const tfplanFormatVersion = 3
-const tfplanFilename = "tfplan"
+const (
+	tfplanFormatVersion = 3
+	tfplanFilename      = "tfplan"
+)
 
 // ---------------------------------------------------------------------------
 // This file deals with the internal structure of the "tfplan" sub-file within
@@ -403,7 +405,6 @@ func ActionFromProto(rawAction planproto.Action) (plans.Action, error) {
 	default:
 		return plans.NoOp, fmt.Errorf("invalid change action %s", rawAction)
 	}
-
 }
 
 func changeFromTfplan(rawChange *planproto.Change) (*plans.ChangeSrc, error) {
@@ -1389,6 +1390,10 @@ func actionInvocationFromTfplan(rawAction *planproto.ActionInvocationInstance) (
 	return ret, nil
 }
 
+func ActionInvocationToProto(action *plans.ActionInvocationInstanceSrc) (*planproto.ActionInvocationInstance, error) {
+	return actionInvocationToTfPlan(action)
+}
+
 func actionInvocationToTfPlan(action *plans.ActionInvocationInstanceSrc) (*planproto.ActionInvocationInstance, error) {
 	if action == nil {
 		return nil, nil

internal/rpcapi/terraform1/stacks/conversion.go

@@ -177,3 +177,10 @@ func NewResourceInstanceObjectInStackAddr(addr stackaddrs.AbsResourceInstanceObj
 		DeposedKey:            addr.Item.DeposedKey.String(),
 	}
 }
+
+func NewActionInvocationInStackAddr(addr stackaddrs.AbsActionInvocationInstance) *ActionInvocationInstanceInStackAddr {
+	return &ActionInvocationInstanceInStackAddr{
+		ComponentInstanceAddr:        addr.Component.String(),
+		ActionInvocationInstanceAddr: addr.Item.String(),
+	}
+}

internal/rpcapi/terraform1/stacks/stacks.proto

@@ -539,7 +539,7 @@ message PlannedChange {
       bool plan_applyable = 4;
       ResourceInstanceDeferred resource_instance_deferred = 5;
       InputVariable input_variable_planned = 6;
-      ActionInvocationInstance action_invocation_instance = 7;
+      ActionInvocationInstance action_invocation_planned = 7;
     }
   }
 

internal/stacks/stackaddrs/in_component.go

@@ -87,6 +87,10 @@ type AbsResourceInstance = InAbsComponentInstance[addrs.AbsResourceInstance]
 // of a resource from inside a particular component instance.
 type AbsResourceInstanceObject = InAbsComponentInstance[addrs.AbsResourceInstanceObject]
 
+// AbsActionInvocationInstance represents an instance of an action from inside a
+// particular component instance.
+type AbsActionInvocationInstance = InAbsComponentInstance[addrs.AbsActionInstance]
+
 // AbsModuleInstance represents an instance of a module from inside a
 // particular component instance.
 //

internal/stacks/stackplan/from_plan.go

@@ -177,6 +177,36 @@ func FromPlan(ctx context.Context, config *configs.Config, plan *plans.Plan, ref
 		seenObjects.Add(objAddr)
 	}
 
+	// Keep track of Action Invocations
+	for _, actionChange := range plan.Changes.ActionInvocations {
+		schema, err := producer.ActionSchema(
+			ctx,
+			actionChange.ProviderAddr.Provider,
+			actionChange.Addr.String(),
+		)
+		if err != nil {
+			diags = diags.Append(tfdiags.Sourceless(
+				tfdiags.Error,
+				"Can't fetch provider schema to save plan",
+				fmt.Sprintf(
+					"Failed to retrieve the schema for %s from provider %s: %s. This is a bug in Terraform.",
+					actionChange.Addr, actionChange.ProviderAddr.Provider, err,
+				),
+			))
+			continue
+		}
+
+		changes = append(changes, &PlannedChangeActionInvocationInstancePlanned{
+			ActionInvocationAddr: stackaddrs.AbsActionInvocationInstance{
+				Component: producer.Addr(),
+				Item:      actionChange.Addr,
+			},
+			Invocation:         actionChange,
+			Schema:             schema,
+			ProviderConfigAddr: actionChange.ProviderAddr,
+		})
+	}
+
 	// We also need to catch any objects that exist in the "prior state"
 	// but don't have any actions planned, since we still need to capture
 	// the prior state part in case it was updated by refreshing during

internal/stacks/stackplan/planned_change.go

@@ -493,7 +493,6 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*stacks.Pla
 			},
 		},
 	}, nil
-
 }
 
 func DynamicValueToTerraform1(val cty.Value, ty cty.Type) (*stacks.DynamicValue, error) {
@@ -853,3 +852,113 @@ func (pc *PlannedChangeProviderFunctionResults) PlannedChangeProto() (*stacks.Pl
 		Raw: []*anypb.Any{&raw},
 	}, nil
 }
+
+type PlannedChangeActionInvocationInstancePlanned struct {
+	ActionInvocationAddr stackaddrs.AbsActionInvocationInstance
+
+	// Invocation describes the planned invocation.
+	Invocation *plans.ActionInvocationInstanceSrc
+
+	// ProviderConfigAddr is the address of the provider configuration
+	// that planned this change, resolved in terms of the configuration for
+	// the component this resource instance object belongs to.
+	ProviderConfigAddr addrs.AbsProviderConfig
+
+	// Schema MUST be the same schema that was used to encode the dynamic
+	// values inside ChangeSrc
+	//
+	// Can be empty if and only if ChangeSrc is nil.
+	Schema providers.ActionSchema
+}
+
+var _ PlannedChange = (*PlannedChangeActionInvocationInstancePlanned)(nil)
+
+func (pc *PlannedChangeActionInvocationInstancePlanned) PlanActionInvocationProto() (*tfstackdata1.PlanActionInvocationPlanned, error) {
+	addr := pc.ActionInvocationAddr
+
+	if pc.Invocation == nil {
+		// This is just a stubby placeholder to remind us to drop the
+		// apparently-deleted-outside-of-Terraform object from the state
+		// if this plan later gets applied.
+
+		return &tfstackdata1.PlanActionInvocationPlanned{
+			ComponentInstanceAddr: addr.Component.String(),
+			ActionInvocationAddr:  addr.Item.String(),
+			ProviderConfigAddr:    pc.ProviderConfigAddr.String(),
+		}, nil
+	}
+
+	invocationProto, err := planfile.ActionInvocationToProto(pc.Invocation)
+	if err != nil {
+		return nil, fmt.Errorf("converting action invocation to proto: %w", err)
+	}
+
+	return &tfstackdata1.PlanActionInvocationPlanned{
+		ComponentInstanceAddr: addr.Component.String(),
+		ActionInvocationAddr:  addr.Item.String(),
+		ProviderConfigAddr:    pc.ProviderConfigAddr.String(),
+		Invocation:            invocationProto,
+	}, nil
+}
+
+func (pc *PlannedChangeActionInvocationInstancePlanned) ChangeDescription() (*stacks.PlannedChange_ChangeDescription, error) {
+	addr := pc.ActionInvocationAddr
+
+	// We only emit an external description if there's an invocation to describe.
+	if pc.Invocation == nil {
+		return nil, nil
+	}
+
+	return &stacks.PlannedChange_ChangeDescription{
+		Description: &stacks.PlannedChange_ChangeDescription_ActionInvocationPlanned{
+			ActionInvocationPlanned: &stacks.PlannedChange_ActionInvocationInstance{
+				Addr:         stacks.NewActionInvocationInStackAddr(addr),
+				ProviderAddr: pc.Invocation.ProviderAddr.Provider.String(),
+
+				ConfigValue: stacks.NewDynamicValue(
+					pc.Invocation.ConfigValue,
+					pc.Invocation.SensitiveConfigPaths,
+				),
+
+				ActionTrigger: nil,
+			},
+		},
+	}, nil
+}
+
+// PlannedChangeProto implements PlannedChange.
+func (pc *PlannedChangeActionInvocationInstancePlanned) PlannedChangeProto() (*stacks.PlannedChange, error) {
+	paip, err := pc.PlanActionInvocationProto()
+	if err != nil {
+		return nil, err
+	}
+	var raw anypb.Any
+	err = anypb.MarshalFrom(&raw, paip, proto.MarshalOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	if pc.Invocation == nil {
+		// We only emit a "raw" in this case, because this is a relatively
+		// uninteresting edge-case. The PlanActionInvocationProto
+		// function should have returned a placeholder value for this use case.
+
+		return &stacks.PlannedChange{
+			Raw: []*anypb.Any{&raw},
+		}, nil
+	}
+
+	var descs []*stacks.PlannedChange_ChangeDescription
+	desc, err := pc.ChangeDescription()
+	if err != nil {
+		return nil, err
+	}
+	if desc != nil {
+		descs = append(descs, desc)
+	}
+
+	return &stacks.PlannedChange{
+		Raw:          []*anypb.Any{&raw},
+		Descriptions: descs,
+	}, nil
+}