add graphql
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
This commit is contained in:
parent
55fa1ee403
commit
6d17a74ffb
@ -6,32 +6,20 @@ option go_package = "github.com/unistack-org/protoc-gen-go-micro/v3/example;exam
|
||||
|
||||
import "tag/tag.proto";
|
||||
import "api/annotations.proto";
|
||||
import "openapiv2/annotations.proto";
|
||||
import "google/protobuf/wrappers.proto";
|
||||
import "graphql.proto";
|
||||
import "openapiv3/annotations.proto";
|
||||
//import "google/protobuf/wrappers.proto";
|
||||
import "graphql/graphql.proto";
|
||||
|
||||
service Example {
|
||||
option (graphql.service) = {
|
||||
host: "localhost:9090";
|
||||
};
|
||||
rpc Call(CallReq) returns (CallRsp) {
|
||||
option (graphql.schema) = {
|
||||
type: QUERY
|
||||
name: "Call"
|
||||
};
|
||||
option (micro.openapiv3.openapiv3_operation) = {
|
||||
option (micro.graphql.rpc) = {type: QUERY};
|
||||
option (micro.openapiv3.openapiv3_operation) = {
|
||||
operation_id: "Call";
|
||||
responses: {
|
||||
key: "default";
|
||||
value: {
|
||||
description: "Error response";
|
||||
schema: {
|
||||
json_schema: {
|
||||
ref: ".example.Error";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
responses: {
|
||||
default: {
|
||||
reference: {_ref: ".example.Error"};
|
||||
};
|
||||
};
|
||||
};
|
||||
option (micro.api.http) = { post: "/v1/example/call/{name}"; body: "*"; };
|
||||
option (micro.api.micro_method) = { timeout: "5s"; };
|
||||
@ -39,7 +27,7 @@ service Example {
|
||||
};
|
||||
|
||||
message CallReq {
|
||||
string name = 1 [(micro.tag.tags) = "xml:\",attr\"" ];
|
||||
string name = 1 [(micro.graphql.field) = {required: true}];
|
||||
string req = 2;
|
||||
};
|
||||
|
||||
|
11
example/schema.graphql
Normal file
11
example/schema.graphql
Normal file
@ -0,0 +1,11 @@
|
||||
directive @Example on FIELD_DEFINITION
|
||||
input CallReqInput {
|
||||
name: String!
|
||||
req: String
|
||||
}
|
||||
type CallRsp {
|
||||
rsp: String
|
||||
}
|
||||
type Query {
|
||||
exampleCall(in: CallReqInput): CallRsp
|
||||
}
|
3
generate.go
Normal file
3
generate.go
Normal file
@ -0,0 +1,3 @@
|
||||
package main
|
||||
|
||||
//go:generate sh -xc "protoc -I./example -I. -I$(go list -f '{{ .Dir }}' -m go.unistack.org/micro-proto/v3) --go-micro_out=components=graphqls,graphql_file=./schema.graphql:./example example/example.proto"
|
4
go.mod
4
go.mod
@ -5,17 +5,17 @@ go 1.20
|
||||
require (
|
||||
github.com/danielvladco/go-proto-gql v0.10.0
|
||||
github.com/fatih/structtag v1.2.0
|
||||
github.com/jhump/protoreflect v1.7.1
|
||||
github.com/vektah/gqlparser/v2 v2.5.1
|
||||
go.unistack.org/micro-proto/v3 v3.4.1
|
||||
golang.org/x/tools v0.11.0
|
||||
google.golang.org/protobuf v1.31.0
|
||||
google.golang.org/protobuf v1.28.1
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/golang/protobuf v1.5.3 // indirect
|
||||
github.com/google/gnostic v0.6.9 // indirect
|
||||
github.com/google/go-cmp v0.5.9 // indirect
|
||||
github.com/jhump/protoreflect v1.7.1 // indirect
|
||||
github.com/kr/text v0.2.0 // indirect
|
||||
golang.org/x/mod v0.12.0 // indirect
|
||||
golang.org/x/sys v0.10.0 // indirect
|
||||
|
4
go.sum
4
go.sum
@ -190,8 +190,8 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
|
||||
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
|
||||
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
|
||||
google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
|
||||
google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
|
||||
google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
|
||||
google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
|
||||
google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
|
9
graphql.go
Normal file
9
graphql.go
Normal file
@ -0,0 +1,9 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"google.golang.org/protobuf/compiler/protogen"
|
||||
)
|
||||
|
||||
func (g *Generator) graphqlGenerate(plugin *protogen.Plugin) error {
|
||||
return nil
|
||||
}
|
32
graphql/callstack.go
Normal file
32
graphql/callstack.go
Normal file
@ -0,0 +1,32 @@
|
||||
package generator
|
||||
|
||||
type Callstack interface {
|
||||
Push(entry interface{})
|
||||
Pop(entry interface{})
|
||||
Has(entry interface{}) bool
|
||||
}
|
||||
|
||||
func NewCallstack() Callstack {
|
||||
return &callstack{stack: make(map[interface{}]int), index: 0}
|
||||
}
|
||||
|
||||
type callstack struct {
|
||||
stack map[interface{}]int
|
||||
sorted []string
|
||||
index int
|
||||
}
|
||||
|
||||
func (c *callstack) Pop(entry interface{}) {
|
||||
delete(c.stack, entry)
|
||||
c.index--
|
||||
}
|
||||
|
||||
func (c *callstack) Push(entry interface{}) {
|
||||
c.stack[entry] = c.index
|
||||
c.index++
|
||||
}
|
||||
|
||||
func (c *callstack) Has(entry interface{}) bool {
|
||||
_, ok := c.stack[entry]
|
||||
return ok
|
||||
}
|
77
graphql/descriptors.go
Normal file
77
graphql/descriptors.go
Normal file
@ -0,0 +1,77 @@
|
||||
package generator
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/jhump/protoreflect/desc"
|
||||
"github.com/vektah/gqlparser/v2/ast"
|
||||
any "google.golang.org/protobuf/types/known/anypb"
|
||||
)
|
||||
|
||||
type ObjectDescriptor struct {
|
||||
*ast.Definition
|
||||
desc.Descriptor
|
||||
|
||||
types []*ObjectDescriptor
|
||||
fields []*FieldDescriptor
|
||||
fieldNames map[string]*FieldDescriptor
|
||||
}
|
||||
|
||||
func (o *ObjectDescriptor) AsGraphql() *ast.Definition {
|
||||
return o.Definition
|
||||
}
|
||||
|
||||
func (o *ObjectDescriptor) uniqueName(f *desc.FieldDescriptor) string {
|
||||
return strings.Title(f.GetName())
|
||||
}
|
||||
|
||||
func (o *ObjectDescriptor) IsInput() bool {
|
||||
return o.Kind == ast.InputObject
|
||||
}
|
||||
|
||||
func (o *ObjectDescriptor) GetFields() []*FieldDescriptor {
|
||||
return o.fields
|
||||
}
|
||||
|
||||
func (o *ObjectDescriptor) GetTypes() []*ObjectDescriptor {
|
||||
return o.types
|
||||
}
|
||||
|
||||
func (o *ObjectDescriptor) IsMessage() bool {
|
||||
_, ok := o.Descriptor.(*desc.MessageDescriptor)
|
||||
return ok
|
||||
}
|
||||
|
||||
// same isEmpty but for mortals
|
||||
func IsEmpty(o *desc.MessageDescriptor) bool { return isEmpty(o, NewCallstack()) }
|
||||
|
||||
// make sure objects are fulled with all objects
|
||||
func isEmpty(o *desc.MessageDescriptor, callstack Callstack) bool {
|
||||
callstack.Push(o)
|
||||
defer callstack.Pop(o)
|
||||
|
||||
if len(o.GetFields()) == 0 {
|
||||
return true
|
||||
}
|
||||
for _, f := range o.GetFields() {
|
||||
objType := f.GetMessageType()
|
||||
if objType == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
// check if the call stack already contains a reference to this type and prevent it from calling itself again
|
||||
if callstack.Has(objType) {
|
||||
return true
|
||||
}
|
||||
if !isEmpty(objType, callstack) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// TODO maybe not compare by strings
|
||||
func IsAny(o *desc.MessageDescriptor) bool {
|
||||
return string((&any.Any{}).ProtoReflect().Descriptor().FullName()) == o.GetFullyQualifiedName()
|
||||
}
|
761
graphql/generator.go
Normal file
761
graphql/generator.go
Normal file
@ -0,0 +1,761 @@
|
||||
package generator
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/jhump/protoreflect/desc"
|
||||
"github.com/vektah/gqlparser/v2/ast"
|
||||
"google.golang.org/protobuf/compiler/protogen"
|
||||
descriptor "google.golang.org/protobuf/types/descriptorpb"
|
||||
|
||||
gqlpb "go.unistack.org/micro-proto/v3/graphql"
|
||||
)
|
||||
|
||||
const (
|
||||
fieldPrefix = "Field"
|
||||
inputSuffix = "Input"
|
||||
typeSep = "_"
|
||||
packageSep = "."
|
||||
anyTypeDescription = "Any is any json type"
|
||||
scalarBytes = "Bytes"
|
||||
goFieldDirective = "goField"
|
||||
|
||||
DefaultExtension = "graphql"
|
||||
)
|
||||
|
||||
func NewSchemas(descs []*desc.FileDescriptor, mergeSchemas, genServiceDesc bool, plugin *protogen.Plugin) (schemas SchemaDescriptorList, err error) {
|
||||
var files []*descriptor.FileDescriptorProto
|
||||
for _, d := range descs {
|
||||
files = append(files, d.AsFileDescriptorProto())
|
||||
}
|
||||
var goref GoRef
|
||||
if plugin != nil {
|
||||
goref, err = NewGoRef(plugin)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
if mergeSchemas {
|
||||
schema := NewSchemaDescriptor(genServiceDesc, goref)
|
||||
for _, file := range descs {
|
||||
err := generateFile(file, schema)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return []*SchemaDescriptor{schema}, nil
|
||||
}
|
||||
|
||||
for _, file := range descs {
|
||||
schema := NewSchemaDescriptor(genServiceDesc, goref)
|
||||
err := generateFile(file, schema)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
schemas = append(schemas, schema)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func generateFile(file *desc.FileDescriptor, schema *SchemaDescriptor) error {
|
||||
schema.FileDescriptors = append(schema.FileDescriptors, file)
|
||||
|
||||
for _, svc := range file.GetServices() {
|
||||
svcOpts := GraphqlServiceOptions(svc.AsServiceDescriptorProto().GetOptions())
|
||||
if svcOpts != nil && svcOpts.Ignore != nil && *svcOpts.Ignore {
|
||||
continue
|
||||
}
|
||||
for _, rpc := range svc.GetMethods() {
|
||||
rpcOpts := GraphqlMethodOptions(rpc.AsMethodDescriptorProto().GetOptions())
|
||||
if rpcOpts != nil && rpcOpts.Ignore != nil && *rpcOpts.Ignore {
|
||||
continue
|
||||
}
|
||||
in, err := schema.CreateObjects(rpc.GetInputType(), true)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
out, err := schema.CreateObjects(rpc.GetOutputType(), false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if rpc.IsServerStreaming() && rpc.IsClientStreaming() {
|
||||
schema.GetMutation().addMethod(svc, rpc, in, out)
|
||||
}
|
||||
|
||||
if rpc.IsServerStreaming() {
|
||||
schema.GetSubscription().addMethod(svc, rpc, in, out)
|
||||
} else {
|
||||
switch GetRequestType(rpcOpts, svcOpts) {
|
||||
case gqlpb.Type_QUERY:
|
||||
schema.GetQuery().addMethod(svc, rpc, in, out)
|
||||
default:
|
||||
schema.GetMutation().addMethod(svc, rpc, in, out)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type SchemaDescriptorList []*SchemaDescriptor
|
||||
|
||||
func (s SchemaDescriptorList) AsGraphql() (astSchema []*ast.Schema) {
|
||||
for _, ss := range s {
|
||||
astSchema = append(astSchema, ss.AsGraphql())
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (s SchemaDescriptorList) GetForDescriptor(file *protogen.File) *SchemaDescriptor {
|
||||
for _, schema := range s {
|
||||
for _, d := range schema.FileDescriptors {
|
||||
if d.AsFileDescriptorProto() == file.Proto {
|
||||
return schema
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func NewSchemaDescriptor(genServiceDesc bool, goref GoRef) *SchemaDescriptor {
|
||||
sd := &SchemaDescriptor{
|
||||
Directives: map[string]*ast.DirectiveDefinition{},
|
||||
reservedNames: map[string]desc.Descriptor{},
|
||||
createdObjects: map[createdObjectKey]*ObjectDescriptor{},
|
||||
generateServiceDescriptors: genServiceDesc,
|
||||
goRef: goref,
|
||||
}
|
||||
for _, name := range graphqlReservedNames {
|
||||
sd.reservedNames[name] = nil
|
||||
}
|
||||
return sd
|
||||
}
|
||||
|
||||
type SchemaDescriptor struct {
|
||||
Directives map[string]*ast.DirectiveDefinition
|
||||
FileDescriptors []*desc.FileDescriptor
|
||||
|
||||
files []*desc.FileDescriptor
|
||||
|
||||
query *RootDefinition
|
||||
mutation *RootDefinition
|
||||
subscription *RootDefinition
|
||||
|
||||
objects []*ObjectDescriptor
|
||||
|
||||
reservedNames map[string]desc.Descriptor
|
||||
createdObjects map[createdObjectKey]*ObjectDescriptor
|
||||
|
||||
generateServiceDescriptors bool
|
||||
|
||||
goRef GoRef
|
||||
}
|
||||
|
||||
type createdObjectKey struct {
|
||||
desc desc.Descriptor
|
||||
input bool
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) AsGraphql() *ast.Schema {
|
||||
queryDef := *s.GetQuery().Definition
|
||||
mutationDef := *s.GetMutation().Definition
|
||||
subscriptionsDef := *s.GetSubscription().Definition
|
||||
schema := &ast.Schema{Types: map[string]*ast.Definition{}, Directives: s.Directives}
|
||||
schema.Query = &queryDef
|
||||
schema.Types["Query"] = &queryDef
|
||||
if s.query.methods == nil {
|
||||
schema.Query.Fields = append(schema.Query.Fields, &ast.FieldDefinition{
|
||||
Name: "dummy",
|
||||
Type: ast.NamedType("Boolean", &ast.Position{}),
|
||||
})
|
||||
}
|
||||
if s.mutation.methods != nil {
|
||||
schema.Mutation = &mutationDef
|
||||
schema.Types["Mutation"] = &mutationDef
|
||||
}
|
||||
if s.subscription.methods != nil {
|
||||
schema.Subscription = &subscriptionsDef
|
||||
schema.Types["Subscription"] = &subscriptionsDef
|
||||
}
|
||||
|
||||
for _, o := range s.objects {
|
||||
def := o.AsGraphql()
|
||||
schema.Types[def.Name] = def
|
||||
}
|
||||
return schema
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) Objects() []*ObjectDescriptor {
|
||||
return s.objects
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) GetMutation() *RootDefinition {
|
||||
if s.mutation == nil {
|
||||
s.mutation = NewRootDefinition(Mutation, s)
|
||||
}
|
||||
return s.mutation
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) GetSubscription() *RootDefinition {
|
||||
if s.subscription == nil {
|
||||
s.subscription = NewRootDefinition(Subscription, s)
|
||||
}
|
||||
return s.subscription
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) GetQuery() *RootDefinition {
|
||||
if s.query == nil {
|
||||
s.query = NewRootDefinition(Query, s)
|
||||
}
|
||||
|
||||
return s.query
|
||||
}
|
||||
|
||||
// make name be unique
|
||||
// just create a map and register every name
|
||||
func (s *SchemaDescriptor) uniqueName(d desc.Descriptor, input bool) (name string) {
|
||||
var collisionPrefix string
|
||||
var suffix string
|
||||
if _, ok := d.(*desc.MessageDescriptor); input && ok {
|
||||
suffix = inputSuffix
|
||||
}
|
||||
name = strings.Title(CamelCaseSlice(strings.Split(strings.TrimPrefix(d.GetFullyQualifiedName(), d.GetFile().GetPackage()+packageSep), packageSep)) + suffix)
|
||||
|
||||
if _, ok := d.(*desc.FieldDescriptor); ok {
|
||||
collisionPrefix = fieldPrefix
|
||||
name = CamelCaseSlice(strings.Split(strings.Trim(d.GetParent().GetName()+packageSep+strings.Title(d.GetName()), packageSep), packageSep))
|
||||
} else {
|
||||
collisionPrefix = CamelCaseSlice(strings.Split(d.GetFile().GetPackage(), packageSep))
|
||||
}
|
||||
|
||||
originalName := name
|
||||
for uniqueSuffix := 0; ; uniqueSuffix++ {
|
||||
d2, ok := s.reservedNames[name]
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
if d2 == d {
|
||||
return name
|
||||
}
|
||||
if uniqueSuffix == 0 {
|
||||
name = collisionPrefix + typeSep + originalName
|
||||
continue
|
||||
}
|
||||
name = collisionPrefix + typeSep + originalName + strconv.Itoa(uniqueSuffix)
|
||||
}
|
||||
|
||||
s.reservedNames[name] = d
|
||||
return
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) CreateObjects(d desc.Descriptor, input bool) (obj *ObjectDescriptor, err error) {
|
||||
// the case if trying to resolve a primitive as a object. In this case we just return nil
|
||||
if d == nil {
|
||||
return
|
||||
}
|
||||
if obj, ok := s.createdObjects[createdObjectKey{d, input}]; ok {
|
||||
return obj, nil
|
||||
}
|
||||
|
||||
obj = &ObjectDescriptor{
|
||||
Definition: &ast.Definition{
|
||||
Description: getDescription(d),
|
||||
Name: s.uniqueName(d, input),
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
Descriptor: d,
|
||||
}
|
||||
|
||||
s.createdObjects[createdObjectKey{d, input}] = obj
|
||||
|
||||
switch dd := d.(type) {
|
||||
case *desc.MessageDescriptor:
|
||||
if IsEmpty(dd) {
|
||||
return obj, nil
|
||||
}
|
||||
if IsAny(dd) {
|
||||
// TODO find a better way to handle any types
|
||||
delete(s.createdObjects, createdObjectKey{d, input})
|
||||
any := s.createScalar(s.uniqueName(dd, false), anyTypeDescription)
|
||||
return any, nil
|
||||
}
|
||||
|
||||
kind := ast.Object
|
||||
if input {
|
||||
kind = ast.InputObject
|
||||
}
|
||||
fields := FieldDescriptorList{}
|
||||
outputOneofRegistrar := map[*desc.OneOfDescriptor]struct{}{}
|
||||
|
||||
for _, df := range dd.GetFields() {
|
||||
fieldOpts := GraphqlFieldOptions(df.AsFieldDescriptorProto().GetOptions())
|
||||
if fieldOpts != nil && fieldOpts.Ignore != nil && *fieldOpts.Ignore {
|
||||
continue
|
||||
}
|
||||
var fieldDirective []*ast.Directive
|
||||
if df.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE && IsEmpty(df.GetMessageType()) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Internally `optional` fields are represented as a oneof, and as such should be skipped.
|
||||
if oneof := df.GetOneOf(); oneof != nil && !df.AsFieldDescriptorProto().GetProto3Optional() {
|
||||
opts := GraphqlOneofOptions(oneof.AsOneofDescriptorProto().GetOptions())
|
||||
if opts.GetIgnore() {
|
||||
continue
|
||||
}
|
||||
if !input {
|
||||
if _, ok := outputOneofRegistrar[oneof]; ok {
|
||||
continue
|
||||
}
|
||||
outputOneofRegistrar[oneof] = struct{}{}
|
||||
field, err := s.createUnion(oneof)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
fields = append(fields, field)
|
||||
continue
|
||||
}
|
||||
|
||||
// create oneofs as directives for input objects
|
||||
directive := &ast.DirectiveDefinition{
|
||||
Description: getDescription(oneof),
|
||||
Name: s.uniqueName(oneof, input),
|
||||
Locations: []ast.DirectiveLocation{ast.LocationInputFieldDefinition},
|
||||
Position: &ast.Position{Src: &ast.Source{}},
|
||||
}
|
||||
s.Directives[directive.Name] = directive
|
||||
fieldDirective = append(fieldDirective, &ast.Directive{
|
||||
Name: directive.Name,
|
||||
Position: &ast.Position{Src: &ast.Source{}},
|
||||
// ParentDefinition: obj.Definition, TODO
|
||||
Definition: directive,
|
||||
Location: ast.LocationInputFieldDefinition,
|
||||
})
|
||||
}
|
||||
|
||||
fieldObj, err := s.CreateObjects(resolveFieldType(df), input)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if fieldObj == nil && df.GetMessageType() != nil {
|
||||
continue
|
||||
}
|
||||
f, err := s.createField(df, fieldObj)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
f.Directives = append(f.Directives, fieldDirective...)
|
||||
fields = append(fields, f)
|
||||
}
|
||||
|
||||
obj.Definition.Fields = fields.AsGraphql()
|
||||
obj.Definition.Kind = kind
|
||||
obj.fields = fields
|
||||
case *desc.EnumDescriptor:
|
||||
obj.Definition.Kind = ast.Enum
|
||||
obj.Definition.EnumValues = enumValues(dd.GetValues())
|
||||
default:
|
||||
panic(fmt.Sprintf("received unexpected value %v of type %T", dd, dd))
|
||||
}
|
||||
|
||||
s.objects = append(s.objects, obj)
|
||||
return obj, nil
|
||||
}
|
||||
|
||||
func resolveFieldType(field *desc.FieldDescriptor) desc.Descriptor {
|
||||
msgType := field.GetMessageType()
|
||||
enumType := field.GetEnumType()
|
||||
if msgType != nil {
|
||||
return msgType
|
||||
}
|
||||
if enumType != nil {
|
||||
return enumType
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func enumValues(evals []*desc.EnumValueDescriptor) (vlist ast.EnumValueList) {
|
||||
for _, eval := range evals {
|
||||
vlist = append(vlist, &ast.EnumValueDefinition{
|
||||
Description: getDescription(eval),
|
||||
Name: eval.GetName(),
|
||||
Position: &ast.Position{},
|
||||
})
|
||||
}
|
||||
|
||||
return vlist
|
||||
}
|
||||
|
||||
type FieldDescriptorList []*FieldDescriptor
|
||||
|
||||
func (fl FieldDescriptorList) AsGraphql() (dl []*ast.FieldDefinition) {
|
||||
for _, f := range fl {
|
||||
dl = append(dl, f.FieldDefinition)
|
||||
}
|
||||
return dl
|
||||
}
|
||||
|
||||
type FieldDescriptor struct {
|
||||
*ast.FieldDefinition
|
||||
*desc.FieldDescriptor
|
||||
|
||||
typ *ObjectDescriptor
|
||||
}
|
||||
|
||||
func (f *FieldDescriptor) GetType() *ObjectDescriptor {
|
||||
return f.typ
|
||||
}
|
||||
|
||||
type MethodDescriptor struct {
|
||||
*desc.ServiceDescriptor
|
||||
*desc.MethodDescriptor
|
||||
|
||||
*ast.FieldDefinition
|
||||
|
||||
input *ObjectDescriptor
|
||||
output *ObjectDescriptor
|
||||
}
|
||||
|
||||
func (m *MethodDescriptor) AsGraphql() *ast.FieldDefinition {
|
||||
return m.FieldDefinition
|
||||
}
|
||||
|
||||
func (m *MethodDescriptor) GetInput() *ObjectDescriptor {
|
||||
return m.input
|
||||
}
|
||||
|
||||
func (m *MethodDescriptor) GetOutput() *ObjectDescriptor {
|
||||
return m.output
|
||||
}
|
||||
|
||||
type RootDefinition struct {
|
||||
*ast.Definition
|
||||
|
||||
Parent *SchemaDescriptor
|
||||
|
||||
methods []*MethodDescriptor
|
||||
reservedNames map[string]ServiceAndMethod
|
||||
}
|
||||
|
||||
type ServiceAndMethod struct {
|
||||
svc *descriptor.ServiceDescriptorProto
|
||||
rpc *descriptor.MethodDescriptorProto
|
||||
}
|
||||
|
||||
func (r *RootDefinition) UniqueName(svc *descriptor.ServiceDescriptorProto, rpc *descriptor.MethodDescriptorProto) (name string) {
|
||||
rpcOpts := GraphqlMethodOptions(rpc.GetOptions())
|
||||
svcOpts := GraphqlServiceOptions(svc.GetOptions())
|
||||
if rpcOpts != nil && rpcOpts.Name != nil {
|
||||
name = *rpcOpts.Name
|
||||
} else if svcOpts != nil && svcOpts.Name != nil {
|
||||
if *svcOpts.Name == "" {
|
||||
name = ToLowerFirst(rpc.GetName())
|
||||
} else {
|
||||
name = *svcOpts.Name + strings.Title(rpc.GetName())
|
||||
}
|
||||
} else {
|
||||
name = ToLowerFirst(svc.GetName()) + strings.Title(rpc.GetName())
|
||||
}
|
||||
|
||||
originalName := name
|
||||
for uniqueSuffix := 0; ; uniqueSuffix++ {
|
||||
snm, ok := r.reservedNames[name]
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
if svc == snm.svc && snm.rpc == rpc {
|
||||
return name
|
||||
}
|
||||
name = originalName + strconv.Itoa(uniqueSuffix)
|
||||
}
|
||||
|
||||
r.reservedNames[name] = ServiceAndMethod{svc, rpc}
|
||||
return
|
||||
}
|
||||
|
||||
func (r *RootDefinition) Methods() []*MethodDescriptor {
|
||||
return r.methods
|
||||
}
|
||||
|
||||
func (r *RootDefinition) addMethod(svc *desc.ServiceDescriptor, rpc *desc.MethodDescriptor, in, out *ObjectDescriptor) {
|
||||
var args ast.ArgumentDefinitionList
|
||||
|
||||
if in != nil && (in.Descriptor != nil && !IsEmpty(in.Descriptor.(*desc.MessageDescriptor)) || in.Definition.Kind == ast.Scalar) {
|
||||
args = append(args, &ast.ArgumentDefinition{
|
||||
Name: "in",
|
||||
Type: ast.NamedType(in.Name, &ast.Position{}),
|
||||
Position: &ast.Position{},
|
||||
})
|
||||
}
|
||||
objType := ast.NamedType("Boolean", &ast.Position{})
|
||||
if out != nil && (out.Descriptor != nil && !IsEmpty(out.Descriptor.(*desc.MessageDescriptor)) || in.Definition.Kind == ast.Scalar) {
|
||||
objType = ast.NamedType(out.Name, &ast.Position{})
|
||||
}
|
||||
|
||||
svcDir := &ast.DirectiveDefinition{
|
||||
Description: getDescription(svc),
|
||||
Name: svc.GetName(),
|
||||
Locations: []ast.DirectiveLocation{ast.LocationFieldDefinition},
|
||||
Position: &ast.Position{Src: &ast.Source{}},
|
||||
}
|
||||
r.Parent.Directives[svcDir.Name] = svcDir
|
||||
|
||||
m := &MethodDescriptor{
|
||||
ServiceDescriptor: svc,
|
||||
MethodDescriptor: rpc,
|
||||
FieldDefinition: &ast.FieldDefinition{
|
||||
Description: getDescription(rpc),
|
||||
Name: r.UniqueName(svc.AsServiceDescriptorProto(), rpc.AsMethodDescriptorProto()),
|
||||
Arguments: args,
|
||||
Type: objType,
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
input: in,
|
||||
output: out,
|
||||
}
|
||||
if r.Parent.generateServiceDescriptors {
|
||||
m.Directives = []*ast.Directive{{
|
||||
Name: svcDir.Name,
|
||||
Position: &ast.Position{},
|
||||
Definition: svcDir,
|
||||
Location: svcDir.Locations[0],
|
||||
}}
|
||||
}
|
||||
|
||||
r.methods = append(r.methods, m)
|
||||
// TODO maybe not do it here?
|
||||
r.Definition.Fields = append(r.Definition.Fields, m.FieldDefinition)
|
||||
}
|
||||
|
||||
type rootName string
|
||||
|
||||
const (
|
||||
Mutation rootName = "Mutation"
|
||||
Query rootName = "Query"
|
||||
Subscription rootName = "Subscription"
|
||||
)
|
||||
|
||||
func NewRootDefinition(name rootName, parent *SchemaDescriptor) *RootDefinition {
|
||||
return &RootDefinition{Definition: &ast.Definition{
|
||||
Kind: ast.Object,
|
||||
Name: string(name),
|
||||
Position: &ast.Position{},
|
||||
}, Parent: parent, reservedNames: map[string]ServiceAndMethod{}}
|
||||
}
|
||||
|
||||
func getDescription(descs ...desc.Descriptor) string {
|
||||
var description []string
|
||||
for _, d := range descs {
|
||||
info := d.GetSourceInfo()
|
||||
if info == nil {
|
||||
continue
|
||||
}
|
||||
if info.LeadingComments != nil {
|
||||
description = append(description, *info.LeadingComments)
|
||||
}
|
||||
if info.TrailingComments != nil {
|
||||
description = append(description, *info.TrailingComments)
|
||||
}
|
||||
}
|
||||
|
||||
return strings.Join(description, "\n")
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) createField(field *desc.FieldDescriptor, obj *ObjectDescriptor) (_ *FieldDescriptor, err error) {
|
||||
fieldAst := &ast.FieldDefinition{
|
||||
Description: getDescription(field),
|
||||
Name: ToLowerFirst(CamelCase(field.GetName())),
|
||||
Type: &ast.Type{Position: &ast.Position{}},
|
||||
Position: &ast.Position{},
|
||||
}
|
||||
fieldOpts := GraphqlFieldOptions(field.AsFieldDescriptorProto().GetOptions())
|
||||
if fieldOpts != nil && fieldOpts.Name != nil {
|
||||
fieldAst.Name = *fieldOpts.Name
|
||||
directive := &ast.DirectiveDefinition{
|
||||
Name: goFieldDirective,
|
||||
Arguments: []*ast.ArgumentDefinition{{
|
||||
Name: "forceResolver",
|
||||
Type: ast.NamedType("Boolean", &ast.Position{}),
|
||||
Position: &ast.Position{},
|
||||
}, {
|
||||
Name: "name",
|
||||
Type: ast.NamedType("String", &ast.Position{}),
|
||||
Position: &ast.Position{},
|
||||
}},
|
||||
Locations: []ast.DirectiveLocation{ast.LocationInputFieldDefinition, ast.LocationFieldDefinition},
|
||||
Position: &ast.Position{Src: &ast.Source{}},
|
||||
}
|
||||
s.Directives[directive.Name] = directive
|
||||
if s.goRef != nil {
|
||||
fieldAst.Directives = []*ast.Directive{{
|
||||
Name: directive.Name,
|
||||
Arguments: []*ast.Argument{{
|
||||
Name: "name",
|
||||
Value: &ast.Value{
|
||||
Raw: s.goRef.FindGoField(field.GetFullyQualifiedName()).GoName,
|
||||
Kind: ast.StringValue,
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
Position: &ast.Position{},
|
||||
}},
|
||||
Position: &ast.Position{},
|
||||
// ParentDefinition: nil, TODO
|
||||
Definition: directive,
|
||||
}}
|
||||
}
|
||||
}
|
||||
switch field.GetType() {
|
||||
case descriptor.FieldDescriptorProto_TYPE_DOUBLE,
|
||||
descriptor.FieldDescriptorProto_TYPE_FLOAT:
|
||||
fieldAst.Type.NamedType = ScalarFloat
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_BYTES:
|
||||
scalar := s.createScalar(scalarBytes, "")
|
||||
fieldAst.Type.NamedType = scalar.Name
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_INT64,
|
||||
descriptor.FieldDescriptorProto_TYPE_SINT64,
|
||||
descriptor.FieldDescriptorProto_TYPE_SFIXED64,
|
||||
descriptor.FieldDescriptorProto_TYPE_INT32,
|
||||
descriptor.FieldDescriptorProto_TYPE_SINT32,
|
||||
descriptor.FieldDescriptorProto_TYPE_SFIXED32,
|
||||
descriptor.FieldDescriptorProto_TYPE_UINT32,
|
||||
descriptor.FieldDescriptorProto_TYPE_FIXED32,
|
||||
descriptor.FieldDescriptorProto_TYPE_UINT64,
|
||||
descriptor.FieldDescriptorProto_TYPE_FIXED64:
|
||||
fieldAst.Type.NamedType = ScalarInt
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_BOOL:
|
||||
fieldAst.Type.NamedType = ScalarBoolean
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_STRING:
|
||||
fieldAst.Type.NamedType = ScalarString
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_GROUP:
|
||||
return nil, fmt.Errorf("proto2 groups are not supported please use proto3 syntax")
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_ENUM:
|
||||
fieldAst.Type.NamedType = obj.Name
|
||||
|
||||
case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
|
||||
fieldAst.Type.NamedType = obj.Name
|
||||
|
||||
default:
|
||||
panic("unknown proto field type")
|
||||
}
|
||||
|
||||
if isRepeated(field) {
|
||||
fieldAst.Type = ast.ListType(fieldAst.Type, &ast.Position{})
|
||||
fieldAst.Type.Elem.NonNull = true
|
||||
}
|
||||
if isRequired(field) {
|
||||
fieldAst.Type.NonNull = true
|
||||
}
|
||||
|
||||
return &FieldDescriptor{
|
||||
FieldDefinition: fieldAst,
|
||||
FieldDescriptor: field,
|
||||
typ: obj,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) createScalar(name string, description string) *ObjectDescriptor {
|
||||
obj := &ObjectDescriptor{
|
||||
Definition: &ast.Definition{
|
||||
Kind: ast.Scalar,
|
||||
Description: description,
|
||||
Name: name,
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
}
|
||||
s.objects = append(s.objects, obj)
|
||||
return obj
|
||||
}
|
||||
|
||||
func (s *SchemaDescriptor) createUnion(oneof *desc.OneOfDescriptor) (*FieldDescriptor, error) {
|
||||
var types []string
|
||||
var objTypes []*ObjectDescriptor
|
||||
for _, choice := range oneof.GetChoices() {
|
||||
obj, err := s.CreateObjects(resolveFieldType(choice), false)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
f, err := s.createField(choice, obj)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
obj = &ObjectDescriptor{
|
||||
Definition: &ast.Definition{
|
||||
Kind: ast.Object,
|
||||
Description: getDescription(f),
|
||||
Name: s.uniqueName(choice, false),
|
||||
Fields: ast.FieldList{f.FieldDefinition},
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
Descriptor: f,
|
||||
fields: []*FieldDescriptor{f},
|
||||
fieldNames: map[string]*FieldDescriptor{},
|
||||
}
|
||||
s.objects = append(s.objects, obj)
|
||||
types = append(types, obj.Name)
|
||||
objTypes = append(objTypes, obj)
|
||||
}
|
||||
obj := &ObjectDescriptor{
|
||||
Definition: &ast.Definition{
|
||||
Kind: ast.Union,
|
||||
Description: getDescription(oneof),
|
||||
Name: s.uniqueName(oneof, false),
|
||||
Types: types,
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
Descriptor: oneof,
|
||||
types: objTypes,
|
||||
}
|
||||
s.objects = append(s.objects, obj)
|
||||
name := ToLowerFirst(CamelCase(oneof.GetName()))
|
||||
opts := GraphqlOneofOptions(oneof.AsOneofDescriptorProto().GetOptions())
|
||||
if opts.GetName() != "" {
|
||||
name = opts.GetName()
|
||||
}
|
||||
return &FieldDescriptor{
|
||||
FieldDefinition: &ast.FieldDefinition{
|
||||
Description: getDescription(oneof),
|
||||
Name: name,
|
||||
Type: ast.NamedType(obj.Name, &ast.Position{}),
|
||||
Position: &ast.Position{},
|
||||
},
|
||||
FieldDescriptor: nil,
|
||||
typ: obj,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func isRepeated(field *desc.FieldDescriptor) bool {
|
||||
return field.GetLabel() == descriptor.FieldDescriptorProto_LABEL_REPEATED
|
||||
}
|
||||
|
||||
func isRequired(field *desc.FieldDescriptor) bool {
|
||||
if v := GraphqlFieldOptions(field.AsFieldDescriptorProto().GetOptions()); v != nil {
|
||||
return v.GetRequired()
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
const (
|
||||
ScalarInt = "Int"
|
||||
ScalarFloat = "Float"
|
||||
ScalarString = "String"
|
||||
ScalarBoolean = "Boolean"
|
||||
ScalarID = "ID"
|
||||
)
|
||||
|
||||
var graphqlReservedNames = []string{"__Directive", "__Type", "__Field", "__EnumValue", "__InputValue", "__Schema", "Int", "Float", "String", "Boolean", "ID"}
|
30
graphql/goreference.go
Normal file
30
graphql/goreference.go
Normal file
@ -0,0 +1,30 @@
|
||||
package generator
|
||||
|
||||
import (
|
||||
"google.golang.org/protobuf/compiler/protogen"
|
||||
)
|
||||
|
||||
type GoRef interface {
|
||||
FindGoField(field string) *protogen.Field
|
||||
}
|
||||
|
||||
func NewGoRef(p *protogen.Plugin) (GoRef, error) {
|
||||
return goRef{p}, nil
|
||||
}
|
||||
|
||||
type goRef struct {
|
||||
*protogen.Plugin
|
||||
}
|
||||
|
||||
func (g goRef) FindGoField(field string) *protogen.Field {
|
||||
for _, file := range g.Files {
|
||||
for _, msg := range file.Messages {
|
||||
for _, f := range msg.Fields {
|
||||
if string(f.Desc.FullName()) == field {
|
||||
return f
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
139
graphql/registry.go
Normal file
139
graphql/registry.go
Normal file
@ -0,0 +1,139 @@
|
||||
package generator
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
"github.com/jhump/protoreflect/desc"
|
||||
"github.com/vektah/gqlparser/v2/ast"
|
||||
)
|
||||
|
||||
type Registry interface {
|
||||
FindMethodByName(op ast.Operation, name string) *desc.MethodDescriptor
|
||||
FindObjectByName(name string) *desc.MessageDescriptor
|
||||
|
||||
// FindObjectByFullyQualifiedName TODO maybe find a better way to get ast definition
|
||||
FindObjectByFullyQualifiedName(fqn string) (*desc.MessageDescriptor, *ast.Definition)
|
||||
|
||||
// FindFieldByName given the proto Descriptor and the graphql field name get the the proto FieldDescriptor
|
||||
FindFieldByName(msg desc.Descriptor, name string) *desc.FieldDescriptor
|
||||
|
||||
// FindUnionFieldByMessageFQNAndName given the proto Descriptor and the graphql field name get the the proto FieldDescriptor
|
||||
FindUnionFieldByMessageFQNAndName(fqn, name string) *desc.FieldDescriptor
|
||||
|
||||
FindGraphqlFieldByProtoField(msg *ast.Definition, name string) *ast.FieldDefinition
|
||||
}
|
||||
|
||||
func NewRegistry(files SchemaDescriptorList) Registry {
|
||||
v := &repository{
|
||||
mu: &sync.RWMutex{},
|
||||
methodsByName: map[ast.Operation]map[string]*desc.MethodDescriptor{},
|
||||
objectsByName: map[string]*desc.MessageDescriptor{},
|
||||
objectsByFQN: map[string]*ObjectDescriptor{},
|
||||
graphqlFieldsByName: map[desc.Descriptor]map[string]*desc.FieldDescriptor{},
|
||||
graphqlUnionFieldsByName: map[string]map[string]*desc.FieldDescriptor{},
|
||||
protoFieldsByName: map[*ast.Definition]map[string]*ast.FieldDefinition{},
|
||||
}
|
||||
for _, f := range files {
|
||||
v.methodsByName[ast.Mutation] = map[string]*desc.MethodDescriptor{}
|
||||
for _, m := range f.GetMutation().Methods() {
|
||||
v.methodsByName[ast.Mutation][m.Name] = m.MethodDescriptor
|
||||
}
|
||||
v.methodsByName[ast.Query] = map[string]*desc.MethodDescriptor{}
|
||||
for _, m := range f.GetQuery().Methods() {
|
||||
v.methodsByName[ast.Query][m.Name] = m.MethodDescriptor
|
||||
}
|
||||
v.methodsByName[ast.Subscription] = map[string]*desc.MethodDescriptor{}
|
||||
for _, m := range f.GetSubscription().Methods() {
|
||||
v.methodsByName[ast.Subscription][m.Name] = m.MethodDescriptor
|
||||
}
|
||||
}
|
||||
for _, f := range files {
|
||||
for _, m := range f.Objects() {
|
||||
switch m.Kind {
|
||||
case ast.Union:
|
||||
fqn := m.Descriptor.GetParent().GetFullyQualifiedName()
|
||||
if _, ok := v.graphqlUnionFieldsByName[fqn]; !ok {
|
||||
v.graphqlUnionFieldsByName[fqn] = map[string]*desc.FieldDescriptor{}
|
||||
}
|
||||
for _, tt := range m.GetTypes() {
|
||||
for _, f := range tt.GetFields() {
|
||||
v.graphqlUnionFieldsByName[fqn][f.Name] = f.FieldDescriptor
|
||||
}
|
||||
}
|
||||
case ast.Object:
|
||||
v.protoFieldsByName[m.Definition] = map[string]*ast.FieldDefinition{}
|
||||
for _, f := range m.GetFields() {
|
||||
if f.FieldDescriptor != nil {
|
||||
v.protoFieldsByName[m.Definition][f.FieldDescriptor.GetName()] = f.FieldDefinition
|
||||
}
|
||||
}
|
||||
case ast.InputObject:
|
||||
v.graphqlFieldsByName[m.Descriptor] = map[string]*desc.FieldDescriptor{}
|
||||
for _, f := range m.GetFields() {
|
||||
v.graphqlFieldsByName[m.Descriptor][f.Name] = f.FieldDescriptor
|
||||
}
|
||||
}
|
||||
switch msgDesc := m.Descriptor.(type) {
|
||||
case *desc.MessageDescriptor:
|
||||
v.objectsByFQN[m.GetFullyQualifiedName()] = m
|
||||
v.objectsByName[m.Name] = msgDesc
|
||||
}
|
||||
}
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
type repository struct {
|
||||
files SchemaDescriptorList
|
||||
mu *sync.RWMutex
|
||||
|
||||
methodsByName map[ast.Operation]map[string]*desc.MethodDescriptor
|
||||
objectsByName map[string]*desc.MessageDescriptor
|
||||
objectsByFQN map[string]*ObjectDescriptor
|
||||
graphqlFieldsByName map[desc.Descriptor]map[string]*desc.FieldDescriptor
|
||||
protoFieldsByName map[*ast.Definition]map[string]*ast.FieldDefinition
|
||||
graphqlUnionFieldsByName map[string]map[string]*desc.FieldDescriptor
|
||||
}
|
||||
|
||||
func (r repository) FindMethodByName(op ast.Operation, name string) *desc.MethodDescriptor {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
m, _ := r.methodsByName[op][name]
|
||||
return m
|
||||
}
|
||||
|
||||
func (r repository) FindObjectByName(name string) *desc.MessageDescriptor {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
o, _ := r.objectsByName[name]
|
||||
return o
|
||||
}
|
||||
|
||||
func (r repository) FindObjectByFullyQualifiedName(fqn string) (*desc.MessageDescriptor, *ast.Definition) {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
o, _ := r.objectsByFQN[fqn]
|
||||
msg, _ := o.Descriptor.(*desc.MessageDescriptor)
|
||||
return msg, o.Definition
|
||||
}
|
||||
|
||||
func (r repository) FindFieldByName(msg desc.Descriptor, name string) *desc.FieldDescriptor {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
f, _ := r.graphqlFieldsByName[msg][name]
|
||||
return f
|
||||
}
|
||||
|
||||
func (r repository) FindUnionFieldByMessageFQNAndName(fqn, name string) *desc.FieldDescriptor {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
f, _ := r.graphqlUnionFieldsByName[fqn][name]
|
||||
return f
|
||||
}
|
||||
|
||||
func (r repository) FindGraphqlFieldByProtoField(msg *ast.Definition, name string) *ast.FieldDefinition {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
f, _ := r.protoFieldsByName[msg][name]
|
||||
return f
|
||||
}
|
291
graphql/utils.go
Normal file
291
graphql/utils.go
Normal file
@ -0,0 +1,291 @@
|
||||
package generator
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/jhump/protoreflect/desc"
|
||||
"google.golang.org/protobuf/proto"
|
||||
descriptor "google.golang.org/protobuf/types/descriptorpb"
|
||||
"google.golang.org/protobuf/types/pluginpb"
|
||||
|
||||
gqlpb "go.unistack.org/micro-proto/v3/graphql"
|
||||
)
|
||||
|
||||
func GraphqlMethodOptions(opts proto.Message) *gqlpb.Rpc {
|
||||
if opts != nil {
|
||||
v := proto.GetExtension(opts, gqlpb.E_Rpc)
|
||||
if v != nil {
|
||||
return v.(*gqlpb.Rpc)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func GraphqlServiceOptions(opts proto.Message) *gqlpb.Svc {
|
||||
if opts != nil {
|
||||
v := proto.GetExtension(opts, gqlpb.E_Svc)
|
||||
if v != nil {
|
||||
return v.(*gqlpb.Svc)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func GraphqlFieldOptions(opts proto.Message) *gqlpb.Field {
|
||||
if opts != nil {
|
||||
v := proto.GetExtension(opts, gqlpb.E_Field)
|
||||
if v != nil && v.(*gqlpb.Field) != nil {
|
||||
return v.(*gqlpb.Field)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func GraphqlOneofOptions(opts proto.Message) *gqlpb.Oneof {
|
||||
if opts != nil {
|
||||
v := proto.GetExtension(opts, gqlpb.E_Oneof)
|
||||
if v != nil && v.(*gqlpb.Oneof) != nil {
|
||||
return v.(*gqlpb.Oneof)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GoCamelCase camel-cases a protobuf name for use as a Go identifier.
|
||||
//
|
||||
// If there is an interior underscore followed by a lower case letter,
|
||||
// drop the underscore and convert the letter to upper case.
|
||||
func GoCamelCase(s string) string {
|
||||
// Invariant: if the next letter is lower case, it must be converted
|
||||
// to upper case.
|
||||
// That is, we process a word at a time, where words are marked by _ or
|
||||
// upper case letter. Digits are treated as words.
|
||||
var b []byte
|
||||
for i := 0; i < len(s); i++ {
|
||||
c := s[i]
|
||||
switch {
|
||||
case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
|
||||
// Skip over '.' in ".{{lowercase}}".
|
||||
case c == '.':
|
||||
b = append(b, '_') // convert '.' to '_'
|
||||
case c == '_' && (i == 0 || s[i-1] == '.'):
|
||||
// Convert initial '_' to ensure we start with a capital letter.
|
||||
// Do the same for '_' after '.' to match historic behavior.
|
||||
b = append(b, 'X') // convert '_' to 'X'
|
||||
case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
|
||||
// Skip over '_' in "_{{lowercase}}".
|
||||
case isASCIIDigit(c):
|
||||
b = append(b, c)
|
||||
default:
|
||||
// Assume we have a letter now - if not, it's a bogus identifier.
|
||||
// The next word is a sequence of characters that must start upper case.
|
||||
if isASCIILower(c) {
|
||||
c -= 'a' - 'A' // convert lowercase to uppercase
|
||||
}
|
||||
b = append(b, c)
|
||||
|
||||
// Accept lower case sequence that follows.
|
||||
for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
|
||||
b = append(b, s[i+1])
|
||||
}
|
||||
}
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
func GetRequestType(rpcOpts *gqlpb.Rpc, svcOpts *gqlpb.Svc) gqlpb.Type {
|
||||
if rpcOpts != nil && rpcOpts.Type != nil {
|
||||
return *rpcOpts.Type
|
||||
}
|
||||
if svcOpts != nil && svcOpts.Type != nil {
|
||||
return *svcOpts.Type
|
||||
}
|
||||
return gqlpb.Type_DEFAULT
|
||||
}
|
||||
|
||||
func CreateDescriptorsFromProto(req *pluginpb.CodeGeneratorRequest) (descs []*desc.FileDescriptor, err error) {
|
||||
dd, err := desc.CreateFileDescriptorsFromSet(&descriptor.FileDescriptorSet{
|
||||
File: req.GetProtoFile(),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, d := range dd {
|
||||
for _, filename := range req.FileToGenerate {
|
||||
if filename == d.GetName() {
|
||||
descs = append(descs, d)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func ResolveProtoFilesRecursively(descs []*desc.FileDescriptor) (files FileDescriptors) {
|
||||
for _, f := range descs {
|
||||
files = append(files, ResolveProtoFilesRecursively(f.GetDependencies())...)
|
||||
files = append(files, f)
|
||||
}
|
||||
|
||||
return files
|
||||
}
|
||||
|
||||
type FileDescriptors []*desc.FileDescriptor
|
||||
|
||||
func (ds FileDescriptors) AsFileDescriptorProto() (files []*descriptor.FileDescriptorProto) {
|
||||
for _, d := range ds {
|
||||
files = append(files, d.AsFileDescriptorProto())
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Split splits the camelcase word and returns a list of words. It also
|
||||
// supports digits. Both lower camel case and upper camel case are supported.
|
||||
// For more info please check: http://en.wikipedia.org/wiki/CamelCase
|
||||
//
|
||||
// Examples
|
||||
//
|
||||
// "" => [""]
|
||||
// "lowercase" => ["lowercase"]
|
||||
// "Class" => ["Class"]
|
||||
// "MyClass" => ["My", "Class"]
|
||||
// "MyC" => ["My", "C"]
|
||||
// "HTML" => ["HTML"]
|
||||
// "PDFLoader" => ["PDF", "Loader"]
|
||||
// "AString" => ["A", "String"]
|
||||
// "SimpleXMLParser" => ["Simple", "XML", "Parser"]
|
||||
// "vimRPCPlugin" => ["vim", "RPC", "Plugin"]
|
||||
// "GL11Version" => ["GL", "11", "Version"]
|
||||
// "99Bottles" => ["99", "Bottles"]
|
||||
// "May5" => ["May", "5"]
|
||||
// "BFG9000" => ["BFG", "9000"]
|
||||
// "BöseÜberraschung" => ["Böse", "Überraschung"]
|
||||
// "Two spaces" => ["Two", " ", "spaces"]
|
||||
// "BadUTF8\xe2\xe2\xa1" => ["BadUTF8\xe2\xe2\xa1"]
|
||||
//
|
||||
// Splitting rules
|
||||
//
|
||||
// 1. If string is not valid UTF-8, return it without splitting as
|
||||
// single item array.
|
||||
// 2. Assign all unicode characters into one of 4 sets: lower case
|
||||
// letters, upper case letters, numbers, and all other characters.
|
||||
// 3. Iterate through characters of string, introducing splits
|
||||
// between adjacent characters that belong to different sets.
|
||||
// 4. Iterate through array of split strings, and if a given string
|
||||
// is upper case:
|
||||
// if subsequent string is lower case:
|
||||
// move last character of upper case string to beginning of
|
||||
// lower case string
|
||||
func SplitCamelCase(src string) (entries []string) {
|
||||
// don't split invalid utf8
|
||||
if !utf8.ValidString(src) {
|
||||
return []string{src}
|
||||
}
|
||||
entries = []string{}
|
||||
var runes [][]rune
|
||||
lastClass := 0
|
||||
class := 0
|
||||
// split into fields based on class of unicode character
|
||||
for _, r := range src {
|
||||
switch true {
|
||||
case unicode.IsLower(r):
|
||||
class = 1
|
||||
case unicode.IsUpper(r):
|
||||
class = 2
|
||||
case unicode.IsDigit(r):
|
||||
class = 3
|
||||
default:
|
||||
class = 4
|
||||
}
|
||||
if class == lastClass {
|
||||
runes[len(runes)-1] = append(runes[len(runes)-1], r)
|
||||
} else {
|
||||
runes = append(runes, []rune{r})
|
||||
}
|
||||
lastClass = class
|
||||
}
|
||||
// handle upper case -> lower case sequences, e.g.
|
||||
// "PDFL", "oader" -> "PDF", "Loader"
|
||||
for i := 0; i < len(runes)-1; i++ {
|
||||
if unicode.IsUpper(runes[i][0]) && unicode.IsLower(runes[i+1][0]) {
|
||||
runes[i+1] = append([]rune{runes[i][len(runes[i])-1]}, runes[i+1]...)
|
||||
runes[i] = runes[i][:len(runes[i])-1]
|
||||
}
|
||||
}
|
||||
// construct []string from results
|
||||
for _, s := range runes {
|
||||
if len(s) > 0 {
|
||||
entries = append(entries, string(s))
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// CamelCase returns the CamelCased name.
|
||||
// If there is an interior underscore followed by a lower case letter,
|
||||
// drop the underscore and convert the letter to upper case.
|
||||
// There is a remote possibility of this rewrite causing a name collision,
|
||||
// but it's so remote we're prepared to pretend it's nonexistent - since the
|
||||
// C++ generator lowercases names, it's extremely unlikely to have two fields
|
||||
// with different capitalizations.
|
||||
// In short, _my_field_name_2 becomes XMyFieldName_2.
|
||||
func CamelCase(s string) string {
|
||||
if s == "" {
|
||||
return ""
|
||||
}
|
||||
t := make([]byte, 0, 32)
|
||||
i := 0
|
||||
if s[0] == '_' {
|
||||
// Need a capital letter; drop the '_'.
|
||||
t = append(t, 'X')
|
||||
i++
|
||||
}
|
||||
// Invariant: if the next letter is lower case, it must be converted
|
||||
// to upper case.
|
||||
// That is, we process a word at a time, where words are marked by _ or
|
||||
// upper case letter. Digits are treated as words.
|
||||
for ; i < len(s); i++ {
|
||||
c := s[i]
|
||||
if c == '_' && i+1 < len(s) && isASCIILower(s[i+1]) {
|
||||
continue // Skip the underscore in s.
|
||||
}
|
||||
if isASCIIDigit(c) {
|
||||
t = append(t, c)
|
||||
continue
|
||||
}
|
||||
// Assume we have a letter now - if not, it's a bogus identifier.
|
||||
// The next word is a sequence of characters that must start upper case.
|
||||
if isASCIILower(c) {
|
||||
c ^= ' ' // Make it a capital letter.
|
||||
}
|
||||
t = append(t, c) // Guaranteed not lower case.
|
||||
// Accept lower case sequence that follows.
|
||||
for i+1 < len(s) && isASCIILower(s[i+1]) {
|
||||
i++
|
||||
t = append(t, s[i])
|
||||
}
|
||||
}
|
||||
return string(t)
|
||||
}
|
||||
|
||||
// CamelCaseSlice is like CamelCase, but the argument is a slice of strings to
|
||||
// be joined with "_".
|
||||
func CamelCaseSlice(elem []string) string { return CamelCase(strings.Join(elem, "_")) }
|
||||
|
||||
// Is c an ASCII lower-case letter?
|
||||
func isASCIILower(c byte) bool {
|
||||
return 'a' <= c && c <= 'z'
|
||||
}
|
||||
|
||||
// Is c an ASCII digit?
|
||||
func isASCIIDigit(c byte) bool {
|
||||
return '0' <= c && c <= '9'
|
||||
}
|
||||
|
||||
func ToLowerFirst(s string) string {
|
||||
if len(s) > 0 {
|
||||
return string(unicode.ToLower(rune(s[0]))) + s[1:]
|
||||
}
|
||||
return ""
|
||||
}
|
23
graphqls.go
23
graphqls.go
@ -3,12 +3,9 @@ package main
|
||||
import (
|
||||
"bytes"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/danielvladco/go-proto-gql/pkg/generator"
|
||||
"github.com/vektah/gqlparser/v2/formatter"
|
||||
generator "go.unistack.org/protoc-gen-go-micro/v3/graphql"
|
||||
"google.golang.org/protobuf/compiler/protogen"
|
||||
"google.golang.org/protobuf/proto"
|
||||
"google.golang.org/protobuf/types/pluginpb"
|
||||
@ -20,7 +17,7 @@ func (g *Generator) graphqlsGenerate(plugin *protogen.Plugin) error {
|
||||
return err
|
||||
}
|
||||
|
||||
gqlDesc, err := generator.NewSchemas(descs, true, true, plugin)
|
||||
gqlDesc, err := generator.NewSchemas(descs, false, false, plugin)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@ -30,10 +27,9 @@ func (g *Generator) graphqlsGenerate(plugin *protogen.Plugin) error {
|
||||
for _, schema := range gqlDesc {
|
||||
buf := &bytes.Buffer{}
|
||||
formatter.NewFormatter(buf).FormatSchema(schema.AsGraphql())
|
||||
protoFileName := schema.FileDescriptors[0].GetName()
|
||||
|
||||
outFiles = append(outFiles, &pluginpb.CodeGeneratorResponse_File{
|
||||
Name: proto.String(resolveGraphqlFilename(protoFileName)),
|
||||
Name: proto.String(g.graphqlFile),
|
||||
Content: proto.String(buf.String()),
|
||||
})
|
||||
}
|
||||
@ -58,16 +54,3 @@ func (g *Generator) graphqlsGenerate(plugin *protogen.Plugin) error {
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func resolveGraphqlFilename(protoFileName string) string {
|
||||
gqlFileName := "schema." + "graphqls"
|
||||
absProtoFileName, err := filepath.Abs(protoFileName)
|
||||
if err == nil {
|
||||
protoDirSlice := strings.Split(filepath.Dir(absProtoFileName), string(filepath.Separator))
|
||||
if len(protoDirSlice) > 0 {
|
||||
gqlFileName = protoDirSlice[len(protoDirSlice)-1] + "." + "graphqls"
|
||||
}
|
||||
}
|
||||
protoDir, _ := path.Split(protoFileName)
|
||||
return path.Join(protoDir, gqlFileName)
|
||||
}
|
||||
|
6
main.go
6
main.go
@ -18,7 +18,7 @@ var (
|
||||
flagComponents = flagSet.String("components", "micro|rpc|http|client|server|openapiv3|graphql", "specify components to generate")
|
||||
flagTagPath = flagSet.String("tag_path", "", "tag rewriting dir")
|
||||
flagOpenapiFile = flagSet.String("openapi_file", "apidocs.swagger.yaml", "openapi file name")
|
||||
flagGraphqlFile = flagSet.String("openapi_file", "schema.graphqls", "graphql file name")
|
||||
flagGraphqlFile = flagSet.String("graphql_file", "schema.graphqls", "graphql file name")
|
||||
flagReflection = flagSet.Bool("reflection", false, "enable server reflection support")
|
||||
flagHelp = flagSet.Bool("help", false, "display help message")
|
||||
)
|
||||
@ -47,6 +47,7 @@ type Generator struct {
|
||||
fieldaligment bool
|
||||
tagPath string
|
||||
openapiFile string
|
||||
graphqlFile string
|
||||
reflection bool
|
||||
plugin *protogen.Plugin
|
||||
}
|
||||
@ -61,6 +62,7 @@ func (g *Generator) Generate(plugin *protogen.Plugin) error {
|
||||
g.fieldaligment = *flagFieldaligment
|
||||
g.tagPath = *flagTagPath
|
||||
g.openapiFile = *flagOpenapiFile
|
||||
g.graphqlFile = *flagGraphqlFile
|
||||
g.reflection = *flagReflection
|
||||
plugin.SupportedFeatures = uint64(pluginpb.CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL)
|
||||
|
||||
@ -106,6 +108,8 @@ func (g *Generator) Generate(plugin *protogen.Plugin) error {
|
||||
err = g.openapiv3Generate(plugin)
|
||||
case "graphqls":
|
||||
err = g.graphqlsGenerate(plugin)
|
||||
case "graphql":
|
||||
err = g.graphqlGenerate(plugin)
|
||||
case "none":
|
||||
break
|
||||
default:
|
||||
|
Loading…
x
Reference in New Issue
Block a user