refactor(sidekick): directly add fields to message (#2355)

We will want to add child types to a message, such as enums and inline
messages. Consuming the message object in `makemessageFields()` allows
us to add types and fields as we parse the fields.

Author: coryan

internal/sidekick/internal/parser/discovery/discovery.go

@@ -72,16 +72,15 @@ func NewAPI(serviceConfig *serviceconfig.Service, contents []byte) (*api.API, er
 		if schema.Type != "object" {
 			return nil, fmt.Errorf("schema %s is not an object: %q", id, schema.Type)
 		}
-		fields, err := makeMessageFields(result, id, schema)
-		if err != nil {
-			return nil, err
-		}
 		message := &api.Message{
 			Name:          name,
 			ID:            id,
 			Package:       packageName,
 			Documentation: schema.Description,
-			Fields:        fields,
+		}
+		err := makeMessageFields(result, message, schema)
+		if err != nil {
+			return nil, err
 		}
 		result.Messages = append(result.Messages, message)
 		result.State.MessageByID[id] = message

internal/sidekick/internal/parser/discovery/message_fields.go

@@ -20,24 +20,23 @@ import (
 	"github.com/googleapis/librarian/internal/sidekick/internal/api"
 )
 
-func makeMessageFields(model *api.API, messageID string, schema *schema) ([]*api.Field, error) {
-	var fields []*api.Field
+func makeMessageFields(model *api.API, message *api.Message, schema *schema) error {
 	for _, input := range schema.Properties {
-		field, err := makeField(model, messageID, input)
+		field, err := makeField(model, message, input)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		if field == nil {
 			continue
 		}
-		fields = append(fields, field)
+		message.Fields = append(message.Fields, field)
 	}
-	return fields, nil
+	return nil
 }
 
-func makeField(model *api.API, messageID string, input *property) (*api.Field, error) {
+func makeField(model *api.API, message *api.Message, input *property) (*api.Field, error) {
 	if input.Schema.Type == "array" {
-		return makeArrayField(model, messageID, input)
+		return makeArrayField(model, message, input)
 	}
 	if input.Schema.AdditionalProperties != nil {
 		// TODO(#2283) - handle map fields
@@ -47,38 +46,33 @@ func makeField(model *api.API, messageID string, input *property) (*api.Field, e
 		// TODO(#2265) - handle inline object...
 		return nil, nil
 	}
-	return makeScalarField(model, messageID, input)
+	return makeScalarField(model, message, input.Name, input.Schema)
 }
 
-func makeArrayField(model *api.API, messageID string, input *property) (*api.Field, error) {
+func makeArrayField(model *api.API, message *api.Message, input *property) (*api.Field, error) {
 	if input.Schema.ItemSchema.Type == "object" && input.Schema.ItemSchema.Properties != nil {
 		// TODO(#2265) - handle inline object...
 		return nil, nil
 	}
-	typez, typezID, err := scalarType(model, messageID, input.Name, input.Schema.ItemSchema)
+	field, err := makeScalarField(model, message, input.Name, input.Schema.ItemSchema)
 	if err != nil {
 		return nil, err
 	}
-	return &api.Field{
-		Name:          input.Name,
-		JSONName:      input.Name, // OpenAPI field names are always camelCase
-		Documentation: input.Schema.Description,
-		Typez:         typez,
-		TypezID:       typezID,
-		Repeated:      true,
-		// TODO(#2268) - deprecated fields?
-	}, nil
+	field.Documentation = input.Schema.Description
+	field.Repeated = true
+	field.Optional = false
+	return field, nil
 }
 
-func makeScalarField(model *api.API, messageID string, input *property) (*api.Field, error) {
-	typez, typezID, err := scalarType(model, messageID, input.Name, input.Schema)
+func makeScalarField(model *api.API, message *api.Message, name string, schema *schema) (*api.Field, error) {
+	typez, typezID, err := scalarType(model, message.ID, name, schema)
 	if err != nil {
 		return nil, err
 	}
 	return &api.Field{
-		Name:          input.Name,
-		JSONName:      input.Name, // OpenAPI field names are always camelCase
-		Documentation: input.Schema.Description,
+		Name:          name,
+		JSONName:      name, // OpenAPI field names are always camelCase
+		Documentation: schema.Description,
 		Typez:         typez,
 		TypezID:       typezID,
 		// TODO(#2268) - deprecated fields?

internal/sidekick/internal/parser/discovery/message_fields_test.go

@@ -69,7 +69,8 @@ func TestMakeMessageFields(t *testing.T) {
 			},
 		},
 	}
-	got, err := makeMessageFields(model, ".package.Message", input)
+	message := &api.Message{ID: ".package.Message"}
+	err := makeMessageFields(model, message, input)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -106,7 +107,7 @@ func TestMakeMessageFields(t *testing.T) {
 		},
 	}
 	less := func(a, b *api.Field) bool { return a.Name < b.Name }
-	if diff := cmp.Diff(want, got, cmpopts.SortSlices(less)); diff != "" {
+	if diff := cmp.Diff(want, message.Fields, cmpopts.SortSlices(less)); diff != "" {
 		t.Errorf("mismatch (-want +got):\n%s", diff)
 	}
 }
@@ -126,8 +127,9 @@ func TestMakeMessageFieldsError(t *testing.T) {
 			},
 		},
 	}
-	if got, err := makeMessageFields(model, ".package.Message", input); err == nil {
-		t.Errorf("expected error makeScalarField(), got=%v, Input=%v", got, input)
+	message := &api.Message{ID: ".package.Message"}
+	if err := makeMessageFields(model, message, input); err == nil {
+		t.Errorf("expected error makeScalarField(), got=%v, Input=%v", message, input)
 	}
 }
 
@@ -145,7 +147,8 @@ func TestMakeArrayFieldError(t *testing.T) {
 			},
 		},
 	}
-	if got, err := makeArrayField(model, ".package.Message", input); err == nil {
+	message := &api.Message{ID: ".package.Message"}
+	if got, err := makeArrayField(model, message, input); err == nil {
 		t.Errorf("expected error makeScalarField(), got=%v, Input=%v", got, input)
 	}
 }
@@ -161,7 +164,8 @@ func TestMakeScalarFieldError(t *testing.T) {
 			Format:      "--unused--",
 		},
 	}
-	if got, err := makeScalarField(model, ".package.Message", input); err == nil {
+	message := &api.Message{ID: ".package.Message"}
+	if got, err := makeScalarField(model, message, input.Name, input.Schema); err == nil {
 		t.Errorf("expected error makeScalarField(), got=%v, Input=%v", got, input)
 	}
 }

internal/sidekick/internal/parser/discovery/methods.go

@@ -98,7 +98,7 @@ func makeMethod(model *api.API, parent *api.Message, doc *document, input *metho
 			Name:   p.Name,
 			Schema: &p.schema,
 		}
-		field, err := makeField(model, fmt.Sprintf(requestMessage.ID, id), prop)
+		field, err := makeField(model, requestMessage, prop)
 		if err != nil {
 			return nil, err
 		}