Incorrect element type of default list or map value in schema causes all default computed values of schema to be silently set to `null`

[inhearst]

Module version

github.com/hashicorp/terraform-plugin-framework v1.5.0

Relevant provider source code

type ExampleResourceModel struct {
	ConfigurableAttribute types.String `tfsdk:"configurable_attribute"`
	Defaulted             types.String `tfsdk:"defaulted"`
	Id                    types.String `tfsdk:"id"`
	Foo                   []FooEntry   `tfsdk:"foo"`
}

type FooEntry struct {
}

func (r *ExampleResource) Schema(ctx context.Context, req resource.SchemaRequest, resp *resource.SchemaResponse) {
	resp.Schema = schema.Schema{
		// This description is used by the documentation generator and the language server.
		MarkdownDescription: "Example resource",

		Attributes: map[string]schema.Attribute{
			"configurable_attribute": schema.StringAttribute{
				MarkdownDescription: "Example configurable attribute",
				Optional:            true,
			},
			"defaulted": schema.StringAttribute{
				MarkdownDescription: "Example configurable attribute with default value",
				Optional:            true,
				Computed:            true,
				Default:             stringdefault.StaticString("example value when not configured"),
			},
			"id": schema.StringAttribute{
				Computed:            true,
				MarkdownDescription: "Example identifier",
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.UseStateForUnknown(),
				},
			},
			"foo": schema.ListNestedAttribute{
				MarkdownDescription: "test",
				Optional:            true,
				NestedObject: schema.NestedAttributeObject{
					Attributes: map[string]schema.Attribute{},
				},
				Computed: true,
				Default:  listdefault.StaticValue(types.ListValueMust(types.Int64Type, []attr.Value{})),
			},
		},
	}
}

Terraform Configuration Files

terraform {
  required_providers {
    scaffolding = {
      source = "edu/scaffolding"
    }
  }
}

provider "scaffolding" {}

resource "scaffolding_example" "example" {
  configurable_attribute = "some-value"
}

output "test" {
  value = scaffolding_example.example
}

Expected Behavior

output.test should have defaulted set to "example value when not configured"

Actual Behavior

output.test.defaulted is null

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # scaffolding_example.example will be created
  + resource "scaffolding_example" "example" {
      + configurable_attribute = "some-value"
      + id                     = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Changes to Outputs:
  + test = {
      + configurable_attribute = "some-value"
      + defaulted              = null
      + foo                    = null
      + id                     = (known after apply)
    }

When commenting out foo in the schema and the model, the correct values appear:

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # scaffolding_example.example will be created
  + resource "scaffolding_example" "example" {
      + configurable_attribute = "some-value"
      + defaulted              = "example value when not configured"
      + id                     = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Changes to Outputs:
  + test = {
      + configurable_attribute = "some-value"
      + defaulted              = "example value when not configured"
      + id                     = (known after apply)
    }

I am fairly new to Terraform plugins and golang, so I could be holding it wrong. But I think this case should at least raise an error. I spent many hours trying to figure out why my Optional+Computed properties were always null on plan/apply.

Steps to Reproduce

1. Apply above patch to https://github.com/hashicorp/terraform-provider-scaffolding-framework
2. go build
3. cd examples/provider
4. tf plan

[inhearst]

I noticed the error. It's the incorrect type of the default value for the list, types.Int64Type. I removed the default and computed properties and now everything works. But, it's still strange, I expected an error.

And in my real code I use an actual API, when getting results back from the API with no default value this error happens. Since, when passing null to the creation, the API autoassigns an empty map instead. It is the reason I wanted a default value to begin with:

│ When applying changes to <XXX>, provider "provider[]" produced an unexpected new value: .foo: was null, but now cty.MapValEmpty(cty.Object(map[string]cty.Type{<...>})).

Trying something more like this:

{
    Computed: true,
    Default:  listdefault.StaticValue(types.ListValueMust(types.ObjectType{}, []attr.Value{})),
}

and it's back to the original nulls issue (actual type is a list of objects)

[inhearst]

Finally, with something like this, everything is alright:

{
   Computed: true,
   Default:  mapdefault.StaticValue(types.MapValueMust(models.Foo{}.GetAttrType(), map[string]attr.Value{})),
}

type Foo struct {
    Foo types.String `tfsdk:"foo"`
    Bar types.String `tfsdk:"bar"`
}

func (r Foo) GetAttrType() attr.Type {
	return types.ObjectType{AttrTypes: map[string]attr.Type{
		"foo": types.StringType,
		"bar": types.StringType,
	}}
}

The attr.Type has to be exact with the fields in the model, or else everything becomes null. I believe this should at least raise an error.

[austinvalle]

Hi there @inhearst 👋🏻, thanks for reporting this and sorry you're running into issues here.

I was able to verify this bug with a similar recreation to yours above (I used a list of strings vs. your list of objects).

func (r *thingResource) Schema(ctx context.Context, req resource.SchemaRequest, resp *resource.SchemaResponse) {
	resp.Schema = schema.Schema{
		Attributes: map[string]schema.Attribute{
			"list": schema.ListAttribute{
				ElementType: types.StringType,
				// Purposeful type mismatch
				Default:  listdefault.StaticValue(types.ListValueMust(types.Int64Type, []attr.Value{})),
				Computed: true,
			},
			"str": schema.StringAttribute{
				Computed: true,
				Default:  stringdefault.StaticString("set me!"),
			},
		},
	}
}

In this recreation, a valid default list (list of int64) is created that doesn't match the schema (list of strings). This eventually causes an error (due to the mismatched schema) while we are attempting to apply the schema default values, however we are ignoring those errors currently as we attempt to catch these types of errors upfront as a richer diagnostic.

For my example, the swallowed error during default transformation would be:

AttributeName("list"): can't use tftypes.List[tftypes.Number] as tftypes.List[tftypes.String]

This results in the observed behavior you mentioned where none of the defaults are applied as we swallow the missed error while also skipping the default value setting.

We'll definitely want to apply a fix for this (perhaps catch this mismatch upfront) but as you mentioned, in the meantime, if you adjust your list default to match the schema, everything will pass through correctly.

This also applies to other collection defaults with mismatched element types (lists, maps, sets) and object defaults with mismatched attribute types.