From 99ee745c76e4a7ece59966a1f356985bc43fd7e0 Mon Sep 17 00:00:00 2001 From: Carlos O'Ryan Date: Fri, 20 Nov 2026 12:46:19 +0000 Subject: [PATCH 1/2] refactor(sidekick/api): add (*API).Filter Add a generic (*API).Filter method to construct a filtered copy of an API surface, keeping Rust/prost-specific reachability rules in internal/librarian/rust/generate_prost_hybrid.go. Part of #7837 --- .../librarian/rust/generate_prost_hybrid.go | 80 +--------- internal/sidekick/api/filter.go | 121 +++++++++++++++ internal/sidekick/api/filter_test.go | 146 ++++++++++++++++++ 3 files changed, 273 insertions(+), 74 deletions(-) create mode 100644 internal/sidekick/api/filter.go create mode 100644 internal/sidekick/api/filter_test.go diff --git a/internal/librarian/rust/generate_prost_hybrid.go b/internal/librarian/rust/generate_prost_hybrid.go index fd9cc67cbb..e790aa4d69 100644 --- a/internal/librarian/rust/generate_prost_hybrid.go +++ b/internal/librarian/rust/generate_prost_hybrid.go @@ -15,7 +15,6 @@ package rust import ( - "cmp" "context" "errors" "fmt" @@ -26,7 +25,6 @@ import ( "github.com/googleapis/librarian/internal/config" "github.com/googleapis/librarian/internal/sidekick/api" - "github.com/googleapis/librarian/internal/sidekick/language" "github.com/googleapis/librarian/internal/sidekick/parser" sidekickrust "github.com/googleapis/librarian/internal/sidekick/rust" "github.com/googleapis/librarian/internal/sidekick/rust_prost" @@ -230,67 +228,12 @@ func filterModelToTypes(model *api.API, rootTypeIDs []string, allowGrpcAnyFields return nil, nil, false, errors.New(strings.TrimSuffix(sb.String(), "\n")) } - // Collect external top-level messages (e.g. google.type.LatLng) referenced by roots. - // We sort external types by ID because model.AllMessages() iterates over a map whose - // iteration order is randomized by the Go runtime. - var externalMessages []*api.Message - for m := range model.AllMessages() { - if m.ID() != "" && reachableMsgs[m.ID()] && !isWKT(m.ID()) && m.ID() != ".google.rpc.Status" && m.Parent() == nil { - if m.Package() != model.PackageName && m.Package() != api.ReservedPackageName { - externalMessages = append(externalMessages, m) - } - } - } - slices.SortFunc(externalMessages, func(a, b *api.Message) int { return cmp.Compare(a.ID(), b.ID()) }) - - // Collect external top-level enums referenced by roots. - var externalEnums []*api.Enum - for e := range model.AllEnums() { - if e.ID() != "" && reachableEnums[e.ID()] && !isWKT(e.ID()) && e.Parent() == nil { - if e.Package() != model.PackageName && e.Package() != api.ReservedPackageName { - externalEnums = append(externalEnums, e) - } + hybridModel := model.Filter(func(id string) bool { + if id == "" || isWKT(id) || id == ".google.rpc.Status" { + return false } - } - slices.SortFunc(externalEnums, func(a, b *api.Enum) int { return cmp.Compare(a.ID(), b.ID()) }) - - // Construct hybridModel for prost conversion code generation. - hybridModel := api.API{ - Name: model.Name, - PackageName: model.PackageName, - Title: model.Title, - Description: model.Description, - Revision: model.Revision, - Services: cloneServices(model.Services), - Messages: language.FilterSlice(model.Messages, func(m *api.Message) bool { return reachableMsgs[m.ID()] }), - ExternalMessages: externalMessages, - Enums: language.FilterSlice(model.Enums, func(e *api.Enum) bool { return reachableEnums[e.ID()] }), - ExternalEnums: externalEnums, - ResourceDefinitions: model.ResourceDefinitions, - QuickstartService: model.QuickstartService, - Codec: model.Codec, - } - for _, s := range hybridModel.Services { - hybridModel.AddService(s) - for _, m := range s.Methods() { - hybridModel.AddMethod(m) - } - } - // Populate messageByID and enumByID with ALL package messages and enums. - // This avoids aliasing model.messageByID while allowing model - // annotation to resolve field types across the entire package. - for m := range model.AllMessages() { - hybridModel.AddMessage(m) - } - for e := range model.AllEnums() { - hybridModel.AddEnum(e) - } - for m := range model.AllMaps() { - hybridModel.AddMap(m) - } - for _, r := range hybridModel.ResourceDefinitions { - hybridModel.AddResource(r) - } + return reachableMsgs[id] || reachableEnums[id] + }) var unusedTypes []string for m := range model.AllMessages() { @@ -305,7 +248,7 @@ func filterModelToTypes(model *api.API, rootTypeIDs []string, allowGrpcAnyFields } slices.Sort(unusedTypes) - return &hybridModel, slices.Compact(unusedTypes), hasGoogleRpcStatus, nil + return hybridModel, slices.Compact(unusedTypes), hasGoogleRpcStatus, nil } func isAnyType(id string) bool { @@ -319,14 +262,3 @@ func isGoogleRpcStatus(id string) bool { func isWKT(id string) bool { return strings.HasPrefix(strings.TrimPrefix(id, "."), "google.protobuf.") } - -func cloneServices(services []*api.Service) []*api.Service { - if services == nil { - return nil - } - cloned := make([]*api.Service, len(services)) - for i, s := range services { - cloned[i] = s.Clone() - } - return cloned -} diff --git a/internal/sidekick/api/filter.go b/internal/sidekick/api/filter.go new file mode 100644 index 0000000000..61c5222317 --- /dev/null +++ b/internal/sidekick/api/filter.go @@ -0,0 +1,121 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import ( + "cmp" + "slices" +) + +// Filter returns a shallow copy of the API containing cloned services and only +// the top-level messages, enums, and external types whose IDs satisfy keep. +// If keep is nil, all types are retained. +// +// Lookup maps on the returned API retain all messages, enums, maps, and +// resources from the receiver so cross-type references continue to resolve +// without aliasing the receiver's maps. +func (a *API) Filter(keep func(id string) bool) *API { + if a == nil { + return nil + } + if keep == nil { + keep = func(string) bool { return true } + } + + var filteredMsgs []*Message + for _, m := range a.Messages { + if keep(m.ID()) { + filteredMsgs = append(filteredMsgs, m) + } + } + var filteredEnums []*Enum + for _, e := range a.Enums { + if keep(e.ID()) { + filteredEnums = append(filteredEnums, e) + } + } + + // Collect external top-level types satisfying keep, sorted by ID because + // AllMessages/AllEnums iterate over maps in randomized order. + var externalMessages []*Message + for m := range a.AllMessages() { + if m.ID() != "" && m.Parent() == nil && m.Package() != a.PackageName && m.Package() != ReservedPackageName && keep(m.ID()) { + externalMessages = append(externalMessages, m) + } + } + slices.SortFunc(externalMessages, func(x, y *Message) int { return cmp.Compare(x.ID(), y.ID()) }) + + var externalEnums []*Enum + for e := range a.AllEnums() { + if e.ID() != "" && e.Parent() == nil && e.Package() != a.PackageName && e.Package() != ReservedPackageName && keep(e.ID()) { + externalEnums = append(externalEnums, e) + } + } + slices.SortFunc(externalEnums, func(x, y *Enum) int { return cmp.Compare(x.ID(), y.ID()) }) + + var services []*Service + quickstart := a.QuickstartService + if a.Services != nil { + services = make([]*Service, len(a.Services)) + for i, s := range a.Services { + services[i] = s.Clone() + if s == a.QuickstartService { + quickstart = services[i] + } + } + } + + filtered := &API{ + Name: a.Name, + PackageName: a.PackageName, + Title: a.Title, + Description: a.Description, + Revision: a.Revision, + Services: services, + Messages: filteredMsgs, + ExternalMessages: externalMessages, + Enums: filteredEnums, + ExternalEnums: externalEnums, + ResourceDefinitions: slices.Clone(a.ResourceDefinitions), + QuickstartService: quickstart, + RubyPackage: a.RubyPackage, + PhpNamespace: a.PhpNamespace, + CsharpNamespace: a.CsharpNamespace, + } + for _, s := range services { + s.model = filtered + filtered.AddService(s) + for _, m := range s.Methods() { + m.model = filtered + filtered.AddMethod(m) + } + } + // Populate lookup maps with all package messages, enums, maps, and + // resources to avoid aliasing a's maps while still resolving field types + // across excluded top-level elements. + for m := range a.AllMessages() { + filtered.AddMessage(m) + } + for e := range a.AllEnums() { + filtered.AddEnum(e) + } + for m := range a.AllMaps() { + filtered.AddMap(m) + } + for _, r := range filtered.ResourceDefinitions { + filtered.AddResource(r) + } + return filtered +} diff --git a/internal/sidekick/api/filter_test.go b/internal/sidekick/api/filter_test.go new file mode 100644 index 0000000000..1ce536f10f --- /dev/null +++ b/internal/sidekick/api/filter_test.go @@ -0,0 +1,146 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import ( + "slices" + "testing" + + "github.com/google/go-cmp/cmp" +) + +func TestAPI_Filter_Nil(t *testing.T) { + if (*API)(nil).Filter(func(string) bool { return true }) != nil { + t.Errorf("(*API)(nil).Filter() should return nil") + } + + m1 := NewTestMessage("M1") + e1 := NewTestEnum("E1") + extM1 := NewTestMessage("ExtM1").WithPackage("google.type") + extE1 := NewTestEnum("ExtE1").WithPackage("google.type") + + model := NewTestAPI([]*Message{m1}, []*Enum{e1}, nil) + model.AddMessage(extM1) + model.AddEnum(extE1) + + got := model.Filter(nil) + if diff := cmp.Diff([]*Message{m1}, got.Messages, allowUnexported()); diff != "" { + t.Errorf("Messages mismatch (-want +got):\n%s", diff) + } + if diff := cmp.Diff([]*Enum{e1}, got.Enums, allowUnexported()); diff != "" { + t.Errorf("Enums mismatch (-want +got):\n%s", diff) + } + if !slices.Contains(got.ExternalMessages, extM1) || !slices.Contains(got.ExternalMessages, model.Message(".google.protobuf.Any")) { + t.Errorf("ExternalMessages = %v, want extM1 and pre-registered external messages retained", got.ExternalMessages) + } + if !slices.Contains(got.ExternalEnums, extE1) || !slices.Contains(got.ExternalEnums, model.Enum(".google.protobuf.NullValue")) { + t.Errorf("ExternalEnums = %v, want extE1 and pre-registered external enums retained", got.ExternalEnums) + } +} + +func TestAPI_Filter(t *testing.T) { + m1 := NewTestMessage("M1") + m2 := NewTestMessage("M2") + e1 := NewTestEnum("E1") + e2 := NewTestEnum("E2") + extM1 := NewTestMessage("ExtM1").WithPackage("google.type") + extM2 := NewTestMessage("ExtM2").WithPackage("google.type") + extE1 := NewTestEnum("ExtE1").WithPackage("google.type") + extE2 := NewTestEnum("ExtE2").WithPackage("google.type") + meth1 := NewTestMethod("Method1").WithInput(m1).WithOutput(m1) + s1 := NewTestService("S1").WithMethods(meth1) + s2 := NewTestService("S2") + res := NewTestResource("test.googleapis.com/Book") + mapType := NewTestMap("AttributesEntry", TypezString, TypezString) + + model := NewTestAPI([]*Message{m1, m2}, []*Enum{e1, e2}, []*Service{s1, s2}) + model.Name = "testapi" + model.Title = "Test API" + model.Description = "Test API description" + model.Revision = "2026-01-01" + model.RubyPackage = "Test::Api" + model.PhpNamespace = "Test\\Api" + model.CsharpNamespace = "Test.Api" + model.QuickstartService = s1 + model.Codec = "orig-codec" + model.ResourceDefinitions = []*Resource{res} + s1.SetAnnotations("svc-codec") + model.AddMessage(extM1) + model.AddMessage(extM2) + model.AddEnum(extE1) + model.AddEnum(extE2) + model.AddMap(mapType) + model.AddResource(res) + + filtered := model.Filter(func(id string) bool { + return id == m1.ID() || id == e1.ID() || id == extM1.ID() || id == extE1.ID() + }) + + if len(filtered.Messages) != 1 || filtered.Messages[0] != m1 { + t.Errorf("got Messages = %v, want [%v]", filtered.Messages, m1) + } + if len(filtered.Enums) != 1 || filtered.Enums[0] != e1 { + t.Errorf("got Enums = %v, want [%v]", filtered.Enums, e1) + } + if len(filtered.ExternalMessages) != 1 || filtered.ExternalMessages[0] != extM1 { + t.Errorf("got ExternalMessages = %v, want [%v]", filtered.ExternalMessages, extM1) + } + if len(filtered.ExternalEnums) != 1 || filtered.ExternalEnums[0] != extE1 { + t.Errorf("got ExternalEnums = %v, want [%v]", filtered.ExternalEnums, extE1) + } + if got := filtered.Message(m2.ID()); got != m2 { + t.Errorf("filtered.Message(%q) = %v, want %v", m2.ID(), got, m2) + } + if got := filtered.Enum(e2.ID()); got != e2 { + t.Errorf("filtered.Enum(%q) = %v, want %v", e2.ID(), got, e2) + } + if got := filtered.Map(mapType.ID()); got != mapType { + t.Errorf("filtered.Map(%q) = %v, want %v", mapType.ID(), got, mapType) + } + if got := filtered.Resource(res.Type()); got != res { + t.Errorf("filtered.Resource(%q) = %v, want %v", res.Type(), got, res) + } + if filtered.Codec != nil { + t.Errorf("filtered.Codec = %v, want nil", filtered.Codec) + } + + services := filtered.Services + if len(services) != 2 { + t.Fatalf("len(filtered.Services) = %d, want 2", len(services)) + } + if services[0] == s1 || services[0].Codec() != nil { + t.Errorf("cloned service did not preserve Clone() semantics") + } + if filtered.QuickstartService != services[0] { + t.Errorf("filtered.QuickstartService = %v, want %v", filtered.QuickstartService, services[0]) + } + if services[0].Model() != filtered { + t.Errorf("services[0].Model() = %v, want %v", services[0].Model(), filtered) + } + methods := services[0].Methods() + if len(methods) != 1 || methods[0].Model() != filtered { + t.Errorf("cloned method Model() = %v, want %v", methods[0].Model(), filtered) + } + if filtered.Name != model.Name || + filtered.PackageName != model.PackageName || + filtered.Title != model.Title || + filtered.Description != model.Description || + filtered.Revision != model.Revision || + filtered.RubyPackage != model.RubyPackage || + filtered.PhpNamespace != model.PhpNamespace || + filtered.CsharpNamespace != model.CsharpNamespace { + t.Errorf("API metadata was not preserved: got %+v", filtered) + } +} From d1504d71e24e12aa1c61d6aa32a06557cd147595 Mon Sep 17 00:00:00 2001 From: Carlos O'Ryan Date: Thu, 29 Oct 2026 18:19:37 +0000 Subject: [PATCH 2/2] refactor(sidekick/api): read-only API Make API fields private with getters and APIBuilder. Part of #7837 Closes #7857 --- .../librarian/rust/create_repo_metadata.go | 2 +- .../rust/generate_prost_hybrid_test.go | 42 +- internal/librarian/rust/resolve.go | 12 +- .../librarian/swift/create_repo_metadata.go | 2 +- internal/sidekick/api/api.go | 142 ++++-- internal/sidekick/api/api_builder.go | 456 ++++++++++++++++++ internal/sidekick/api/api_test.go | 107 ++++ internal/sidekick/api/apitest/apitest.go | 20 + internal/sidekick/api/deprecated.go | 6 +- internal/sidekick/api/deprecated_test.go | 6 +- internal/sidekick/api/discovery.go | 4 +- internal/sidekick/api/filter.go | 66 +-- internal/sidekick/api/filter_test.go | 107 ++-- internal/sidekick/api/method_test.go | 2 +- .../sidekick/api/resource_identification.go | 6 +- .../api/resource_identification_test.go | 8 +- .../sidekick/api/resource_name_heuristic.go | 2 +- internal/sidekick/api/service_test.go | 2 +- internal/sidekick/api/skip.go | 12 +- internal/sidekick/api/skip_test.go | 12 +- internal/sidekick/api/test.go | 60 ++- internal/sidekick/api/test_test.go | 16 +- internal/sidekick/api/validate.go | 10 +- internal/sidekick/api/validate_test.go | 12 +- internal/sidekick/api/well_known_types.go | 8 +- internal/sidekick/api/xref.go | 12 +- internal/sidekick/api/xref_aip_test.go | 12 +- internal/sidekick/api/xref_samples_test.go | 2 +- internal/sidekick/api/xref_test.go | 2 +- .../sidekick/codec_sample/annotate_model.go | 10 +- .../codec_sample/annotate_model_test.go | 4 +- internal/sidekick/dart/annotate.go | 49 +- internal/sidekick/dart/annotate_test.go | 38 +- internal/sidekick/dart/dart.go | 2 +- internal/sidekick/dart/generate.go | 4 +- internal/sidekick/language/gotemplate_test.go | 9 +- internal/sidekick/parser/disco_test.go | 34 +- .../sidekick/parser/discovery/discovery.go | 37 +- .../parser/discovery/discovery_test.go | 21 +- internal/sidekick/parser/discovery/enum.go | 2 +- .../parser/discovery/enum_field_test.go | 15 +- .../parser/discovery/inline_object_field.go | 4 +- .../discovery/inline_object_field_test.go | 12 +- .../sidekick/parser/discovery/map_field.go | 12 +- .../parser/discovery/map_field_test.go | 17 +- .../parser/discovery/message_fields.go | 14 +- .../parser/discovery/message_fields_test.go | 15 +- internal/sidekick/parser/discovery/methods.go | 12 +- .../sidekick/parser/discovery/methods_test.go | 6 +- .../sidekick/parser/discovery/services.go | 10 +- .../parser/discovery/services_test.go | 15 +- internal/sidekick/parser/openapi.go | 55 +-- internal/sidekick/parser/openapi_test.go | 16 +- internal/sidekick/parser/package_name.go | 13 +- internal/sidekick/parser/parser.go | 34 +- internal/sidekick/parser/parser_test.go | 20 +- internal/sidekick/parser/protobuf.go | 78 +-- .../sidekick/parser/protobuf_mixin_test.go | 10 +- internal/sidekick/parser/protobuf_test.go | 32 +- internal/sidekick/rust/annotate_enum.go | 4 +- internal/sidekick/rust/annotate_field.go | 8 +- internal/sidekick/rust/annotate_field_test.go | 2 +- internal/sidekick/rust/annotate_message.go | 4 +- internal/sidekick/rust/annotate_method.go | 6 +- internal/sidekick/rust/annotate_model.go | 39 +- internal/sidekick/rust/annotate_model_test.go | 36 +- internal/sidekick/rust/annotate_oneof.go | 6 +- internal/sidekick/rust/annotate_service.go | 2 +- internal/sidekick/rust/bigquery.go | 6 +- internal/sidekick/rust/codec.go | 29 +- internal/sidekick/rust/codec_test.go | 34 +- internal/sidekick/rust/generate.go | 32 +- .../sidekick/rust/generate_convert_test.go | 6 +- internal/sidekick/rust/prost.go | 4 +- internal/sidekick/rust/prost_test.go | 6 +- internal/sidekick/rust/used_by_test.go | 8 +- internal/sidekick/rust_prost/annotate.go | 4 +- internal/sidekick/rust_prost/annotate_test.go | 2 +- .../sidekick/swift/annotate_field_test.go | 4 +- .../sidekick/swift/annotate_lro_any_test.go | 2 +- internal/sidekick/swift/annotate_message.go | 4 +- .../sidekick/swift/annotate_message_test.go | 5 +- .../sidekick/swift/annotate_method_test.go | 16 +- internal/sidekick/swift/annotate_model.go | 36 +- .../sidekick/swift/annotate_model_test.go | 74 ++- internal/sidekick/swift/annotate_service.go | 16 +- .../sidekick/swift/annotate_service_test.go | 35 +- internal/sidekick/swift/codec.go | 2 +- internal/sidekick/swift/codec_test.go | 9 +- internal/sidekick/swift/doc_link.go | 2 +- internal/sidekick/swift/field_type_name.go | 8 +- .../sidekick/swift/field_type_name_test.go | 4 +- internal/sidekick/swift/generate.go | 18 +- .../sidekick/swift/generate_conversions.go | 4 +- .../sidekick/swift/generate_lro_any_test.go | 10 +- .../swift/generate_message_swift_test.go | 5 +- .../swift/generate_method_signatures_test.go | 9 +- .../sidekick/swift/generate_readme_test.go | 4 +- .../swift/generate_service_swift_test.go | 26 +- .../sidekick/swift/generate_snippets_test.go | 23 +- .../sidekick/swift/generate_storage_test.go | 11 +- internal/sidekick/swift/generate_stub_test.go | 25 +- internal/sidekick/swift/library_name.go | 12 +- internal/sidekick/swift/package_name.go | 2 +- internal/sidekick/swift/storage.go | 28 +- .../templates/docc/landing_page.md.gotmpl | 2 +- .../swift/templates/package/README.md.gotmpl | 2 +- 107 files changed, 1537 insertions(+), 849 deletions(-) create mode 100644 internal/sidekick/api/api_builder.go create mode 100644 internal/sidekick/api/api_test.go diff --git a/internal/librarian/rust/create_repo_metadata.go b/internal/librarian/rust/create_repo_metadata.go index 1389cc0f3d..a72dee7bc9 100644 --- a/internal/librarian/rust/create_repo_metadata.go +++ b/internal/librarian/rust/create_repo_metadata.go @@ -42,7 +42,7 @@ func createRepoMetadata(cfg *config.Config, library *config.Library, sources *so } func needsRepoMetadata(model *api.API, library *config.Library) bool { - if len(model.Services) == 0 { + if len(model.Services()) == 0 { return false } if len(library.APIs) == 0 { diff --git a/internal/librarian/rust/generate_prost_hybrid_test.go b/internal/librarian/rust/generate_prost_hybrid_test.go index fb5b4c4ac5..75b52b453c 100644 --- a/internal/librarian/rust/generate_prost_hybrid_test.go +++ b/internal/librarian/rust/generate_prost_hybrid_test.go @@ -146,8 +146,8 @@ func TestFilterModelToTypes(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - if len(filtered.Messages) != 1 || filtered.Messages[0].ID() != streamingMsg.ID() { - t.Errorf("got messages %v, want [%s]", filtered.Messages, streamingMsg.ID()) + if len(filtered.Messages()) != 1 || filtered.Messages()[0].ID() != streamingMsg.ID() { + t.Errorf("got messages %v, want [%s]", filtered.Messages(), streamingMsg.ID()) } if len(unused) != 1 || unused[0] != unusedMsg.ID() { t.Errorf("got unused %v, want [%s]", unused, unusedMsg.ID()) @@ -172,8 +172,8 @@ func TestFilterModelToTypesUnusedFieldLookup(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - if len(filtered.Messages) != 1 || filtered.Messages[0].ID() != streamMsg.ID() { - t.Errorf("got messages %v, want [%s]", filtered.Messages, streamMsg.ID()) + if len(filtered.Messages()) != 1 || filtered.Messages()[0].ID() != streamMsg.ID() { + t.Errorf("got messages %v, want [%s]", filtered.Messages(), streamMsg.ID()) } if got := filtered.Message(childData.ID()); got != childData { t.Errorf("filtered.Message(%q) = %v, want %v", childData.ID(), got, childData) @@ -191,9 +191,10 @@ func TestFilterModelToTypesExternalTypes(t *testing.T) { api.NewTestField("day").WithEnumType(externalEnum), ) - model := api.NewTestAPI([]*api.Message{streamMsg}, []*api.Enum{}, []*api.Service{}) - model.AddMessage(externalMsg) - model.AddEnum(externalEnum) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{streamMsg}, []*api.Enum{}, []*api.Service{})). + AddMessage(externalMsg). + AddEnum(externalEnum). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -203,14 +204,14 @@ func TestFilterModelToTypesExternalTypes(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - if len(filtered.Messages) != 1 || filtered.Messages[0].ID() != streamMsg.ID() { - t.Errorf("got package messages %v, want [%s]", filtered.Messages, streamMsg.ID()) + if len(filtered.Messages()) != 1 || filtered.Messages()[0].ID() != streamMsg.ID() { + t.Errorf("got package messages %v, want [%s]", filtered.Messages(), streamMsg.ID()) } - if len(filtered.ExternalMessages) != 1 || filtered.ExternalMessages[0].ID() != externalMsg.ID() { - t.Errorf("got ExternalMessages %v, want [%s]", filtered.ExternalMessages, externalMsg.ID()) + if len(filtered.ExternalMessages()) != 1 || filtered.ExternalMessages()[0].ID() != externalMsg.ID() { + t.Errorf("got ExternalMessages %v, want [%s]", filtered.ExternalMessages(), externalMsg.ID()) } - if len(filtered.ExternalEnums) != 1 || filtered.ExternalEnums[0].ID() != externalEnum.ID() { - t.Errorf("got ExternalEnums %v, want [%s]", filtered.ExternalEnums, externalEnum.ID()) + if len(filtered.ExternalEnums()) != 1 || filtered.ExternalEnums()[0].ID() != externalEnum.ID() { + t.Errorf("got ExternalEnums %v, want [%s]", filtered.ExternalEnums(), externalEnum.ID()) } } @@ -374,16 +375,17 @@ func TestFilterModelToTypesGoogleRpcStatus(t *testing.T) { api.NewTestField("status").WithMessageType(statusMsg), ) - statusModel := api.NewTestAPI([]*api.Message{reqMsg}, []*api.Enum{}, []*api.Service{}) - statusModel.AddMessage(statusMsg) + statusModel := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{reqMsg}, []*api.Enum{}, []*api.Service{})). + AddMessage(statusMsg). + BuildSyntaxTree() filtered, unused, hasStatus, err := filterModelToTypes(statusModel, []string{reqMsg.ID()}, nil) if err != nil { t.Fatalf("unexpected error for google.rpc.Status: %v", err) } - if len(filtered.Messages) != 1 { - t.Errorf("got %d messages, want 1 (StreamReq only, google.rpc.Status handled via Codec)", len(filtered.Messages)) + if len(filtered.Messages()) != 1 { + t.Errorf("got %d messages, want 1 (StreamReq only, google.rpc.Status handled via Codec)", len(filtered.Messages())) } if !hasStatus { @@ -474,7 +476,7 @@ func TestFilterModelToTypesMultipleRoots(t *testing.T) { t.Fatalf("unexpected error: %v", err) } var gotMessages []string - for _, m := range filtered.Messages { + for _, m := range filtered.Messages() { gotMessages = append(gotMessages, m.ID()) } less := func(a, b string) bool { return a < b } @@ -501,7 +503,7 @@ func TestFilterModelToTypesCyclicRecursion(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - if len(filtered.Messages) != 1 { - t.Errorf("expected 1 parsed message, got %d", len(filtered.Messages)) + if len(filtered.Messages()) != 1 { + t.Errorf("expected 1 parsed message, got %d", len(filtered.Messages())) } } diff --git a/internal/librarian/rust/resolve.go b/internal/librarian/rust/resolve.go index c036a625bf..0d6a982b35 100644 --- a/internal/librarian/rust/resolve.go +++ b/internal/librarian/rust/resolve.go @@ -61,24 +61,24 @@ func findExternalPackages(lib *config.Library, sources *sources.Sources, pc *con for _, api := range lib.APIs { ownedPackages[toPackageName(api.Path)] = true } - for _, s := range model.Services { + for _, s := range model.Services() { ownedPackages[s.Package()] = true } - for _, m := range model.Messages { + for _, m := range model.Messages() { ownedPackages[m.Package()] = true } - for _, e := range model.Enums { + for _, e := range model.Enums() { ownedPackages[e.Package()] = true } // Identify all dependencies. var targetIDs []string - for _, s := range model.Services { + for _, s := range model.Services() { targetIDs = append(targetIDs, s.ID()) } - for _, m := range model.Messages { + for _, m := range model.Messages() { targetIDs = append(targetIDs, m.ID()) } - for _, e := range model.Enums { + for _, e := range model.Enums() { targetIDs = append(targetIDs, e.ID()) } allDeps, err := api.FindDependencies(model, targetIDs) diff --git a/internal/librarian/swift/create_repo_metadata.go b/internal/librarian/swift/create_repo_metadata.go index 0e2ae2d13b..c8142280a3 100644 --- a/internal/librarian/swift/create_repo_metadata.go +++ b/internal/librarian/swift/create_repo_metadata.go @@ -66,7 +66,7 @@ func createRepoMetadata(cfg *config.Config, library *config.Library, src *source } func needsRepoMetadata(model *api.API, library *config.Library) bool { - if len(model.Services) == 0 { + if len(model.Services()) == 0 { return false } if len(library.APIs) == 0 { diff --git a/internal/sidekick/api/api.go b/internal/sidekick/api/api.go index 7d09ac5965..bc78cafb00 100644 --- a/internal/sidekick/api/api.go +++ b/internal/sidekick/api/api.go @@ -17,40 +17,41 @@ package api import ( "iter" "maps" + "slices" ) // API represents an API surface. type API struct { // Name of the API (e.g. secretmanager). - Name string + name string // Name of the package name in the source specification format. For Protobuf // this may be `google.cloud.secretmanager.v1`. - PackageName string + packageName string // The API Title (e.g. "Secret Manager API" or "Cloud Spanner API"). - Title string + title string // The API Description. - Description string + description string // The API Revision. In discovery-based services this is the "revision" // attribute. - Revision string + revision string // Services are a collection of services that make up the API. - Services []*Service + services []*Service // Messages are a collection of messages used to process request and // responses in the API. - Messages []*Message + messages []*Message // ExternalMessages are top-level messages from external packages (e.g. google.type.LatLng). - ExternalMessages []*Message + externalMessages []*Message // Enums - Enums []*Enum + enums []*Enum // ExternalEnums are top-level enums from external packages. - ExternalEnums []*Enum + externalEnums []*Enum // ResourceDefinitions contains the data from the `google.api.resource_definition` annotation. - ResourceDefinitions []*Resource + resourceDefinitions []*Resource // QuickstartService is the service that will be used to generate the quickstart sample // at the package level. - QuickstartService *Service + quickstartService *Service // Language specific annotations. - Codec any + codec any // serviceByID returns a service that is associated with the API. serviceByID map[string]*Service @@ -78,7 +79,7 @@ type API struct { // for Swift uses this to emit warnings if: (1) the Ruby override differs // from the standard name, and (2) there is no override in the // `librarian.yaml` file. - RubyPackage string + rubyPackage string // PhpNamespace captures the namespace override for PHP. // @@ -93,7 +94,7 @@ type API struct { // for Swift uses this to emit warnings if: (1) the PHP override differs // from the standard name, and (2) there is no override in the // `librarian.yaml` file. - PhpNamespace string + phpNamespace string // CsharpNamespace captures the namespace override for C#. // @@ -107,7 +108,7 @@ type API struct { // for Swift uses this to emit warnings if: (1) the C# override differs // from the standard name, and (2) there is no override in the // `librarian.yaml` file. - CsharpNamespace string + csharpNamespace string } // ModelOverride holds configuration overrides for an API model. @@ -119,12 +120,97 @@ type ModelOverride struct { SkippedIDs []string } +// Name returns the name of the API (e.g. secretmanager). +func (a *API) Name() string { + return a.name +} + +// PackageName returns the package name in the source specification format. +func (a *API) PackageName() string { + return a.packageName +} + +// Title returns the API title. +func (a *API) Title() string { + return a.title +} + +// Description returns the API description. +func (a *API) Description() string { + return a.description +} + +// Revision returns the API revision. +func (a *API) Revision() string { + return a.revision +} + +// Services returns the collection of services that make up the API. +func (a *API) Services() []*Service { + return slices.Clone(a.services) +} + +// Messages returns the collection of messages in the API. +func (a *API) Messages() []*Message { + return slices.Clone(a.messages) +} + +// ExternalMessages returns top-level messages from external packages. +func (a *API) ExternalMessages() []*Message { + return slices.Clone(a.externalMessages) +} + +// Enums returns the collection of enums in the API. +func (a *API) Enums() []*Enum { + return slices.Clone(a.enums) +} + +// ExternalEnums returns top-level enums from external packages. +func (a *API) ExternalEnums() []*Enum { + return slices.Clone(a.externalEnums) +} + +// ResourceDefinitions returns the resource definitions from google.api.resource_definition. +func (a *API) ResourceDefinitions() []*Resource { + return slices.Clone(a.resourceDefinitions) +} + +// QuickstartService returns the service used to generate the package-level quickstart sample. +func (a *API) QuickstartService() *Service { + return a.quickstartService +} + +// Codec returns the language-specific annotations. +func (a *API) Codec() any { + return a.codec +} + +// SetAnnotations sets the language-specific annotations on the API. +func (a *API) SetAnnotations(codec any) { + a.codec = codec +} + +// RubyPackage returns the package name override for Ruby. +func (a *API) RubyPackage() string { + return a.rubyPackage +} + +// PhpNamespace returns the namespace override for PHP. +func (a *API) PhpNamespace() string { + return a.phpNamespace +} + +// CsharpNamespace returns the namespace override for C#. +func (a *API) CsharpNamespace() string { + return a.csharpNamespace +} + // HasMessages returns true if the API contains messages (most do). // // This is useful in Go templates to skip code that only makes sense // when per-message code follows. func (a *API) HasMessages() bool { - return len(a.Messages) != 0 + return len(a.messages) != 0 } // HasServices returns true if the API contains services (most do). @@ -132,7 +218,7 @@ func (a *API) HasMessages() bool { // This is useful in Go templates to skip code that only makes sense // when per-service code follows. func (a *API) HasServices() bool { - return len(a.Services) != 0 + return len(a.services) != 0 } // ModelCodec returns the Codec field with an alternative name. @@ -140,7 +226,7 @@ func (a *API) HasServices() bool { // In some Go templates we want to access the annotations for the // enclosing model. func (a *API) ModelCodec() any { - return a.Codec + return a.codec } // Service returns a service that is associated with the API. @@ -153,8 +239,7 @@ func (a *API) AllServices() iter.Seq[*Service] { return maps.Values(a.serviceByID) } -// AddService adds a service to the API. -func (a *API) AddService(s *Service) { +func (a *API) addService(s *Service) { if a.serviceByID == nil { a.serviceByID = make(map[string]*Service) } @@ -171,8 +256,7 @@ func (a *API) AllMethods() iter.Seq[*Method] { return maps.Values(a.methodByID) } -// AddMethod adds a method to the API. -func (a *API) AddMethod(m *Method) { +func (a *API) addMethod(m *Method) { if a.methodByID == nil { a.methodByID = make(map[string]*Method) } @@ -189,8 +273,7 @@ func (a *API) AllMessages() iter.Seq[*Message] { return maps.Values(a.messageByID) } -// AddMessage adds a message to the API. -func (a *API) AddMessage(m *Message) { +func (a *API) addMessage(m *Message) { if a.messageByID == nil { a.messageByID = make(map[string]*Message) } @@ -207,8 +290,7 @@ func (a *API) AllEnums() iter.Seq[*Enum] { return maps.Values(a.enumByID) } -// AddEnum adds an enum to the API. -func (a *API) AddEnum(e *Enum) { +func (a *API) addEnum(e *Enum) { if a.enumByID == nil { a.enumByID = make(map[string]*Enum) } @@ -225,8 +307,7 @@ func (a *API) AllResources() iter.Seq[*Resource] { return maps.Values(a.resourceByType) } -// AddResource adds a resource to the API. -func (a *API) AddResource(r *Resource) { +func (a *API) addResource(r *Resource) { if a.resourceByType == nil { a.resourceByType = make(map[string]*Resource) } @@ -243,8 +324,7 @@ func (a *API) AllMaps() iter.Seq[*Map] { return maps.Values(a.mapByID) } -// AddMap adds a map to the API. -func (a *API) AddMap(m *Map) { +func (a *API) addMap(m *Map) { if a.mapByID == nil { a.mapByID = make(map[string]*Map) } diff --git a/internal/sidekick/api/api_builder.go b/internal/sidekick/api/api_builder.go new file mode 100644 index 0000000000..aebb54a910 --- /dev/null +++ b/internal/sidekick/api/api_builder.go @@ -0,0 +1,456 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import ( + "iter" + "maps" + "slices" +) + +// APIBuilder constructs an [API]. +type APIBuilder struct { + a API + paginationOverrides []PaginationOverride + resourceNameHeuristic bool + override ModelOverride + commentOverrides []DocumentationOverride +} + +// NewAPIBuilder creates a new [APIBuilder]. +func NewAPIBuilder() *APIBuilder { + return &APIBuilder{ + a: API{ + serviceByID: make(map[string]*Service), + methodByID: make(map[string]*Method), + messageByID: make(map[string]*Message), + enumByID: make(map[string]*Enum), + resourceByType: make(map[string]*Resource), + mapByID: make(map[string]*Map), + }, + } +} + +// NewAPIBuilderFrom creates a new [APIBuilder] initialized from an existing [API]. +func NewAPIBuilderFrom(a *API) *APIBuilder { + b := NewAPIBuilder() + if a == nil { + return b + } + b.a = API{ + name: a.name, + packageName: a.packageName, + title: a.title, + description: a.description, + revision: a.revision, + services: slices.Clone(a.services), + messages: slices.Clone(a.messages), + externalMessages: slices.Clone(a.externalMessages), + enums: slices.Clone(a.enums), + externalEnums: slices.Clone(a.externalEnums), + resourceDefinitions: slices.Clone(a.resourceDefinitions), + quickstartService: a.quickstartService, + codec: a.codec, + serviceByID: maps.Clone(a.serviceByID), + methodByID: maps.Clone(a.methodByID), + messageByID: maps.Clone(a.messageByID), + enumByID: maps.Clone(a.enumByID), + resourceByType: maps.Clone(a.resourceByType), + mapByID: maps.Clone(a.mapByID), + rubyPackage: a.rubyPackage, + phpNamespace: a.phpNamespace, + csharpNamespace: a.csharpNamespace, + } + if b.a.serviceByID == nil { + b.a.serviceByID = make(map[string]*Service) + } + if b.a.methodByID == nil { + b.a.methodByID = make(map[string]*Method) + } + if b.a.messageByID == nil { + b.a.messageByID = make(map[string]*Message) + } + if b.a.enumByID == nil { + b.a.enumByID = make(map[string]*Enum) + } + if b.a.resourceByType == nil { + b.a.resourceByType = make(map[string]*Resource) + } + if b.a.mapByID == nil { + b.a.mapByID = make(map[string]*Map) + } + return b +} + +// NewAnnotatedAPI creates a minimal [API] whose Codec field is set to codec. +func NewAnnotatedAPI(codec any) *API { + return &API{codec: codec} +} + +// WithName sets the API name. +func (b *APIBuilder) WithName(name string) *APIBuilder { + b.a.name = name + return b +} + +// Name returns the API name currently set on the builder. +func (b *APIBuilder) Name() string { + return b.a.name +} + +// WithPackageName sets the API package name. +func (b *APIBuilder) WithPackageName(packageName string) *APIBuilder { + b.a.packageName = packageName + return b +} + +// PackageName returns the API package name currently set on the builder. +func (b *APIBuilder) PackageName() string { + return b.a.packageName +} + +// WithTitle sets the API title. +func (b *APIBuilder) WithTitle(title string) *APIBuilder { + b.a.title = title + return b +} + +// Title returns the API title currently set on the builder. +func (b *APIBuilder) Title() string { + return b.a.title +} + +// WithDescription sets the API description. +func (b *APIBuilder) WithDescription(description string) *APIBuilder { + b.a.description = description + return b +} + +// Description returns the API description currently set on the builder. +func (b *APIBuilder) Description() string { + return b.a.description +} + +// WithRevision sets the API revision. +func (b *APIBuilder) WithRevision(revision string) *APIBuilder { + b.a.revision = revision + return b +} + +// WithServices sets the services slice. +func (b *APIBuilder) WithServices(services ...*Service) *APIBuilder { + b.a.services = services + return b +} + +// AppendService appends a service to the services slice. +func (b *APIBuilder) AppendService(services ...*Service) *APIBuilder { + b.a.services = append(b.a.services, services...) + return b +} + +// Services returns the services slice currently set on the builder. +func (b *APIBuilder) Services() []*Service { + return slices.Clone(b.a.services) +} + +// SortServices sorts the services slice using cmpFunc. +func (b *APIBuilder) SortServices(cmpFunc func(a, b *Service) int) *APIBuilder { + slices.SortStableFunc(b.a.services, cmpFunc) + return b +} + +// WithMessages sets the messages slice. +func (b *APIBuilder) WithMessages(messages ...*Message) *APIBuilder { + if len(messages) == 0 { + b.a.messages = make([]*Message, 0) + } else { + b.a.messages = messages + } + return b +} + +// AppendMessage appends a message to the messages slice. +func (b *APIBuilder) AppendMessage(messages ...*Message) *APIBuilder { + b.a.messages = append(b.a.messages, messages...) + return b +} + +// Messages returns the messages slice currently set on the builder. +func (b *APIBuilder) Messages() []*Message { + return slices.Clone(b.a.messages) +} + +// SortMessages sorts the messages slice using cmpFunc. +func (b *APIBuilder) SortMessages(cmpFunc func(a, b *Message) int) *APIBuilder { + slices.SortStableFunc(b.a.messages, cmpFunc) + return b +} + +// WithExternalMessages sets the external messages slice. +func (b *APIBuilder) WithExternalMessages(messages ...*Message) *APIBuilder { + b.a.externalMessages = messages + return b +} + +// WithEnums sets the enums slice. +func (b *APIBuilder) WithEnums(enums ...*Enum) *APIBuilder { + b.a.enums = enums + return b +} + +// AppendEnum appends an enum to the enums slice. +func (b *APIBuilder) AppendEnum(enums ...*Enum) *APIBuilder { + b.a.enums = append(b.a.enums, enums...) + return b +} + +// Enums returns the enums slice currently set on the builder. +func (b *APIBuilder) Enums() []*Enum { + return slices.Clone(b.a.enums) +} + +// WithExternalEnums sets the external enums slice. +func (b *APIBuilder) WithExternalEnums(enums ...*Enum) *APIBuilder { + b.a.externalEnums = enums + return b +} + +// WithResourceDefinitions sets the resource definitions slice. +func (b *APIBuilder) WithResourceDefinitions(resources ...*Resource) *APIBuilder { + b.a.resourceDefinitions = resources + return b +} + +// AppendResourceDefinitions appends resources to the resource definitions slice. +func (b *APIBuilder) AppendResourceDefinitions(resources ...*Resource) *APIBuilder { + b.a.resourceDefinitions = append(b.a.resourceDefinitions, resources...) + return b +} + +// ResourceDefinitions returns the resource definitions currently set on the builder. +func (b *APIBuilder) ResourceDefinitions() []*Resource { + return slices.Clone(b.a.resourceDefinitions) +} + +// WithQuickstartService sets the quickstart service. +func (b *APIBuilder) WithQuickstartService(s *Service) *APIBuilder { + b.a.quickstartService = s + return b +} + +// WithRubyPackage sets the Ruby package override. +func (b *APIBuilder) WithRubyPackage(pkg string) *APIBuilder { + b.a.rubyPackage = pkg + return b +} + +// RubyPackage returns the Ruby package override currently set on the builder. +func (b *APIBuilder) RubyPackage() string { + return b.a.rubyPackage +} + +// WithPhpNamespace sets the PHP namespace override. +func (b *APIBuilder) WithPhpNamespace(ns string) *APIBuilder { + b.a.phpNamespace = ns + return b +} + +// PhpNamespace returns the PHP namespace override currently set on the builder. +func (b *APIBuilder) PhpNamespace() string { + return b.a.phpNamespace +} + +// WithCsharpNamespace sets the C# namespace override. +func (b *APIBuilder) WithCsharpNamespace(ns string) *APIBuilder { + b.a.csharpNamespace = ns + return b +} + +// CsharpNamespace returns the C# namespace override currently set on the builder. +func (b *APIBuilder) CsharpNamespace() string { + return b.a.csharpNamespace +} + +// LoadWellKnownTypes populates well-known types into the symbol tables. +func (b *APIBuilder) LoadWellKnownTypes() *APIBuilder { + b.a.loadWellKnownTypes() + return b +} + +// AddService registers a service in the symbol table. +func (b *APIBuilder) AddService(s *Service) *APIBuilder { + b.a.addService(s) + return b +} + +// Service looks up a service in the symbol table. +func (b *APIBuilder) Service(id string) *Service { + return b.a.Service(id) +} + +// AddMethod registers a method in the symbol table. +func (b *APIBuilder) AddMethod(m *Method) *APIBuilder { + b.a.addMethod(m) + return b +} + +// Method looks up a method in the symbol table. +func (b *APIBuilder) Method(id string) *Method { + return b.a.Method(id) +} + +// AddMessage registers a message in the symbol table. +func (b *APIBuilder) AddMessage(m *Message) *APIBuilder { + b.a.addMessage(m) + return b +} + +// Message looks up a message in the symbol table. +func (b *APIBuilder) Message(id string) *Message { + return b.a.Message(id) +} + +// AddEnum registers an enum in the symbol table. +func (b *APIBuilder) AddEnum(e *Enum) *APIBuilder { + b.a.addEnum(e) + return b +} + +// Enum looks up an enum in the symbol table. +func (b *APIBuilder) Enum(id string) *Enum { + return b.a.Enum(id) +} + +// AddResource registers a resource in the symbol table. +func (b *APIBuilder) AddResource(r *Resource) *APIBuilder { + b.a.addResource(r) + return b +} + +// AllResources returns an iterator over the resources in the symbol table. +func (b *APIBuilder) AllResources() iter.Seq[*Resource] { + return b.a.AllResources() +} + +// AddMap registers a map in the symbol table. +func (b *APIBuilder) AddMap(m *Map) *APIBuilder { + b.a.addMap(m) + return b +} + +// WithMaps registers multiple maps in the symbol table. +func (b *APIBuilder) WithMaps(maps ...*Map) *APIBuilder { + for _, m := range maps { + b.a.addMap(m) + } + return b +} + +// Map looks up a map in the symbol table. +func (b *APIBuilder) Map(id string) *Map { + return b.a.Map(id) +} + +// AllMaps returns an iterator over the maps in the symbol table. +func (b *APIBuilder) AllMaps() iter.Seq[*Map] { + return b.a.AllMaps() +} + +// UpdatePackageName sets the package name from the first service, message, or +// enum if it is not already set. +func (b *APIBuilder) UpdatePackageName() *APIBuilder { + if b.a.packageName != "" { + return b + } + if len(b.a.services) > 0 { + b.a.packageName = b.a.services[0].packagez + } else if len(b.a.messages) > 0 { + b.a.packageName = b.a.messages[0].packagez + } else if len(b.a.enums) > 0 { + b.a.packageName = b.a.enums[0].packagez + } + return b +} + +// AddDiscoveryLroAnnotations attaches Discovery LRO metadata to LRO-returning +// methods and injects synthetic `getOperation` polling methods onto services. +func (b *APIBuilder) AddDiscoveryLroAnnotations(discoveryConfig *Discovery) error { + return AddDiscoveryLroAnnotations(&b.a, discoveryConfig) +} + +// WithPaginationOverrides configures pagination overrides for [APIBuilder.Build]. +func (b *APIBuilder) WithPaginationOverrides(overrides []PaginationOverride) *APIBuilder { + b.paginationOverrides = overrides + return b +} + +// WithResourceNameHeuristic configures heuristic target resource identification for [APIBuilder.Build]. +func (b *APIBuilder) WithResourceNameHeuristic(enabled bool) *APIBuilder { + b.resourceNameHeuristic = enabled + return b +} + +// WithOverride configures model overrides for [APIBuilder.Build]. +func (b *APIBuilder) WithOverride(override ModelOverride) *APIBuilder { + b.override = override + return b +} + +// WithCommentOverrides configures documentation overrides for [APIBuilder.Build]. +func (b *APIBuilder) WithCommentOverrides(overrides []DocumentationOverride) *APIBuilder { + b.commentOverrides = overrides + return b +} + +// BuildSyntaxTree returns the constructed [API] without running cross-referencing +// or validation passes. +func (b *APIBuilder) BuildSyntaxTree() *API { + return &NewAPIBuilderFrom(&b.a).a +} + +// Build runs pagination detection, recursive field labeling, cross-referencing, +// target resource identification, element skipping, documentation patching, +// validation, and model overrides, and returns the finalized [API]. +func (b *APIBuilder) Build() (*API, error) { + model := b.BuildSyntaxTree() + UpdateMethodPagination(b.paginationOverrides, model) + LabelRecursiveFields(model) + if err := CrossReference(model); err != nil { + return nil, err + } + if err := IdentifyTargetResources(model, b.resourceNameHeuristic); err != nil { + return nil, err + } + if err := SkipModelElements(model, b.override); err != nil { + return nil, err + } + if err := PatchDocumentation(model, b.commentOverrides); err != nil { + return nil, err + } + if err := Validate(model); err != nil { + return nil, err + } + if b.override.Name != "" { + model.name = b.override.Name + } + if b.override.Title != "" { + model.title = b.override.Title + } + if b.override.Description != "" { + model.description = b.override.Description + } + return model, nil +} diff --git a/internal/sidekick/api/api_test.go b/internal/sidekick/api/api_test.go new file mode 100644 index 0000000000..f59eec9cb1 --- /dev/null +++ b/internal/sidekick/api/api_test.go @@ -0,0 +1,107 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import ( + "testing" + + "github.com/google/go-cmp/cmp" +) + +func TestAPI(t *testing.T) { + msg1 := NewMessageBuilder().WithName("Msg1").WithID(".test.Msg1").Build() + msg2 := NewMessageBuilder().WithName("Msg2").WithID(".test.Msg2").Build() + extMsg := NewMessageBuilder().WithName("ExtMsg").WithID(".ext.Msg").Build() + en := NewEnumBuilder().WithName("En").WithID(".test.En").Build() + extEn := NewEnumBuilder().WithName("ExtEn").WithID(".ext.En").Build() + svc := NewServiceBuilder().WithName("Svc").WithID(".test.Svc").Build() + r1 := NewResourceBuilder().WithType("test.googleapis.com/R1").Build() + r2 := NewResourceBuilder().WithType("test.googleapis.com/R2").Build() + + got := NewAPIBuilder(). + WithName("test"). + WithPackageName("testpkg"). + WithTitle("Test API"). + WithDescription("Test description."). + WithRevision("v1"). + WithRubyPackage("Test::V1"). + WithPhpNamespace("Test\\V1"). + WithCsharpNamespace("Test.V1"). + WithMessages(msg1). + AppendMessage(msg2). + WithExternalMessages(extMsg). + WithEnums(en). + WithExternalEnums(extEn). + WithServices(svc). + WithResourceDefinitions(r1). + AppendResourceDefinitions(r2). + WithQuickstartService(svc). + AddMessage(msg1). + AddEnum(en). + AddService(svc). + AddResource(r1). + BuildSyntaxTree() + + got.SetAnnotations("api-codec") + + want := &API{ + name: "test", + packageName: "testpkg", + title: "Test API", + description: "Test description.", + revision: "v1", + rubyPackage: "Test::V1", + phpNamespace: "Test\\V1", + csharpNamespace: "Test.V1", + messages: []*Message{msg1, msg2}, + externalMessages: []*Message{extMsg}, + enums: []*Enum{en}, + externalEnums: []*Enum{extEn}, + services: []*Service{svc}, + resourceDefinitions: []*Resource{r1, r2}, + quickstartService: svc, + messageByID: map[string]*Message{".test.Msg1": msg1}, + enumByID: map[string]*Enum{".test.En": en}, + serviceByID: map[string]*Service{".test.Svc": svc}, + methodByID: map[string]*Method{}, + resourceByType: map[string]*Resource{"test.googleapis.com/R1": r1}, + mapByID: map[string]*Map{}, + codec: "api-codec", + } + if diff := cmp.Diff(want, got, allowUnexported()); diff != "" { + t.Errorf("API mismatch (-want +got):\n%s", diff) + } + if got.Name() != want.name || got.PackageName() != want.packageName || got.Title() != want.title || got.Description() != want.description || got.Revision() != want.revision || got.RubyPackage() != want.rubyPackage || got.PhpNamespace() != want.phpNamespace || got.CsharpNamespace() != want.csharpNamespace || got.QuickstartService() != svc || got.Codec() != "api-codec" { + t.Errorf("unexpected API fields: %+v", got) + } + if len(got.Messages()) != 2 || got.Messages()[0] != msg1 || got.Messages()[1] != msg2 || len(got.ExternalMessages()) != 1 || got.ExternalMessages()[0] != extMsg || len(got.Enums()) != 1 || got.Enums()[0] != en || len(got.ExternalEnums()) != 1 || got.ExternalEnums()[0] != extEn || len(got.Services()) != 1 || got.Services()[0] != svc || len(got.ResourceDefinitions()) != 2 || got.ResourceDefinitions()[0] != r1 || got.ResourceDefinitions()[1] != r2 { + t.Errorf("API slice inputs were not cloned") + } + + got.Messages()[0] = nil + got.ExternalMessages()[0] = nil + got.Enums()[0] = nil + got.ExternalEnums()[0] = nil + got.Services()[0] = nil + got.ResourceDefinitions()[0] = nil + if got.Messages()[0] != msg1 || got.ExternalMessages()[0] != extMsg || got.Enums()[0] != en || got.ExternalEnums()[0] != extEn || got.Services()[0] != svc || got.ResourceDefinitions()[0] != r1 { + t.Errorf("API slice getters should return defensive copies") + } + + a2 := NewAPIBuilderFrom(got).WithName("test2").BuildSyntaxTree() + if a2.Name() != "test2" || len(a2.Messages()) != 2 || a2.Message(".test.Msg1") != msg1 { + t.Errorf("NewAPIBuilderFrom should copy maps and slices: %+v", a2) + } +} diff --git a/internal/sidekick/api/apitest/apitest.go b/internal/sidekick/api/apitest/apitest.go index 2f9e9dd72c..aca991581f 100644 --- a/internal/sidekick/api/apitest/apitest.go +++ b/internal/sidekick/api/apitest/apitest.go @@ -100,10 +100,30 @@ func IgnoreServiceFields(names ...string) cmp.Option { }, cmp.Ignore()) } +// IgnoreAPIFields returns a [cmp.Option] that ignores the named unexported +// fields on [api.API]. +func IgnoreAPIFields(names ...string) cmp.Option { + set := make(map[string]bool, len(names)) + for _, n := range names { + set["."+n] = true + } + apiType := reflect.TypeFor[api.API]() + return cmp.FilterPath(func(p cmp.Path) bool { + if len(p) < 2 { + return false + } + if p.Index(-2).Type() != apiType { + return false + } + return set[p.Last().String()] + }, cmp.Ignore()) +} + // AllowUnexported returns a [cmp.Option] that permits comparing unexported // fields on all read-only [api] AST and metadata structs. func AllowUnexported() cmp.Option { return cmp.AllowUnexported( + api.API{}, api.DiscoveryLro{}, api.Enum{}, api.EnumValue{}, diff --git a/internal/sidekick/api/deprecated.go b/internal/sidekick/api/deprecated.go index 9c45df12b6..9d84e9f90b 100644 --- a/internal/sidekick/api/deprecated.go +++ b/internal/sidekick/api/deprecated.go @@ -16,17 +16,17 @@ package api // HasDeprecatedEntities returns true if the API has any deprecated entities. func (model *API) HasDeprecatedEntities() bool { - for _, e := range model.Enums { + for _, e := range model.enums { if e.hasDeprecatedEntities() { return true } } - for _, m := range model.Messages { + for _, m := range model.messages { if m.hasDeprecatedEntities() { return true } } - for _, s := range model.Services { + for _, s := range model.services { if s.hasDeprecatedEntities() { return true } diff --git a/internal/sidekick/api/deprecated_test.go b/internal/sidekick/api/deprecated_test.go index 93e07116f7..72fc9c98e8 100644 --- a/internal/sidekick/api/deprecated_test.go +++ b/internal/sidekick/api/deprecated_test.go @@ -32,19 +32,19 @@ func TestDeprecatedAPI(t *testing.T) { } model = newAPI() - model.Enums[0].WithDeprecated(true) + model.Enums()[0].WithDeprecated(true) if !model.HasDeprecatedEntities() { t.Errorf("deprecated enum should result in deprecated entities for model %v", model) } model = newAPI() - model.Messages[0].WithDeprecated(true) + model.Messages()[0].WithDeprecated(true) if !model.HasDeprecatedEntities() { t.Errorf("deprecated message should result in deprecated entities for model %v", model) } model = newAPI() - model.Services[0].WithDeprecated(true) + model.Services()[0].WithDeprecated(true) if !model.HasDeprecatedEntities() { t.Errorf("deprecated service should result in deprecated entities for model %v", model) } diff --git a/internal/sidekick/api/discovery.go b/internal/sidekick/api/discovery.go index f021f60933..258816b883 100644 --- a/internal/sidekick/api/discovery.go +++ b/internal/sidekick/api/discovery.go @@ -135,7 +135,7 @@ func AddDiscoveryLroAnnotations(model *API, discoveryConfig *Discovery) error { return nil } lroServices := discoveryConfig.LroServices() - for _, svc := range model.Services { + for _, svc := range model.services { if _, ok := lroServices[svc.ID()]; ok { continue } @@ -179,7 +179,7 @@ func AddDiscoveryLroAnnotations(model *API, discoveryConfig *Discovery) error { WithIsLroPoller(true). Build() svc.methods = append(svc.methods, method) - model.AddMethod(method) + model.addMethod(method) } return nil } diff --git a/internal/sidekick/api/filter.go b/internal/sidekick/api/filter.go index 61c5222317..e0141ed040 100644 --- a/internal/sidekick/api/filter.go +++ b/internal/sidekick/api/filter.go @@ -35,23 +35,24 @@ func (a *API) Filter(keep func(id string) bool) *API { } var filteredMsgs []*Message - for _, m := range a.Messages { + for _, m := range a.Messages() { if keep(m.ID()) { filteredMsgs = append(filteredMsgs, m) } } var filteredEnums []*Enum - for _, e := range a.Enums { + for _, e := range a.Enums() { if keep(e.ID()) { filteredEnums = append(filteredEnums, e) } } + pkgName := a.PackageName() // Collect external top-level types satisfying keep, sorted by ID because // AllMessages/AllEnums iterate over maps in randomized order. var externalMessages []*Message for m := range a.AllMessages() { - if m.ID() != "" && m.Parent() == nil && m.Package() != a.PackageName && m.Package() != ReservedPackageName && keep(m.ID()) { + if m.ID() != "" && m.Parent() == nil && m.Package() != pkgName && m.Package() != ReservedPackageName && keep(m.ID()) { externalMessages = append(externalMessages, m) } } @@ -59,63 +60,66 @@ func (a *API) Filter(keep func(id string) bool) *API { var externalEnums []*Enum for e := range a.AllEnums() { - if e.ID() != "" && e.Parent() == nil && e.Package() != a.PackageName && e.Package() != ReservedPackageName && keep(e.ID()) { + if e.ID() != "" && e.Parent() == nil && e.Package() != pkgName && e.Package() != ReservedPackageName && keep(e.ID()) { externalEnums = append(externalEnums, e) } } slices.SortFunc(externalEnums, func(x, y *Enum) int { return cmp.Compare(x.ID(), y.ID()) }) + origServices := a.Services() + origQuickstart := a.QuickstartService() var services []*Service - quickstart := a.QuickstartService - if a.Services != nil { - services = make([]*Service, len(a.Services)) - for i, s := range a.Services { + quickstart := origQuickstart + if origServices != nil { + services = make([]*Service, len(origServices)) + for i, s := range origServices { services[i] = s.Clone() - if s == a.QuickstartService { + if s == origQuickstart { quickstart = services[i] } } } + resourceDefs := a.ResourceDefinitions() filtered := &API{ - Name: a.Name, - PackageName: a.PackageName, - Title: a.Title, - Description: a.Description, - Revision: a.Revision, - Services: services, - Messages: filteredMsgs, - ExternalMessages: externalMessages, - Enums: filteredEnums, - ExternalEnums: externalEnums, - ResourceDefinitions: slices.Clone(a.ResourceDefinitions), - QuickstartService: quickstart, - RubyPackage: a.RubyPackage, - PhpNamespace: a.PhpNamespace, - CsharpNamespace: a.CsharpNamespace, + name: a.Name(), + packageName: pkgName, + title: a.Title(), + description: a.Description(), + revision: a.Revision(), + services: services, + messages: filteredMsgs, + externalMessages: externalMessages, + enums: filteredEnums, + externalEnums: externalEnums, + resourceDefinitions: resourceDefs, + quickstartService: quickstart, + rubyPackage: a.RubyPackage(), + phpNamespace: a.PhpNamespace(), + csharpNamespace: a.CsharpNamespace(), } for _, s := range services { s.model = filtered - filtered.AddService(s) + filtered.addService(s) for _, m := range s.Methods() { m.model = filtered - filtered.AddMethod(m) + filtered.addMethod(m) } } // Populate lookup maps with all package messages, enums, maps, and // resources to avoid aliasing a's maps while still resolving field types // across excluded top-level elements. for m := range a.AllMessages() { - filtered.AddMessage(m) + filtered.addMessage(m) } for e := range a.AllEnums() { - filtered.AddEnum(e) + filtered.addEnum(e) } for m := range a.AllMaps() { - filtered.AddMap(m) + filtered.addMap(m) } - for _, r := range filtered.ResourceDefinitions { - filtered.AddResource(r) + for _, r := range resourceDefs { + filtered.addResource(r) } return filtered } diff --git a/internal/sidekick/api/filter_test.go b/internal/sidekick/api/filter_test.go index 1ce536f10f..5bf85452bb 100644 --- a/internal/sidekick/api/filter_test.go +++ b/internal/sidekick/api/filter_test.go @@ -31,22 +31,25 @@ func TestAPI_Filter_Nil(t *testing.T) { extM1 := NewTestMessage("ExtM1").WithPackage("google.type") extE1 := NewTestEnum("ExtE1").WithPackage("google.type") - model := NewTestAPI([]*Message{m1}, []*Enum{e1}, nil) - model.AddMessage(extM1) - model.AddEnum(extE1) + model := NewAPIBuilderFrom(NewTestAPI([]*Message{m1}, []*Enum{e1}, nil)). + AddMessage(extM1). + AddEnum(extE1). + BuildSyntaxTree() got := model.Filter(nil) - if diff := cmp.Diff([]*Message{m1}, got.Messages, allowUnexported()); diff != "" { - t.Errorf("Messages mismatch (-want +got):\n%s", diff) + if diff := cmp.Diff([]*Message{m1}, got.Messages(), allowUnexported()); diff != "" { + t.Errorf("Messages() mismatch (-want +got):\n%s", diff) } - if diff := cmp.Diff([]*Enum{e1}, got.Enums, allowUnexported()); diff != "" { - t.Errorf("Enums mismatch (-want +got):\n%s", diff) + if diff := cmp.Diff([]*Enum{e1}, got.Enums(), allowUnexported()); diff != "" { + t.Errorf("Enums() mismatch (-want +got):\n%s", diff) } - if !slices.Contains(got.ExternalMessages, extM1) || !slices.Contains(got.ExternalMessages, model.Message(".google.protobuf.Any")) { - t.Errorf("ExternalMessages = %v, want extM1 and pre-registered external messages retained", got.ExternalMessages) + extMsgs := got.ExternalMessages() + if !slices.Contains(extMsgs, extM1) || !slices.Contains(extMsgs, model.Message(".google.protobuf.Any")) { + t.Errorf("ExternalMessages() = %v, want extM1 and pre-registered external messages retained", extMsgs) } - if !slices.Contains(got.ExternalEnums, extE1) || !slices.Contains(got.ExternalEnums, model.Enum(".google.protobuf.NullValue")) { - t.Errorf("ExternalEnums = %v, want extE1 and pre-registered external enums retained", got.ExternalEnums) + extEnums := got.ExternalEnums() + if !slices.Contains(extEnums, extE1) || !slices.Contains(extEnums, model.Enum(".google.protobuf.NullValue")) { + t.Errorf("ExternalEnums() = %v, want extE1 and pre-registered external enums retained", extEnums) } } @@ -65,40 +68,44 @@ func TestAPI_Filter(t *testing.T) { res := NewTestResource("test.googleapis.com/Book") mapType := NewTestMap("AttributesEntry", TypezString, TypezString) - model := NewTestAPI([]*Message{m1, m2}, []*Enum{e1, e2}, []*Service{s1, s2}) - model.Name = "testapi" - model.Title = "Test API" - model.Description = "Test API description" - model.Revision = "2026-01-01" - model.RubyPackage = "Test::Api" - model.PhpNamespace = "Test\\Api" - model.CsharpNamespace = "Test.Api" - model.QuickstartService = s1 - model.Codec = "orig-codec" - model.ResourceDefinitions = []*Resource{res} + model := NewTestAPI([]*Message{m1, m2}, []*Enum{e1, e2}, []*Service{s1, s2}). + WithName("testapi"). + WithTitle("Test API"). + WithDescription("Test API description"). + WithRevision("2026-01-01"). + WithRubyPackage("Test::Api"). + WithPhpNamespace("Test\\Api"). + WithCsharpNamespace("Test.Api"). + WithQuickstartService(s1). + WithResourceDefinitions(res) + model.SetAnnotations("orig-codec") s1.SetAnnotations("svc-codec") - model.AddMessage(extM1) - model.AddMessage(extM2) - model.AddEnum(extE1) - model.AddEnum(extE2) - model.AddMap(mapType) - model.AddResource(res) + model.addMessage(extM1) + model.addMessage(extM2) + model.addEnum(extE1) + model.addEnum(extE2) + model.addMap(mapType) + model.addResource(res) filtered := model.Filter(func(id string) bool { return id == m1.ID() || id == e1.ID() || id == extM1.ID() || id == extE1.ID() }) - if len(filtered.Messages) != 1 || filtered.Messages[0] != m1 { - t.Errorf("got Messages = %v, want [%v]", filtered.Messages, m1) + msgs := filtered.Messages() + if len(msgs) != 1 || msgs[0] != m1 { + t.Errorf("got Messages() = %v, want [%v]", msgs, m1) } - if len(filtered.Enums) != 1 || filtered.Enums[0] != e1 { - t.Errorf("got Enums = %v, want [%v]", filtered.Enums, e1) + enums := filtered.Enums() + if len(enums) != 1 || enums[0] != e1 { + t.Errorf("got Enums() = %v, want [%v]", enums, e1) } - if len(filtered.ExternalMessages) != 1 || filtered.ExternalMessages[0] != extM1 { - t.Errorf("got ExternalMessages = %v, want [%v]", filtered.ExternalMessages, extM1) + extMsgs := filtered.ExternalMessages() + if len(extMsgs) != 1 || extMsgs[0] != extM1 { + t.Errorf("got ExternalMessages() = %v, want [%v]", extMsgs, extM1) } - if len(filtered.ExternalEnums) != 1 || filtered.ExternalEnums[0] != extE1 { - t.Errorf("got ExternalEnums = %v, want [%v]", filtered.ExternalEnums, extE1) + extEnums := filtered.ExternalEnums() + if len(extEnums) != 1 || extEnums[0] != extE1 { + t.Errorf("got ExternalEnums() = %v, want [%v]", extEnums, extE1) } if got := filtered.Message(m2.ID()); got != m2 { t.Errorf("filtered.Message(%q) = %v, want %v", m2.ID(), got, m2) @@ -112,19 +119,19 @@ func TestAPI_Filter(t *testing.T) { if got := filtered.Resource(res.Type()); got != res { t.Errorf("filtered.Resource(%q) = %v, want %v", res.Type(), got, res) } - if filtered.Codec != nil { - t.Errorf("filtered.Codec = %v, want nil", filtered.Codec) + if filtered.Codec() != nil { + t.Errorf("filtered.Codec() = %v, want nil", filtered.Codec()) } - services := filtered.Services + services := filtered.Services() if len(services) != 2 { - t.Fatalf("len(filtered.Services) = %d, want 2", len(services)) + t.Fatalf("len(filtered.Services()) = %d, want 2", len(services)) } if services[0] == s1 || services[0].Codec() != nil { t.Errorf("cloned service did not preserve Clone() semantics") } - if filtered.QuickstartService != services[0] { - t.Errorf("filtered.QuickstartService = %v, want %v", filtered.QuickstartService, services[0]) + if filtered.QuickstartService() != services[0] { + t.Errorf("filtered.QuickstartService() = %v, want %v", filtered.QuickstartService(), services[0]) } if services[0].Model() != filtered { t.Errorf("services[0].Model() = %v, want %v", services[0].Model(), filtered) @@ -133,14 +140,14 @@ func TestAPI_Filter(t *testing.T) { if len(methods) != 1 || methods[0].Model() != filtered { t.Errorf("cloned method Model() = %v, want %v", methods[0].Model(), filtered) } - if filtered.Name != model.Name || - filtered.PackageName != model.PackageName || - filtered.Title != model.Title || - filtered.Description != model.Description || - filtered.Revision != model.Revision || - filtered.RubyPackage != model.RubyPackage || - filtered.PhpNamespace != model.PhpNamespace || - filtered.CsharpNamespace != model.CsharpNamespace { + if filtered.Name() != model.Name() || + filtered.PackageName() != model.PackageName() || + filtered.Title() != model.Title() || + filtered.Description() != model.Description() || + filtered.Revision() != model.Revision() || + filtered.RubyPackage() != model.RubyPackage() || + filtered.PhpNamespace() != model.PhpNamespace() || + filtered.CsharpNamespace() != model.CsharpNamespace() { t.Errorf("API metadata was not preserved: got %+v", filtered) } } diff --git a/internal/sidekick/api/method_test.go b/internal/sidekick/api/method_test.go index 023c42989c..051a75f0a1 100644 --- a/internal/sidekick/api/method_test.go +++ b/internal/sidekick/api/method_test.go @@ -33,7 +33,7 @@ func TestMethod(t *testing.T) { sig := NewMethodSignatureBuilder().WithNames("name").Build() svc := NewServiceBuilder().WithName("Svc").Build() srcSvc := NewServiceBuilder().WithName("SrcSvc").Build() - model := NewTestAPI(nil, nil, nil) + model := NewAPIBuilder().WithName("test").BuildSyntaxTree() got := NewMethodBuilder(). WithName("GetBook"). diff --git a/internal/sidekick/api/resource_identification.go b/internal/sidekick/api/resource_identification.go index 1030970984..33dcb15d1c 100644 --- a/internal/sidekick/api/resource_identification.go +++ b/internal/sidekick/api/resource_identification.go @@ -31,7 +31,7 @@ func IdentifyTargetResources(model *API, enableHeuristics bool) error { // Build the set of known resource names for the heuristic. vocabulary := BuildHeuristicVocabulary(model) - for _, service := range model.Services { + for _, service := range model.services { for _, method := range service.Methods() { if method.PathInfo() == nil { continue @@ -282,8 +282,8 @@ func getServiceHost(method *Method) (string, error) { if method.Service() != nil && method.Service().DefaultHost() != "" { return method.Service().DefaultHost(), nil } - if method.Model() != nil && method.Model().Name != "" { - return method.Model().Name + ".googleapis.com", nil + if method.Model() != nil && method.Model().Name() != "" { + return method.Model().Name() + ".googleapis.com", nil } return "", fmt.Errorf("consistency error: no service host found for method %q", method.Name()) } diff --git a/internal/sidekick/api/resource_identification_test.go b/internal/sidekick/api/resource_identification_test.go index dda7dad39b..d565a2db20 100644 --- a/internal/sidekick/api/resource_identification_test.go +++ b/internal/sidekick/api/resource_identification_test.go @@ -478,7 +478,7 @@ func TestIdentifyTargetResources_Heuristic(t *testing.T) { t.Run(test.name, func(t *testing.T) { model, binding := setupTestModel(test.serviceID, test.path, test.fields) if test.resources != nil { - model.ResourceDefinitions = test.resources + model.WithResourceDefinitions(test.resources...) } // Add Get methods to populate vocabulary @@ -486,7 +486,7 @@ func TestIdentifyTargetResources_Heuristic(t *testing.T) { m := NewTestMethod("GetSomething"). WithBindings(NewPathBindingBuilder().WithPathTemplate(p).Build()). WithIsAIPStandard(true) - model.Services[0].WithMethods(m) + model.Services()[0].WithMethods(m) } IdentifyTargetResources(model, true) @@ -544,8 +544,8 @@ func TestIdentifyTargetResources_PreservesExistingTargetResource(t *testing.T) { WithID(".google.cloud.compute.v1.Instances"). WithMethods(method) model := NewTestAPI(nil, nil, []*Service{service}).WithName("test-api") - method.model = model - service.model = model + method.WithModel(model) + service.WithModel(model) if err := IdentifyTargetResources(model, true); err != nil { t.Fatal(err) diff --git a/internal/sidekick/api/resource_name_heuristic.go b/internal/sidekick/api/resource_name_heuristic.go index 14079aeded..034143d9bb 100644 --- a/internal/sidekick/api/resource_name_heuristic.go +++ b/internal/sidekick/api/resource_name_heuristic.go @@ -49,7 +49,7 @@ func BuildHeuristicVocabulary(model *API) map[string]bool { "get", "list", "create", "update", "delete", "patch", "insert", } - for _, service := range model.Services { + for _, service := range model.services { for _, m := range service.Methods() { nameLower := strings.ToLower(m.Name()) diff --git a/internal/sidekick/api/service_test.go b/internal/sidekick/api/service_test.go index c4a9b3ae3a..8741bcff4e 100644 --- a/internal/sidekick/api/service_test.go +++ b/internal/sidekick/api/service_test.go @@ -23,7 +23,7 @@ import ( func TestService(t *testing.T) { m1 := NewMethodBuilder().WithName("M1").Build() m2 := NewMethodBuilder().WithName("M2").Build() - model := NewTestAPI(nil, nil, nil) + model := NewAPIBuilder().WithName("test").BuildSyntaxTree() b := NewServiceBuilder(). WithName("BookService"). diff --git a/internal/sidekick/api/skip.go b/internal/sidekick/api/skip.go index 898fc55565..13135aa43f 100644 --- a/internal/sidekick/api/skip.go +++ b/internal/sidekick/api/skip.go @@ -62,12 +62,12 @@ func SkipModelElements(model *API, overrides ModelOverride) error { } func skipModelElementsImpl(model *API, skip func(id string) bool, skipField func(id string) bool) error { - for _, m := range model.Messages { + for _, m := range model.messages { skipMessageElements(m, skip, skipField) } - model.Enums = slices.DeleteFunc(model.Enums, func(x *Enum) bool { return skip(x.ID()) }) - model.Messages = slices.DeleteFunc(model.Messages, func(x *Message) bool { return skip(x.id) }) - model.Services = slices.DeleteFunc(model.Services, func(x *Service) bool { return skip(x.ID()) }) + model.enums = slices.DeleteFunc(model.enums, func(x *Enum) bool { return skip(x.ID()) }) + model.messages = slices.DeleteFunc(model.messages, func(x *Message) bool { return skip(x.ID()) }) + model.services = slices.DeleteFunc(model.services, func(x *Service) bool { return skip(x.ID()) }) for service := range model.AllServices() { service.methods = slices.DeleteFunc(service.methods, func(x *Method) bool { return skip(x.ID()) }) @@ -83,8 +83,8 @@ func skipModelElementsImpl(model *API, skip func(id string) bool, skipField func } } } - if model.QuickstartService != nil && !slices.Contains(model.Services, model.QuickstartService) { - model.QuickstartService = findQuickstartService(model) + if model.quickstartService != nil && !slices.Contains(model.services, model.quickstartService) { + model.quickstartService = findQuickstartService(model) } return nil } diff --git a/internal/sidekick/api/skip_test.go b/internal/sidekick/api/skip_test.go index e02f5c0e3c..e628e8e1b4 100644 --- a/internal/sidekick/api/skip_test.go +++ b/internal/sidekick/api/skip_test.go @@ -67,7 +67,7 @@ func TestSkipMessages(t *testing.T) { }) want := []*Message{m0, m2} - if diff := cmp.Diff(want, model.Messages, allowUnexported()); diff != "" { + if diff := cmp.Diff(want, model.Messages(), allowUnexported()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -84,7 +84,7 @@ func TestSkipEnums(t *testing.T) { want := []*Enum{e0, e2} - if diff := cmp.Diff(want, model.Enums, allowUnexported()); diff != "" { + if diff := cmp.Diff(want, model.Enums(), allowUnexported()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -139,7 +139,7 @@ func TestSkipServices(t *testing.T) { want := []*Service{s0, s2} - if diff := cmp.Diff(want, model.Services, allowUnexported(), ignoreServiceFields("model")); diff != "" { + if diff := cmp.Diff(want, model.Services(), allowUnexported(), ignoreServiceFields("model")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -182,7 +182,7 @@ func TestSkipMethods(t *testing.T) { }) wantServices := []*Service{s0, s1, s2} - if diff := cmp.Diff(wantServices, model.Services, allowUnexported(), ignoreServiceFields("model")); diff != "" { + if diff := cmp.Diff(wantServices, model.Services(), allowUnexported(), ignoreServiceFields("model")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -260,7 +260,7 @@ func TestIncludeMethods(t *testing.T) { }) wantServices := []*Service{s1} - if diff := cmp.Diff(wantServices, model.Services, allowUnexported(), ignoreMethodFields(methodIgnoreFields...), ignoreServiceFields("model", "quickstartMethod")); diff != "" { + if diff := cmp.Diff(wantServices, model.Services(), allowUnexported(), ignoreMethodFields(methodIgnoreFields...), ignoreServiceFields("model", "quickstartMethod")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -438,7 +438,7 @@ func TestSkipPreservesExternalAndDependencyMessagesInSymbolTable(t *testing.T) { f1 := NewTestField("field1").WithType(TypezString) m0 := NewTestMessage("Message0").WithFields(f0, f1) model := NewTestAPI([]*Message{m0}, []*Enum{}, []*Service{}) - model.AddMessage(timestamp) + model.addMessage(timestamp) CrossReference(model) if err := SkipModelElements(model, ModelOverride{ diff --git a/internal/sidekick/api/test.go b/internal/sidekick/api/test.go index 14df0cadd1..587512998a 100644 --- a/internal/sidekick/api/test.go +++ b/internal/sidekick/api/test.go @@ -25,10 +25,10 @@ import ( // NewTestAPI creates a new test API. func NewTestAPI(messages []*Message, enums []*Enum, services []*Service) *API { model := &API{ - Name: "Test", - Messages: messages, - Enums: enums, - Services: services, + name: "Test", + messages: messages, + enums: enums, + services: services, messageByID: make(map[string]*Message), methodByID: make(map[string]*Method), enumByID: make(map[string]*Enum), @@ -36,6 +36,7 @@ func NewTestAPI(messages []*Message, enums []*Enum, services []*Service) *API { resourceByType: make(map[string]*Resource), mapByID: make(map[string]*Map), } + model.loadWellKnownTypes() var indexMessage func(m *Message) indexMessage = func(m *Message) { @@ -45,7 +46,7 @@ func NewTestAPI(messages []*Message, enums []*Enum, services []*Service) *API { } for _, f := range m.fields { if f.MapType() != nil { - model.AddMap(f.MapType()) + model.addMap(f.MapType()) } } for _, e := range m.enums { @@ -61,15 +62,15 @@ func NewTestAPI(messages []*Message, enums []*Enum, services []*Service) *API { } } for _, m := range messages { - model.PackageName = m.packagez + model.packageName = m.packagez indexMessage(m) } for _, e := range enums { - model.PackageName = e.Package() + model.packageName = e.Package() model.enumByID[e.ID()] = e } for _, s := range services { - model.PackageName = s.Package() + model.packageName = s.Package() model.serviceByID[s.ID()] = s for _, m := range s.Methods() { model.methodByID[m.ID()] = m @@ -98,62 +99,85 @@ func NewTestAPI(messages []*Message, enums []*Enum, services []*Service) *API { } } - model.LoadWellKnownTypes() return model } // WithName changes the name of an API instance. func (a *API) WithName(name string) *API { - a.Name = name + a.name = name return a } // WithTitle changes the title of an API instance. func (a *API) WithTitle(title string) *API { - a.Title = title + a.title = title return a } // WithDescription changes the description of an API instance. func (a *API) WithDescription(description string) *API { - a.Description = description + a.description = description + return a +} + +// WithRevision changes the revision of an API instance. +func (a *API) WithRevision(revision string) *API { + a.revision = revision return a } // WithQuickstartService sets the quickstart service on an API instance. func (a *API) WithQuickstartService(service *Service) *API { - a.QuickstartService = service + a.quickstartService = service return a } // WithPackageName changes the package name of an API instance. func (a *API) WithPackageName(name string) *API { - a.PackageName = name + a.packageName = name return a } // WithCsharpNamespace changes the CsharpNamespace of an API instance. func (a *API) WithCsharpNamespace(name string) *API { - a.CsharpNamespace = name + a.csharpNamespace = name return a } // WithPhpNamespace changes the PhpNamespace of an API instance. func (a *API) WithPhpNamespace(name string) *API { - a.PhpNamespace = name + a.phpNamespace = name return a } // WithRubyPackage changes the RubyNamespace of an API instance. func (a *API) WithRubyPackage(name string) *API { - a.RubyPackage = name + a.rubyPackage = name + return a +} + +// WithResourceDefinitions sets the resource definitions on an API instance. +func (a *API) WithResourceDefinitions(resources ...*Resource) *API { + a.resourceDefinitions = resources + return a +} + +// WithExternalMessages sets the external messages on an API instance. +func (a *API) WithExternalMessages(messages ...*Message) *API { + a.externalMessages = messages + return a +} + +// WithExternalEnums sets the external enums on an API instance. +func (a *API) WithExternalEnums(enums ...*Enum) *API { + a.externalEnums = enums return a } // WithMaps adds maps to the API. func (a *API) WithMaps(maps ...*Map) *API { for _, m := range maps { - a.AddMap(m) + a.addMap(m) } return a } diff --git a/internal/sidekick/api/test_test.go b/internal/sidekick/api/test_test.go index f20d759623..00f4cb3691 100644 --- a/internal/sidekick/api/test_test.go +++ b/internal/sidekick/api/test_test.go @@ -345,17 +345,17 @@ func TestAPI_FluentSetters(t *testing.T) { WithDescription("Custom Description"). WithQuickstartService(svc) - if got, want := model.Name, "custom-name"; got != want { - t.Errorf("model.Name = %q, want %q", got, want) + if got, want := model.Name(), "custom-name"; got != want { + t.Errorf("model.Name() = %q, want %q", got, want) } - if got, want := model.Title, "Custom Title"; got != want { - t.Errorf("model.Title = %q, want %q", got, want) + if got, want := model.Title(), "Custom Title"; got != want { + t.Errorf("model.Title() = %q, want %q", got, want) } - if got, want := model.Description, "Custom Description"; got != want { - t.Errorf("model.Description = %q, want %q", got, want) + if got, want := model.Description(), "Custom Description"; got != want { + t.Errorf("model.Description() = %q, want %q", got, want) } - if got := model.QuickstartService; got != svc { - t.Errorf("model.QuickstartService = %v, want %v", got, svc) + if got := model.QuickstartService(); got != svc { + t.Errorf("model.QuickstartService() = %v, want %v", got, svc) } } diff --git a/internal/sidekick/api/validate.go b/internal/sidekick/api/validate.go index 87ddf3ac69..9e86d43fa4 100644 --- a/internal/sidekick/api/validate.go +++ b/internal/sidekick/api/validate.go @@ -23,7 +23,7 @@ import ( // Validate verifies the model satisfies the requires to be used by Codecs. func Validate(model *API) error { validatePkg := func(newPackage, elementName string) error { - if model.PackageName == newPackage { + if model.packageName == newPackage { return nil } // Special exceptions for mixin services @@ -33,20 +33,20 @@ func Validate(model *API) error { return nil } return fmt.Errorf("sidekick requires all top-level elements to be in the same package want=%q, got=%q for %q", - model.PackageName, newPackage, elementName) + model.packageName, newPackage, elementName) } - for _, s := range model.Services { + for _, s := range model.services { if err := validatePkg(s.Package(), s.ID()); err != nil { return err } } - for _, m := range model.Messages { + for _, m := range model.messages { if err := validatePkg(m.Package(), m.ID()); err != nil { return err } } - for _, e := range model.Enums { + for _, e := range model.enums { if err := validatePkg(e.Package(), e.ID()); err != nil { return err } diff --git a/internal/sidekick/api/validate_test.go b/internal/sidekick/api/validate_test.go index 9112a90ae1..54a7d2d2d7 100644 --- a/internal/sidekick/api/validate_test.go +++ b/internal/sidekick/api/validate_test.go @@ -38,7 +38,7 @@ func TestValidateMessageMismatch(t *testing.T) { []*Service{NewTestService("s1").WithPackage("p1")}). WithPackageName("p1") if err := Validate(test); err == nil { - t.Errorf("expected an error in API validation got=%s", test.PackageName) + t.Errorf("expected an error in API validation got=%s", test.PackageName()) } test = NewTestAPI( @@ -47,7 +47,7 @@ func TestValidateMessageMismatch(t *testing.T) { []*Service{NewTestService("s1").WithPackage("p1")}). WithPackageName("p1") if err := Validate(test); err == nil { - t.Errorf("expected an error in API validation got=%s", test.PackageName) + t.Errorf("expected an error in API validation got=%s", test.PackageName()) } test = NewTestAPI( @@ -56,7 +56,7 @@ func TestValidateMessageMismatch(t *testing.T) { []*Service{NewTestService("s1").WithPackage("p1"), NewTestService("s2").WithPackage("p2")}). WithPackageName("p1") if err := Validate(test); err == nil { - t.Errorf("expected an error in API validation got=%s", test.PackageName) + t.Errorf("expected an error in API validation got=%s", test.PackageName()) } } @@ -67,7 +67,7 @@ func TestValidateMessageMismatchNoPackage(t *testing.T) { []*Service{NewTestService("s1").WithPackage("p1")}). WithPackageName("") if err := Validate(test); err == nil { - t.Errorf("expected an error in API validation got=%s", test.PackageName) + t.Errorf("expected an error in API validation got=%s", test.PackageName()) } test = NewTestAPI( @@ -76,7 +76,7 @@ func TestValidateMessageMismatchNoPackage(t *testing.T) { []*Service{NewTestService("s1").WithPackage("p1")}). WithPackageName("") if err := Validate(test); err == nil { - t.Errorf("expected an error in API validation got=%s", test.PackageName) + t.Errorf("expected an error in API validation got=%s", test.PackageName()) } test = NewTestAPI( @@ -85,7 +85,7 @@ func TestValidateMessageMismatchNoPackage(t *testing.T) { []*Service{NewTestService("s1").WithPackage("p1"), NewTestService("s2").WithPackage("p2")}). WithPackageName("") if err := Validate(test); err == nil { - t.Errorf("expected an error in API validation got=%s", test.PackageName) + t.Errorf("expected an error in API validation got=%s", test.PackageName()) } } diff --git a/internal/sidekick/api/well_known_types.go b/internal/sidekick/api/well_known_types.go index c055a1ddb2..d813bec395 100644 --- a/internal/sidekick/api/well_known_types.go +++ b/internal/sidekick/api/well_known_types.go @@ -53,16 +53,16 @@ const ( WktStringValueID = ".google.protobuf.StringValue" ) -// LoadWellKnownTypes adds well-known types to `state`. +// loadWellKnownTypes adds well-known types to `state`. // // Some source specification formats (Discovery, OpenAPI) must manually add the // well-known types. In Protobuf these types are automatically defined in the // protoc output. -func (model *API) LoadWellKnownTypes() { +func (model *API) loadWellKnownTypes() { for _, message := range wellKnownMessages { - model.AddMessage(message) + model.addMessage(message) } - model.AddEnum(NewEnumBuilder(). + model.addEnum(NewEnumBuilder(). WithID(WktNullValueID). WithName("NullValue"). WithPackage("google.protobuf"). diff --git a/internal/sidekick/api/xref.go b/internal/sidekick/api/xref.go index 55d3633229..09357b9095 100644 --- a/internal/sidekick/api/xref.go +++ b/internal/sidekick/api/xref.go @@ -125,10 +125,10 @@ func enrichSamples(model *API) { enrichMethodSamples(m) } - for _, s := range model.Services { + for _, s := range model.services { s.quickstartMethod = findQuickstartMethod(s) } - model.QuickstartService = findQuickstartService(model) + model.quickstartService = findQuickstartService(model) } func findQuickstartMethod(s *Service) *Method { @@ -201,14 +201,14 @@ func findQuickstartMethod(s *Service) *Method { } func findQuickstartService(api *API) *Service { - if len(api.Services) == 0 { + if len(api.services) == 0 { return nil } var nonDeprecated []*Service var deprecated []*Service - for _, s := range api.Services { + for _, s := range api.services { if len(s.Methods()) > 0 { if s.Deprecated() { deprecated = append(deprecated, s) @@ -224,7 +224,7 @@ func findQuickstartService(api *API) *Service { } if len(searchList) == 0 { - return api.Services[0] + return api.services[0] } if len(searchList) == 1 { @@ -255,7 +255,7 @@ func findQuickstartService(api *API) *Service { searchList = servicesWithAnyQuickstart } - lowerApiName := strings.ToLower(api.Name) + lowerApiName := strings.ToLower(api.name) for _, s := range searchList { if strings.Contains(strings.ToLower(s.Name()), lowerApiName) { return s diff --git a/internal/sidekick/api/xref_aip_test.go b/internal/sidekick/api/xref_aip_test.go index fbc9fc74a7..0a7fb0cf6d 100644 --- a/internal/sidekick/api/xref_aip_test.go +++ b/internal/sidekick/api/xref_aip_test.go @@ -42,13 +42,11 @@ func newAIPTestFixture() *aipTestFixture { nonExistentResourceField := NewTestField("name").WithResourceReference("nonexistent.googleapis.com/NonExistent") wildcardResourceField := NewTestField("name").WithResourceReference("*") - model := &API{ - ResourceDefinitions: []*Resource{resource, resourceWithoutSingular}, - resourceByType: map[string]*Resource{ - resource.Type(): resource, - resourceWithoutSingular.Type(): resourceWithoutSingular, - }, - } + model := NewAPIBuilder(). + WithResourceDefinitions(resource, resourceWithoutSingular). + AddResource(resource). + AddResource(resourceWithoutSingular). + BuildSyntaxTree() return &aipTestFixture{ resource: resource, diff --git a/internal/sidekick/api/xref_samples_test.go b/internal/sidekick/api/xref_samples_test.go index 503c9bbe20..be1ed738c4 100644 --- a/internal/sidekick/api/xref_samples_test.go +++ b/internal/sidekick/api/xref_samples_test.go @@ -211,7 +211,7 @@ func TestEnrichSamplesWithResourceNamePattern(t *testing.T) { WithChildTypeReference("test.googleapis.com/Child") message := NewTestMessage("Message").WithFields(field) model := NewTestAPI([]*Message{message}, []*Enum{}, []*Service{}) - model.AddResource(res) + model.addResource(res) if err := CrossReference(model); err != nil { t.Fatal(err) diff --git a/internal/sidekick/api/xref_test.go b/internal/sidekick/api/xref_test.go index 9868d0543a..0db6a56642 100644 --- a/internal/sidekick/api/xref_test.go +++ b/internal/sidekick/api/xref_test.go @@ -135,7 +135,7 @@ func TestCrossReferenceService(t *testing.T) { mixin := NewTestService("Mixin").WithID(".external.Mixin") model := NewTestAPI([]*Message{}, []*Enum{}, []*Service{service}) - model.AddService(mixin) + model.addService(mixin) if err := CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/codec_sample/annotate_model.go b/internal/sidekick/codec_sample/annotate_model.go index 480d1f1aff..779bd25b4a 100644 --- a/internal/sidekick/codec_sample/annotate_model.go +++ b/internal/sidekick/codec_sample/annotate_model.go @@ -25,21 +25,21 @@ type modelAnnotations struct { } func (c *codec) annotateModel(model *api.API) error { - model.Codec = &modelAnnotations{ + model.SetAnnotations(&modelAnnotations{ CopyrightYear: c.CopyrightYear, BoilerPlate: license.HeaderBulk(), - } - for _, m := range model.Messages { + }) + for _, m := range model.Messages() { if err := c.annotateMessage(m); err != nil { return err } } - for _, e := range model.Enums { + for _, e := range model.Enums() { if err := c.annotateEnum(e); err != nil { return err } } - for _, s := range model.Services { + for _, s := range model.Services() { if err := c.annotateService(s); err != nil { return err } diff --git a/internal/sidekick/codec_sample/annotate_model_test.go b/internal/sidekick/codec_sample/annotate_model_test.go index f084026df4..4792302eb8 100644 --- a/internal/sidekick/codec_sample/annotate_model_test.go +++ b/internal/sidekick/codec_sample/annotate_model_test.go @@ -54,9 +54,9 @@ func TestAnnotateModel(t *testing.T) { if err := c.annotateModel(test.model); err != nil { t.Fatal(err) } - got, ok := test.model.Codec.(*modelAnnotations) + got, ok := test.model.Codec().(*modelAnnotations) if !ok { - t.Fatalf("expected *modelAnnotations, got %T", test.model.Codec) + t.Fatalf("expected *modelAnnotations, got %T", test.model.Codec()) } if diff := cmp.Diff(test.want, got); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) diff --git a/internal/sidekick/dart/annotate.go b/internal/sidekick/dart/annotate.go index 937a2e6e84..c364c5152f 100644 --- a/internal/sidekick/dart/annotate.go +++ b/internal/sidekick/dart/annotate.go @@ -137,7 +137,7 @@ func (m *modelAnnotations) HasDocLines() bool { // HasServices returns true if the model has services. func (m *modelAnnotations) HasServices() bool { - return len(m.Parent.Services) > 0 + return len(m.Parent.Services()) > 0 } // HasDependencies returns true if the model has package dependencies. @@ -452,36 +452,38 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { } } + origModel := annotate.model // Register any missing WKTs. - registerMissingWkt(annotate.model) + annotate.registerMissingWkt() model := annotate.model // Traverse and annotate the enums defined in this API. - for _, e := range model.Enums { + for _, e := range model.Enums() { annotate.annotateEnum(e) } // Traverse and annotate the messages defined in this API. - for _, m := range model.Messages { + for _, m := range model.Messages() { annotate.annotateMessage(m) } - for _, s := range model.Services { + services := model.Services() + for _, s := range services { annotate.annotateService(s) } var fakes []string - for _, s := range model.Services { + for _, s := range services { fakes = append(fakes, "Fake"+s.Name()) } slices.Sort(fakes) // Remove our package self-reference. - delete(annotate.imports, model.PackageName) + delete(annotate.imports, model.PackageName()) // Add the import for ServiceClient and related functionality. - if len(model.Services) > 0 { + if len(services) > 0 { annotate.imports[serviceClientImport] = true annotate.imports[retryImport] = true } @@ -492,7 +494,7 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { // an `enum` or `message`. annotate.imports[encodingImport] = true - if len(model.Services) > 0 && len(apiKeyEnvironmentVariables) == 0 { + if len(services) > 0 && len(apiKeyEnvironmentVariables) == 0 { return errors.New("all packages that define a service must define 'api-keys-environment-variables'") } @@ -511,7 +513,7 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { return err } - mainFileNameWithExtension := strcase.ToSnake(model.Name) + ".dart" + mainFileNameWithExtension := strcase.ToSnake(model.Name()) + ".dart" if libraryPathOverride != "" { mainFileNameWithExtension = libraryPathOverride } @@ -522,7 +524,7 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { var exampleMethodResponseType string var exampleMethodReturnsValue bool - if exampleService, exampleMethod := findExampleMethod(model.Services); exampleService != nil && exampleMethod != nil { + if exampleService, exampleMethod := findExampleMethod(services); exampleService != nil && exampleMethod != nil { exampleServiceName = exampleService.Codec().(*serviceAnnotations).Name mAnn := exampleMethod.Codec().(*methodAnnotation) exampleMethodName = mAnn.Name @@ -532,7 +534,7 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { } slices.Sort(devDependencies) - docLines := formatDocComments(model.Description, model) + docLines := formatDocComments(model.Description(), model) ann := &modelAnnotations{ ExampleServiceName: exampleServiceName, ExampleMethodName: exampleMethodName, @@ -549,8 +551,8 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { "", " Code generated by sidekick. DO NOT EDIT."), DefaultHost: func() string { - if len(model.Services) > 0 { - return model.Services[0].DefaultHost() + if len(services) > 0 { + return services[0].DefaultHost() } return "" }(), @@ -571,7 +573,10 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error { UseWorkspace: useWorkspace, } - model.Codec = ann + model.SetAnnotations(ann) + if origModel != model { + origModel.SetAnnotations(ann) + } return nil } @@ -1502,7 +1507,7 @@ func (annotate *annotateModel) resolveMessageName(message *api.Message, returnVo } func (annotate *annotateModel) updateUsedPackages(packageName string) { - selfReference := annotate.model.PackageName == packageName + selfReference := annotate.model.PackageName() == packageName if !selfReference { // Use the packageMapping info to add any necessary import. dartImport, ok := annotate.packageMapping[packageName] @@ -1516,9 +1521,11 @@ func (annotate *annotateModel) updateUsedPackages(packageName string) { } } -func registerMissingWkt(model *api.API) { +func (annotate *annotateModel) registerMissingWkt() { // If these definitions weren't provided by protoc then provide our own // placeholders. + ab := api.NewAPIBuilderFrom(annotate.model) + changed := false for _, message := range []struct { ID string Name string @@ -1527,15 +1534,19 @@ func registerMissingWkt(model *api.API) { {".google.protobuf.Any", "Any", "google.protobuf"}, {".google.protobuf.Empty", "Empty", "google.protobuf"}, } { - msg := model.Message(message.ID) + msg := annotate.model.Message(message.ID) if msg == nil { - model.AddMessage(api.NewMessageBuilder(). + ab.AddMessage(api.NewMessageBuilder(). WithID(message.ID). WithName(message.Name). WithPackage(message.Package). Build()) + changed = true } } + if changed { + annotate.model = ab.BuildSyntaxTree() + } } // findExampleMethod tries to find a service method that can be easily used as an diff --git a/internal/sidekick/dart/annotate_test.go b/internal/sidekick/dart/annotate_test.go index 7bccecc33a..6e26a7632e 100644 --- a/internal/sidekick/dart/annotate_test.go +++ b/internal/sidekick/dart/annotate_test.go @@ -48,7 +48,7 @@ func TestAnnotateModel(t *testing.T) { t.Fatal(err) } - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("google_cloud_test", codec.PackageName); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) @@ -72,7 +72,7 @@ func TestAnnotateModel_HasDocLines(t *testing.T) { if err := annotate1.annotateModel(options); err != nil { t.Fatal(err) } - codec1 := modelWithDesc.Codec.(*modelAnnotations) + codec1 := modelWithDesc.Codec().(*modelAnnotations) if !codec1.HasDocLines() { t.Errorf("Expected HasDocLines() to be true when description is provided") } @@ -81,7 +81,7 @@ func TestAnnotateModel_HasDocLines(t *testing.T) { if err := annotate2.annotateModel(options); err != nil { t.Fatal(err) } - codec2 := modelWithoutDesc.Codec.(*modelAnnotations) + codec2 := modelWithoutDesc.Codec().(*modelAnnotations) if codec2.HasDocLines() { t.Errorf("Expected HasDocLines() to be false when description is empty") } @@ -100,7 +100,7 @@ func TestAnnotateModel_FakeList(t *testing.T) { t.Fatal(err) } - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) want := "FakeAccessApprovalService, FakeSecretManagerService" if diff := cmp.Diff(want, codec.FakeList); diff != "" { @@ -118,7 +118,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"library-path-override": "src/buffers.dart"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("src/buffers.dart", codec.MainFileNameWithExtension); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -127,7 +127,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"package-name-override": "google-cloud-type"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("google-cloud-type", codec.PackageName); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -136,7 +136,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"dev-dependencies": "test,mockito"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff([]string{"mockito", "test"}, codec.DevDependencies); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -148,7 +148,7 @@ func TestAnnotateModel_Options(t *testing.T) { "package:google_cloud_bar": "^1.2.3", "package:google_cloud_foo": "^4.5.6"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if !slices.Contains(codec.PackageDependencies, packageDependency{Name: "google_cloud_foo", Constraint: "^4.5.6"}) { t.Errorf("missing 'google_cloud_foo' in Codec.PackageDependencies, got %v", codec.PackageDependencies) } @@ -160,7 +160,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"extra-exports": "export 'package:google_cloud_gax/gax.dart' show Any; export 'package:google_cloud_gax/gax.dart' show Status;"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff([]string{ "export 'package:google_cloud_gax/gax.dart' show Any", "export 'package:google_cloud_gax/gax.dart' show Status"}, codec.Exports); diff != "" { @@ -171,7 +171,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"extra-imports": "dart:math; package:my_package/my_file.dart", "package:my_package": "^1.0.0"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if !slices.Contains(codec.Imports, "import 'dart:math';") { t.Errorf("missing 'dart:math' in Codec.Imports, got %v", codec.Imports) } @@ -183,7 +183,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"version": "1.2.3"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("1.2.3", codec.PackageVersion); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -192,7 +192,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"part-file": "src/test.p.dart"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("src/test.p.dart", codec.PartFileReference); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -201,7 +201,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"readme-after-title-text": "> [!TIP] Still beta!"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("> [!TIP] Still beta!", codec.ReadMeAfterTitleText); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -210,7 +210,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"readme-quickstart-text": "## Getting Started\n..."}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("## Getting Started\n...", codec.ReadMeQuickstartText); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -219,7 +219,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"repository-url": "http://example.com/repo"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("http://example.com/repo", codec.RepositoryURL); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -228,7 +228,7 @@ func TestAnnotateModel_Options(t *testing.T) { { map[string]string{"issue-tracker-url": "http://example.com/issues"}, func(t *testing.T, am *annotateModel) { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("http://example.com/issues", codec.IssueTrackerURL); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -342,7 +342,7 @@ func TestAnnotateModel_Examples_ValidMethod(t *testing.T) { t.Fatal(err) } - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("ServiceWithMethods", codec.ExampleServiceName); diff != "" { t.Errorf("mismatch ExampleServiceName (-want +got):\n%s", diff) @@ -376,7 +376,7 @@ func TestAnnotateModel_Examples_NoMethod(t *testing.T) { t.Fatal(err) } - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) if diff := cmp.Diff("", codec.ExampleServiceName); diff != "" { t.Errorf("mismatch ExampleServiceName (-want +got):\n%s", diff) @@ -1934,7 +1934,7 @@ func TestAnnotateField(t *testing.T) { model := api.NewTestAPI([]*api.Message{message, empty}, []*api.Enum{enumState}, nil).WithMaps(mapEntry) annotate := newAnnotateModel(model) - registerMissingWkt(annotate.model) + annotate.registerMissingWkt() annotate.annotateField(field) got := field.Codec().(*fieldAnnotation) diff --git a/internal/sidekick/dart/dart.go b/internal/sidekick/dart/dart.go index 7fbc398650..4ba014785c 100644 --- a/internal/sidekick/dart/dart.go +++ b/internal/sidekick/dart/dart.go @@ -238,7 +238,7 @@ func packageName(api *api.API, packageNameOverride string) string { // Convert 'google.protobuf' to 'google_cloud_protobuf' and // 'google.cloud.language.v2' to 'google_cloud_language_v2. - packageName := api.PackageName + packageName := api.PackageName() packageName = strings.TrimPrefix(packageName, "google.cloud.") packageName = strings.TrimPrefix(packageName, "google.") return "google_cloud_" + strings.ReplaceAll(packageName, ".", "_") diff --git a/internal/sidekick/dart/generate.go b/internal/sidekick/dart/generate.go index f7c0df6cf1..7b7a21e7f7 100644 --- a/internal/sidekick/dart/generate.go +++ b/internal/sidekick/dart/generate.go @@ -37,7 +37,7 @@ func Generate(ctx context.Context, model *api.API, outdir string, codec map[stri return err } - err := parsedTemplates.GenerateFromModel(outdir, model, generatedFiles(model)) + err := parsedTemplates.GenerateFromModel(outdir, annotate.model, generatedFiles(annotate.model)) if err == nil { // Check if we're configured to skip formatting. skipFormat := codec["skip-format"] @@ -49,7 +49,7 @@ func Generate(ctx context.Context, model *api.API, outdir string, codec map[stri } func generatedFiles(model *api.API) []language.GeneratedFile { - codec := model.Codec.(*modelAnnotations) + codec := model.Codec().(*modelAnnotations) mainFileNameWithExtension := codec.MainFileNameWithExtension files := language.WalkTemplatesDir(dartTemplates, "templates") diff --git a/internal/sidekick/language/gotemplate_test.go b/internal/sidekick/language/gotemplate_test.go index 6c490a4f67..ef9607f5fc 100644 --- a/internal/sidekick/language/gotemplate_test.go +++ b/internal/sidekick/language/gotemplate_test.go @@ -83,10 +83,11 @@ func TestTemplatesExecuteAndGenerate(t *testing.T) { t.Fatal(err) } - model := api.NewTestAPI(nil, nil, nil) - model.Name = "Outer" - model.Description = "1" - model.Title = "" + model := api.NewAPIBuilder(). + WithName("Outer"). + WithDescription("1"). + WithTitle(""). + BuildSyntaxTree() outDir := t.TempDir() files := WalkTemplatesDir(fsys, "templates") diff --git a/internal/sidekick/parser/disco_test.go b/internal/sidekick/parser/disco_test.go index fa4b4b7762..1764e02489 100644 --- a/internal/sidekick/parser/disco_test.go +++ b/internal/sidekick/parser/disco_test.go @@ -37,17 +37,17 @@ func TestDisco_Parse(t *testing.T) { wantTitle := "Secret Manager API" wantDescription := "Stores sensitive data such as API keys, passwords, and certificates.\nProvides convenience while improving security." wantPackageName := "google.cloud.secretmanager.v1" - if got.Name != wantName { - t.Errorf("want = %q; got = %q", wantName, got.Name) + if got.Name() != wantName { + t.Errorf("want = %q; got = %q", wantName, got.Name()) } - if got.Title != wantTitle { - t.Errorf("want = %q; got = %q", wantTitle, got.Title) + if got.Title() != wantTitle { + t.Errorf("want = %q; got = %q", wantTitle, got.Title()) } - if diff := cmp.Diff(wantDescription, got.Description); diff != "" { + if diff := cmp.Diff(wantDescription, got.Description()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } - if got.PackageName != wantPackageName { - t.Errorf("want = %q; got = %q", wantPackageName, got.PackageName) + if got.PackageName() != wantPackageName { + t.Errorf("want = %q; got = %q", wantPackageName, got.PackageName()) } } @@ -68,13 +68,13 @@ func TestDisco_FindSources(t *testing.T) { wantName := "compute" wantTitle := "Compute Engine API" wantDescription := "Creates and runs virtual machines on Google Cloud Platform. " - if got.Name != wantName { - t.Errorf("want = %q; got = %q", wantName, got.Name) + if got.Name() != wantName { + t.Errorf("want = %q; got = %q", wantName, got.Name()) } - if got.Title != wantTitle { - t.Errorf("want = %q; got = %q", wantTitle, got.Title) + if got.Title() != wantTitle { + t.Errorf("want = %q; got = %q", wantTitle, got.Title()) } - if diff := cmp.Diff(wantDescription, got.Description); diff != "" { + if diff := cmp.Diff(wantDescription, got.Description()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -91,13 +91,13 @@ func TestDisco_ParseNoServiceConfig(t *testing.T) { wantName := "compute" wantTitle := "Compute Engine API" wantDescription := "Creates and runs virtual machines on Google Cloud Platform. " - if got.Name != wantName { - t.Errorf("want = %q; got = %q", wantName, got.Name) + if got.Name() != wantName { + t.Errorf("want = %q; got = %q", wantName, got.Name()) } - if got.Title != wantTitle { - t.Errorf("want = %q; got = %q", wantTitle, got.Title) + if got.Title() != wantTitle { + t.Errorf("want = %q; got = %q", wantTitle, got.Title()) } - if diff := cmp.Diff(wantDescription, got.Description); diff != "" { + if diff := cmp.Diff(wantDescription, got.Description()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } diff --git a/internal/sidekick/parser/discovery/discovery.go b/internal/sidekick/parser/discovery/discovery.go index 61561fbeaf..2d1ce5ac0f 100644 --- a/internal/sidekick/parser/discovery/discovery.go +++ b/internal/sidekick/parser/discovery/discovery.go @@ -35,32 +35,27 @@ func NewAPI(serviceConfig *serviceconfig.Service, contents []byte, discoveryConf if err != nil { return nil, err } - result := &api.API{ - Name: doc.Name, - Title: doc.Title, - Description: doc.Description, - Revision: doc.Revision, - Messages: make([]*api.Message, 0), - } - // Discovery docs use some well-known types inspired by Protobuf. With - // protoc these types are automatically included via `import` statements. - // In the Discovery docs JSON inputs, these types are not automatically - // included. - result.LoadWellKnownTypes() + result := api.NewAPIBuilder(). + WithName(doc.Name). + WithTitle(doc.Title). + WithDescription(doc.Description). + WithRevision(doc.Revision). + WithMessages(). + LoadWellKnownTypes() // Discovery docs do not define a service name or package name. The service // config may provide one. packageName := "" if serviceConfig != nil { - result.Name = strings.TrimSuffix(serviceConfig.Name, ".googleapis.com") - result.Title = serviceConfig.Title + result.WithName(strings.TrimSuffix(serviceConfig.Name, ".googleapis.com")). + WithTitle(serviceConfig.Title) if serviceConfig.Documentation != nil { - result.Description = serviceConfig.Documentation.Summary + result.WithDescription(serviceConfig.Documentation.Summary) } names := svcconfig.ExtractPackageName(serviceConfig) if names != nil { packageName, _ = names.PackageName, names.ServiceName - result.PackageName = packageName + result.WithPackageName(packageName) } } @@ -79,12 +74,12 @@ func NewAPI(serviceConfig *serviceconfig.Service, contents []byte, discoveryConf return nil, err } message := mb.Build() - result.Messages = append(result.Messages, message) + result.AppendMessage(message) result.AddMessage(message) } // The messages must be sorted otherwise the generated code gets different // output on each run. - slices.SortStableFunc(result.Messages, compareMessages) + result.SortMessages(compareMessages) for _, resource := range doc.Resources { if err := addServiceRecursive(result, doc, resource); err != nil { @@ -93,13 +88,13 @@ func NewAPI(serviceConfig *serviceconfig.Service, contents []byte, discoveryConf } // The services must be sorted otherwise the generated code gets different // output on each run. - slices.SortStableFunc(result.Services, compareServices) + result.SortServices(compareServices) - if err := api.AddDiscoveryLroAnnotations(result, discoveryConfig); err != nil { + if err := result.AddDiscoveryLroAnnotations(discoveryConfig); err != nil { return nil, err } - return result, nil + return result.BuildSyntaxTree(), nil } // A document is an API discovery document. diff --git a/internal/sidekick/parser/discovery/discovery_test.go b/internal/sidekick/parser/discovery/discovery_test.go index 37d89e4192..0d73deaccf 100644 --- a/internal/sidekick/parser/discovery/discovery_test.go +++ b/internal/sidekick/parser/discovery/discovery_test.go @@ -21,7 +21,6 @@ import ( "testing" "github.com/google/go-cmp/cmp" - "github.com/google/go-cmp/cmp/cmpopts" "github.com/googleapis/librarian/internal/sample" "github.com/googleapis/librarian/internal/serviceconfig" "github.com/googleapis/librarian/internal/sidekick/api" @@ -35,10 +34,10 @@ func TestSorted(t *testing.T) { if err != nil { t.Fatal(err) } - if !slices.IsSortedFunc(got.Messages, compareMessages) { + if !slices.IsSortedFunc(got.Messages(), compareMessages) { t.Fatalf("unsorted messages after parsing") } - if !slices.IsSortedFunc(got.Services, compareServices) { + if !slices.IsSortedFunc(got.Services(), compareServices) { t.Fatalf("unsorted messages after parsing") } } @@ -51,9 +50,9 @@ func TestInfo(t *testing.T) { want := api.NewTestAPI(nil, nil, nil). WithName("compute"). WithTitle("Compute Engine API"). - WithDescription("Creates and runs virtual machines on Google Cloud Platform. ") - want.Revision = "20250810" - if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(api.API{}, "Services", "Messages", "Enums"), cmpopts.IgnoreUnexported(api.API{})); diff != "" { + WithDescription("Creates and runs virtual machines on Google Cloud Platform. "). + WithRevision("20250810") + if diff := cmp.Diff(want, got, apitest.AllowUnexported(), apitest.IgnoreAPIFields("services", "messages", "enums", "serviceByID", "methodByID", "messageByID", "enumByID", "resourceByType", "mapByID")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -72,16 +71,16 @@ func TestServiceConfigOverridesInfo(t *testing.T) { WithName(sc.Name). WithTitle(sc.Title). WithDescription(sc.Documentation.Summary). - WithPackageName("google.cloud.secretmanager.v1") - want.Revision = "20250810" - if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(api.API{}, "Services", "Messages", "Enums"), cmpopts.IgnoreUnexported(api.API{})); diff != "" { + WithPackageName("google.cloud.secretmanager.v1"). + WithRevision("20250810") + if diff := cmp.Diff(want, got, apitest.AllowUnexported(), apitest.IgnoreAPIFields("services", "messages", "enums", "serviceByID", "methodByID", "messageByID", "enumByID", "resourceByType", "mapByID")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } if len(sc.Apis) != 2 { t.Fatalf("expected 2 APIs in service config") } - if !strings.HasPrefix(sc.Apis[1].Name, got.PackageName) { - t.Errorf("mismatched package name want = %q, got = %q", sc.Apis[1].Name, got.PackageName) + if !strings.HasPrefix(sc.Apis[1].Name, got.PackageName()) { + t.Errorf("mismatched package name want = %q, got = %q", sc.Apis[1].Name, got.PackageName()) } } diff --git a/internal/sidekick/parser/discovery/enum.go b/internal/sidekick/parser/discovery/enum.go index 20d40cf78f..f0e38dd978 100644 --- a/internal/sidekick/parser/discovery/enum.go +++ b/internal/sidekick/parser/discovery/enum.go @@ -20,7 +20,7 @@ import ( "github.com/googleapis/librarian/internal/sidekick/api" ) -func makeMessageEnum(model *api.API, mb *api.MessageBuilder, name string, schema *schema) error { +func makeMessageEnum(model *api.APIBuilder, mb *api.MessageBuilder, name string, schema *schema) error { if schema.Enums == nil { return nil } diff --git a/internal/sidekick/parser/discovery/enum_field_test.go b/internal/sidekick/parser/discovery/enum_field_test.go index a2f4ec88e8..24264f1cfd 100644 --- a/internal/sidekick/parser/discovery/enum_field_test.go +++ b/internal/sidekick/parser/discovery/enum_field_test.go @@ -23,8 +23,7 @@ import ( ) func TestMakeEnumFields(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -104,8 +103,7 @@ func TestMakeEnumFields(t *testing.T) { } func TestMakeEnumFieldsDeprecated(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -178,8 +176,7 @@ func TestMakeEnumFieldsDeprecated(t *testing.T) { } func TestMakeEnumFieldsWithDeprecatedValues(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -267,8 +264,7 @@ func TestMakeEnumFieldsWithDeprecatedValues(t *testing.T) { } func TestMakeEnumFieldsDescriptionError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -297,8 +293,7 @@ func TestMakeEnumFieldsDescriptionError(t *testing.T) { } func TestMakeEnumFieldsDeprecatedError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { diff --git a/internal/sidekick/parser/discovery/inline_object_field.go b/internal/sidekick/parser/discovery/inline_object_field.go index 54e6c72bf8..1bcaf40989 100644 --- a/internal/sidekick/parser/discovery/inline_object_field.go +++ b/internal/sidekick/parser/discovery/inline_object_field.go @@ -20,11 +20,11 @@ import ( "github.com/googleapis/librarian/internal/sidekick/api" ) -func maybeInlineObjectField(model *api.API, parentBuilder *api.MessageBuilder, name string, input *schema) (*api.Field, error) { +func maybeInlineObjectField(model *api.APIBuilder, parentBuilder *api.MessageBuilder, name string, input *schema) (*api.Field, error) { return makeInlineObjectField(model, parentBuilder, name, input, input.Description, true, false) } -func makeInlineObjectField(model *api.API, parentBuilder *api.MessageBuilder, name string, input *schema, description string, optional, repeated bool) (*api.Field, error) { +func makeInlineObjectField(model *api.APIBuilder, parentBuilder *api.MessageBuilder, name string, input *schema, description string, optional, repeated bool) (*api.Field, error) { if input.Type != "object" || input.Properties == nil { return nil, nil } diff --git a/internal/sidekick/parser/discovery/inline_object_field_test.go b/internal/sidekick/parser/discovery/inline_object_field_test.go index fd647dceac..782ebbf942 100644 --- a/internal/sidekick/parser/discovery/inline_object_field_test.go +++ b/internal/sidekick/parser/discovery/inline_object_field_test.go @@ -23,8 +23,7 @@ import ( ) func TestMaybeInlineObject(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Type: "object", Description: "A field with an inline object.", @@ -96,8 +95,7 @@ func TestMaybeInlineObject(t *testing.T) { } func TestArrayWithInlineObject(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &property{ Name: "arrayWithObject", Schema: &schema{ @@ -173,8 +171,7 @@ func TestArrayWithInlineObject(t *testing.T) { } func TestMaybeInlineObjectErrors(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Type: "object", Description: "A field with an inline object.", @@ -195,8 +192,7 @@ func TestMaybeInlineObjectErrors(t *testing.T) { } func TestArrayWithInlineObjectError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &property{ Name: "arrayWithObject", Schema: &schema{ diff --git a/internal/sidekick/parser/discovery/map_field.go b/internal/sidekick/parser/discovery/map_field.go index f1ad61daaa..560f1bba22 100644 --- a/internal/sidekick/parser/discovery/map_field.go +++ b/internal/sidekick/parser/discovery/map_field.go @@ -20,7 +20,7 @@ import ( "github.com/googleapis/librarian/internal/sidekick/api" ) -func maybeMapField(model *api.API, mb *api.MessageBuilder, input *property) (*api.Field, error) { +func maybeMapField(model *api.APIBuilder, mb *api.MessageBuilder, input *property) (*api.Field, error) { if input.Schema.Type != "object" || input.Schema.Format != "" { return nil, nil } @@ -37,12 +37,12 @@ func maybeMapField(model *api.API, mb *api.MessageBuilder, input *property) (*ap return maybeMapOfPrimitiveField(model, mb, input) } -func maybeMapOfObjectField(model *api.API, mb *api.MessageBuilder, input *property) *api.Field { +func maybeMapOfObjectField(model *api.APIBuilder, mb *api.MessageBuilder, input *property) *api.Field { if input.Schema.AdditionalProperties.Ref == "" { return nil } message := mb.Build() - valueTypezID := fmt.Sprintf(".%s.%s", model.PackageName, input.Schema.AdditionalProperties.Ref) + valueTypezID := fmt.Sprintf(".%s.%s", model.PackageName(), input.Schema.AdditionalProperties.Ref) typezID := insertMapType(model, api.TypezMessage, valueTypezID) field := api.NewFieldBuilder(). WithName(input.Name). @@ -57,7 +57,7 @@ func maybeMapOfObjectField(model *api.API, mb *api.MessageBuilder, input *proper return field } -func maybeMapOfEnumField(model *api.API, mb *api.MessageBuilder, input *property) (*api.Field, error) { +func maybeMapOfEnumField(model *api.APIBuilder, mb *api.MessageBuilder, input *property) (*api.Field, error) { if input.Schema.AdditionalProperties.Enums == nil { return nil, nil } @@ -80,7 +80,7 @@ func maybeMapOfEnumField(model *api.API, mb *api.MessageBuilder, input *property return field, nil } -func maybeMapOfPrimitiveField(model *api.API, mb *api.MessageBuilder, input *property) (*api.Field, error) { +func maybeMapOfPrimitiveField(model *api.APIBuilder, mb *api.MessageBuilder, input *property) (*api.Field, error) { message := mb.Build() valueTypez, valueTypezID, err := scalarType(model, message.ID(), input.Name, input.Schema.AdditionalProperties) if err != nil { @@ -100,7 +100,7 @@ func maybeMapOfPrimitiveField(model *api.API, mb *api.MessageBuilder, input *pro return field, nil } -func insertMapType(model *api.API, valueTypez api.Typez, valueTypezID string) string { +func insertMapType(model *api.APIBuilder, valueTypez api.Typez, valueTypezID string) string { id := fmt.Sprintf("$map", valueTypezID) if model.Map(id) != nil { return id diff --git a/internal/sidekick/parser/discovery/map_field_test.go b/internal/sidekick/parser/discovery/map_field_test.go index 5643890a59..bccd1ca84f 100644 --- a/internal/sidekick/parser/discovery/map_field_test.go +++ b/internal/sidekick/parser/discovery/map_field_test.go @@ -37,8 +37,7 @@ func newTestDiscoveryMessage(fields ...*api.Field) *api.Message { } func TestMapFields(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -79,8 +78,7 @@ func TestMapFields(t *testing.T) { } func TestMapFieldWithObjectValues(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -122,8 +120,7 @@ func TestMapFieldWithObjectValues(t *testing.T) { } func TestMapFieldWithEnumValues(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -216,7 +213,7 @@ func TestMapScalarTypes(t *testing.T) { {"object", "google.protobuf.Struct", api.TypezMessage, ".google.protobuf.Struct"}, {"object", "google.protobuf.Any", api.TypezMessage, ".google.protobuf.Any"}, } { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() input := &schema{ Properties: []*property{ { @@ -263,8 +260,7 @@ func TestMapScalarTypes(t *testing.T) { } func TestMapFieldEnumError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -287,8 +283,7 @@ func TestMapFieldEnumError(t *testing.T) { } func TestMapFieldScalarError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { diff --git a/internal/sidekick/parser/discovery/message_fields.go b/internal/sidekick/parser/discovery/message_fields.go index 13167445cc..a65bee890c 100644 --- a/internal/sidekick/parser/discovery/message_fields.go +++ b/internal/sidekick/parser/discovery/message_fields.go @@ -20,7 +20,7 @@ import ( "github.com/googleapis/librarian/internal/sidekick/api" ) -func makeMessageFields(model *api.API, mb *api.MessageBuilder, schema *schema) error { +func makeMessageFields(model *api.APIBuilder, mb *api.MessageBuilder, schema *schema) error { for _, input := range schema.Properties { field, err := makeField(model, mb, input, true) if err != nil { @@ -31,7 +31,7 @@ func makeMessageFields(model *api.API, mb *api.MessageBuilder, schema *schema) e return nil } -func makeField(model *api.API, mb *api.MessageBuilder, input *property, optional bool) (*api.Field, error) { +func makeField(model *api.APIBuilder, mb *api.MessageBuilder, input *property, optional bool) (*api.Field, error) { if input.Schema.Type == "array" { return makeArrayField(model, mb, input) } @@ -44,7 +44,7 @@ func makeField(model *api.API, mb *api.MessageBuilder, input *property, optional return makeScalarFieldWithOptions(model, mb, input.Name, input.Schema, input.Schema.Description, optional, false) } -func makeArrayField(model *api.API, mb *api.MessageBuilder, input *property) (*api.Field, error) { +func makeArrayField(model *api.APIBuilder, mb *api.MessageBuilder, input *property) (*api.Field, error) { field, err := makeInlineObjectField(model, mb, input.Name, input.Schema.ItemSchema, input.Schema.Description, false, true) if err != nil || field != nil { return field, err @@ -52,11 +52,11 @@ func makeArrayField(model *api.API, mb *api.MessageBuilder, input *property) (*a return makeScalarFieldWithOptions(model, mb, input.Name, input.Schema.ItemSchema, input.Schema.Description, false, true) } -func makeScalarField(model *api.API, mb *api.MessageBuilder, name string, schema *schema) (*api.Field, error) { +func makeScalarField(model *api.APIBuilder, mb *api.MessageBuilder, name string, schema *schema) (*api.Field, error) { return makeScalarFieldWithOptions(model, mb, name, schema, schema.Description, true, false) } -func makeScalarFieldWithOptions(model *api.API, mb *api.MessageBuilder, name string, schema *schema, description string, optional, repeated bool) (*api.Field, error) { +func makeScalarFieldWithOptions(model *api.APIBuilder, mb *api.MessageBuilder, name string, schema *schema, description string, optional, repeated bool) (*api.Field, error) { if err := makeMessageEnum(model, mb, name, schema); err != nil { return nil, err } @@ -78,9 +78,9 @@ func makeScalarFieldWithOptions(model *api.API, mb *api.MessageBuilder, name str Build(), nil } -func scalarType(model *api.API, messageID, name string, input *schema) (api.Typez, string, error) { +func scalarType(model *api.APIBuilder, messageID, name string, input *schema) (api.Typez, string, error) { if input.Type == "" && input.Ref != "" { - typezID := fmt.Sprintf(".%s.%s", model.PackageName, input.Ref) + typezID := fmt.Sprintf(".%s.%s", model.PackageName(), input.Ref) return api.TypezMessage, typezID, nil } switch input.Type { diff --git a/internal/sidekick/parser/discovery/message_fields_test.go b/internal/sidekick/parser/discovery/message_fields_test.go index 102a45e25a..5af82c0707 100644 --- a/internal/sidekick/parser/discovery/message_fields_test.go +++ b/internal/sidekick/parser/discovery/message_fields_test.go @@ -24,8 +24,7 @@ import ( ) func TestMakeMessageFields(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) - model.PackageName = "package" + model := api.NewAPIBuilder().WithPackageName("package") input := &schema{ Properties: []*property{ { @@ -123,7 +122,7 @@ func TestMakeMessageFields(t *testing.T) { } func TestMakeMessageFieldsError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() input := &schema{ Properties: []*property{ { @@ -144,7 +143,7 @@ func TestMakeMessageFieldsError(t *testing.T) { } func TestMakeArrayFieldError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() input := &property{ Name: "field", Schema: &schema{ @@ -164,7 +163,7 @@ func TestMakeArrayFieldError(t *testing.T) { } func TestMakeScalarFieldError(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() input := &property{ Name: "field", Schema: &schema{ @@ -207,7 +206,7 @@ func TestScalarTypes(t *testing.T) { {"object", "google.protobuf.Struct", api.TypezMessage, ".google.protobuf.Struct"}, {"object", "google.protobuf.Any", api.TypezMessage, ".google.protobuf.Any"}, } { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() input := &schema{ ID: ".package.Message.field", Description: "The field description.", @@ -230,7 +229,7 @@ func TestScalarTypes(t *testing.T) { } func TestScalarUnknownType(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() input := &schema{ ID: ".package.Message.field", Description: "The field description.", @@ -243,7 +242,7 @@ func TestScalarUnknownType(t *testing.T) { } func TestScalarUnknownFormats(t *testing.T) { - model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{}) + model := api.NewAPIBuilder() for _, test := range []struct { Type string }{ diff --git a/internal/sidekick/parser/discovery/methods.go b/internal/sidekick/parser/discovery/methods.go index 1a8ad613bf..da09f4c6e5 100644 --- a/internal/sidekick/parser/discovery/methods.go +++ b/internal/sidekick/parser/discovery/methods.go @@ -21,7 +21,7 @@ import ( "github.com/googleapis/librarian/internal/sidekick/api" ) -func makeServiceMethods(model *api.API, service *api.ServiceBuilder, doc *document, resource *resource) error { +func makeServiceMethods(model *api.APIBuilder, service *api.ServiceBuilder, doc *document, resource *resource) error { // It is Okay to reuse the ID, sidekick uses different the namespaces // for messages vs. services. parentBuilder := api.NewMessageBuilder(). @@ -32,7 +32,7 @@ func makeServiceMethods(model *api.API, service *api.ServiceBuilder, doc *docume WithServicePlaceholder(true) parent := parentBuilder.Build() model.AddMessage(parent) - model.Messages = append(model.Messages, parent) + model.AppendMessage(parent) for _, input := range resource.Methods { method, err := makeMethod(model, parentBuilder, doc, input) if err != nil { @@ -45,7 +45,7 @@ func makeServiceMethods(model *api.API, service *api.ServiceBuilder, doc *docume return nil } -func makeMethod(model *api.API, parentBuilder *api.MessageBuilder, doc *document, input *method) (*api.Method, error) { +func makeMethod(model *api.APIBuilder, parentBuilder *api.MessageBuilder, doc *document, input *method) (*api.Method, error) { parent := parentBuilder.Build() id := fmt.Sprintf("%s.%s", parent.ID(), input.Name) if input.MediaUpload != nil { @@ -65,7 +65,7 @@ func makeMethod(model *api.API, parentBuilder *api.MessageBuilder, doc *document requestBuilder := api.NewMessageBuilder(). WithName(fmt.Sprintf("%sRequest", input.Name)). WithID(requestMessageID). - WithPackage(model.PackageName). + WithPackage(model.PackageName()). WithSyntheticRequest(true). WithDocumentation(fmt.Sprintf("Synthetic request message for the [%s()][%s] method.", input.Name, id[1:])). WithParent(parent). @@ -170,12 +170,12 @@ func bodyFieldName(fieldNames map[string]bool) (string, error) { return "body", nil } -func getMethodType(model *api.API, methodID, name string, typez *schema) (string, error) { +func getMethodType(model *api.APIBuilder, methodID, name string, typez *schema) (string, error) { if typez == nil { return ".google.protobuf.Empty", nil } if typez.Ref == "" { return "", fmt.Errorf("expected a ref-like schema for %s in method %s", name, methodID) } - return fmt.Sprintf(".%s.%s", model.PackageName, typez.Ref), nil + return fmt.Sprintf(".%s.%s", model.PackageName(), typez.Ref), nil } diff --git a/internal/sidekick/parser/discovery/methods_test.go b/internal/sidekick/parser/discovery/methods_test.go index 886954364e..6cdadee83b 100644 --- a/internal/sidekick/parser/discovery/methods_test.go +++ b/internal/sidekick/parser/discovery/methods_test.go @@ -316,6 +316,7 @@ func TestMakeServiceMethodsError(t *testing.T) { if err != nil { t.Fatal(err) } + ab := api.NewAPIBuilderFrom(model) doc := document{} input := &resource{ Name: "testResource", @@ -330,7 +331,7 @@ func TestMakeServiceMethodsError(t *testing.T) { WithName("Service"). WithPackage("test"). WithID(".test.Service") - if err := makeServiceMethods(model, service, &doc, input); err == nil { + if err := makeServiceMethods(ab, service, &doc, input); err == nil { t.Errorf("expected error on method with media upload, service=%v", service) } } @@ -340,6 +341,7 @@ func TestMakeMethodError(t *testing.T) { if err != nil { t.Fatal(err) } + ab := api.NewAPIBuilderFrom(model) for _, test := range []struct { Name string @@ -361,7 +363,7 @@ func TestMakeMethodError(t *testing.T) { } { doc := document{} parent := api.NewMessageBuilderFrom(api.NewTestMessage("Service").WithPackage("test")) - if got, err := makeMethod(model, parent, &doc, &test.Input); err == nil { + if got, err := makeMethod(ab, parent, &doc, &test.Input); err == nil { t.Errorf("expected error on method[%s], got=%v", test.Name, got) } } diff --git a/internal/sidekick/parser/discovery/services.go b/internal/sidekick/parser/discovery/services.go index a261302444..3b9fb5b50e 100644 --- a/internal/sidekick/parser/discovery/services.go +++ b/internal/sidekick/parser/discovery/services.go @@ -21,7 +21,7 @@ import ( "github.com/googleapis/librarian/internal/sidekick/api" ) -func addServiceRecursive(model *api.API, doc *document, resource *resource) error { +func addServiceRecursive(model *api.APIBuilder, doc *document, resource *resource) error { if len(resource.Methods) != 0 { if err := addService(model, doc, resource); err != nil { return err @@ -35,12 +35,12 @@ func addServiceRecursive(model *api.API, doc *document, resource *resource) erro return nil } -func addService(model *api.API, doc *document, resource *resource) error { - id := fmt.Sprintf(".%s.%s", model.PackageName, resource.Name) +func addService(model *api.APIBuilder, doc *document, resource *resource) error { + id := fmt.Sprintf(".%s.%s", model.PackageName(), resource.Name) sb := api.NewServiceBuilder(). WithID(id). WithName(resource.Name). - WithPackage(model.PackageName). + WithPackage(model.PackageName()). WithDocumentation(fmt.Sprintf("Service for the `%s` resource.", resource.Name)). WithDefaultHost(strings.TrimSuffix(strings.TrimPrefix(doc.RootURL, "https://"), "/")). WithDeprecated(resource.Deprecated) @@ -48,7 +48,7 @@ func addService(model *api.API, doc *document, resource *resource) error { return err } service := sb.Build() - model.Services = append(model.Services, service) + model.AppendService(service) model.AddService(service) return nil } diff --git a/internal/sidekick/parser/discovery/services_test.go b/internal/sidekick/parser/discovery/services_test.go index 01e2789267..2d803a71e0 100644 --- a/internal/sidekick/parser/discovery/services_test.go +++ b/internal/sidekick/parser/discovery/services_test.go @@ -85,18 +85,19 @@ func TestServiceDeprecated(t *testing.T) { if err != nil { t.Fatal(err) } + ab := api.NewAPIBuilderFrom(model) doc := document{} input := resource{ Name: "TestDeprecated", Deprecated: true, } - if err := addService(model, &doc, &input); err != nil { + if err := addService(ab, &doc, &input); err != nil { t.Fatal(err) } want := newDiscoveryTestService("TestDeprecated"). WithDocumentation("Service for the `TestDeprecated` resource."). WithDeprecated(true) - got := model.Service(want.ID()) + got := ab.Service(want.ID()) if got == nil { t.Fatalf("missing service %s", want.ID()) } @@ -147,14 +148,15 @@ func TestServiceTopLevelMethodErrors(t *testing.T) { if err != nil { t.Fatal(err) } + ab := api.NewAPIBuilderFrom(model) doc := document{} input := resource{ Methods: []*method{ {MediaUpload: &mediaUpload{}}, }, } - if err := addServiceRecursive(model, &doc, &input); err == nil { - t.Errorf("expected error in addServiceRecursive invalid top-level method, got=%v", model.Services) + if err := addServiceRecursive(ab, &doc, &input); err == nil { + t.Errorf("expected error in addServiceRecursive invalid top-level method, got=%v", ab.Services()) } } @@ -163,6 +165,7 @@ func TestServiceChildMethodErrors(t *testing.T) { if err != nil { t.Fatal(err) } + ab := api.NewAPIBuilderFrom(model) doc := document{} input := resource{ Resources: []*resource{ @@ -173,7 +176,7 @@ func TestServiceChildMethodErrors(t *testing.T) { }, }, } - if err := addServiceRecursive(model, &doc, &input); err == nil { - t.Errorf("expected error in addServiceRecursive invalid child method, got=%v", model.Services) + if err := addServiceRecursive(ab, &doc, &input); err == nil { + t.Errorf("expected error in addServiceRecursive invalid child method, got=%v", ab.Services()) } } diff --git a/internal/sidekick/parser/openapi.go b/internal/sidekick/parser/openapi.go index 1b1b6ab10e..e95fdd0eda 100644 --- a/internal/sidekick/parser/openapi.go +++ b/internal/sidekick/parser/openapi.go @@ -64,23 +64,17 @@ func createDocModel(contents []byte) (*libopenapi.DocumentModel[v3.Document], er } func makeAPIForOpenAPI(serviceConfig *serviceconfig.Service, model *libopenapi.DocumentModel[v3.Document]) (*api.API, error) { - result := &api.API{ - Name: "", - Title: model.Model.Info.Title, - Description: model.Model.Info.Description, - Messages: make([]*api.Message, 0), - } - // OpenAPI (for Google) uses some well-known types inspired by Protobuf. - // With protoc these types are automatically included via `import` - // statements. In the OpenAPI JSON inputs, these types are not automatically - // included. - result.LoadWellKnownTypes() + result := api.NewAPIBuilder(). + WithTitle(model.Model.Info.Title). + WithDescription(model.Model.Info.Description). + WithMessages(). + LoadWellKnownTypes() if serviceConfig != nil { - result.Name = strings.TrimSuffix(serviceConfig.Name, ".googleapis.com") - result.Title = serviceConfig.Title + result.WithName(strings.TrimSuffix(serviceConfig.Name, ".googleapis.com")). + WithTitle(serviceConfig.Title) if serviceConfig.Documentation != nil { - result.Description = serviceConfig.Documentation.Summary + result.WithDescription(serviceConfig.Documentation.Summary) } } @@ -91,7 +85,7 @@ func makeAPIForOpenAPI(serviceConfig *serviceconfig.Service, model *libopenapi.D names := svcconfig.ExtractPackageName(serviceConfig) if names != nil { serviceName, packageName = names.ServiceName, names.PackageName - result.PackageName = packageName + result.WithPackageName(packageName) } for name, msg := range model.Model.Components.Schemas.FromOldest() { @@ -113,7 +107,7 @@ func makeAPIForOpenAPI(serviceConfig *serviceconfig.Service, model *libopenapi.D WithFields(fields...). Build() - result.Messages = append(result.Messages, message) + result.AppendMessage(message) result.AddMessage(message) } @@ -121,11 +115,12 @@ func makeAPIForOpenAPI(serviceConfig *serviceconfig.Service, model *libopenapi.D if err != nil { return nil, err } - updateAutoPopulatedFields(serviceConfig, result) - return result, nil + apiModel := result.BuildSyntaxTree() + updateAutoPopulatedFields(serviceConfig, apiModel) + return apiModel, nil } -func makeServices(a *api.API, model *libopenapi.DocumentModel[v3.Document], packageName, serviceName string) error { +func makeServices(a *api.APIBuilder, model *libopenapi.DocumentModel[v3.Document], packageName, serviceName string) error { // It is hard to imagine an OpenAPI specification without at least some // RPCs, but we can simplify the tests if we support specifications without // paths or without any useful methods in the paths. @@ -141,11 +136,11 @@ func makeServices(a *api.API, model *libopenapi.DocumentModel[v3.Document], pack WithName(serviceName). WithID(sID). WithPackage(packageName). - WithDocumentation(a.Description). + WithDocumentation(a.Description()). WithDefaultHost(defaultHost(model)). WithMethods(methods...). Build() - a.Services = append(a.Services, service) + a.AppendService(service) a.AddService(service) return nil } @@ -164,7 +159,7 @@ func defaultHost(model *libopenapi.DocumentModel[v3.Document]) string { return strings.TrimPrefix(defaultHost, "https://") } -func makeMethods(a *api.API, model *libopenapi.DocumentModel[v3.Document], packageName, serviceName, serviceID string) ([]*api.Method, error) { +func makeMethods(a *api.APIBuilder, model *libopenapi.DocumentModel[v3.Document], packageName, serviceName, serviceID string) ([]*api.Method, error) { if model.Model.Paths == nil { // The method has no path, there is nothing to generate. return nil, nil @@ -180,7 +175,7 @@ func makeMethods(a *api.API, model *libopenapi.DocumentModel[v3.Document], packa WithServicePlaceholder(true) parent := parentBuilder.Build() a.AddMessage(parent) - a.Messages = append(a.Messages, parent) + a.AppendMessage(parent) var methods []*api.Method for pattern, item := range model.Model.Paths.PathItems.FromOldest() { @@ -245,7 +240,7 @@ func makeMethods(a *api.API, model *libopenapi.DocumentModel[v3.Document], packa // makeRequestMessage creates (if needed) the request message for `operation`. Returns the message // and the body field path (if any) for the request. -func makeRequestMessage(a *api.API, parentBuilder *api.MessageBuilder, operation *v3.Operation, packageName, template string) (*api.Message, string, error) { +func makeRequestMessage(a *api.APIBuilder, parentBuilder *api.MessageBuilder, operation *v3.Operation, packageName, template string) (*api.Message, string, error) { parent := parentBuilder.Build() messageName := fmt.Sprintf("%sRequest", operation.OperationId) id := fmt.Sprintf("%s.%s", parent.ID(), messageName) @@ -341,7 +336,7 @@ func openapiIsAutoPopulated(typez api.Typez, schema *base.Schema, p *v3.Paramete return typez == api.TypezString && schema.Format == "uuid" && openapiFieldIsOptional(p) } -func makeResponseMessage(api *api.API, operation *v3.Operation, packageName string) (*api.Message, error) { +func makeResponseMessage(api *api.APIBuilder, operation *v3.Operation, packageName string) (*api.Message, error) { if operation.Responses == nil { return nil, fmt.Errorf("missing Responses in specification for operation %s", operation.OperationId) } @@ -383,7 +378,7 @@ func makeQueryParameters(operation *v3.Operation) map[string]bool { return queryParameters } -func makeMessageFields(model *api.API, packageName, messageName string, message *base.Schema) ([]*api.Field, error) { +func makeMessageFields(model *api.APIBuilder, packageName, messageName string, message *base.Schema) ([]*api.Field, error) { var fields []*api.Field for name, f := range message.Properties.FromOldest() { schema, err := f.BuildSchema() @@ -400,7 +395,7 @@ func makeMessageFields(model *api.API, packageName, messageName string, message return fields, nil } -func makeField(model *api.API, packageName, messageName, name string, optional bool, field *base.Schema) (*api.Field, error) { +func makeField(model *api.APIBuilder, packageName, messageName, name string, optional bool, field *base.Schema) (*api.Field, error) { if len(field.AllOf) != 0 { // Simple object fields name an AllOf attribute, but no `Type` attribute. return makeObjectField(model, packageName, messageName, name, false, field) @@ -438,7 +433,7 @@ func makeScalarField(packageName, messageName, name string, schema *base.Schema, Build(), nil } -func makeObjectField(model *api.API, packageName, messageName, name string, repeated bool, field *base.Schema) (*api.Field, error) { +func makeObjectField(model *api.APIBuilder, packageName, messageName, name string, repeated bool, field *base.Schema) (*api.Field, error) { if len(field.AllOf) != 0 { return makeObjectFieldAllOf(packageName, messageName, name, repeated, field) } @@ -499,7 +494,7 @@ func makeObjectField(model *api.API, packageName, messageName, name string, repe return nil, fmt.Errorf("unknown object field type for field %s.%s", messageName, name) } -func makeArrayField(model *api.API, packageName, messageName, name string, field *base.Schema) (*api.Field, error) { +func makeArrayField(model *api.APIBuilder, packageName, messageName, name string, field *base.Schema) (*api.Field, error) { if !field.Items.IsA() { return nil, fmt.Errorf("cannot handle arrays without an `Items` field for %s.%s", messageName, name) } @@ -552,7 +547,7 @@ func makeObjectFieldAllOf(packageName, messageName, name string, repeated bool, return nil, fmt.Errorf("cannot build any AllOf schema for field %s.%s", messageName, name) } -func makeMap(model *api.API, messageName, name string, schema *base.Schema) (*api.Map, error) { +func makeMap(model *api.APIBuilder, messageName, name string, schema *base.Schema) (*api.Map, error) { valueTypez, valueID, err := scalarType(messageName, name, schema) if err != nil { return nil, err diff --git a/internal/sidekick/parser/openapi_test.go b/internal/sidekick/parser/openapi_test.go index f52a33d22e..8b52c44af9 100644 --- a/internal/sidekick/parser/openapi_test.go +++ b/internal/sidekick/parser/openapi_test.go @@ -19,7 +19,6 @@ import ( "testing" "github.com/google/go-cmp/cmp" - "github.com/google/go-cmp/cmp/cmpopts" "github.com/googleapis/librarian/internal/sample" "github.com/googleapis/librarian/internal/serviceconfig" "github.com/googleapis/librarian/internal/sidekick/api" @@ -231,7 +230,7 @@ func TestOpenAPI_SimpleObject(t *testing.T) { t.Fatalf("Error in makeAPI() %q", err) } - apitest.CheckMessage(t, test.Messages[0], newTestOpenAPIFakeMessage( + apitest.CheckMessage(t, test.Messages()[0], newTestOpenAPIFakeMessage( api.NewTestField("fObject"). WithDocumentation("An object field."). WithType(api.TypezMessage). @@ -266,7 +265,7 @@ func TestOpenAPI_Any(t *testing.T) { t.Errorf("Error in makeAPI() %q", err) } - apitest.CheckMessage(t, test.Messages[0], newTestOpenAPIFakeMessage( + apitest.CheckMessage(t, test.Messages()[0], newTestOpenAPIFakeMessage( api.NewTestField("fMap").WithType(api.TypezMessage).WithTypezID(".google.protobuf.Any").WithOptional(), )) } @@ -303,7 +302,7 @@ func TestOpenAPI_MapString(t *testing.T) { api.NewTestField("fMapS32").WithType(api.TypezMap).WithTypezID("$map").WithMap(), api.NewTestField("fMapS64").WithType(api.TypezMap).WithTypezID("$map").WithMap(), ) - apitest.CheckMessage(t, test.Messages[0], wantMap) + apitest.CheckMessage(t, test.Messages()[0], wantMap) } func TestOpenAPI_MapInteger(t *testing.T) { @@ -336,7 +335,7 @@ func TestOpenAPI_MapInteger(t *testing.T) { api.NewTestField("fMapI32").WithType(api.TypezMap).WithTypezID("$map").WithMap(), api.NewTestField("fMapI64").WithType(api.TypezMap).WithTypezID("$map").WithMap(), ) - apitest.CheckMessage(t, test.Messages[0], wantMapInteger) + apitest.CheckMessage(t, test.Messages()[0], wantMapInteger) } func openapiSecretManagerAPI(t *testing.T) *api.API { @@ -536,7 +535,7 @@ func TestOpenAPI_MakeApiWithServiceConfig(t *testing.T) { t.Fatalf("Error in makeAPI() %q", err) } want := sample.API() - if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(api.API{}, "Services", "Messages", "Enums"), cmpopts.IgnoreUnexported(api.API{})); diff != "" { + if diff := cmp.Diff(want, got, apitest.AllowUnexported(), apitest.IgnoreAPIFields("services", "messages", "enums", "serviceByID", "methodByID", "messageByID", "enumByID", "resourceByType", "mapByID")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } @@ -553,13 +552,12 @@ func TestOpenAPI_MakeApiServiceConfigOverridesDescription(t *testing.T) { } serviceConfig := sample.ServiceConfig() serviceConfig.Documentation.Summary = "Test Only - Override Description." - want := sample.API() - want.Description = serviceConfig.Documentation.Summary + want := sample.API().WithDescription(serviceConfig.Documentation.Summary) got, err := makeAPIForOpenAPI(serviceConfig, model) if err != nil { t.Fatalf("Error in makeAPI() %q", err) } - if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(api.API{}, "Services", "Messages", "Enums"), cmpopts.IgnoreUnexported(api.API{})); diff != "" { + if diff := cmp.Diff(want, got, apitest.AllowUnexported(), apitest.IgnoreAPIFields("services", "messages", "enums", "serviceByID", "methodByID", "messageByID", "enumByID", "resourceByType", "mapByID")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } diff --git a/internal/sidekick/parser/package_name.go b/internal/sidekick/parser/package_name.go index 7230435367..ecc2230895 100644 --- a/internal/sidekick/parser/package_name.go +++ b/internal/sidekick/parser/package_name.go @@ -19,15 +19,6 @@ import "github.com/googleapis/librarian/internal/sidekick/api" // updatePackageName() sets the PackageName field if it is not set. This happens // often with protobuf libraries that lack a service config YAML file, typically // type-only libraries. -func updatePackageName(model *api.API) { - if model.PackageName != "" { - return - } - if len(model.Services) > 0 { - model.PackageName = model.Services[0].Package() - } else if len(model.Messages) > 0 { - model.PackageName = model.Messages[0].Package() - } else if len(model.Enums) > 0 { - model.PackageName = model.Enums[0].Package() - } +func updatePackageName(model *api.APIBuilder) { + model.UpdatePackageName() } diff --git a/internal/sidekick/parser/parser.go b/internal/sidekick/parser/parser.go index a847400cc3..8ff78aeaa8 100644 --- a/internal/sidekick/parser/parser.go +++ b/internal/sidekick/parser/parser.go @@ -91,32 +91,10 @@ func CreateModel(cfg *ModelConfig) (*api.API, error) { if err != nil { return nil, err } - api.UpdateMethodPagination(cfg.PaginationOverrides, model) - api.LabelRecursiveFields(model) - if err := api.CrossReference(model); err != nil { - return nil, err - } - if err := api.IdentifyTargetResources(model, cfg.ResourceNameHeuristic); err != nil { - return nil, err - } - if err := api.SkipModelElements(model, cfg.Override); err != nil { - return nil, err - } - if err := api.PatchDocumentation(model, cfg.CommentOverrides); err != nil { - return nil, err - } - // Verify all the services, messages and enums are in the same package. - if err := api.Validate(model); err != nil { - return nil, err - } - if cfg.Override.Name != "" { - model.Name = cfg.Override.Name - } - if cfg.Override.Title != "" { - model.Title = cfg.Override.Title - } - if cfg.Override.Description != "" { - model.Description = cfg.Override.Description - } - return model, nil + return api.NewAPIBuilderFrom(model). + WithPaginationOverrides(cfg.PaginationOverrides). + WithResourceNameHeuristic(cfg.ResourceNameHeuristic). + WithOverride(cfg.Override). + WithCommentOverrides(cfg.CommentOverrides). + Build() } diff --git a/internal/sidekick/parser/parser_test.go b/internal/sidekick/parser/parser_test.go index a152900dee..02c1f66f76 100644 --- a/internal/sidekick/parser/parser_test.go +++ b/internal/sidekick/parser/parser_test.go @@ -52,17 +52,17 @@ func TestCreateModelDisco(t *testing.T) { wantTitle := "Secret Manager API" wantDescription := "Stores sensitive data such as API keys, passwords, and certificates.\nProvides convenience while improving security." wantPackageName := "google.cloud.secretmanager.v1" - if got.Name != wantName { - t.Errorf("want = %q; got = %q", wantName, got.Name) + if got.Name() != wantName { + t.Errorf("want = %q; got = %q", wantName, got.Name()) } - if got.Title != wantTitle { - t.Errorf("want = %q; got = %q", wantTitle, got.Title) + if got.Title() != wantTitle { + t.Errorf("want = %q; got = %q", wantTitle, got.Title()) } - if diff := cmp.Diff(wantDescription, got.Description); diff != "" { + if diff := cmp.Diff(wantDescription, got.Description()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } - if got.PackageName != wantPackageName { - t.Errorf("want = %q; got = %q", wantPackageName, got.PackageName) + if got.PackageName() != wantPackageName { + t.Errorf("want = %q; got = %q", wantPackageName, got.PackageName()) } // This is strange, but we want to verify the package name override from // the service config YAML applies to the message IDs too. @@ -138,9 +138,9 @@ func TestCreateModelOverrides(t *testing.T) { want string } testCases := []TestCase{ - {model.Name, "Name Override"}, - {model.Title, "Title Override"}, - {model.Description, "Description Override"}, + {model.Name(), "Name Override"}, + {model.Title(), "Title Override"}, + {model.Description(), "Description Override"}, } for _, c := range testCases { if c.got != c.want { diff --git a/internal/sidekick/parser/protobuf.go b/internal/sidekick/parser/protobuf.go index cbca2b01e5..ace7729160 100644 --- a/internal/sidekick/parser/protobuf.go +++ b/internal/sidekick/parser/protobuf.go @@ -275,17 +275,17 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code mixinFileDesc []*descriptorpb.FileDescriptorProto enabledMixinMethods mixinMethods = make(map[string]bool) ) - result := &api.API{} + result := api.NewAPIBuilder() if serviceConfig != nil { - result.Title = serviceConfig.Title + result.WithTitle(serviceConfig.Title) if serviceConfig.Documentation != nil { - result.Description = serviceConfig.Documentation.Summary + result.WithDescription(serviceConfig.Documentation.Summary) } withLongrunning := requiresLongrunningMixin(req) enabledMixinMethods, mixinFileDesc = loadMixins(serviceConfig, withLongrunning) names := svcconfig.ExtractPackageName(serviceConfig) if names != nil { - result.PackageName = names.PackageName + result.WithPackageName(names.PackageName) } } @@ -298,6 +298,7 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code fileComments[f] = extractSourceComments(f) } + var resourceDefs []*api.Resource for _, f := range append(req.GetProtoFile(), mixinFileDesc...) { fFQN := "." + f.GetPackage() comments := fileComments[f] @@ -316,29 +317,30 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code if err != nil { return nil, err } - result.ResourceDefinitions = append(result.ResourceDefinitions, resources...) + resourceDefs = append(resourceDefs, resources...) } // Consolidate resources. // Message-level resources (in result.AllResources take precedence over - // file-level resources (already in result.ResourceDefinitions). + // file-level resources (already in resourceDefs). seen := map[string]int{} - for i, r := range result.ResourceDefinitions { + for i, r := range resourceDefs { seen[r.Type()] = i } for r := range result.AllResources() { if i, found := seen[r.Type()]; found { - result.ResourceDefinitions[i] = r + resourceDefs[i] = r } else { - seen[r.Type()] = len(result.ResourceDefinitions) - result.ResourceDefinitions = append(result.ResourceDefinitions, r) + seen[r.Type()] = len(resourceDefs) + resourceDefs = append(resourceDefs, r) } } // Sort to ensure deterministic output. - slices.SortFunc(result.ResourceDefinitions, func(a, b *api.Resource) int { + slices.SortFunc(resourceDefs, func(a, b *api.Resource) int { return strings.Compare(a.Type(), b.Type()) }) + result.WithResourceDefinitions(resourceDefs...) // Collect all mixin methods enabled for services in this API. type mixinMethodSpec struct { @@ -376,26 +378,26 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code fFQN := "." + f.GetPackage() comments := fileComments[f] - if value, err := protobufUpdateFileOption(result.CsharpNamespace, f.GetOptions().GetCsharpNamespace()); err == nil { - result.CsharpNamespace = value + if value, err := protobufUpdateFileOption(result.CsharpNamespace(), f.GetOptions().GetCsharpNamespace()); err == nil { + result.WithCsharpNamespace(value) } else { return nil, err } - if value, err := protobufUpdateFileOption(result.PhpNamespace, f.GetOptions().GetPhpNamespace()); err == nil { - result.PhpNamespace = value + if value, err := protobufUpdateFileOption(result.PhpNamespace(), f.GetOptions().GetPhpNamespace()); err == nil { + result.WithPhpNamespace(value) } else { return nil, err } // TODO(https://github.com/googleapis/librarian/issues/7091) - also use protobufUpdateFileOption() for Ruby - if result.RubyPackage == "" { - result.RubyPackage = f.GetOptions().GetRubyPackage() + if result.RubyPackage() == "" { + result.WithRubyPackage(f.GetOptions().GetRubyPackage()) } // Messages for _, m := range f.MessageType { mFQN := fFQN + "." + m.GetName() if msg := result.Message(mFQN); msg != nil { - result.Messages = append(result.Messages, msg) + result.AppendMessage(msg) } else { slog.Warn("missing message in symbol table", "message", mFQN) } @@ -405,7 +407,7 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code for _, e := range f.EnumType { eFQN := fFQN + "." + e.GetName() if e := result.Enum(eFQN); e != nil { - result.Enums = append(result.Enums, e) + result.AppendEnum(e) } else { slog.Warn("missing enum in symbol table", "message", eFQN) } @@ -444,15 +446,16 @@ func makeAPIForProtobuf(serviceConfig *serviceconfig.Service, req *pluginpb.Code service := processService(result, s, sFQN, f.GetPackage(), lookupComment(comments, sPath), methods) fileServices = append(fileServices, service) } - result.Services = append(result.Services, fileServices...) + result.AppendService(fileServices...) } - if result.Name == "" && serviceConfig != nil { - result.Name = strings.TrimSuffix(serviceConfig.Name, ".googleapis.com") + if result.Name() == "" && serviceConfig != nil { + result.WithName(strings.TrimSuffix(serviceConfig.Name, ".googleapis.com")) } updatePackageName(result) - updateAutoPopulatedFields(serviceConfig, result) - return result, nil + apiModel := result.BuildSyntaxTree() + updateAutoPopulatedFields(serviceConfig, apiModel) + return apiModel, nil } // requiresLongrunningMixin finds out if any method returns a LRO. This is used @@ -512,7 +515,7 @@ func protobufUpdateFileOption(current, got string) (string, error) { return "", fmt.Errorf("mismatched file option value, want=%s got=%s", current, got) } -func normalizeTypes(model *api.API, in *descriptorpb.FieldDescriptorProto, isOneOf bool, fb *api.FieldBuilder) { +func normalizeTypes(model *api.APIBuilder, in *descriptorpb.FieldDescriptorProto, isOneOf bool, fb *api.FieldBuilder) { typezID := in.GetTypeName() repeated := in.Label != nil && *in.Label == descriptorpb.FieldDescriptorProto_LABEL_REPEATED fb.WithTypez(descriptorpbToTypez[in.GetType()]). @@ -565,7 +568,7 @@ func normalizeTypes(model *api.API, in *descriptorpb.FieldDescriptorProto, isOne } } -func processService(model *api.API, s *descriptorpb.ServiceDescriptorProto, sFQN, packagez, doc string, methods []*api.Method) *api.Service { +func processService(model *api.APIBuilder, s *descriptorpb.ServiceDescriptorProto, sFQN, packagez, doc string, methods []*api.Method) *api.Service { service := api.NewServiceBuilder(). WithName(s.GetName()). WithID(sFQN). @@ -579,27 +582,28 @@ func processService(model *api.API, s *descriptorpb.ServiceDescriptorProto, sFQN return service } -func processMethod(model *api.API, m *descriptorpb.MethodDescriptorProto, mFQN, packagez, serviceID, apiVersion, doc string) (*api.Method, error) { - pathInfo, err := parsePathInfo(m, model) +func processMethod(model *api.APIBuilder, m *descriptorpb.MethodDescriptorProto, mFQN, packagez, serviceID, apiVersion, doc string) (*api.Method, error) { + pathInfo, err := parsePathInfo(m, model.BuildSyntaxTree()) if err != nil { return nil, fmt.Errorf("unsupported http method for %q: %w", mFQN, err) } return buildProtobufMethod(model, m, mFQN, packagez, serviceID, apiVersion, doc, pathInfo) } -func processMixinMethod(model *api.API, m *descriptorpb.MethodDescriptorProto, mFQN, originalFQN, packagez, serviceID, apiVersion string, mixin *api.Service, serviceConfig *serviceconfig.Service) (*api.Method, error) { - defaultPathInfo, err := parsePathInfo(m, model) +func processMixinMethod(model *api.APIBuilder, m *descriptorpb.MethodDescriptorProto, mFQN, originalFQN, packagez, serviceID, apiVersion string, mixin *api.Service, serviceConfig *serviceconfig.Service) (*api.Method, error) { + st := model.BuildSyntaxTree() + defaultPathInfo, err := parsePathInfo(m, st) if err != nil { return nil, fmt.Errorf("unsupported http method for %q: %w", mFQN, err) } - pathInfo, doc, err := serviceConfigMethodOverrides(mFQN, originalFQN, m.GetInputType(), defaultPathInfo, serviceConfig, model, mixin) + pathInfo, doc, err := serviceConfigMethodOverrides(mFQN, originalFQN, m.GetInputType(), defaultPathInfo, serviceConfig, st, mixin) if err != nil { return nil, err } return buildProtobufMethod(model, m, mFQN, packagez, serviceID, apiVersion, doc, pathInfo) } -func buildProtobufMethod(model *api.API, m *descriptorpb.MethodDescriptorProto, mFQN, packagez, serviceID, apiVersion, doc string, pathInfo *api.PathInfo) (*api.Method, error) { +func buildProtobufMethod(model *api.APIBuilder, m *descriptorpb.MethodDescriptorProto, mFQN, packagez, serviceID, apiVersion, doc string, pathInfo *api.PathInfo) (*api.Method, error) { routing, err := parseRoutingAnnotations(mFQN, m) if err != nil { return nil, fmt.Errorf("cannot parse routing annotations for %q: %w", mFQN, err) @@ -636,7 +640,7 @@ func isProto2(f *descriptorpb.FileDescriptorProto) bool { return f.GetSyntax() == "" || f.GetSyntax() == "proto2" } -func processMessage(model *api.API, m *descriptorpb.DescriptorProto, mFQN, packagez string, proto2 bool, parent *api.Message, comments map[string]string, pathPrefix []int32) (*api.Message, error) { +func processMessage(model *api.APIBuilder, m *descriptorpb.DescriptorProto, mFQN, packagez string, proto2 bool, parent *api.Message, comments map[string]string, pathPrefix []int32) (*api.Message, error) { mb := api.NewMessageBuilder(). WithName(m.GetName()). WithID(mFQN). @@ -702,7 +706,7 @@ func processMessage(model *api.API, m *descriptorpb.DescriptorProto, mFQN, packa return message, nil } -func processField(model *api.API, mf *descriptorpb.FieldDescriptorProto, mFQN string, proto2 bool, doc string) (*api.Field, error) { +func processField(model *api.APIBuilder, mf *descriptorpb.FieldDescriptorProto, mFQN string, proto2 bool, doc string) (*api.Field, error) { isProtoOptional := mf.Proto3Optional != nil && *mf.Proto3Optional isOneOf := mf.OneofIndex != nil && !isProtoOptional fieldID := mFQN + "." + mf.GetName() @@ -727,7 +731,7 @@ func processField(model *api.API, mf *descriptorpb.FieldDescriptorProto, mFQN st return fb.Build(), nil } -func processMapEntry(model *api.API, nm *descriptorpb.DescriptorProto, nmFQN string) error { +func processMapEntry(model *api.APIBuilder, nm *descriptorpb.DescriptorProto, nmFQN string) error { var keyField, valueField *api.Field for _, mf := range nm.Field { field, err := processField(model, mf, nmFQN, false, "") @@ -749,7 +753,7 @@ func processMapEntry(model *api.API, nm *descriptorpb.DescriptorProto, nmFQN str return nil } -func processResourceAnnotation(opts *descriptorpb.MessageOptions, mb *api.MessageBuilder, model *api.API) error { +func processResourceAnnotation(opts *descriptorpb.MessageOptions, mb *api.MessageBuilder, model *api.APIBuilder) error { if !proto.HasExtension(opts, eResource) { return nil } @@ -840,7 +844,7 @@ func processResourceReference(f *descriptorpb.FieldDescriptorProto, fieldID stri return nil } -func processEnum(model *api.API, e *descriptorpb.EnumDescriptorProto, eFQN, packagez string, parent *api.Message, comments map[string]string, pathPrefix []int32) *api.Enum { +func processEnum(model *api.APIBuilder, e *descriptorpb.EnumDescriptorProto, eFQN, packagez string, parent *api.Message, comments map[string]string, pathPrefix []int32) *api.Enum { var values []*api.EnumValue for i, ev := range e.Value { enumValue := api.NewEnumValueBuilder(). diff --git a/internal/sidekick/parser/protobuf_mixin_test.go b/internal/sidekick/parser/protobuf_mixin_test.go index a446a257dd..a516b87cbf 100644 --- a/internal/sidekick/parser/protobuf_mixin_test.go +++ b/internal/sidekick/parser/protobuf_mixin_test.go @@ -56,7 +56,7 @@ func TestProtobuf_LocationMixin(t *testing.T) { if err != nil { t.Fatal(err) } - for _, service := range test.Services { + for _, service := range test.Services() { if service.ID() == ".google.cloud.location.Locations" { t.Fatalf("Mixin %s should not be in list of services to generate", service.ID()) } @@ -122,7 +122,7 @@ func TestProtobuf_IAMMixin(t *testing.T) { if err != nil { t.Fatal(err) } - for _, service := range test.Services { + for _, service := range test.Services() { if service.ID() == ".google.iam.v1.IAMPolicy" { t.Fatalf("Mixin %s should not be in list of services to generate", service.ID()) } @@ -194,7 +194,7 @@ func TestProtobuf_OperationMixin(t *testing.T) { if err != nil { t.Fatal(err) } - for _, service := range test.Services { + for _, service := range test.Services() { if service.ID() == ".google.longrunning.Operations" { t.Fatalf("Mixin %s should not be in list of services to generate", service.ID()) } @@ -277,7 +277,7 @@ func TestProtobuf_OperationMixinNoEmpty(t *testing.T) { if err != nil { t.Fatal(err) } - for _, service := range test.Services { + for _, service := range test.Services() { if service.ID() == ".google.longrunning.Operations" { t.Fatalf("Mixin %s should not be in list of services to generate", service.ID()) } @@ -356,7 +356,7 @@ func TestProtobuf_DuplicateMixin(t *testing.T) { if err != nil { t.Fatal(err) } - for _, service := range test.Services { + for _, service := range test.Services() { if service.ID() == ".google.longrunning.Operations" { t.Fatalf("Mixin %s should not be in list of services to generate", service.ID()) } diff --git a/internal/sidekick/parser/protobuf_test.go b/internal/sidekick/parser/protobuf_test.go index 56b7525ce1..e8847d2025 100644 --- a/internal/sidekick/parser/protobuf_test.go +++ b/internal/sidekick/parser/protobuf_test.go @@ -43,13 +43,13 @@ func TestProtobuf_Info(t *testing.T) { if err != nil { t.Fatalf("Failed to make API for Protobuf %v", err) } - if got.Name != "secretmanager" { - t.Errorf("want = %q; got = %q", "secretmanager", got.Name) + if got.Name() != "secretmanager" { + t.Errorf("want = %q; got = %q", "secretmanager", got.Name()) } - if got.Title != sc.Title { - t.Errorf("want = %q; got = %q", sc.Title, got.Title) + if got.Title() != sc.Title { + t.Errorf("want = %q; got = %q", sc.Title, got.Title()) } - if diff := cmp.Diff(sc.Documentation.Summary, got.Description); diff != "" { + if diff := cmp.Diff(sc.Documentation.Summary, got.Description()); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -70,7 +70,7 @@ func TestProtobuf_PartialInfo(t *testing.T) { WithPackageName("test"). WithTitle("Secret Manager API"). WithDescription("") - if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(api.API{}, "Services", "Messages", "Enums"), cmpopts.IgnoreUnexported(api.API{})); diff != "" { + if diff := cmp.Diff(want, got, apitest.AllowUnexported(), apitest.IgnoreAPIFields("services", "messages", "enums", "serviceByID", "methodByID", "messageByID", "enumByID", "resourceByType", "mapByID")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -317,7 +317,7 @@ func TestProtobuf_SkipExternalMessages(t *testing.T) { ) apitest.CheckMessage(t, message, want) // Only `LocalMessage` should be found in the messages list: - for _, msg := range test.Messages { + for _, msg := range test.Messages() { if msg.ID() == ".test.ImportedMessage" { t.Errorf("imported messages should not be in message list %v", msg) } @@ -351,7 +351,7 @@ func TestProtobuf_SkipExternaEnums(t *testing.T) { } apitest.CheckEnum(t, *enum, *wantEnum) // Only `LocalMessage` should be found in the messages list: - for _, msg := range test.Messages { + for _, msg := range test.Messages() { if msg.ID() == ".test.ImportedMessage" { t.Errorf("imported messages should not be in message list %v", msg) } @@ -1146,7 +1146,7 @@ func TestProtobuf_AutoPopulated(t *testing.T) { if err != nil { t.Fatalf("Failed to make API for Protobuf %v", err) } - for _, service := range test.Services { + for _, service := range test.Services() { if service.ID() == ".google.longrunning.Operations" { t.Fatalf("Mixin %s should not be in list of services to generate", service.ID()) } @@ -1320,8 +1320,8 @@ func TestProtobuf_ResourceAnnotations(t *testing.T) { t.Run("API.ResourceDefinitions", func(t *testing.T) { // We expect 2 ResourceDefinitions: Shelf (file-level) and Book (message-level). - if len(test.ResourceDefinitions) != 2 { - t.Fatalf("Expected 2 ResourceDefinitions, got %d", len(test.ResourceDefinitions)) + if len(test.ResourceDefinitions()) != 2 { + t.Fatalf("Expected 2 ResourceDefinitions, got %d", len(test.ResourceDefinitions())) } // Verify Shelf @@ -1336,7 +1336,7 @@ func TestProtobuf_ResourceAnnotations(t *testing.T) { ) // Find Shelf in the slice var foundShelf *api.Resource - for _, r := range test.ResourceDefinitions { + for _, r := range test.ResourceDefinitions() { if r.Type() == "library.googleapis.com/Shelf" { foundShelf = r break @@ -1370,7 +1370,7 @@ func TestProtobuf_ResourceAnnotations(t *testing.T) { WithSingular("book") // Find Book in the slice var foundBook *api.Resource - for _, r := range test.ResourceDefinitions { + for _, r := range test.ResourceDefinitions() { if r.Type() == "library.googleapis.com/Book" { foundBook = r break @@ -1518,10 +1518,10 @@ func TestProtobuf_ResourceCoverage(t *testing.T) { // Verify only 1 resource exists and it is the message-level one ("book_message"). // This confirms that message-level resources overwrite file-level resources with the same type. - if len(test.ResourceDefinitions) != 1 { - t.Fatalf("Expected 1 ResourceDefinition, got %d", len(test.ResourceDefinitions)) + if len(test.ResourceDefinitions()) != 1 { + t.Fatalf("Expected 1 ResourceDefinition, got %d", len(test.ResourceDefinitions())) } - got := test.ResourceDefinitions[0] + got := test.ResourceDefinitions()[0] if got.Singular() != "book_message" { t.Errorf("Expected singular 'book_message', got %q", got.Singular()) } diff --git a/internal/sidekick/rust/annotate_enum.go b/internal/sidekick/rust/annotate_enum.go index 8f5f2761f2..c472487e3b 100644 --- a/internal/sidekick/rust/annotate_enum.go +++ b/internal/sidekick/rust/annotate_enum.go @@ -66,7 +66,7 @@ func (c *codec) annotateEnum(e *api.Enum, model *api.API, full bool) error { } } - qualifiedName, err := c.fullyQualifiedEnumName(e, model.PackageName) + qualifiedName, err := c.fullyQualifiedEnumName(e, model.PackageName()) if err != nil { return err } @@ -101,7 +101,7 @@ func (c *codec) annotateEnum(e *api.Enum, model *api.API, full bool) error { ModuleName: toSnake(enumName(e)), QualifiedName: qualifiedName, RelativeName: relativeName, - ProstRelativeName: c.prostTypeName(e.Package(), prostEnumRelativePath(e), model.PackageName), + ProstRelativeName: c.prostTypeName(e.Package(), prostEnumRelativePath(e), model.PackageName()), NameInExamples: nameInExamples, IsWktNullValue: nameInExamples == "wkt::NullValue", SerializeAsString: c.serializeEnumsAsStrings, diff --git a/internal/sidekick/rust/annotate_field.go b/internal/sidekick/rust/annotate_field.go index 37775b0253..6f9920c1e3 100644 --- a/internal/sidekick/rust/annotate_field.go +++ b/internal/sidekick/rust/annotate_field.go @@ -185,7 +185,7 @@ func (c *codec) messageFieldSerdeAs(field *api.Field) string { } func (c *codec) annotateField(field *api.Field, message *api.Message, model *api.API) (*fieldAnnotations, error) { - fqMessageName, err := c.fullyQualifiedMessageName(message, model.PackageName) + fqMessageName, err := c.fullyQualifiedMessageName(message, model.PackageName()) if err != nil { return nil, err } @@ -193,11 +193,11 @@ func (c *codec) annotateField(field *api.Field, message *api.Message, model *api if err != nil { return nil, err } - fieldType, err := c.fieldType(field, model, false, model.PackageName) + fieldType, err := c.fieldType(field, model, false, model.PackageName()) if err != nil { return nil, err } - primitiveFieldType, err := c.fieldType(field, model, true, model.PackageName) + primitiveFieldType, err := c.fieldType(field, model, true, model.PackageName()) if err != nil { return nil, err } @@ -254,7 +254,7 @@ func (c *codec) annotateField(field *api.Field, message *api.Message, model *api } if targetType != nil { - fieldFqName, err := c.fullyQualifiedMessageName(targetType, model.PackageName) + fieldFqName, err := c.fullyQualifiedMessageName(targetType, model.PackageName()) if err != nil { return nil, err } diff --git a/internal/sidekick/rust/annotate_field_test.go b/internal/sidekick/rust/annotate_field_test.go index 13224a8a1f..4743bb72f2 100644 --- a/internal/sidekick/rust/annotate_field_test.go +++ b/internal/sidekick/rust/annotate_field_test.go @@ -353,7 +353,7 @@ func TestSameTypeNameFieldAnnotations(t *testing.T) { WithFields(repeatedField, messageField) model := api.NewTestAPI([]*api.Message{message}, nil, nil).WithMaps(mapType) - model.AddMessage(innerMessage) + model = api.NewAPIBuilderFrom(model).AddMessage(innerMessage).BuildSyntaxTree() api.CrossReference(model) api.LabelRecursiveFields(model) codec := newTestCodec(t, libconfig.SpecProtobuf, "test", map[string]string{}) diff --git a/internal/sidekick/rust/annotate_message.go b/internal/sidekick/rust/annotate_message.go index a5c8735639..1f27e9b575 100644 --- a/internal/sidekick/rust/annotate_message.go +++ b/internal/sidekick/rust/annotate_message.go @@ -68,7 +68,7 @@ func (a *messageAnnotation) SingleFeatureGate() bool { // are also annotated. // Basic annotations are useful for annotating external messages with information used in samples. func (c *codec) annotateMessage(m *api.Message, model *api.API, full bool) error { - qualifiedName, err := c.fullyQualifiedMessageName(m, model.PackageName) + qualifiedName, err := c.fullyQualifiedMessageName(m, model.PackageName()) if err != nil { return err } @@ -79,7 +79,7 @@ func (c *codec) annotateMessage(m *api.Message, model *api.API, full bool) error ModuleName: c.MessageModuleName(m), QualifiedName: qualifiedName, RelativeName: relativeName, - ProstRelativeName: c.prostTypeName(m.Package(), prostMessageRelativePath(m), model.PackageName), + ProstRelativeName: c.prostTypeName(m.Package(), prostMessageRelativePath(m), model.PackageName()), NameInExamples: nameInExamples, PackageModuleName: packageToModuleName(m.Package()), SourceFQN: strings.TrimPrefix(m.ID(), "."), diff --git a/internal/sidekick/rust/annotate_method.go b/internal/sidekick/rust/annotate_method.go index 77c7f44ff3..9a3faf5d55 100644 --- a/internal/sidekick/rust/annotate_method.go +++ b/internal/sidekick/rust/annotate_method.go @@ -327,7 +327,7 @@ func (c *codec) annotateMethod(m *api.Method) (*methodAnnotation, error) { variant.SetAnnotations(routingVariantAnnotations) } } - returnType, err := c.methodInOutTypeName(m.OutputTypeID(), m.Model(), m.Model().PackageName) + returnType, err := c.methodInOutTypeName(m.OutputTypeID(), m.Model(), m.Model().PackageName()) if err != nil { return nil, err } @@ -387,11 +387,11 @@ func (c *codec) annotateMethod(m *api.Method) (*methodAnnotation, error) { annotation.Attributes = []string{"#[allow(clippy::should_implement_trait)]"} } if m.OperationInfo() != nil { - metadataType, err := c.methodInOutTypeName(m.OperationInfo().MetadataTypeID(), m.Model(), m.Model().PackageName) + metadataType, err := c.methodInOutTypeName(m.OperationInfo().MetadataTypeID(), m.Model(), m.Model().PackageName()) if err != nil { return nil, err } - responseType, err := c.methodInOutTypeName(m.OperationInfo().ResponseTypeID(), m.Model(), m.Model().PackageName) + responseType, err := c.methodInOutTypeName(m.OperationInfo().ResponseTypeID(), m.Model(), m.Model().PackageName()) if err != nil { return nil, err } diff --git a/internal/sidekick/rust/annotate_model.go b/internal/sidekick/rust/annotate_model.go index 857f69b8a7..eb12ad5aa0 100644 --- a/internal/sidekick/rust/annotate_model.go +++ b/internal/sidekick/rust/annotate_model.go @@ -170,7 +170,7 @@ func (m *modelAnnotations) GrpcServices() []*api.Service { // GrpcRootTypeIDs returns the root message type IDs for all generated gRPC methods in the model. func GrpcRootTypeIDs(model *api.API) []string { var rootTypeIDs []string - for _, s := range model.Services { + for _, s := range model.Services() { for _, m := range s.Methods() { if ann, ok := m.Codec().(*methodAnnotation); ok && ann.IsGrpc { if m.InputTypeID() != "" { @@ -191,29 +191,32 @@ func GrpcRootTypeIDs(model *api.API) []string { // actions. For example, the template action {{ range .Services }} uses the // [modelAnnotations.Services] field. func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { - codec.hasServices = len(model.Services) > 0 + services := model.Services() + externalEnums := model.ExternalEnums() + externalMessages := model.ExternalMessages() + codec.hasServices = len(services) > 0 resolveUsedPackages(model, codec.extraPackages, codec.hasGrpc(model)) // Annotate enums and messages that we intend to generate. In the // process we discover the external dependencies and trim the list of // packages used by this API. // This API's enums and messages get full annotations. - for _, e := range model.Enums { + for _, e := range model.Enums() { if err := codec.annotateEnum(e, model, true); err != nil { return nil, err } } - for _, e := range model.ExternalEnums { + for _, e := range externalEnums { if err := codec.annotateEnum(e, model, true); err != nil { return nil, err } } - for _, m := range model.Messages { + for _, m := range model.Messages() { if err := codec.annotateMessage(m, model, true); err != nil { return nil, err } } - for _, m := range model.ExternalMessages { + for _, m := range externalMessages { if err := codec.annotateMessage(m, model, true); err != nil { return nil, err } @@ -238,7 +241,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { } hasLROs := false hasDiscoveryLROs := false - for _, s := range model.Services { + for _, s := range services { for _, m := range s.Methods() { if !codec.generateMethod(m) { continue @@ -271,7 +274,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { } } - servicesSubset := language.FilterSlice(model.Services, func(s *api.Service) bool { + servicesSubset := language.FilterSlice(services, func(s *api.Service) bool { return slices.ContainsFunc(s.Methods(), func(m *api.Method) bool { return codec.generateMethod(m) }) }) // The maximum (15) was chosen more or less arbitrarily circa 2025-06. At @@ -284,8 +287,8 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { // used. findUsedPackages(model, codec) defaultHost := func() string { - if len(model.Services) > 0 { - return model.Services[0].DefaultHost() + if len(services) > 0 { + return services[0].DefaultHost() } return "" }() @@ -307,9 +310,9 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { } else { return nil, fmt.Errorf("%w: %q not found in generated services for package %q", errQuickstartServiceNotFound, codec.quickstartServiceOverride, codec.packageName(model)) } - } else if model.QuickstartService != nil { - if slices.ContainsFunc(servicesSubset, func(s *api.Service) bool { return s == model.QuickstartService }) { - quickstartService = model.QuickstartService + } else if model.QuickstartService() != nil { + if slices.ContainsFunc(servicesSubset, func(s *api.Service) bool { return s == model.QuickstartService() }) { + quickstartService = model.QuickstartService() } } @@ -330,7 +333,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { } includeRpcStatusConversion := codec.includeRpcStatusConversion - if codecMap, ok := model.Codec.(map[string]string); ok && codecMap["include-rpc-status-conversion"] == "true" { + if codecMap, ok := model.Codec().(map[string]string); ok && codecMap["include-rpc-status-conversion"] == "true" { includeRpcStatusConversion = true } @@ -348,7 +351,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { ann := &modelAnnotations{ PackageName: codec.packageName(model), - PackageModuleName: packageToModuleName(model.PackageName), + PackageModuleName: packageToModuleName(model.PackageName()), PackageNamespace: codec.rootModuleName(model), PackageVersion: codec.version, ReleaseLevel: codec.releaseLevel, @@ -364,7 +367,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { DefaultHost: defaultHost, DefaultHostShort: defaultHostShort, Services: servicesSubset, - NameToLower: strings.ToLower(model.Name), + NameToLower: strings.ToLower(model.Name()), NotForPublication: codec.doNotPublish, DisabledRustdocWarnings: codec.disabledRustdocWarnings, DisabledClippyWarnings: codec.disabledClippyWarnings, @@ -372,7 +375,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { ExtraFeatures: extraFeatures, ExtraModules: extraModules, InternalModules: codec.internalModules, - Incomplete: slices.ContainsFunc(model.Services, func(s *api.Service) bool { + Incomplete: slices.ContainsFunc(services, func(s *api.Service) bool { return slices.ContainsFunc(s.Methods(), func(m *api.Method) bool { return !codec.generateMethod(m) }) }), GenerateSetterSamples: codec.generateSetterSamples, @@ -384,7 +387,7 @@ func annotateModel(model *api.API, codec *codec) (*modelAnnotations, error) { codec.addFeatureAnnotations(model, ann) - model.Codec = ann + model.SetAnnotations(ann) return ann, nil } diff --git a/internal/sidekick/rust/annotate_model_test.go b/internal/sidekick/rust/annotate_model_test.go index 03ee7d2755..1e6cb15f80 100644 --- a/internal/sidekick/rust/annotate_model_test.go +++ b/internal/sidekick/rust/annotate_model_test.go @@ -232,7 +232,7 @@ func TestInternalBuildersAnnotation(t *testing.T) { if got.InternalBuilders != test.Want { t.Errorf("mismatch in InternalBuilders, want=%v, got=%v", test.Want, got.InternalBuilders) } - svcAnn := model.Services[0].Codec().(*serviceAnnotations) + svcAnn := model.Services()[0].Codec().(*serviceAnnotations) if svcAnn.InternalBuilders != test.Want { t.Errorf("mismatch in service InternalBuilders, want=%v, got=%v", test.Want, svcAnn.InternalBuilders) } @@ -290,7 +290,7 @@ func TestHandwrittenSurfaceAnnotation(t *testing.T) { if err != nil { t.Fatal(err) } - svc0Ann := model.Services[0].Codec().(*serviceAnnotations) + svc0Ann := model.Services()[0].Codec().(*serviceAnnotations) if svc0Ann.HasVeneer != test.wantService0Veneer { t.Errorf("mismatch in Service0 HasVeneer, want=%v, got=%v", test.wantService0Veneer, svc0Ann.HasVeneer) } @@ -301,7 +301,7 @@ func TestHandwrittenSurfaceAnnotation(t *testing.T) { t.Errorf("mismatch in Service0 GenerateRpcSamples, want=%v, got=%v", test.wantService0Samples, svc0Ann.GenerateRpcSamples) } - svc1Ann := model.Services[1].Codec().(*serviceAnnotations) + svc1Ann := model.Services()[1].Codec().(*serviceAnnotations) if svc1Ann.HasVeneer != test.wantService1Veneer { t.Errorf("mismatch in Service1 HasVeneer, want=%v, got=%v", test.wantService1Veneer, svc1Ann.HasVeneer) } @@ -340,7 +340,7 @@ func TestGrpcClientAnnotation(t *testing.T) { if got.GrpcClient != test.Want { t.Errorf("mismatch in GrpcClient, want=%v, got=%v", test.Want, got.GrpcClient) } - svcAnn := model.Services[0].Codec().(*serviceAnnotations) + svcAnn := model.Services()[0].Codec().(*serviceAnnotations) if svcAnn.GrpcClient != test.Want { t.Errorf("mismatch in service GrpcClient, want=%v, got=%v", test.Want, svcAnn.GrpcClient) } @@ -350,8 +350,8 @@ func TestGrpcClientAnnotation(t *testing.T) { func TestQuickstartServiceAnnotation(t *testing.T) { t.Run("survives filtering", func(t *testing.T) { model := newTestAnnotateModelAPI(t) - // model.Services[0] is Service0, model.Services[1] is Service1 - model.WithQuickstartService(model.Services[1]) + // model.Services()[0] is Service0, model.Services()[1] is Service1 + model.WithQuickstartService(model.Services()[1]) codec := newTestCodec(t, libconfig.SpecProtobuf, "", nil) got, err := annotateModel(model, codec) @@ -362,7 +362,7 @@ func TestQuickstartServiceAnnotation(t *testing.T) { if got.QuickstartService == nil { t.Fatal("QuickstartService should not be nil") } - if got.QuickstartService != model.Services[1] { + if got.QuickstartService != model.Services()[1] { t.Errorf("expected QuickstartService to be Service1, got %v", got.QuickstartService.Name()) } }) @@ -379,7 +379,7 @@ func TestQuickstartServiceAnnotation(t *testing.T) { filteredService := api.NewTestService("FilteredService"). WithPackage(""). WithMethods(noBindingsMethod) - model.AddService(filteredService) + model = api.NewAPIBuilderFrom(model).AddService(filteredService).BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -400,7 +400,7 @@ func TestQuickstartServiceAnnotation(t *testing.T) { t.Run("with override", func(t *testing.T) { model := newTestAnnotateModelAPI(t) - model.WithQuickstartService(model.Services[0]) // Set default to 0 + model.WithQuickstartService(model.Services()[0]) // Set default to 0 codec := newTestCodec(t, libconfig.SpecProtobuf, "", nil) // Set override to Service1 @@ -414,7 +414,7 @@ func TestQuickstartServiceAnnotation(t *testing.T) { if got.QuickstartService == nil { t.Fatal("QuickstartService should not be nil") } - if got.QuickstartService != model.Services[1] { + if got.QuickstartService != model.Services()[1] { t.Errorf("expected QuickstartService to be overridden to Service1, got %v", got.QuickstartService.Name()) } }) @@ -551,7 +551,7 @@ func TestGenerateRpcSamples(t *testing.T) { "generate-rpc-samples": "true", }) annotateModel(model, codec) - if !model.Codec.(*modelAnnotations).GenerateRpcSamples { + if !model.Codec().(*modelAnnotations).GenerateRpcSamples { t.Errorf("GenerateRpcSamples should be true") } } @@ -562,7 +562,7 @@ func TestGenerateSetterSamples(t *testing.T) { "generate-setter-samples": "true", }) annotateModel(model, codec) - if !model.Codec.(*modelAnnotations).GenerateSetterSamples { + if !model.Codec().(*modelAnnotations).GenerateSetterSamples { t.Errorf("GenerateSetterSamples should be true") } } @@ -826,9 +826,9 @@ func TestExternalTypesAnnotations(t *testing.T) { WithOneOfs(oneof) extEnum := api.NewTestEnum("DayOfWeek").WithPackage("google.type") - model := api.NewTestAPI(nil, nil, nil) - model.ExternalMessages = []*api.Message{extMsg} - model.ExternalEnums = []*api.Enum{extEnum} + model := api.NewTestAPI(nil, nil, nil). + WithExternalMessages(extMsg). + WithExternalEnums(extEnum) if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -882,9 +882,9 @@ func TestExternalTypesAnnotations(t *testing.T) { t.Run("with prost-path option", func(t *testing.T) { extMsg2 := api.NewTestMessage("LatLng").WithPackage("google.type") extEnum2 := api.NewTestEnum("DayOfWeek").WithPackage("google.type") - model2 := api.NewTestAPI(nil, nil, nil) - model2.ExternalMessages = []*api.Message{extMsg2} - model2.ExternalEnums = []*api.Enum{extEnum2} + model2 := api.NewTestAPI(nil, nil, nil). + WithExternalMessages(extMsg2). + WithExternalEnums(extEnum2) codec2 := newTestCodec(t, libconfig.SpecProtobuf, "", map[string]string{ "template-override": "templates/convert-prost", diff --git a/internal/sidekick/rust/annotate_oneof.go b/internal/sidekick/rust/annotate_oneof.go index e0f8214741..c9e7eb6ccd 100644 --- a/internal/sidekick/rust/annotate_oneof.go +++ b/internal/sidekick/rust/annotate_oneof.go @@ -69,14 +69,14 @@ func (a *oneOfAnnotation) SingleFeatureGate() bool { } func (c *codec) annotateOneOf(oneof *api.OneOf, message *api.Message, model *api.API) (*oneOfAnnotation, error) { - scope, err := c.messageScopeName(message, "", model.PackageName) + scope, err := c.messageScopeName(message, "", model.PackageName()) if err != nil { return nil, err } enumName := c.OneOfEnumName(oneof) qualifiedName := fmt.Sprintf("%s::%s", scope, enumName) relativeEnumName := strings.TrimPrefix(qualifiedName, c.modulePath+"::") - structQualifiedName, err := c.fullyQualifiedMessageName(message, model.PackageName) + structQualifiedName, err := c.fullyQualifiedMessageName(message, model.PackageName()) if err != nil { return nil, err } @@ -92,7 +92,7 @@ func (c *codec) annotateOneOf(oneof *api.OneOf, message *api.Message, model *api EnumName: enumName, QualifiedName: qualifiedName, RelativeName: relativeEnumName, - ProstRelativeName: c.prostTypeName(message.Package(), prostMessageModulePath(message)+"::"+toProstPascal(enumName), model.PackageName), + ProstRelativeName: c.prostTypeName(message.Package(), prostMessageModulePath(message)+"::"+toProstPascal(enumName), model.PackageName()), StructQualifiedName: structQualifiedName, NameInExamples: nameInExamples, FieldType: fmt.Sprintf("%s::%s", scope, enumName), diff --git a/internal/sidekick/rust/annotate_service.go b/internal/sidekick/rust/annotate_service.go index c3a589678c..289c2132a1 100644 --- a/internal/sidekick/rust/annotate_service.go +++ b/internal/sidekick/rust/annotate_service.go @@ -220,7 +220,7 @@ func (c *codec) annotateService(s *api.Service) (*serviceAnnotations, error) { Methods: methods, DefaultHost: s.DefaultHost(), LROTypes: lroTypes, - APITitle: s.Model().Title, + APITitle: s.Model().Title(), PerServiceFeatures: c.perServiceFeatures, HasVeneer: c.serviceHasVeneer(s.ID()), Incomplete: slices.ContainsFunc(allMethods, func(m *api.Method) bool { return !c.generateMethod(m) }), diff --git a/internal/sidekick/rust/bigquery.go b/internal/sidekick/rust/bigquery.go index bcf0c08473..a945a34bc0 100644 --- a/internal/sidekick/rust/bigquery.go +++ b/internal/sidekick/rust/bigquery.go @@ -49,7 +49,7 @@ func newUnifiedMessage(c *codec, model *api.API, msgNames []string, skipFieldFn // Index fields by their name and collect names for _, msgName := range msgNames { - m := model.Message(fmt.Sprintf(".%s.%s", model.PackageName, msgName)) + m := model.Message(fmt.Sprintf(".%s.%s", model.PackageName(), msgName)) if m == nil { return nil, fmt.Errorf("failed to locate message %q", msgName) } @@ -94,9 +94,9 @@ func (m *unifiedMessage) createSyntheticMessage(name string) (*api.Message, erro fields = append(fields, clone) } msg := api.NewMessageBuilder(). - WithID(fmt.Sprintf(".%s.%s", m.model.PackageName, name)). + WithID(fmt.Sprintf(".%s.%s", m.model.PackageName(), name)). WithName(name). - WithPackage(m.model.PackageName). + WithPackage(m.model.PackageName()). WithSyntheticRequest(true). WithFields(fields...). Build() diff --git a/internal/sidekick/rust/codec.go b/internal/sidekick/rust/codec.go index b2fb3b9c97..4367e0e16b 100644 --- a/internal/sidekick/rust/codec.go +++ b/internal/sidekick/rust/codec.go @@ -387,10 +387,11 @@ type packagez struct { } func resolveUsedPackages(model *api.API, extraPackages []*packagez, hasGrpc bool) { - hasServices := len(model.Services) > 0 + services := model.Services() + hasServices := len(services) > 0 hasLROs := false hasAutoPopulation := false - for _, s := range model.Services { + for _, s := range services { // In practice, barely any services have auto-population. We are // almost always performing the full loop. `break`ing early does // not save us any computations. @@ -526,11 +527,11 @@ func (c *codec) mapType(f *api.Field, model *api.API) (string, error) { if mapType == nil || mapType.Key() == nil || mapType.Value() == nil { return "", fmt.Errorf("missing map type for field %s (%s)", f.ID(), f.TypezID()) } - key, err := c.fieldType(mapType.Key(), model, true, model.PackageName) + key, err := c.fieldType(mapType.Key(), model, true, model.PackageName()) if err != nil { return "", err } - val, err := c.fieldType(mapType.Value(), model, true, model.PackageName) + val, err := c.fieldType(mapType.Value(), model, true, model.PackageName()) if err != nil { return "", err } @@ -1491,7 +1492,7 @@ func (c *codec) serviceRustdocLink(s *api.Service, model *api.API) string { if ok { return fmt.Sprintf("%s::client::%s", mapped.name, toPascal(name)) } - if !slices.Contains(model.Services, s) { + if !slices.Contains(model.Services(), s) { return "" } return fmt.Sprintf("crate::client::%s", toPascal(name)) @@ -1499,7 +1500,7 @@ func (c *codec) serviceRustdocLink(s *api.Service, model *api.API) string { func usePackage(source string, model *api.API, c *codec) { mapped, ok := c.packageMapping[source] - if ok && source != model.PackageName { + if ok && source != model.PackageName() { mapped.used = true } } @@ -1549,13 +1550,13 @@ func findUsedPackagesField(f *api.Field, model *api.API, c *codec) { } func findUsedPackages(model *api.API, c *codec) { - for _, message := range model.Messages { + for _, message := range model.Messages() { findUsedPackagesMessage(message, model, c, map[string]bool{}) } - for _, enum := range model.Enums { + for _, enum := range model.Enums() { usePackage(enum.Package(), model, c) } - for _, s := range model.Services { + for _, s := range model.Services() { for _, method := range s.Methods() { if m := model.Message(method.InputTypeID()); m != nil { findUsedPackagesMessage(m, model, c, map[string]bool{}) @@ -1615,11 +1616,11 @@ func PackageName(api *api.API, packageNameOverride string) string { if len(packageNameOverride) > 0 { return packageNameOverride } - name := strings.TrimPrefix(api.PackageName, "google.cloud.") + name := strings.TrimPrefix(api.PackageName(), "google.cloud.") name = strings.TrimPrefix(name, "google.") name = strings.ReplaceAll(name, ".", "-") if name == "" { - name = api.Name + name = api.Name() } return "google-cloud-" + name } @@ -1709,11 +1710,11 @@ func (c *codec) templateSupportsGrpc() bool { } func (c *codec) hasBidiStreaming(model *api.API) bool { - return c.templateSupportsGrpc() && slices.ContainsFunc(model.Services, (*api.Service).HasBidiStreaming) + return c.templateSupportsGrpc() && slices.ContainsFunc(model.Services(), (*api.Service).HasBidiStreaming) } func (c *codec) hasServerStreaming(model *api.API) bool { - return c.templateSupportsGrpc() && slices.ContainsFunc(model.Services, (*api.Service).HasServerSideStreaming) + return c.templateSupportsGrpc() && slices.ContainsFunc(model.Services(), (*api.Service).HasServerSideStreaming) } func (c *codec) hasStreaming(model *api.API) bool { @@ -1725,7 +1726,7 @@ func (c *codec) hasGrpc(model *api.API) bool { return false } if c.defaultTransport == "grpc" { - return len(model.Services) > 0 + return len(model.Services()) > 0 } return c.hasStreaming(model) } diff --git a/internal/sidekick/rust/codec_test.go b/internal/sidekick/rust/codec_test.go index f7f1cc4462..b4bd59dc68 100644 --- a/internal/sidekick/rust/codec_test.go +++ b/internal/sidekick/rust/codec_test.go @@ -561,7 +561,7 @@ func TestWellKnownTypesAsMethod(t *testing.T) { c := createRustCodec() want := "wkt::Empty" - got, err := c.methodInOutTypeName(".google.protobuf.Empty", model, model.PackageName) + got, err := c.methodInOutTypeName(".google.protobuf.Empty", model, model.PackageName()) if err != nil { t.Fatal(err) } @@ -634,7 +634,7 @@ func TestMethodInOut(t *testing.T) { c := createRustCodec() want := "crate::model::Target" - got, err := c.methodInOutTypeName("..Target", model, model.PackageName) + got, err := c.methodInOutTypeName("..Target", model, model.PackageName()) if err != nil { t.Fatal(err) } @@ -643,7 +643,7 @@ func TestMethodInOut(t *testing.T) { } want = "crate::model::target::Nested" - got, err = c.methodInOutTypeName("..Target.Nested", model, model.PackageName) + got, err = c.methodInOutTypeName("..Target.Nested", model, model.PackageName()) if err != nil { t.Fatal(err) } @@ -725,7 +725,7 @@ func TestFieldType(t *testing.T) { if !ok { t.Fatalf("missing expected value for %s", field.Name()) } - got, err := c.fieldType(field, model, false, model.PackageName) + got, err := c.fieldType(field, model, false, model.PackageName()) if err != nil { t.Fatal(err) } @@ -737,7 +737,7 @@ func TestFieldType(t *testing.T) { if !ok { t.Fatalf("missing expected value for %s", field.Name()) } - got, err = c.fieldType(field, model, true, model.PackageName) + got, err = c.fieldType(field, model, true, model.PackageName()) if err != nil { t.Fatal(err) } @@ -775,7 +775,7 @@ func TestOneOfFieldType(t *testing.T) { if !ok { t.Fatalf("missing expected value for %s", field.Name()) } - got, err := c.oneOfFieldType(field, model, model.PackageName) + got, err := c.oneOfFieldType(field, model, model.PackageName()) if err != nil { t.Fatal(err) } @@ -828,7 +828,7 @@ func TestFieldMapTypeValues(t *testing.T) { model := api.NewTestAPI([]*api.Message{message, otherMessage}, nil, nil).WithMaps(mapThing) api.LabelRecursiveFields(model) c := createRustCodec() - got, err := c.fieldType(field, model, false, model.PackageName) + got, err := c.fieldType(field, model, false, model.PackageName()) if err != nil { t.Fatal(err) } @@ -871,7 +871,7 @@ func TestFieldMapTypeKey(t *testing.T) { model := api.NewTestAPI([]*api.Message{message}, []*api.Enum{enum}, nil).WithMaps(mapThing) api.LabelRecursiveFields(model) c := createRustCodec() - got, err := c.fieldType(field, model, false, model.PackageName) + got, err := c.fieldType(field, model, false, model.PackageName()) if err != nil { t.Fatal(err) } @@ -1646,9 +1646,11 @@ func TestFormatDocCommentsSkippedMethodsAndServices(t *testing.T) { // Model has someService in model.Services, but skippedService is omitted from model.Services model := api.NewTestAPI(nil, nil, []*api.Service{someService}) - model.AddMethod(skippedMethod) - model.AddMethod(skippedServiceMethod) - model.AddService(skippedService) + model = api.NewAPIBuilderFrom(model). + AddMethod(skippedMethod). + AddMethod(skippedServiceMethod). + AddService(skippedService). + BuildSyntaxTree() c := &codec{ modulePath: "crate::model", @@ -1883,8 +1885,10 @@ func makeApiForRustFormatDocCommentsCrossLinks() *api.API { []*api.Message{someMessage}, nil, []*api.Service{someService, renamedService, yellyService}) - a.AddMessage(api.NewTestMessage("SetIamPolicyRequest").WithPackage("google.iam.v1")) - a.AddService(api.NewTestService("IAMPolicy").WithPackage("google.iam.v1")) + a = api.NewAPIBuilderFrom(a). + AddMessage(api.NewTestMessage("SetIamPolicyRequest").WithPackage("google.iam.v1")). + AddService(api.NewTestService("IAMPolicy").WithPackage("google.iam.v1")). + BuildSyntaxTree() return a } @@ -2020,7 +2024,7 @@ func TestMessageNames(t *testing.T) { }, } { t.Run(test.want, func(t *testing.T) { - got, err := c.fullyQualifiedMessageName(test.m, model.PackageName) + got, err := c.fullyQualifiedMessageName(test.m, model.PackageName()) if err != nil { t.Fatal(err) } @@ -2054,7 +2058,7 @@ func TestEnumNames(t *testing.T) { if got := enumName(test.enum); got != test.wantEnum { t.Errorf("enumName(%q) = %q; want = %s", test.enum.Name(), got, test.wantEnum) } - got, err := c.fullyQualifiedEnumName(test.enum, model.PackageName) + got, err := c.fullyQualifiedEnumName(test.enum, model.PackageName()) if err != nil { t.Fatal(err) } diff --git a/internal/sidekick/rust/generate.go b/internal/sidekick/rust/generate.go index a6ef6d3a6b..77d0877918 100644 --- a/internal/sidekick/rust/generate.go +++ b/internal/sidekick/rust/generate.go @@ -61,12 +61,10 @@ func GenerateStorage(ctx context.Context, outdir string, storageModel *api.API, return err } - model := &api.API{ - Codec: &storageAnnotations{ - Storage: storageModel, - Control: controlModel, - }, - } + model := api.NewAnnotatedAPI(&storageAnnotations{ + Storage: storageModel, + Control: controlModel, + }) generatedFiles := language.WalkTemplatesDir(templates, "templates/storage") return parsedTemplates.GenerateFromModel(outdir, model, generatedFiles) } @@ -124,18 +122,16 @@ func GenerateBigQueryBuilder(ctx context.Context, outdir string, model *api.API, return err } - model = &api.API{ - Codec: &bigQueryAnnotations{ - Model: model, - QueryBuilderFields: queryBuilder.fieldGroupList(), - QueryBuilderMsg: queryBuilderMsg, - QueryBuilderRequestMsg: queryBuilderRequestMsg, - QueryMetadataFields: queryMetadata.fieldGroupList(), - QueryMetadataMsg: queryMetadataMsg, - CompleteQueryMetadataFields: completeQueryMetadata.fieldGroupList(), - CompleteQueryMetadataMsg: completeQueryMetadataMsg, - }, - } + model = api.NewAnnotatedAPI(&bigQueryAnnotations{ + Model: model, + QueryBuilderFields: queryBuilder.fieldGroupList(), + QueryBuilderMsg: queryBuilderMsg, + QueryBuilderRequestMsg: queryBuilderRequestMsg, + QueryMetadataFields: queryMetadata.fieldGroupList(), + QueryMetadataMsg: queryMetadataMsg, + CompleteQueryMetadataFields: completeQueryMetadata.fieldGroupList(), + CompleteQueryMetadataMsg: completeQueryMetadataMsg, + }) generatedFiles := language.WalkTemplatesDir(templates, "templates/bigquery") return parsedTemplates.GenerateFromModel(outdir, model, generatedFiles) diff --git a/internal/sidekick/rust/generate_convert_test.go b/internal/sidekick/rust/generate_convert_test.go index 0f484a71b2..e2db2a5599 100644 --- a/internal/sidekick/rust/generate_convert_test.go +++ b/internal/sidekick/rust/generate_convert_test.go @@ -416,8 +416,10 @@ func TestGenerateConvertAcronyms(t *testing.T) { outDir := t.TempDir() model := api.NewTestAPI([]*api.Message{vertexAISearchMsg, retrievalMsg}, []*api.Enum{ipVersionEnum}, []*api.Service{dnsService}) - model.ExternalMessages = []*api.Message{extDNSConfigMsg} - model.AddMessage(extDNSConfigMsg) + model = api.NewAPIBuilderFrom(model). + WithExternalMessages(extDNSConfigMsg). + AddMessage(extDNSConfigMsg). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/rust/prost.go b/internal/sidekick/rust/prost.go index 54d9926afb..da01f8aa10 100644 --- a/internal/sidekick/rust/prost.go +++ b/internal/sidekick/rust/prost.go @@ -65,13 +65,13 @@ func (c *codec) prostFieldType(f *api.Field, model *api.API) (string, error) { if m == nil { return "", fmt.Errorf("unable to lookup field type (%q) for field %s", f.TypezID(), f.ID()) } - return c.qualifyProstPath(m.Package(), prostMessageRelativePath(m), model.PackageName), nil + return c.qualifyProstPath(m.Package(), prostMessageRelativePath(m), model.PackageName()), nil case api.TypezEnum: e := model.Enum(f.TypezID()) if e == nil { return "", fmt.Errorf("unable to lookup field type (%q) for field %s", f.TypezID(), f.ID()) } - return c.qualifyProstPath(e.Package(), prostEnumRelativePath(e), model.PackageName), nil + return c.qualifyProstPath(e.Package(), prostEnumRelativePath(e), model.PackageName()), nil case api.TypezGroup, api.TypezMap: return "", nil default: diff --git a/internal/sidekick/rust/prost_test.go b/internal/sidekick/rust/prost_test.go index 72e312693d..0e7b2dbc02 100644 --- a/internal/sidekick/rust/prost_test.go +++ b/internal/sidekick/rust/prost_test.go @@ -33,10 +33,8 @@ func TestProstFieldType_ExternalAndSamePackageWkt(t *testing.T) { message := api.NewTestMessage("Event"). WithPackage("test.v1"). WithFields(enumField, msgField, tsField) - model := api.NewTestAPI([]*api.Message{message}, nil, nil) - model.AddEnum(extEnum) - model.AddMessage(extMsg) - model.AddMessage(wktTimestamp) + model := api.NewTestAPI([]*api.Message{message, extMsg, wktTimestamp}, []*api.Enum{extEnum}, nil). + WithPackageName("test.v1") if err := api.CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/rust/used_by_test.go b/internal/sidekick/rust/used_by_test.go index 8a5cd477ae..91fb609dac 100644 --- a/internal/sidekick/rust/used_by_test.go +++ b/internal/sidekick/rust/used_by_test.go @@ -386,8 +386,10 @@ func TestFindUsedPackages(t *testing.T) { WithMethods(method) model := api.NewTestAPI([]*api.Message{resource, createResourceReq}, nil, []*api.Service{service}) - model.AddMessage(operation) - model.AddMessage(operationMetadata) + model = api.NewAPIBuilderFrom(model). + AddMessage(operation). + AddMessage(operationMetadata). + BuildSyntaxTree() c, err := newCodec(libconfig.SpecProtobuf, map[string]string{ "package:common": "package=google-cloud-common,source=google.cloud.common", @@ -434,7 +436,7 @@ func TestFindUsedPackages_MapFields(t *testing.T) { message.WithFields(mapField) model := api.NewTestAPI([]*api.Message{message}, nil, nil).WithMaps(mapEntry) - model.AddMessage(externalMessage) + model = api.NewAPIBuilderFrom(model).AddMessage(externalMessage).BuildSyntaxTree() c, err := newCodec(libconfig.SpecProtobuf, map[string]string{ "package:external": "package=external-package,source=external", diff --git a/internal/sidekick/rust_prost/annotate.go b/internal/sidekick/rust_prost/annotate.go index e7226057a2..cf1b75b3fe 100644 --- a/internal/sidekick/rust_prost/annotate.go +++ b/internal/sidekick/rust_prost/annotate.go @@ -72,10 +72,10 @@ func (codec *codec) annotateModel(model *api.API, cfg *parser.ModelConfig) error UnusedTypes: codec.UnusedTypes, WktTypes: rust.ProstWktTypes(), } - for _, s := range model.Services { + for _, s := range model.Services() { codec.annotateService(s) } - model.Codec = annotations + model.SetAnnotations(annotations) return nil } diff --git a/internal/sidekick/rust_prost/annotate_test.go b/internal/sidekick/rust_prost/annotate_test.go index d1f25a63c7..2b3e2e9750 100644 --- a/internal/sidekick/rust_prost/annotate_test.go +++ b/internal/sidekick/rust_prost/annotate_test.go @@ -51,7 +51,7 @@ func TestModelAnnotations(t *testing.T) { "../../testdata/googleapis/google/type/f2.proto", }, } - if diff := cmp.Diff(want, model.Codec, cmpopts.IgnoreFields(modelAnnotations{}, "BoilerPlate", "WktTypes")); diff != "" { + if diff := cmp.Diff(want, model.Codec(), cmpopts.IgnoreFields(modelAnnotations{}, "BoilerPlate", "WktTypes")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } diff --git a/internal/sidekick/swift/annotate_field_test.go b/internal/sidekick/swift/annotate_field_test.go index 965b4578bc..6d5da2b166 100644 --- a/internal/sidekick/swift/annotate_field_test.go +++ b/internal/sidekick/swift/annotate_field_test.go @@ -209,7 +209,7 @@ func TestAnnotateField_TypeNames(t *testing.T) { FieldType: test.wantType, BaseFieldType: test.wantType, DocLines: []string{"Test documentation."}, - Model: model.Codec.(*modelAnnotations), + Model: model.Codec().(*modelAnnotations), ProtoFieldName: "testField", ProtoFieldNamePascal: "TestField", PrimitiveFieldType: test.wantType, @@ -249,7 +249,7 @@ func TestAnnotateField_PackageName(t *testing.T) { BaseFieldType: "GoogleCloudExternalV1.SomeMessage", PackageName: "google.cloud.external.v1", DocLines: []string{"The external message."}, - Model: model.Codec.(*modelAnnotations), + Model: model.Codec().(*modelAnnotations), ProtoFieldName: "externalMessage", ProtoFieldNamePascal: "ExternalMessage", PrimitiveFieldType: "GoogleCloudExternalV1.SomeMessage", diff --git a/internal/sidekick/swift/annotate_lro_any_test.go b/internal/sidekick/swift/annotate_lro_any_test.go index 816f0c5234..bfa80bb77b 100644 --- a/internal/sidekick/swift/annotate_lro_any_test.go +++ b/internal/sidekick/swift/annotate_lro_any_test.go @@ -147,7 +147,7 @@ func TestLROAnyTypes_PayloadTypeNotGenerated(t *testing.T) { // Stand in for a payload type another module owns. model.Message(".google.storage.control.v2.Folder").SetAnnotations(nil) - types, err := c.lroAnyTypes(model.Services[0].Methods()) + types, err := c.lroAnyTypes(model.Services()[0].Methods()) if err != nil { t.Fatal(err) } diff --git a/internal/sidekick/swift/annotate_message.go b/internal/sidekick/swift/annotate_message.go index 0ef81cbf3d..3077279b0a 100644 --- a/internal/sidekick/swift/annotate_message.go +++ b/internal/sidekick/swift/annotate_message.go @@ -199,7 +199,7 @@ func (c *codec) annotateMessage(message *api.Message, model *modelAnnotations) e if err != nil { return err } - if wktDep != nil && wktDep.ApiPackage != c.Model.PackageName { + if wktDep != nil && wktDep.ApiPackage != c.Model.PackageName() { // Messages generated in the library for WKT library (we have a few) // should not import the library. annotations.DependsOn[wktDep.Name] = wktDep @@ -228,7 +228,7 @@ func (c *codec) annotateMessage(message *api.Message, model *modelAnnotations) e if message.Deprecated() { fieldCodec.DiagnoseType = false } - if fieldCodec.PackageName != "" && fieldCodec.PackageName != c.Model.PackageName { + if fieldCodec.PackageName != "" && fieldCodec.PackageName != c.Model.PackageName() { dep, err := c.addApiPackageDependency(fieldCodec.PackageName) if err != nil { return err diff --git a/internal/sidekick/swift/annotate_message_test.go b/internal/sidekick/swift/annotate_message_test.go index 14c341bf82..bd6f587837 100644 --- a/internal/sidekick/swift/annotate_message_test.go +++ b/internal/sidekick/swift/annotate_message_test.go @@ -416,8 +416,9 @@ func TestAnnotateMessage_DiscoveryRequests(t *testing.T) { WithID(test.service.ID()). WithMessages(test.request). WithServicePlaceholder() - model := api.NewTestAPI([]*api.Message{servicePlaceholder}, nil, []*api.Service{test.service}) - model.AddMessage(test.request) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{servicePlaceholder}, nil, []*api.Service{test.service})). + AddMessage(test.request). + BuildSyntaxTree() codec := newTestCodec(t, model, nil) if err := codec.annotateModel(); err != nil { t.Fatal(err) diff --git a/internal/sidekick/swift/annotate_method_test.go b/internal/sidekick/swift/annotate_method_test.go index 4ce356dfca..ae66fc034b 100644 --- a/internal/sidekick/swift/annotate_method_test.go +++ b/internal/sidekick/swift/annotate_method_test.go @@ -314,10 +314,11 @@ func TestAnnotateMethod_WithExternalMessages(t *testing.T) { WithVerb("POST"). WithPathTemplate(api.NewPathTemplateBuilder().Build()) service := api.NewTestService("TestService").WithMethods(method) - model := api.NewTestAPI([]*api.Message{}, nil, []*api.Service{service}). - WithPackageName("google.cloud.test.v1") - model.AddMessage(inputMessage) - model.AddMessage(outputMessage) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{}, nil, []*api.Service{service}). + WithPackageName("google.cloud.test.v1")). + AddMessage(inputMessage). + AddMessage(outputMessage). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -1153,9 +1154,10 @@ func TestAnnotateMethod_HTTPBody(t *testing.T) { WithPathTemplate(api.NewPathTemplateBuilder().WithLiteral("v1").WithLiteral("test").Build()). WithBodyFieldPath(test.bodyFieldPath) service := api.NewTestService("TestService").WithMethods(method) - model := api.NewTestAPI([]*api.Message{wrapperReq, regularMsg}, nil, []*api.Service{service}). - WithPackageName("test") - model.AddMessage(httpBodyMsg) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{wrapperReq, regularMsg}, nil, []*api.Service{service}). + WithPackageName("test")). + AddMessage(httpBodyMsg). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/swift/annotate_model.go b/internal/sidekick/swift/annotate_model.go index f722923fdd..be28d9d8cd 100644 --- a/internal/sidekick/swift/annotate_model.go +++ b/internal/sidekick/swift/annotate_model.go @@ -67,6 +67,9 @@ type modelAnnotations struct { // Markdown (`README.md`), resolving proto cross-reference links to Swift // Package Index URLs and stripping unresolved links to their display text. ReadmeDocLines []string + + // QuickstartService is the service used to generate the package-level quickstart sample. + QuickstartService *api.Service } // traitDefinition provides information about each package trait. @@ -177,20 +180,21 @@ func (c *codec) annotateModel() error { if dep, ok := c.ApiPackages[wellKnownProtobufPackage]; ok { annotations.WktPackage = dep.Name } - c.Model.Codec = annotations - for _, message := range c.Model.Messages { + c.Model.SetAnnotations(annotations) + for _, message := range c.Model.Messages() { if err := c.annotateMessage(message, annotations); err != nil { return err } } - for _, enum := range c.Model.Enums { + for _, enum := range c.Model.Enums() { if err := c.annotateEnum(enum, annotations); err != nil { return err } } c.annotateLROAnyFields() + services := c.Model.Services() if c.QuickstartServiceOverride != "" { - idx := slices.IndexFunc(c.Model.Services, func(s *api.Service) bool { + idx := slices.IndexFunc(services, func(s *api.Service) bool { clientName := pascalCase(c.ServiceName(s) + "Client") return strings.EqualFold(s.Name(), c.QuickstartServiceOverride) || strings.EqualFold(c.ServiceName(s), c.QuickstartServiceOverride) || @@ -199,15 +203,17 @@ func (c *codec) annotateModel() error { if idx == -1 { return fmt.Errorf("%w: %q not found in services for package %q", errQuickstartServiceNotFound, c.QuickstartServiceOverride, c.PackageName) } - c.Model.QuickstartService = c.Model.Services[idx] - } else if c.Model.QuickstartService == nil && len(c.Model.Services) > 0 { - c.Model.QuickstartService = c.Model.Services[0] + annotations.QuickstartService = services[idx] + } else if c.Model.QuickstartService() != nil { + annotations.QuickstartService = c.Model.QuickstartService() + } else if len(services) > 0 { + annotations.QuickstartService = services[0] } // The services are annotated last because the annotation assumes messages // and enums are already annotated. - allTraits := make([]*traitDefinition, 0, len(c.Model.Services)) + allTraits := make([]*traitDefinition, 0, len(services)) var generatedMethods []*api.Method - for _, service := range c.Model.Services { + for _, service := range services { ann, err := c.annotateService(service, annotations) if err != nil { return err @@ -233,14 +239,14 @@ func (c *codec) annotateModel() error { } if !c.Module { var modelScopes []string - if c.Model.PackageName != "" { - modelScopes = []string{c.Model.PackageName} + if c.Model.PackageName() != "" { + modelScopes = []string{c.Model.PackageName()} } - docLines, err := c.formatDocumentation(c.Model.Description, modelScopes) + docLines, err := c.formatDocumentation(c.Model.Description(), modelScopes) if err != nil { return err } - readmeDocLines, err := c.formatReadmeDocumentation(c.Model.Description, modelScopes) + readmeDocLines, err := c.formatReadmeDocumentation(c.Model.Description(), modelScopes) if err != nil { return err } @@ -250,8 +256,8 @@ func (c *codec) annotateModel() error { if !c.PerServiceTraits { // The maximum (15) was chosen more or less arbitrarily circa 2026-05. At // the time, only a handful of packages exceeded this number of services. - if len(c.Model.Services) > 15 { - slog.Warn("package has more than 15 services, consider enabling per-service features", "package", c.LibraryName, "count", len(c.Model.Services)) + if len(services) > 15 { + slog.Warn("package has more than 15 services, consider enabling per-service features", "package", c.LibraryName, "count", len(services)) } return nil } diff --git a/internal/sidekick/swift/annotate_model_test.go b/internal/sidekick/swift/annotate_model_test.go index 786da7435d..09c87e5514 100644 --- a/internal/sidekick/swift/annotate_model_test.go +++ b/internal/sidekick/swift/annotate_model_test.go @@ -40,7 +40,7 @@ func TestModelAnnotations(t *testing.T) { MonorepoRoot: ".", WktPackage: "GoogleWKT", } - if diff := cmp.Diff(want, model.Codec, cmpopts.IgnoreFields(modelAnnotations{}, "BoilerPlate", "DependsOn")); diff != "" { + if diff := cmp.Diff(want, model.Codec(), cmpopts.IgnoreFields(modelAnnotations{}, "BoilerPlate", "DependsOn", "QuickstartService")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -71,7 +71,7 @@ func TestModelAnnotations_MessagesWithWkt(t *testing.T) { if err := codec.annotateModel(); err != nil { t.Fatal(err) } - ann := test.model.Codec.(*modelAnnotations) + ann := test.model.Codec().(*modelAnnotations) got := []string{} for _, d := range ann.Dependencies() { got = append(got, d.Name) @@ -96,9 +96,10 @@ func TestModelAnnotations_WithExternalDependencies(t *testing.T) { service := api.NewTestService("TestService"). WithPackage("google.cloud.test.v1") - model := api.NewTestAPI( - []*api.Message{message}, nil, []*api.Service{service}) - model.AddMessage(externalMessage) + model := api.NewAPIBuilderFrom(api.NewTestAPI( + []*api.Message{message}, nil, []*api.Service{service})). + AddMessage(externalMessage). + BuildSyntaxTree() codec := newTestCodec(t, model, nil) codec.withExtraDependencies(t, []config.SwiftDependency{ {ApiPackage: "google.cloud.external.v1", Name: "GoogleCloudExternalWithOverrideV1"}, @@ -110,9 +111,9 @@ func TestModelAnnotations_WithExternalDependencies(t *testing.T) { t.Fatal(err) } - ann, ok := model.Codec.(*modelAnnotations) + ann, ok := model.Codec().(*modelAnnotations) if !ok { - t.Fatalf("expected model.Codec to be *modelAnnotations, got %T", model.Codec) + t.Fatalf("expected model.Codec() to be *modelAnnotations, got %T", model.Codec()) } want := map[string]bool{ @@ -130,7 +131,7 @@ func TestModelAnnotations_WithExternalDependencies(t *testing.T) { t.Errorf("mismatch (-want +got):\n%s", diff) } - msg := model.Messages[0] + msg := model.Messages()[0] msgAnn, ok := msg.Codec().(*messageAnnotations) if !ok { t.Fatalf("expected message.Codec() to be *messageAnnotations, got %T", msg.Codec()) @@ -161,9 +162,9 @@ func TestModelAnnotations_IgnoreSelfDependency(t *testing.T) { t.Errorf("expected to not set ignore self dependency, got %v", dep) } - ann, ok := model.Codec.(*modelAnnotations) + ann, ok := model.Codec().(*modelAnnotations) if !ok { - t.Fatalf("expected model.Codec to be *modelAnnotations, got %T", model.Codec) + t.Fatalf("expected model.Codec() to be *modelAnnotations, got %T", model.Codec()) } // Self dependency should be ignored, other should be present. @@ -225,9 +226,9 @@ func TestModelAnnotations_Pagination(t *testing.T) { t.Fatal(err) } - ann, ok := model.Codec.(*modelAnnotations) + ann, ok := model.Codec().(*modelAnnotations) if !ok { - t.Fatalf("expected model.Codec to be *modelAnnotations, got %T", model.Codec) + t.Fatalf("expected model.Codec() to be *modelAnnotations, got %T", model.Codec()) } if _, ok := ann.DependsOn["GoogleGax"]; !ok { @@ -248,9 +249,9 @@ func TestModelAnnotations_Gating(t *testing.T) { t.Fatal(err) } - ann, ok := model.Codec.(*modelAnnotations) + ann, ok := model.Codec().(*modelAnnotations) if !ok { - t.Fatalf("expected model.Codec to be *modelAnnotations, got %T", model.Codec) + t.Fatalf("expected model.Codec() to be *modelAnnotations, got %T", model.Codec()) } wantAllTraits := []*traitDefinition{ @@ -281,58 +282,53 @@ func TestQuickstartServiceOverride(t *testing.T) { WithPackageName("test.pkg") t.Run("defaults to first service when no override", func(t *testing.T) { - m := *model - m.Services = []*api.Service{service1, service2} - m.QuickstartService = nil - codec := newTestCodec(t, &m, nil) + m := api.NewAPIBuilderFrom(model).WithServices(service1, service2).WithQuickstartService(nil).BuildSyntaxTree() + codec := newTestCodec(t, m, nil) if err := codec.annotateModel(); err != nil { t.Fatal(err) } - if m.QuickstartService != service1 { - t.Errorf("expected QuickstartService to default to service1, got %v", m.QuickstartService) + ann := m.Codec().(*modelAnnotations) + if ann.QuickstartService != service1 { + t.Errorf("expected QuickstartService to default to service1, got %v", ann.QuickstartService) } }) t.Run("overrides quickstart service by service name", func(t *testing.T) { - m := *model - m.Services = []*api.Service{service1, service2} - m.QuickstartService = nil + m := api.NewAPIBuilderFrom(model).WithServices(service1, service2).WithQuickstartService(nil).BuildSyntaxTree() lib := &config.Library{ Swift: &config.SwiftPackage{QuickstartServiceOverride: "Service2"}, } - codec := newTestCodec(t, &m, lib) + codec := newTestCodec(t, m, lib) if err := codec.annotateModel(); err != nil { t.Fatal(err) } - if m.QuickstartService != service2 { - t.Errorf("expected QuickstartService to be service2, got %v", m.QuickstartService) + ann := m.Codec().(*modelAnnotations) + if ann.QuickstartService != service2 { + t.Errorf("expected QuickstartService to be service2, got %v", ann.QuickstartService) } }) t.Run("overrides quickstart service by client name", func(t *testing.T) { - m := *model - m.Services = []*api.Service{service1, service2} - m.QuickstartService = nil + m := api.NewAPIBuilderFrom(model).WithServices(service1, service2).WithQuickstartService(nil).BuildSyntaxTree() lib := &config.Library{ Swift: &config.SwiftPackage{QuickstartServiceOverride: "Service2Client"}, } - codec := newTestCodec(t, &m, lib) + codec := newTestCodec(t, m, lib) if err := codec.annotateModel(); err != nil { t.Fatal(err) } - if m.QuickstartService != service2 { - t.Errorf("expected QuickstartService to be service2, got %v", m.QuickstartService) + ann := m.Codec().(*modelAnnotations) + if ann.QuickstartService != service2 { + t.Errorf("expected QuickstartService to be service2, got %v", ann.QuickstartService) } }) t.Run("returns error when override not found", func(t *testing.T) { - m := *model - m.Services = []*api.Service{service1, service2} - m.QuickstartService = nil + m := api.NewAPIBuilderFrom(model).WithServices(service1, service2).WithQuickstartService(nil).BuildSyntaxTree() lib := &config.Library{ Swift: &config.SwiftPackage{QuickstartServiceOverride: "NonExistentService"}, } - codec := newTestCodec(t, &m, lib) + codec := newTestCodec(t, m, lib) err := codec.annotateModel() if !errors.Is(err, errQuickstartServiceNotFound) { t.Errorf("expected errQuickstartServiceNotFound, got %v", err) @@ -392,9 +388,9 @@ func TestModelAnnotations_DescriptionLinks(t *testing.T) { if err := codec.annotateModel(); err != nil { t.Fatal(err) } - ann, ok := model.Codec.(*modelAnnotations) + ann, ok := model.Codec().(*modelAnnotations) if !ok { - t.Fatalf("expected model.Codec to be *modelAnnotations, got %T", model.Codec) + t.Fatalf("expected model.Codec() to be *modelAnnotations, got %T", model.Codec()) } if !ann.HasDocLines() { t.Error("expected HasDocLines() to be true") @@ -424,7 +420,7 @@ func TestModelAnnotations_ModuleSkipsDocLines(t *testing.T) { if err := codec.annotateModel(); err != nil { t.Fatal(err) } - ann := model.Codec.(*modelAnnotations) + ann := model.Codec().(*modelAnnotations) if ann.HasDocLines() { t.Errorf("expected HasDocLines() to be false for modules, got %v", ann.DocLines) } diff --git a/internal/sidekick/swift/annotate_service.go b/internal/sidekick/swift/annotate_service.go index e7825e9a19..6942315923 100644 --- a/internal/sidekick/swift/annotate_service.go +++ b/internal/sidekick/swift/annotate_service.go @@ -216,7 +216,7 @@ func (c *codec) annotateService(service *api.Service, model *modelAnnotations) ( // If the dependency is marked as "required_by_services", then we force it // as an import for the generated service files. for _, p := range c.Dependencies { - if p.ApiPackage == c.Model.PackageName || p.Name == c.LibraryName { + if p.ApiPackage == c.Model.PackageName() || p.Name == c.LibraryName { continue } if p.RequiredByServices { @@ -234,7 +234,7 @@ func (c *codec) annotateService(service *api.Service, model *modelAnnotations) ( for _, method := range methods { if method.InputType() != nil { - if method.InputType().Package() != c.Model.PackageName { + if method.InputType().Package() != c.Model.PackageName() { dep, err := c.addApiPackageDependency(method.InputType().Package()) if err != nil { return nil, err @@ -246,7 +246,7 @@ func (c *codec) annotateService(service *api.Service, model *modelAnnotations) ( } } if method.OutputType() != nil { - if method.OutputType().Package() != c.Model.PackageName { + if method.OutputType().Package() != c.Model.PackageName() { dep, err := c.addApiPackageDependency(method.OutputType().Package()) if err != nil { return nil, err @@ -274,7 +274,7 @@ func (c *codec) annotateService(service *api.Service, model *modelAnnotations) ( // body.contentType directly. Swift's MemberImportVisibility requires // importing the defining module (GoogleApi) in the transport file even if // GoogleApi does not appear in the service's public signatures. - if ma, ok := method.Codec().(*methodAnnotations); ok && ma.IsHTTPBodyRequest && c.Model.PackageName != "google.api" { + if ma, ok := method.Codec().(*methodAnnotations); ok && ma.IsHTTPBodyRequest && c.Model.PackageName() != "google.api" { dep, err := c.addApiPackageDependency("google.api") if err != nil { return nil, err @@ -329,7 +329,7 @@ func (c *codec) addFieldDependencies(annotations *serviceAnnotations, field *api if err != nil { return err } - if item.Package() != c.Model.PackageName { + if item.Package() != c.Model.PackageName() { dep, err := c.addApiPackageDependency(item.Package()) if err != nil { return err @@ -345,7 +345,7 @@ func (c *codec) addFieldDependencies(annotations *serviceAnnotations, field *api if err != nil { return err } - if item.Package() != c.Model.PackageName { + if item.Package() != c.Model.PackageName() { dep, err := c.addApiPackageDependency(item.Package()) if err != nil { return err @@ -388,7 +388,7 @@ func (c *codec) addLroDependencies(annotations *serviceAnnotations, method *api. if err != nil { return err } - if respMsg.Package() != c.Model.PackageName { + if respMsg.Package() != c.Model.PackageName() { dep, err := c.addApiPackageDependency(respMsg.Package()) if err != nil { return err @@ -404,7 +404,7 @@ func (c *codec) addLroDependencies(annotations *serviceAnnotations, method *api. if err != nil { return err } - if metaMsg.Package() != c.Model.PackageName { + if metaMsg.Package() != c.Model.PackageName() { dep, err := c.addApiPackageDependency(metaMsg.Package()) if err != nil { return err diff --git a/internal/sidekick/swift/annotate_service_test.go b/internal/sidekick/swift/annotate_service_test.go index 674018fbb5..30bdbe2ff7 100644 --- a/internal/sidekick/swift/annotate_service_test.go +++ b/internal/sidekick/swift/annotate_service_test.go @@ -204,7 +204,7 @@ func TestAnnotateService_Gating(t *testing.T) { t.Fatal(err) } - for _, service := range model.Services { + for _, service := range model.Services() { t.Run(service.Name(), func(t *testing.T) { ann, ok := service.Codec().(*serviceAnnotations) if !ok { @@ -245,7 +245,7 @@ func TestAnnotateService_RequiredServices(t *testing.T) { wantRequired := map[string]*api.Service{ sourceService.ID(): sourceService, } - if diff := cmp.Diff(wantRequired, targetCodec.RequiredServices, apitest.AllowUnexported(), apitest.IgnoreMethodFields("model"), apitest.IgnoreServiceFields("model")); diff != "" { + if diff := cmp.Diff(wantRequired, targetCodec.RequiredServices, apitest.AllowUnexported(), apitest.IgnoreMethodFields("model"), apitest.IgnoreServiceFields("model"), cmpopts.IgnoreFields(modelAnnotations{}, "QuickstartService")); diff != "" { t.Errorf("mismatch (-want +got):\n%s", diff) } } @@ -329,9 +329,10 @@ func TestAnnotateService_Pagination(t *testing.T) { service := api.NewTestService("TestService").WithMethods(list) - model := api.NewTestAPI([]*api.Message{inputType, outputType}, nil, []*api.Service{service}). - WithPackageName("test") - model.AddMessage(itemType) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{inputType, outputType}, nil, []*api.Service{service}). + WithPackageName("test")). + AddMessage(itemType). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -381,10 +382,11 @@ func TestAnnotateService_MapPagination(t *testing.T) { service := api.NewTestService("TestService").WithMethods(list) - model := api.NewTestAPI([]*api.Message{inputType, outputType}, nil, []*api.Service{service}). + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{inputType, outputType}, nil, []*api.Service{service}). WithPackageName("test"). - WithMaps(mapType) - model.AddMessage(itemType) + WithMaps(mapType)). + AddMessage(itemType). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -454,9 +456,10 @@ func TestAnnotateService_MethodSignatures(t *testing.T) { WithVerb("POST"). WithPathTemplate(api.NewPathTemplateBuilder().WithLiteral("v1").WithLiteral("things").Build()) service := api.NewTestService("TestService").WithMethods(create) - model := api.NewTestAPI([]*api.Message{inputType, outputType}, nil, []*api.Service{service}). - WithPackageName("test") - model.AddMessage(thing) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{inputType, outputType}, nil, []*api.Service{service}). + WithPackageName("test")). + AddMessage(thing). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -672,8 +675,7 @@ func TestAnnotateService_SkipStreamingMethods(t *testing.T) { WithClientSideStreaming() service := api.NewTestService("StreamingTestService").WithMethods(unary, serverStreaming, clientStreaming, bidiStreaming) - model := api.NewTestAPI([]*api.Message{req, resp}, nil, []*api.Service{service}) - model.PackageName = "test" + model := api.NewTestAPI([]*api.Message{req, resp}, nil, []*api.Service{service}).WithPackageName("test") if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -711,9 +713,10 @@ func TestAnnotateService_HTTPBodyRequestImports(t *testing.T) { WithVerb("POST"). WithPathTemplate(api.NewPathTemplateBuilder().WithLiteral("v1").WithLiteral("webhook").Build()) service := api.NewTestService("TestService").WithMethods(method) - model := api.NewTestAPI([]*api.Message{req, resp}, nil, []*api.Service{service}). - WithPackageName("test") - model.AddMessage(httpBodyMsg) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{req, resp}, nil, []*api.Service{service}). + WithPackageName("test")). + AddMessage(httpBodyMsg). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/swift/codec.go b/internal/sidekick/swift/codec.go index e95d74c243..441f3c5fea 100644 --- a/internal/sidekick/swift/codec.go +++ b/internal/sidekick/swift/codec.go @@ -353,7 +353,7 @@ func (c *codec) addDependency(dep *Dependency) (*Dependency, error) { if c.skipDependency(dep) { return nil, nil } - if ann, ok := c.Model.Codec.(*modelAnnotations); ok { + if ann, ok := c.Model.Codec().(*modelAnnotations); ok { ann.DependsOn[dep.Name] = dep } return dep, nil diff --git a/internal/sidekick/swift/codec_test.go b/internal/sidekick/swift/codec_test.go index f9f1fb4ebf..2c9a76083c 100644 --- a/internal/sidekick/swift/codec_test.go +++ b/internal/sidekick/swift/codec_test.go @@ -433,10 +433,11 @@ func makeRequiredServicesTestModel() *api.API { WithPackage("test"). WithMethods(internalMixin, externalMixin) - model := api.NewTestAPI([]*api.Message{placeholder, inputType, outputType}, nil, []*api.Service{sourceService, targetService}) - model.AddMessage(externalRequest) - model.AddMessage(externalResponse) - model.AddService(externalService) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{placeholder, inputType, outputType}, nil, []*api.Service{sourceService, targetService})). + AddMessage(externalRequest). + AddMessage(externalResponse). + AddService(externalService). + BuildSyntaxTree() api.CrossReference(model) return model } diff --git a/internal/sidekick/swift/doc_link.go b/internal/sidekick/swift/doc_link.go index b4ca08c9c1..f212412bfb 100644 --- a/internal/sidekick/swift/doc_link.go +++ b/internal/sidekick/swift/doc_link.go @@ -41,7 +41,7 @@ func (c *codec) docLink(packageName, name string) string { // Swift keywords are escaped with backticks in code (e.g. `get`, `protocol`), // but DocC symbol links require unescaped symbol names. name = strings.ReplaceAll(name, "`", "") - if packageName != c.Model.PackageName { + if packageName != c.Model.PackageName() { // TODO(#5072) - we have not implemented cross-reference links to external packages. return fmt.Sprintf("https://www.google.com/search?q=Swift+%s+%s", packageName, name) } diff --git a/internal/sidekick/swift/field_type_name.go b/internal/sidekick/swift/field_type_name.go index c5d353bd39..e90d9131ce 100644 --- a/internal/sidekick/swift/field_type_name.go +++ b/internal/sidekick/swift/field_type_name.go @@ -169,7 +169,7 @@ func (c *codec) fullyQualifiedMessageTypeName(m *api.Message) (string, error) { // there is no package, so return the bare type name return name, nil } - if m.Package() == c.Model.PackageName { + if m.Package() == c.Model.PackageName() { // this is the current package if c.Module || c.LibraryName == "" { // LibraryName is intentionally left empty when generating a module @@ -220,7 +220,7 @@ func (c *codec) typePrefix(packageName, name string) (string, error) { if err != nil || prefix != "" { return prefix, err } - if c.Model == nil || packageName != c.Model.PackageName { + if c.Model == nil || packageName != c.Model.PackageName() { return "", nil } if c.Module || c.LibraryName == "" { @@ -250,12 +250,12 @@ func (c *codec) typePrefix(packageName, name string) (string, error) { func (c *codec) externalTypePrefix(packageName string) (string, error) { dep, ok := c.ApiPackages[packageName] if !ok { - if packageName == c.Model.PackageName { + if packageName == c.Model.PackageName() { return "", nil } return "", fmt.Errorf("package %q not found in ApiPackages", packageName) } - if packageName == c.Model.PackageName && (!c.Module || c.TargetLibraryName == dep.Name) { + if packageName == c.Model.PackageName() && (!c.Module || c.TargetLibraryName == dep.Name) { return "", nil } return dep.Name, nil diff --git a/internal/sidekick/swift/field_type_name_test.go b/internal/sidekick/swift/field_type_name_test.go index b0a8aa3b76..c04e2d1baf 100644 --- a/internal/sidekick/swift/field_type_name_test.go +++ b/internal/sidekick/swift/field_type_name_test.go @@ -312,7 +312,7 @@ func TestFieldTypeName_ExternalMessage(t *testing.T) { WithPackageName("google.cloud.test.v1") c := newTestCodec(t, model, nil) ann := &modelAnnotations{DependsOn: map[string]*Dependency{}} - c.Model.Codec = ann + c.Model.SetAnnotations(ann) c.withExtraDependencies(t, []config.SwiftDependency{ { ApiPackage: "google.cloud.external.v1", @@ -342,7 +342,7 @@ func TestFieldTypeName_ExternalEnum(t *testing.T) { WithPackageName("google.cloud.test.v1") c := newTestCodec(t, model, nil) ann := &modelAnnotations{DependsOn: map[string]*Dependency{}} - c.Model.Codec = ann + c.Model.SetAnnotations(ann) c.withExtraDependencies(t, []config.SwiftDependency{ { ApiPackage: "google.cloud.external.v1", diff --git a/internal/sidekick/swift/generate.go b/internal/sidekick/swift/generate.go index 79123a88e8..cf36a149ff 100644 --- a/internal/sidekick/swift/generate.go +++ b/internal/sidekick/swift/generate.go @@ -109,7 +109,7 @@ func (c *codec) generateDocc(outdir string, model *api.API) error { OutputPath: output, }, } - if annotations, ok := model.Codec.(*modelAnnotations); ok && annotations.HasTraits() { + if annotations, ok := model.Codec().(*modelAnnotations); ok && annotations.HasTraits() { files = append(files, language.GeneratedFile{ TemplatePath: "templates/docc/package_traits.md.gotmpl", OutputPath: filepath.Join("Sources", c.LibraryName, c.LibraryName+".docc", "PackageTraits.md"), @@ -119,7 +119,7 @@ func (c *codec) generateDocc(outdir string, model *api.API) error { } func (c *codec) generateMessages(outdir string, model *api.API) error { - for _, m := range model.Messages { + for _, m := range model.Messages() { name := m.Name() if m.Parent() == nil && m.Package() == wellKnownProtobufPackage { name = "WKT" + m.Name() @@ -142,7 +142,7 @@ func (c *codec) generateMessages(outdir string, model *api.API) error { } func (c *codec) generateEnums(outdir string, model *api.API) error { - for _, e := range model.Enums { + for _, e := range model.Enums() { name := e.Name() if e.Parent() == nil && e.Package() == wellKnownProtobufPackage { name = "WKT" + e.Name() @@ -159,7 +159,7 @@ func (c *codec) generateEnums(outdir string, model *api.API) error { } func (c *codec) generateServices(outdir string, model *api.API) error { - for _, s := range model.Services { + for _, s := range model.Services() { generated := language.GeneratedFile{ TemplatePath: "templates/common/service.swift.gotmpl", OutputPath: c.swiftFilename(s.Name()), @@ -176,7 +176,7 @@ func (c *codec) generateStubs(outdir string, model *api.API) error { if c.isGrpc() { transportTemplate = "templates/grpc/transport.swift.gotmpl" } - for _, s := range model.Services { + for _, s := range model.Services() { for _, stub := range []struct { suffix string template string @@ -210,7 +210,7 @@ func (c *codec) generateLROAnyConverter(outdir string, model *api.API) error { // gRPC transport generates. return nil } - annotations, ok := model.Codec.(*modelAnnotations) + annotations, ok := model.Codec().(*modelAnnotations) if ok && annotations.HasLROAnyTypes() { generated := language.GeneratedFile{ TemplatePath: "templates/grpc/lro_any_converter.swift.gotmpl", @@ -222,7 +222,7 @@ func (c *codec) generateLROAnyConverter(outdir string, model *api.API) error { } func (c *codec) generateSnippets(outdir string, model *api.API) error { - for _, s := range model.Services { + for _, s := range model.Services() { // If two services differ only in case (such as `fooService` and // `FooService`), then this might generate clashing filenames in // filesystems that are case insensitive. @@ -262,7 +262,7 @@ func (c *codec) generateSnippets(outdir string, model *api.API) error { } func (c *codec) generateClients(outdir string, model *api.API) error { - if len(model.Services) == 0 { + if len(model.Services()) == 0 { return nil } generated := language.GeneratedFile{ @@ -273,7 +273,7 @@ func (c *codec) generateClients(outdir string, model *api.API) error { } func (c *codec) generatePackageVersion(outdir string, model *api.API) error { - if len(model.Services) > 0 { + if len(model.Services()) > 0 { return nil } generated := language.GeneratedFile{ diff --git a/internal/sidekick/swift/generate_conversions.go b/internal/sidekick/swift/generate_conversions.go index 0b25b14b26..dd6aa8e1f5 100644 --- a/internal/sidekick/swift/generate_conversions.go +++ b/internal/sidekick/swift/generate_conversions.go @@ -46,7 +46,7 @@ func GenerateConversions(ctx context.Context, model *api.API, outdir string, lib } func (c *codec) generateEnumConversions(outdir string) error { - for _, e := range c.Model.Enums { + for _, e := range c.Model.Enums() { if e.Parent() != nil { continue } @@ -64,7 +64,7 @@ func (c *codec) generateEnumConversions(outdir string) error { } func (c *codec) generateMessageConversions(outdir string) error { - for _, m := range c.Model.Messages { + for _, m := range c.Model.Messages() { if m.Parent() != nil || m.ServicePlaceholder() { continue } diff --git a/internal/sidekick/swift/generate_lro_any_test.go b/internal/sidekick/swift/generate_lro_any_test.go index f5671dd2bd..5d41ce320e 100644 --- a/internal/sidekick/swift/generate_lro_any_test.go +++ b/internal/sidekick/swift/generate_lro_any_test.go @@ -200,10 +200,12 @@ func lroAnyTwoServiceTestModel(t *testing.T) *api.API { WithPackage("google.storage.control.v2"). WithMethods(method) - model.Messages = append(model.Messages, managedFolder) - model.AddMessage(managedFolder) - model.Services = append(model.Services, service) - model.AddService(service) + model = api.NewAPIBuilderFrom(model). + AppendMessage(managedFolder). + AddMessage(managedFolder). + AppendService(service). + AddService(service). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/swift/generate_message_swift_test.go b/internal/sidekick/swift/generate_message_swift_test.go index 9d1a61d565..a8211049cc 100644 --- a/internal/sidekick/swift/generate_message_swift_test.go +++ b/internal/sidekick/swift/generate_message_swift_test.go @@ -187,8 +187,9 @@ func TestGenerateMessage_WithExternalImports(t *testing.T) { api.NewTestField("ext_field").WithMessageType(externalMessage), ) - model := api.NewTestAPI([]*api.Message{message}, nil, nil) - model.AddMessage(externalMessage) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{message}, nil, nil)). + AddMessage(externalMessage). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { diff --git a/internal/sidekick/swift/generate_method_signatures_test.go b/internal/sidekick/swift/generate_method_signatures_test.go index 3e2a46a0e8..bcf9340139 100644 --- a/internal/sidekick/swift/generate_method_signatures_test.go +++ b/internal/sidekick/swift/generate_method_signatures_test.go @@ -272,12 +272,13 @@ func newModelWithSignatures(t *testing.T) *api.API { service := api.NewTestService("TestService"). WithPackage("test"). WithMethods(simpleMethod, paginationMethod, lroMethod, discoveryLroMethod) - model := api.NewTestAPI([]*api.Message{ + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{ requestType, responseType, itemType, paginationResponseType, operationType, lroResultType, lroMetadataType, }, nil, []*api.Service{service}). - WithPackageName("test") - model.AddMessage(getOperationInputType) - model.AddMessage(operationType) + WithPackageName("test")). + AddMessage(getOperationInputType). + AddMessage(operationType). + BuildSyntaxTree() return model } diff --git a/internal/sidekick/swift/generate_readme_test.go b/internal/sidekick/swift/generate_readme_test.go index c07edab0ea..e2d0001d3d 100644 --- a/internal/sidekick/swift/generate_readme_test.go +++ b/internal/sidekick/swift/generate_readme_test.go @@ -263,8 +263,8 @@ func TestGenerateReadme_WithRevision(t *testing.T) { WithPackage(pkg) model := api.NewTestAPI([]*api.Message{message}, nil, nil). WithPackageName(pkg). - WithTitle("Compute Engine API") - model.Revision = "20260101" + WithTitle("Compute Engine API"). + WithRevision("20260101") library := &config.Library{ Name: "google-cloud-compute-v1", diff --git a/internal/sidekick/swift/generate_service_swift_test.go b/internal/sidekick/swift/generate_service_swift_test.go index 5005fd1093..b016eba0de 100644 --- a/internal/sidekick/swift/generate_service_swift_test.go +++ b/internal/sidekick/swift/generate_service_swift_test.go @@ -222,8 +222,9 @@ func TestGenerateService_WithImports(t *testing.T) { WithPathTemplate(api.NewPathTemplateBuilder().Build()), ) - model := api.NewTestAPI([]*api.Message{inputMessage}, nil, []*api.Service{iam}) - model.AddMessage(externalMessage) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{inputMessage}, nil, []*api.Service{iam})). + AddMessage(externalMessage). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { @@ -744,9 +745,10 @@ func TestGenerateService_LRO(t *testing.T) { WithPackage("google.cloud.workflows.v1"). WithMethods(createWorkflow, getOperation) - model := api.NewTestAPI([]*api.Message{inputType, workflowType, metadataType}, nil, []*api.Service{workflows}) - model.AddMessage(operationType) - model.AddMessage(getOperationInputType) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{inputType, workflowType, metadataType}, nil, []*api.Service{workflows})). + AddMessage(operationType). + AddMessage(getOperationInputType). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { @@ -854,9 +856,10 @@ func TestGenerateService_LRO_Empty(t *testing.T) { WithPackage("google.cloud.workflows.v1"). WithMethods(deleteWorkflow, getOperation) - model := api.NewTestAPI([]*api.Message{inputType, metadataType}, nil, []*api.Service{workflows}) - model.AddMessage(operationType) - model.AddMessage(getOperationInputType) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{inputType, metadataType}, nil, []*api.Service{workflows})). + AddMessage(operationType). + AddMessage(getOperationInputType). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { @@ -1381,9 +1384,10 @@ func TestGenerateService_HTTPBody(t *testing.T) { WithPackage("google.cloud.aiplatform.v1"). WithMethods(rawPredict, directBody) - model := api.NewTestAPI([]*api.Message{rawPredictReq}, nil, []*api.Service{service}) - model.AddMessage(httpBodyMsg) - model.AddMessage(emptyResp) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{rawPredictReq}, nil, []*api.Service{service})). + AddMessage(httpBodyMsg). + AddMessage(emptyResp). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { diff --git a/internal/sidekick/swift/generate_snippets_test.go b/internal/sidekick/swift/generate_snippets_test.go index 6e6a3b2423..c82480c283 100644 --- a/internal/sidekick/swift/generate_snippets_test.go +++ b/internal/sidekick/swift/generate_snippets_test.go @@ -115,9 +115,10 @@ func TestGenerateSnippets(t *testing.T) { WithOutput(thing). WithPathTemplate(api.NewPathTemplateBuilder().WithLiteral("v1").WithLiteral("one").Build()) testService := api.NewTestService("TestService").WithMethods(getThing) - model := api.NewTestAPI([]*api.Message{thing, getThingRequest}, nil, []*api.Service{testService}). - WithPackageName("test") - model.AddResource(thingResource) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{thing, getThingRequest}, nil, []*api.Service{testService}). + WithPackageName("test")). + AddResource(thingResource). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -198,9 +199,10 @@ func TestGenerateSnippets_Diagnose(t *testing.T) { testService := api.NewTestService("TestService"). WithDeprecated(test.serviceDeprecated). WithMethods(getThing) - model := api.NewTestAPI([]*api.Message{thing, getThingRequest}, nil, []*api.Service{testService}). - WithPackageName("test") - model.AddResource(thingResource) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{thing, getThingRequest}, nil, []*api.Service{testService}). + WithPackageName("test")). + AddResource(thingResource). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -253,10 +255,11 @@ func TestGenerateSnippets_UpdateMask(t *testing.T) { WithOutput(thing). WithPathTemplate(api.NewPathTemplateBuilder().WithLiteral("v1").WithLiteral("things").Build()) testService := api.NewTestService("TestService").WithMethods(updateThing) - model := api.NewTestAPI([]*api.Message{thing, updateThingRequest}, nil, []*api.Service{testService}). - WithPackageName("test") - model.AddResource(thingResource) - model.LoadWellKnownTypes() + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{thing, updateThingRequest}, nil, []*api.Service{testService}). + WithPackageName("test")). + AddResource(thingResource). + LoadWellKnownTypes(). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/swift/generate_storage_test.go b/internal/sidekick/swift/generate_storage_test.go index a469c81f4d..28d91166b9 100644 --- a/internal/sidekick/swift/generate_storage_test.go +++ b/internal/sidekick/swift/generate_storage_test.go @@ -132,11 +132,12 @@ func TestGenerateStorage_MultiModel(t *testing.T) { ). WithDefaultHost("storage.googleapis.com") - controlModel := api.NewTestAPI([]*api.Message{folder, createFolderRequest, renameFolderRequest, renameFolderMetadata}, nil, []*api.Service{controlService}) - controlModel.AddMessage(policy) - controlModel.AddMessage(getIamPolicyRequest) - controlModel.AddMessage(operation) - controlModel.AddMessage(getOperationRequest) + controlModel := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{folder, createFolderRequest, renameFolderRequest, renameFolderMetadata}, nil, []*api.Service{controlService})). + AddMessage(policy). + AddMessage(getIamPolicyRequest). + AddMessage(operation). + AddMessage(getOperationRequest). + BuildSyntaxTree() if err := api.CrossReference(controlModel); err != nil { t.Fatal(err) } diff --git a/internal/sidekick/swift/generate_stub_test.go b/internal/sidekick/swift/generate_stub_test.go index 24caad3eda..fb404c22be 100644 --- a/internal/sidekick/swift/generate_stub_test.go +++ b/internal/sidekick/swift/generate_stub_test.go @@ -41,9 +41,10 @@ func TestGenerateStub_Structure(t *testing.T) { WithPathTemplate(api.NewPathTemplateBuilder().Build()), ) - model := api.NewTestAPI(nil, nil, []*api.Service{service}) - model.AddMessage(request) - model.AddMessage(response) + model := api.NewAPIBuilderFrom(api.NewTestAPI(nil, nil, []*api.Service{service})). + AddMessage(request). + AddMessage(response). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { @@ -282,11 +283,12 @@ func TestGenerateStub_Grpc(t *testing.T) { getOperation, ) - model := api.NewTestAPI([]*api.Message{folder, createFolderRequest, deleteFolderRequest}, nil, []*api.Service{service}) - model.AddService(operationsService) - model.AddMessage(empty) - model.AddMessage(operation) - model.AddMessage(getOperationRequest) + model := api.NewAPIBuilderFrom(api.NewTestAPI([]*api.Message{folder, createFolderRequest, deleteFolderRequest}, nil, []*api.Service{service})). + AddService(operationsService). + AddMessage(empty). + AddMessage(operation). + AddMessage(getOperationRequest). + BuildSyntaxTree() if err := api.CrossReference(model); err != nil { t.Fatal(err) } @@ -416,9 +418,10 @@ func TestGenerateStub_MultipleBindings(t *testing.T) { WithPackage("google.cloud.test.v1"). WithMethods(getResource) - model := api.NewTestAPI(nil, nil, []*api.Service{service}) - model.AddMessage(request) - model.AddMessage(response) + model := api.NewAPIBuilderFrom(api.NewTestAPI(nil, nil, []*api.Service{service})). + AddMessage(request). + AddMessage(response). + BuildSyntaxTree() swiftCfg := swiftConfig(t, []config.SwiftDependency{ { diff --git a/internal/sidekick/swift/library_name.go b/internal/sidekick/swift/library_name.go index cd68779e07..b55852a432 100644 --- a/internal/sidekick/swift/library_name.go +++ b/internal/sidekick/swift/library_name.go @@ -34,10 +34,10 @@ func LibraryName(api *api.API, swiftCfg *config.SwiftPackage) (string, error) { if swiftCfg != nil && swiftCfg.LibraryNameOverride != "" { return swiftCfg.LibraryNameOverride, nil } - if api.PackageName == "" { + if api.PackageName() == "" { return "", fmt.Errorf("API package name must not be empty") } - parts := strings.Split(api.PackageName, ".") + parts := strings.Split(api.PackageName(), ".") for i, p := range parts { parts[i] = strcase.ToCamel(p) } @@ -46,9 +46,9 @@ func LibraryName(api *api.API, swiftCfg *config.SwiftPackage) (string, error) { lang string value string }{ - {"C#", strings.ReplaceAll(api.CsharpNamespace, ".", "")}, - {"PHP", strings.ReplaceAll(api.PhpNamespace, "\\", "")}, - {"Ruby", strings.ReplaceAll(api.RubyPackage, "::", "")}, + {"C#", strings.ReplaceAll(api.CsharpNamespace(), ".", "")}, + {"PHP", strings.ReplaceAll(api.PhpNamespace(), "\\", "")}, + {"Ruby", strings.ReplaceAll(api.RubyPackage(), "::", "")}, } var messages []string for _, alt := range alternatives { @@ -60,7 +60,7 @@ func LibraryName(api *api.API, swiftCfg *config.SwiftPackage) (string, error) { } } if len(messages) != 0 { - return "", fmt.Errorf(requiresLibraryNameOverrideFormat, api.PackageName, strings.Join(messages, "\n")) + return "", fmt.Errorf(requiresLibraryNameOverrideFormat, api.PackageName(), strings.Join(messages, "\n")) } return libraryName, nil diff --git a/internal/sidekick/swift/package_name.go b/internal/sidekick/swift/package_name.go index 4bab866cb6..103c040934 100644 --- a/internal/sidekick/swift/package_name.go +++ b/internal/sidekick/swift/package_name.go @@ -24,7 +24,7 @@ import ( // PackageName returns the Swift package name for the API. func PackageName(api *api.API) string { - return strings.ReplaceAll(api.PackageName, ".", "-") + return strings.ReplaceAll(api.PackageName(), ".", "-") } // PackageRepoName derives the split repository name for a library. diff --git a/internal/sidekick/swift/storage.go b/internal/sidekick/swift/storage.go index e82f854595..0bfca8b68e 100644 --- a/internal/sidekick/swift/storage.go +++ b/internal/sidekick/swift/storage.go @@ -60,14 +60,14 @@ func GenerateStorage( } defaultHost := "storage.googleapis.com" - for _, s := range controlModel.Services { + for _, s := range controlModel.Services() { if s.DefaultHost() != "" { defaultHost = s.DefaultHost() break } } if defaultHost == "storage.googleapis.com" { - for _, s := range storageModel.Services { + for _, s := range storageModel.Services() { if s.DefaultHost() != "" { defaultHost = s.DefaultHost() break @@ -78,7 +78,7 @@ func GenerateStorage( var serviceImports []string importSet := make(map[string]bool) for _, model := range []*api.API{storageModel, controlModel} { - for _, s := range model.Services { + for _, s := range model.Services() { if sa, ok := s.Codec().(*serviceAnnotations); ok { for _, imp := range sa.PublicServiceImports() { // StorageControl only defines unified methods for bucket, folder, and IAM operations, @@ -94,7 +94,7 @@ func GenerateStorage( slices.Sort(serviceImports) var boilerPlate []string - if ma, ok := controlModel.Codec.(*modelAnnotations); ok { + if ma, ok := controlModel.Codec().(*modelAnnotations); ok { boilerPlate = ma.BoilerPlate } @@ -104,17 +104,15 @@ func GenerateStorage( packageVersion = library.Version } - mergedModel := &api.API{ - Codec: &storageAnnotations{ - Storage: storageModel, - Control: controlModel, - DefaultHost: defaultHost, - ServiceImports: serviceImports, - CopyrightYear: copyrightYear, - PackageVersion: packageVersion, - BoilerPlate: boilerPlate, - }, - } + mergedModel := api.NewAnnotatedAPI(&storageAnnotations{ + Storage: storageModel, + Control: controlModel, + DefaultHost: defaultHost, + ServiceImports: serviceImports, + CopyrightYear: copyrightYear, + PackageVersion: packageVersion, + BoilerPlate: boilerPlate, + }) generatedFiles := language.WalkTemplatesDir(templates, "templates/storage") generatedFiles = append(generatedFiles, language.GeneratedFile{ diff --git a/internal/sidekick/swift/templates/docc/landing_page.md.gotmpl b/internal/sidekick/swift/templates/docc/landing_page.md.gotmpl index 4b0a4676ac..3c82a826bf 100644 --- a/internal/sidekick/swift/templates/docc/landing_page.md.gotmpl +++ b/internal/sidekick/swift/templates/docc/landing_page.md.gotmpl @@ -45,7 +45,7 @@ to learn about this library. This is a type-only library containing a collection of common types used by other Google Cloud packages. It does not contain client types to make RPCs. {{- end }} -{{- with .QuickstartService }} +{{- with .Codec.QuickstartService }} ## Quickstart diff --git a/internal/sidekick/swift/templates/package/README.md.gotmpl b/internal/sidekick/swift/templates/package/README.md.gotmpl index b1c2721f07..3fa0cfa443 100644 --- a/internal/sidekick/swift/templates/package/README.md.gotmpl +++ b/internal/sidekick/swift/templates/package/README.md.gotmpl @@ -48,7 +48,7 @@ to learn about this library. This is a type-only library containing a collection of common types used by other Google Cloud packages. It does not contain client types to make RPCs. {{- end }} -{{- with .QuickstartService }} +{{- with .Codec.QuickstartService }} ## Quickstart