First action

Author: YakDriver

internal/framework/action_test.go

@@ -13,12 +13,12 @@ import (
 func TestActionWithConfigureCompilation(t *testing.T) {
 	// This test ensures our new types compile correctly
 	var action ActionWithConfigure
-	
+
 	// Test that it has the Meta method from withMeta
 	if action.Meta() != nil {
 		t.Error("Expected nil meta before configuration")
 	}
-	
+
 	// Test that it embeds withMeta correctly
 	action.meta = &conns.AWSClient{}
 	if action.Meta() == nil {
@@ -32,15 +32,15 @@ func TestActionWithModelCompilation(t *testing.T) {
 	type testModel struct {
 		Name string `tfsdk:"name"`
 	}
-	
+
 	// This test ensures our new generic type compiles correctly
 	var action ActionWithModel[testModel]
-	
+
 	// Test that it has the Meta method from ActionWithConfigure
 	if action.Meta() != nil {
 		t.Error("Expected nil meta before configuration")
 	}
-	
+
 	// Test that it embeds ActionWithConfigure correctly
 	action.meta = &conns.AWSClient{}
 	if action.Meta() == nil {

internal/framework/action_with_model.go

@@ -5,6 +5,7 @@ package framework
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/hashicorp/terraform-plugin-framework/action/schema"
 	"github.com/hashicorp/terraform-plugin-framework/diag"
@@ -20,6 +21,8 @@ type ActionWithModel[T any] struct {
 
 // ValidateModel validates the action's model against a schema.
 func (a *ActionWithModel[T]) ValidateModel(ctx context.Context, schema *schema.UnlinkedSchema) diag.Diagnostics {
+	fmt.Printf("DEBUG: ActionWithModel.ValidateModel() called with schema having %d attributes\n", len(schema.Attributes))
+
 	var diags diag.Diagnostics
 	state := tfsdk.State{
 		Raw:    tftypes.NewValue(schema.Type().TerraformType(ctx), nil),
@@ -28,6 +31,13 @@ func (a *ActionWithModel[T]) ValidateModel(ctx context.Context, schema *schema.U
 
 	diags.Append(a.validateModel(ctx, &state)...)
 
+	fmt.Printf("DEBUG: ActionWithModel.ValidateModel() completed, has errors: %t\n", diags.HasError())
+	if diags.HasError() {
+		for _, d := range diags {
+			fmt.Printf("DEBUG: ActionWithModel.ValidateModel() error: %s - %s\n", d.Summary(), d.Detail())
+		}
+	}
+
 	return diags
 }
 

internal/provider/framework/action_test.go

@@ -65,16 +65,16 @@ func (t *testAction) ValidateModel(ctx context.Context, schema *schema.UnlinkedS
 
 // Ensure testAction implements required interfaces
 var (
-	_ action.Action                  = (*testAction)(nil)
-	_ framework.ActionValidateModel  = (*testAction)(nil)
+	_ action.Action                 = (*testAction)(nil)
+	_ framework.ActionValidateModel = (*testAction)(nil)
 )
 
 func TestWrappedAction_Basic(t *testing.T) {
 	ctx := context.Background()
-	
+
 	// Create test action
 	inner := &testAction{}
-	
+
 	// Create wrapped action with minimal options
 	opts := wrappedActionOptions{
 		bootstrapContext: func(ctx context.Context, getAttribute getAttributeFunc, c *conns.AWSClient) (context.Context, diag.Diagnostics) {
@@ -83,29 +83,29 @@ func TestWrappedAction_Basic(t *testing.T) {
 		interceptors: interceptorInvocations{},
 		typeName:     "aws_test_action",
 	}
-	
+
 	wrapped := newWrappedAction(inner, opts)
-	
+
 	// Test Metadata
 	metaReq := action.MetadataRequest{
 		ProviderTypeName: "aws",
 	}
 	var metaResp action.MetadataResponse
 	wrapped.Metadata(ctx, metaReq, &metaResp)
-	
+
 	if metaResp.TypeName != "aws_test_action" {
 		t.Errorf("Expected TypeName 'aws_test_action', got '%s'", metaResp.TypeName)
 	}
-	
+
 	// Test Schema
 	schemaReq := action.SchemaRequest{}
 	var schemaResp action.SchemaResponse
 	wrapped.Schema(ctx, schemaReq, &schemaResp)
-	
+
 	if schemaResp.Diagnostics.HasError() {
 		t.Errorf("Schema method returned errors: %v", schemaResp.Diagnostics)
 	}
-	
+
 	if unlinkedSchema, ok := schemaResp.Schema.(schema.UnlinkedSchema); ok {
 		if _, exists := unlinkedSchema.Attributes["test_param"]; !exists {
 			t.Error("Expected 'test_param' attribute in schema")
@@ -117,10 +117,10 @@ func TestWrappedAction_Basic(t *testing.T) {
 
 func TestActionInterceptors_RegionInjection(t *testing.T) {
 	ctx := context.Background()
-	
+
 	// Create test action
 	inner := &testAction{}
-	
+
 	// Create wrapped action with region interceptor
 	opts := wrappedActionOptions{
 		bootstrapContext: func(ctx context.Context, getAttribute getAttributeFunc, c *conns.AWSClient) (context.Context, diag.Diagnostics) {
@@ -131,18 +131,18 @@ func TestActionInterceptors_RegionInjection(t *testing.T) {
 		},
 		typeName: "aws_test_action",
 	}
-	
+
 	wrapped := newWrappedAction(inner, opts)
-	
+
 	// Test Schema with region injection
 	schemaReq := action.SchemaRequest{}
 	var schemaResp action.SchemaResponse
 	wrapped.Schema(ctx, schemaReq, &schemaResp)
-	
+
 	if schemaResp.Diagnostics.HasError() {
 		t.Errorf("Schema method returned errors: %v", schemaResp.Diagnostics)
 	}
-	
+
 	if unlinkedSchema, ok := schemaResp.Schema.(schema.UnlinkedSchema); ok {
 		if _, exists := unlinkedSchema.Attributes["region"]; !exists {
 			t.Error("Expected 'region' attribute to be injected into schema")

internal/provider/framework/provider.go

@@ -387,6 +387,14 @@ func (p *frameworkProvider) EphemeralResources(ctx context.Context) []func() eph
 //
 // All actions must have unique type names.
 func (p *frameworkProvider) Actions(ctx context.Context) []func() action.Action {
+	fmt.Printf("DEBUG: frameworkProvider.Actions() called, returning %d actions\n", len(p.actions))
+	for i, actionFunc := range p.actions {
+		// Create a temporary instance to get the type name
+		tempAction := actionFunc()
+		if wrappedAction, ok := tempAction.(*wrappedAction); ok {
+			fmt.Printf("DEBUG:   Action %d: %s\n", i, wrappedAction.opts.typeName)
+		}
+	}
 	return slices.Clone(p.actions)
 }
 
@@ -545,6 +553,8 @@ func (p *frameworkProvider) initialize(ctx context.Context) error {
 					continue
 				}
 
+				fmt.Printf("DEBUG: Registering action: %s from service package: %s\n", typeName, sp.ServicePackageName())
+
 				var isRegionOverrideEnabled bool
 				if v := v.Region; !tfunique.IsHandleNil(v) && v.Value().IsOverrideEnabled {
 					isRegionOverrideEnabled = true

internal/provider/framework/region.go

@@ -5,6 +5,7 @@ package framework
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/YakDriver/regexache"
 	"github.com/hashicorp/terraform-plugin-framework/action"
@@ -417,8 +418,11 @@ func (a actionInjectRegionAttributeInterceptor) schema(ctx context.Context, opts
 
 	switch response, when := opts.response, opts.when; when {
 	case After:
+		fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() called AFTER, schema type: %T\n", response.Schema)
 		if schema, ok := response.Schema.(aschema.UnlinkedSchema); ok {
+			fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() processing UnlinkedSchema with %d attributes\n", len(schema.Attributes))
 			if _, exists := schema.Attributes[names.AttrRegion]; !exists {
+				fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() injecting region attribute\n")
 				// Inject a top-level "region" attribute.
 				if schema.Attributes == nil {
 					schema.Attributes = make(map[string]aschema.Attribute)
@@ -428,8 +432,15 @@ func (a actionInjectRegionAttributeInterceptor) schema(ctx context.Context, opts
 					Description: names.TopLevelRegionAttributeDescription,
 				}
 				response.Schema = schema
+				fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() region attribute injected, now %d attributes\n", len(schema.Attributes))
+			} else {
+				fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() region attribute already exists\n")
 			}
+		} else {
+			fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() schema is NOT UnlinkedSchema, got %T\n", response.Schema)
 		}
+	default:
+		fmt.Printf("DEBUG: actionInjectRegionAttributeInterceptor.schema() called with when=%v\n", when)
 	}
 
 	return diags

internal/provider/framework/wrap.go

@@ -5,6 +5,7 @@ package framework
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/hashicorp/terraform-plugin-framework/action"
 	aschema "github.com/hashicorp/terraform-plugin-framework/action/schema"
@@ -304,13 +305,17 @@ func newWrappedAction(inner action.Action, opts wrappedActionOptions) action.Act
 
 func (w *wrappedAction) Metadata(ctx context.Context, request action.MetadataRequest, response *action.MetadataResponse) {
 	// This method does not call down to the inner action.
+	fmt.Printf("DEBUG: wrappedAction.Metadata() called, setting TypeName to: %s\n", w.opts.typeName)
 	response.TypeName = w.opts.typeName
 }
 
 func (w *wrappedAction) Schema(ctx context.Context, request action.SchemaRequest, response *action.SchemaResponse) {
+	fmt.Printf("DEBUG: wrappedAction.Schema() called for action: %s\n", w.opts.typeName)
+
 	ctx, diags := w.opts.bootstrapContext(ctx, nil, w.meta)
 	response.Diagnostics.Append(diags...)
 	if response.Diagnostics.HasError() {
+		fmt.Printf("DEBUG: wrappedAction.Schema() bootstrap context failed for %s\n", w.opts.typeName)
 		return
 	}
 
@@ -320,20 +325,42 @@ func (w *wrappedAction) Schema(ctx context.Context, request action.SchemaRequest
 	}
 	response.Diagnostics.Append(interceptedHandler(w.opts.interceptors.actionSchema(), f, w.meta)(ctx, &request, response)...)
 
+	fmt.Printf("DEBUG: wrappedAction.Schema() after interceptors, schema type: %T\n", response.Schema)
+
 	// Validate the action's model against the schema.
 	if v, ok := w.inner.(framework.ActionValidateModel); ok {
+		fmt.Printf("DEBUG: wrappedAction.Schema() action implements ActionValidateModel for %s\n", w.opts.typeName)
 		if schema, ok := response.Schema.(aschema.UnlinkedSchema); ok {
+			fmt.Printf("DEBUG: wrappedAction.Schema() schema is UnlinkedSchema with %d attributes for %s\n", len(schema.Attributes), w.opts.typeName)
 			response.Diagnostics.Append(v.ValidateModel(ctx, &schema)...)
 			if response.Diagnostics.HasError() {
+				fmt.Printf("DEBUG: wrappedAction.Schema() model validation failed for %s\n", w.opts.typeName)
 				response.Diagnostics.AddError("action model validation error", w.opts.typeName)
 				return
 			}
+			fmt.Printf("DEBUG: wrappedAction.Schema() model validation succeeded for %s\n", w.opts.typeName)
 		} else {
+			fmt.Printf("DEBUG: wrappedAction.Schema() schema is NOT UnlinkedSchema, got %T for %s\n", response.Schema, w.opts.typeName)
 			response.Diagnostics.AddError("unsupported action schema type", w.opts.typeName)
 		}
 	} else {
+		fmt.Printf("DEBUG: wrappedAction.Schema() action does NOT implement ActionValidateModel for %s\n", w.opts.typeName)
 		response.Diagnostics.AddError("missing framework.ActionValidateModel", w.opts.typeName)
 	}
+
+	fmt.Printf("DEBUG: wrappedAction.Schema() completed for %s, has errors: %t\n", w.opts.typeName, response.Diagnostics.HasError())
+
+	// Final debug: show what we're actually returning
+	if !response.Diagnostics.HasError() {
+		if schema, ok := response.Schema.(aschema.UnlinkedSchema); ok {
+			fmt.Printf("DEBUG: wrappedAction.Schema() FINAL SCHEMA for %s:\n", w.opts.typeName)
+			fmt.Printf("DEBUG:   Description: %s\n", schema.Description)
+			fmt.Printf("DEBUG:   Attributes (%d):\n", len(schema.Attributes))
+			for name, attr := range schema.Attributes {
+				fmt.Printf("DEBUG:     - %s: %T\n", name, attr)
+			}
+		}
+	}
 }
 
 func (w *wrappedAction) Invoke(ctx context.Context, request action.InvokeRequest, response *action.InvokeResponse) {