How to create a custom terraform datasource provider schema for a map of maps values?

I have a golang function that returns roles of type map[string]map[string]string

eg:

    map[foo:map[name:abc env:dev id:465 project:e-1] boo:map[name:def env:prd id:82 project:e-1] :doo[name:ght env:stg id:353 project:e-3]]

and I created a schema for it like the following...

func dataSourceAccountHelper() *schema.Resource {
	return &schema.Resource{
		Read: accountHelperRead,

		Schema: map[string]*schema.Schema{
		
			"roles": {
				Type: schema.TypeMap,
				Elem: &schema.Schema{
					Type:     schema.TypeMap,
					Computed: true,
					Elem: &schema.Schema{
						Type: schema.TypeString,
					},
				},

				Computed: true,
			},

			"id": &schema.Schema{
				Computed: true,
				Type:     schema.TypeString,
			},
		},
	}
}

And the create method to pass the role values to the schema

func rolesRead(d *schema.ResourceData, m interface{}) error {
	filteredRoles := filterAccounts("john") // returns `map[string]map[string]string`



	if err := d.Set("account_map", filteredRoles); err != nil {
		return err
	}

	//accountMaps := make(map[string]interface{})

	d.SetId("-")

	return nil
}

but the Terraform output is an empty map, how do I fix it please help

Outputs:

output = {
  "roles" = tomap(null) /* of map of string */
  "id" = tostring(null)
}

expecting output like

Outputs:

output = {
  "roles" = { foo    = {name = "abc" env = "dev" id= 465 project = "e-1"}
              boo    = {name = "efg" env = "prd" id= 82 project = "e-2"}       
            },
  "id" = "-"
}

What you are trying to do here is not possbile with the legacy Terraform SDK that you are using. Maps can only be of primitive types: TypeString, TypeInt, TypeBool.

To create this structure you'll need to migrate to the new framework, which is built for the type system of modern Terraform rather than (as is the case for SDKv2) the type system of classic Terraform v0.11 and earlier.

In the Terraform Plugin Framework, the equivalent structure to what you tried to describe here is MapNestedAttribute, with the following describing the schema structure you showed in your question:

schema.MapNestedAttribute{
    NestedObject: schema.NestedAttributeObject{
        Attributes: map[string]schema.Attribute{
            "name": schema.StringAttribute{
                // ...
            },
            "env": schema.StringAttribute{
                // ...
            },
            "id": schema.NumberAttribute{
                // ...
            },
            "project": schema.StringAttribute{
                // ...
            },
        },
    },
}

This represents a map of objects with the given attributes, and so the above schema type is equivalent to the following type constraint as might be written in a Terraform module using the Terraform language's type constraint syntax:

map(
  object({
    name    = string
    env     = string
    id      = number
    project = string
  })
)