feat: add Description support for VariableDefinition (September 2025 spec)

Implements Description? on VariableDefinition per the September 2025
GraphQL spec (graphql-spec PR #1170), following the same pattern
established in PR #1331 for OperationDefinition and FragmentDefinition.

- Parser: handle optional string/block-string description before $Variable
- Printer: output variable descriptions when present
- JSON Schema Builder: propagate variable descriptions to JSON Schema
  property description fields, with fallback to argument descriptions
  from the schema definition when no variable description is provided

Resolves ENG-9301

Author: asoorm

v2/pkg/ast/ast_variable_definition.go

@@ -16,8 +16,9 @@ type VariableDefinitionList struct {
 
 // VariableDefinition
 // example:
-// $devicePicSize: Int = 100 @small
+// "The device picture size" $devicePicSize: Int = 100 @small
 type VariableDefinition struct {
+	Description   Description       // optional, describes the variable (September 2025 spec)
 	VariableValue Value             // $ Name
 	Colon         position.Position // :
 	Type          int               // e.g. String
@@ -93,3 +94,14 @@ func (d *Document) VariablePathByArgumentRefAndArgumentPath(argumentRef int, arg
 	// The variable path should be the variable name, e.g., "a", and then the 2nd element from the path onwards
 	return append([]string{string(variableNameBytes)}, argumentPath[1:]...), nil
 }
+
+func (d *Document) VariableDefinitionDescriptionBytes(ref int) ByteSlice {
+	if !d.VariableDefinitions[ref].Description.IsDefined {
+		return nil
+	}
+	return d.Input.ByteSlice(d.VariableDefinitions[ref].Description.Content)
+}
+
+func (d *Document) VariableDefinitionDescriptionString(ref int) string {
+	return unsafebytes.BytesToString(d.VariableDefinitionDescriptionBytes(ref))
+}

v2/pkg/astparser/parser.go

@@ -1557,6 +1557,17 @@ func (p *Parser) parseVariableDefinitionList() (list ast.VariableDefinitionList)
 		case keyword.RPAREN:
 			list.RPAREN = p.read().TextPosition
 			return
+		case keyword.STRING, keyword.BLOCKSTRING:
+			// Description before variable definition (September 2025 spec)
+			description := p.parseDescription()
+			if cap(list.Refs) == 0 {
+				list.Refs = p.document.Refs[p.document.NextRefIndex()][:0]
+			}
+			ref := p.parseVariableDefinitionWithDescription(&description)
+			if cap(list.Refs) == 0 {
+				list.Refs = p.document.Refs[p.document.NextRefIndex()][:0]
+			}
+			list.Refs = append(list.Refs, ref)
 		case keyword.DOLLAR:
 			if cap(list.Refs) == 0 {
 				list.Refs = p.document.Refs[p.document.NextRefIndex()][:0]
@@ -1567,7 +1578,7 @@ func (p *Parser) parseVariableDefinitionList() (list ast.VariableDefinitionList)
 			}
 			list.Refs = append(list.Refs, ref)
 		default:
-			p.errUnexpectedToken(p.read(), keyword.RPAREN, keyword.DOLLAR)
+			p.errUnexpectedToken(p.read(), keyword.RPAREN, keyword.DOLLAR, keyword.STRING, keyword.BLOCKSTRING)
 			return
 		}
 
@@ -1578,9 +1589,17 @@ func (p *Parser) parseVariableDefinitionList() (list ast.VariableDefinitionList)
 }
 
 func (p *Parser) parseVariableDefinition() int {
+	return p.parseVariableDefinitionWithDescription(nil)
+}
+
+func (p *Parser) parseVariableDefinitionWithDescription(description *ast.Description) int {
 
 	var variableDefinition ast.VariableDefinition
 
+	if description != nil {
+		variableDefinition.Description = *description
+	}
+
 	variableDefinition.VariableValue.Kind = ast.ValueKindVariable
 	variableDefinition.VariableValue.Ref, variableDefinition.VariableValue.Position = p.parseVariableValue()
 

v2/pkg/astparser/parser_test.go

@@ -2986,6 +2986,41 @@ func TestParseFragmentsWithDescriptions(t *testing.T) {
 	assert.False(t, userWithoutDescFrag.Description.IsDefined, "UserWithoutDescription should not have description")
 }
 
+func TestParseVariablesWithDescriptions(t *testing.T) {
+	operationsFile, err := os.ReadFile("./testdata/variable_with_description.graphql")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	doc, report := ParseGraphqlDocumentBytes(operationsFile)
+	if report.HasErrors() {
+		t.Fatal(report)
+	}
+
+	// Verify we parsed the operation
+	require.Len(t, doc.OperationDefinitions, 1)
+
+	opDef := doc.OperationDefinitions[0]
+	require.True(t, opDef.HasVariableDefinitions)
+	require.Len(t, opDef.VariableDefinitions.Refs, 3)
+
+	// First variable: $id with single-line description
+	var1 := doc.VariableDefinitions[opDef.VariableDefinitions.Refs[0]]
+	assert.True(t, var1.Description.IsDefined, "$id should have description")
+	assert.False(t, var1.Description.IsBlockString, "$id description should be single-line")
+	assert.Equal(t, "The unique employee identifier", doc.Input.ByteSliceString(var1.Description.Content))
+
+	// Second variable: $department with block string description
+	var2 := doc.VariableDefinitions[opDef.VariableDefinitions.Refs[1]]
+	assert.True(t, var2.Description.IsDefined, "$department should have description")
+	assert.True(t, var2.Description.IsBlockString, "$department description should be block string")
+	assert.Contains(t, doc.Input.ByteSliceString(var2.Description.Content), "The department to filter by")
+
+	// Third variable: $limit without description (backward compatibility)
+	var3 := doc.VariableDefinitions[opDef.VariableDefinitions.Refs[2]]
+	assert.False(t, var3.Description.IsDefined, "$limit should not have description")
+}
+
 func BenchmarkParseStarwars(b *testing.B) {
 
 	inputFileName := "./testdata/starwars.schema.graphql"

v2/pkg/astparser/testdata/variable_with_description.graphql

@@ -0,0 +1,18 @@
+"""
+Get an employee by their ID
+"""
+query FindEmployee(
+  "The unique employee identifier"
+  $id: ID!
+  """
+  The department to filter by.
+  Optional parameter for narrowing results.
+  """
+  $department: String
+  $limit: Int = 10
+) {
+  employee(id: $id) {
+    id
+    name
+  }
+}

v2/pkg/astprinter/astprinter.go

@@ -231,6 +231,11 @@ func (p *printVisitor) EnterVariableDefinition(ref int) {
 		p.write(literal.LPAREN)
 	}
 
+	if p.document.VariableDefinitions[ref].Description.IsDefined {
+		p.must(p.document.PrintDescription(p.document.VariableDefinitions[ref].Description, nil, 0, p.out))
+		p.write(literal.SPACE)
+	}
+
 	p.must(p.document.PrintValue(p.document.VariableDefinitions[ref].VariableValue, p.out))
 	p.write(literal.COLON)
 	p.write(literal.SPACE)

v2/pkg/astprinter/astprinter_test.go

@@ -787,6 +787,36 @@ User fields fragment
 """
 fragment UserFields on User {id name}`)
 	})
+	t.Run("variable with single-line description", func(t *testing.T) {
+		run(t, `query GetUser("The user ID" $id: ID!) {
+	user(id: $id) {
+		id
+	}
+}`, `query GetUser("The user ID" $id: ID!){user(id: $id){id}}`)
+	})
+	t.Run("variable with block string description", func(t *testing.T) {
+		run(t, `query GetUser("""The unique identifier""" $id: ID!) {
+	user(id: $id) {
+		id
+	}
+}`, `query GetUser("""
+The unique identifier
+""" $id: ID!){user(id: $id){id}}`)
+	})
+	t.Run("multiple variables with mixed descriptions", func(t *testing.T) {
+		run(t, `query Search("The search query" $query: String!, $limit: Int) {
+	search(query: $query, limit: $limit) {
+		id
+	}
+}`, `query Search("The search query" $query: String!, $limit: Int){search(query: $query, limit: $limit){id}}`)
+	})
+	t.Run("variable without description unchanged", func(t *testing.T) {
+		run(t, `query GetUser($id: ID!) {
+	user(id: $id) {
+		id
+	}
+}`, `query GetUser($id: ID!){user(id: $id){id}}`)
+	})
 }
 
 func TestPrintArgumentWithBeforeAfterValue(t *testing.T) {

v2/pkg/engine/jsonschema/variables_schema.go

@@ -131,6 +131,17 @@ func (v *VariablesSchemaBuilder) EnterVariableDefinition(ref int) {
 		v.schema.Required = append(v.schema.Required, varName)
 	}
 
+	// Set variable description: use the variable's own description if present (AC2),
+	// otherwise fall back to the field argument description from the schema (AC3)
+	if v.operationDocument.VariableDefinitions[ref].Description.IsDefined {
+		varSchema.Description = v.operationDocument.VariableDefinitionDescriptionString(ref)
+	} else {
+		// Fall back to argument description from schema definition
+		if desc := v.findArgumentDescriptionForVariable(varName); desc != "" {
+			varSchema.Description = desc
+		}
+	}
+
 	// Set default value if exists
 	if v.operationDocument.VariableDefinitionHasDefaultValue(ref) {
 		defaultValue := v.operationDocument.VariableDefinitionDefaultValue(ref)
@@ -150,6 +161,85 @@ func (v *VariablesSchemaBuilder) EnterVariableDefinition(ref int) {
 	v.schema.Properties[varName] = varSchema
 }
 
+// findArgumentDescriptionForVariable looks up the argument description from the schema definition
+// for a variable by matching it to field arguments in the operation's root selection set.
+func (v *VariablesSchemaBuilder) findArgumentDescriptionForVariable(varName string) string {
+	if len(v.operationDocument.OperationDefinitions) == 0 {
+		return ""
+	}
+
+	operationDef := v.operationDocument.OperationDefinitions[0]
+	if !operationDef.HasSelections {
+		return ""
+	}
+
+	// Determine root type name
+	var rootTypeName string
+	switch operationDef.OperationType {
+	case ast.OperationTypeQuery:
+		rootTypeName = "Query"
+	case ast.OperationTypeMutation:
+		rootTypeName = "Mutation"
+	case ast.OperationTypeSubscription:
+		rootTypeName = "Subscription"
+	default:
+		return ""
+	}
+
+	rootType, exists := v.definitionDocument.Index.FirstNodeByNameStr(rootTypeName)
+	if !exists || rootType.Kind != ast.NodeKindObjectTypeDefinition {
+		return ""
+	}
+
+	// Iterate through root fields in the operation's selection set
+	selectionSetRef := operationDef.SelectionSet
+	for _, selectionRef := range v.operationDocument.SelectionSets[selectionSetRef].SelectionRefs {
+		selection := v.operationDocument.Selections[selectionRef]
+		if selection.Kind != ast.SelectionKindField {
+			continue
+		}
+
+		fieldRef := selection.Ref
+		// Check if this field has arguments referencing our variable
+		if !v.operationDocument.FieldHasArguments(fieldRef) {
+			continue
+		}
+
+		for _, argRef := range v.operationDocument.Fields[fieldRef].Arguments.Refs {
+			argValue := v.operationDocument.ArgumentValue(argRef)
+			if argValue.Kind != ast.ValueKindVariable {
+				continue
+			}
+			argVarName := v.operationDocument.VariableValueNameString(argValue.Ref)
+			if argVarName != varName {
+				continue
+			}
+
+			// Found the argument that references this variable.
+			// Look up the corresponding argument definition in the schema.
+			argName := v.operationDocument.ArgumentNameString(argRef)
+			fieldName := v.operationDocument.FieldNameString(fieldRef)
+
+			// Find this field in the root type definition
+			for _, fieldDefRef := range v.definitionDocument.ObjectTypeDefinitions[rootType.Ref].FieldsDefinition.Refs {
+				if v.definitionDocument.FieldDefinitionNameString(fieldDefRef) != fieldName {
+					continue
+				}
+				// Find the argument definition
+				for _, argDefRef := range v.definitionDocument.FieldDefinitionArgumentsDefinitions(fieldDefRef) {
+					if v.definitionDocument.InputValueDefinitionNameString(argDefRef) == argName {
+						if v.definitionDocument.InputValueDefinitions[argDefRef].Description.IsDefined {
+							return v.definitionDocument.InputValueDefinitionDescriptionString(argDefRef)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return ""
+}
+
 // GetSchema returns the built schema
 func (v *VariablesSchemaBuilder) GetSchema() *JsonSchema {
 	// If we have required fields, the root schema cannot be nullable