unsupported dependency type %q; datasources can only depend

Error message

unsupported dependency type %q; datasources can only depend on local, var or data.

What it means

DatasourceBlock.RegisterDependency records which components a datasource depends on so they can be evaluated in order. Only data, local, and var MTypes are accepted (var is a NOOP since vars evaluate first). This error is thrown when a dependency refString has any other MType, meaning the datasource depends on a component kind that cannot participate in datasource dependency ordering.

Source

Thrown at hcl2template/types.refstring.go:130

		for _, val := range cfg.InputVariables {
			if val.Name != rs.Name {
				continue
			}
			return val, nil
		}
	}

	return nil, fmt.Errorf("Unsupported component: %q, only vars, locals and datasources can be fetched by their refString", rs)
}

func (ds *DatasourceBlock) RegisterDependency(rs refString) error {
	switch rs.MType {
	case "data", "local":
		ds.Dependencies = append(ds.Dependencies, rs)
	// NOOP: vars are always evaluated beforehand for datasources
	case "var":
	default:
		return fmt.Errorf("unsupported dependency type %q; datasources can only depend on local, var or data.", rs.MType)
	}

	return nil
}

func (loc *LocalBlock) RegisterDependency(rs refString) error {
	switch rs.MType {
	case "data", "local":
		loc.dependencies = append(loc.dependencies, rs)
	// NOOP: vars are always evaluated beforehand for locals
	case "var":
	default:
		return fmt.Errorf("unsupported dependency type %q; locals can only depend on local, var or data.", rs.MType)
	}

	return nil
}

View on GitHub (pinned to eb36e3c3e4)

Solutions

Only pass refStrings created via NewRefString/NewRefStringFromDep rooted at data, local, or var.
Fix the MType on hand-built refStrings to the correct component kind before registering.
If the datasource genuinely depends on another component type, restructure the template — datasources can only order against locals, vars, and other datasources.

Example fix

// before
rs, _ := NewRefString("foo.bar") // unsupported root
err := ds.RegisterDependency(rs)
// after
rs, err := NewRefString("data.amazon-ami.my_ami")
if err != nil { return err }
err = ds.RegisterDependency(rs)

Defensive patterns

Strategy: validation

Validate before calling

// only register dependencies whose MType is data, local or var
switch rs.MType {
case "data", "local", "var":
	// ok to register
default:
	return fmt.Errorf("refusing to register dependency %q: unsupported MType", rs)
}

Type guard

func isRegisterableDependency(rs refString) bool {
	return rs.MType == "data" || rs.MType == "local" || rs.MType == "var"
}

Try / catch

if err := ds.RegisterDependency(rs); err != nil {
	return fmt.Errorf("bad dependency %s for datasource: %w", rs, err)
}

Prevention

Construct dependency refStrings only via NewRefString/NewRefStringFromDep so MType is always valid.
Never hand-write refString{MType: ""} structs; empty MType hits this default branch.
Keep dependency extraction limited to traversals rooted at data/local/var.

When it happens

Trigger: Calling ds.RegisterDependency with a refString whose MType is not 'data', 'local', or 'var' — e.g. a refString constructed manually with an empty or wrong MType, or a dependency extracted from a traversal rooted at something other than data/local/var.

Common situations: Plugin or tooling code building refStrings by hand and leaving MType empty; a refactor introducing a new reference root without updating RegisterDependency; passing a builder or post-processor reference as a datasource dependency.

Related errors

AI-assisted analysis of hashicorp/packer@eb36e3c3e4 (2026-09-05). Data as JSON: /api/errors/b7f3511d697e109e. Report an issue: GitHub.