From 20fcabe5b7a0237ae5a1b8d76e6d0b27e65dd614 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E4=BC=9F=E4=B9=90?= Date: Thu, 31 Aug 2023 14:23:31 +0800 Subject: [PATCH] x --- Makefile | 2 +- api/user.ts | 17 +-- api/user_http.pb.go | 12 +- cmd/gin-kit/main.go | 10 ++ cmd/kit/main.go | 11 ++ cmd/ts/main.go | 16 ++- proto/buf.gen.yaml | 2 +- proto/v1/user.pb.go | 221 ++++++++++++++++++++++++++++++++ proto/v1/user.pb.validate.go | 239 +++++++++++++++++++++++++++++++++++ proto/v1/user.ts | 15 +++ proto/v1/user_grpc.pb.go | 109 ++++++++++++++++ proto/v1/user_http.pb.go | 14 ++ user.ts | 15 +++ 13 files changed, 664 insertions(+), 19 deletions(-) create mode 100644 proto/v1/user.pb.go create mode 100644 proto/v1/user.pb.validate.go create mode 100644 proto/v1/user.ts create mode 100644 proto/v1/user_grpc.pb.go create mode 100644 proto/v1/user_http.pb.go create mode 100644 user.ts diff --git a/Makefile b/Makefile index 6f036ce..47cb7d3 100644 --- a/Makefile +++ b/Makefile @@ -15,6 +15,6 @@ testts: make ts gen: #protoc -I ./third_party -I ./proto --ts_out=./api --go_out=./api --go-grpc_out=./api --kit_out=./api --gin-kit_out=./api --validate_out="lang=go:./api" ./proto/*.proto - protoc -I ./third_party -I ./proto --ts_out=./api --go_out=./api --go-grpc_out=./api --kit_out=./api --validate_out="lang=go:./api" ./proto/*.proto + protoc -I ./third_party -I ./proto --ts_out=prefix=/api/v1/sendmail:./api --go_out=./api --go-grpc_out=./api --kit_out=./api --validate_out="lang=go:./api" ./proto/*.proto auth: protoc --go_out=. ./third_party/auth/auth.proto \ No newline at end of file diff --git a/api/user.ts b/api/user.ts index cb74f26..97785b0 100644 --- a/api/user.ts +++ b/api/user.ts @@ -1,8 +1,9 @@ +// http.prefix:/api/v1/sendmail // @ts-ignore import {Config,http} from "./http"; export interface request { - user_id: string - user_password: string + userId: number + userPassword: string } export interface response { @@ -12,21 +13,21 @@ export interface response { export class userService{ static async list(data :request, param?: Partial>):Promise{ - return http('/api/v1/user/list', { + return http('/api/v1/sendmail/api/v1/user/list', { ...param, data: data, method:'GET' }) } static async all(data :request, param?: Partial>):Promise{ - return http('/api/v1/user/all', { + return http('/api/v1/sendmail/api/v1/user/all', { ...param, data: data, method:'GET' }) } static async auto(data :request, param?: Partial>):Promise{ - return http('/api/v1/user/auto', { + return http('/api/v1/sendmail/api/v1/user/auto', { ...param, data: data, method:'GET' @@ -34,7 +35,7 @@ export class userService{ } //有 "user:list" static async loginWithList(data :request, param?: Partial>):Promise{ - return http('/api/v1/user/login_list', { + return http('/api/v1/sendmail/api/v1/user/login_list', { ...param, data: data, method:'GET' @@ -42,14 +43,14 @@ export class userService{ } // 没有 "user:list" 权限 static async login(data :request, param?: Partial>):Promise{ - return http('/api/v1/user/login', { + return http('/api/v1/sendmail/api/v1/user/login', { ...param, data: data, method:'GET' }) } static async login1(data :request, param?: Partial>):Promise{ - return http('/api/v1/user/login1', { + return http('/api/v1/sendmail/api/v1/user/login1', { ...param, data: data, method:'POST' diff --git a/api/user_http.pb.go b/api/user_http.pb.go index e8946e6..7eeee46 100644 --- a/api/user_http.pb.go +++ b/api/user_http.pb.go @@ -17,12 +17,12 @@ type UserHTTPServer interface { func RegisterUserHTTPServer(s *http.Server, srv UserServer) { r := s.Route("/") - r.GET("/api/v1/user/list", _User_List0_HTTP_Handler(srv)) - r.GET("/api/v1/user/all", _User_All0_HTTP_Handler(srv)) - r.GET("/api/v1/user/auto", _User_Auto0_HTTP_Handler(srv)) - r.GET("/api/v1/user/login_list", _User_LoginWithList0_HTTP_Handler(srv)) - r.GET("/api/v1/user/login", _User_Login0_HTTP_Handler(srv)) - r.POST("/api/v1/user/login1", _User_Login10_HTTP_Handler(srv)) + r.GET("//api/v1/user/list", _User_List0_HTTP_Handler(srv)) + r.GET("//api/v1/user/all", _User_All0_HTTP_Handler(srv)) + r.GET("//api/v1/user/auto", _User_Auto0_HTTP_Handler(srv)) + r.GET("//api/v1/user/login_list", _User_LoginWithList0_HTTP_Handler(srv)) + r.GET("//api/v1/user/login", _User_Login0_HTTP_Handler(srv)) + r.POST("//api/v1/user/login1", _User_Login10_HTTP_Handler(srv)) } func _User_List0_HTTP_Handler(srv UserHTTPServer) func(ctx http.Context) error { return func(ctx http.Context) error { diff --git a/cmd/gin-kit/main.go b/cmd/gin-kit/main.go index f0fb73c..12fcbe7 100644 --- a/cmd/gin-kit/main.go +++ b/cmd/gin-kit/main.go @@ -1,6 +1,7 @@ package main import ( + "flag" "fmt" protogen2 "git.diulo.com/mogfee/kit/protogen" "google.golang.org/protobuf/compiler/protogen" @@ -12,10 +13,16 @@ func main() { u := &Kit{ imports: map[string]string{}, } + var flags flag.FlagSet + flags.StringVar(&u.Prefix, "prefix", "", "API path prefix") + protogen.Options{ + ParamFunc: flags.Set, + }.Run(u.Generate) protogen.Options{}.Run(u.Generate) } type Kit struct { + Prefix string imports map[string]string } @@ -61,6 +68,9 @@ func (u *Kit) Generate(plugin *protogen.Plugin) error { if method == "" { continue } + if u.Prefix != "" { + path = u.Prefix + path + } t.P(`app.`, method, `("`, path, `",http`, m.GoName, `Handler(srv,m...))`) } t.P(`}`) diff --git a/cmd/kit/main.go b/cmd/kit/main.go index 4f135e7..3a11d56 100644 --- a/cmd/kit/main.go +++ b/cmd/kit/main.go @@ -1,6 +1,7 @@ package main import ( + "flag" "fmt" protogen2 "git.diulo.com/mogfee/kit/protogen" "google.golang.org/protobuf/compiler/protogen" @@ -12,11 +13,18 @@ func main() { u := &Kit{ imports: map[string]string{}, } + var flags flag.FlagSet + flags.StringVar(&u.Prefix, "prefix", "", "API path prefix") + protogen.Options{ + ParamFunc: flags.Set, + }.Run(u.Generate) + protogen.Options{}.Run(u.Generate) } type Kit struct { imports map[string]string + Prefix string } func (u *Kit) addImports(imp string) { @@ -80,6 +88,9 @@ func (u *Kit) Generate(plugin *protogen.Plugin) error { if method == "" { continue } + if u.Prefix != "" { + path = u.Prefix + path + } t.P(`r.`, method, `("`, path, `",_`, s.GoName, `_`, m.GoName, `0_HTTP_Handler(srv))`) } t.P(`}`) diff --git a/cmd/ts/main.go b/cmd/ts/main.go index a42a557..1a3dc44 100644 --- a/cmd/ts/main.go +++ b/cmd/ts/main.go @@ -1,6 +1,7 @@ package main import ( + "flag" "fmt" protogen2 "git.diulo.com/mogfee/kit/protogen" "google.golang.org/protobuf/compiler/protogen" @@ -9,23 +10,28 @@ import ( func main() { u := &Kit{} - protogen.Options{}.Run(u.Generate) + var flags flag.FlagSet + flags.StringVar(&u.Prefix, "prefix", "", "API path prefix") + protogen.Options{ + ParamFunc: flags.Set, + }.Run(u.Generate) } type Kit struct { + Prefix string } func (u *Kit) Generate(plugin *protogen.Plugin) error { if len(plugin.Files) < 1 { return nil } - for _, f := range plugin.Files { if len(f.Services) == 0 { continue } fname := f.GeneratedFilenamePrefix + ".ts" t := plugin.NewGeneratedFile(fname, f.GoImportPath) + t.P(`// http.prefix:`, u.Prefix) t.P(`// @ts-ignore`) t.P(`import {Config,http} from "./http";`) for _, s := range f.Messages { @@ -52,7 +58,8 @@ func (u *Kit) Generate(plugin *protogen.Plugin) error { if vv.Desc.IsList() { typ = append(typ, "[]") } - t.P(` `, vv.Desc.FullName().Name(), isRequired, ` `, strings.Join(typ, "")) + //t.P(` `, vv.Desc.FullName().Name(), isRequired, ` `, strings.Join(typ, "")) + t.P(` `, vv.Desc.JSONName(), isRequired, ` `, strings.Join(typ, "")) } t.P(`}`) t.P() @@ -64,6 +71,9 @@ func (u *Kit) Generate(plugin *protogen.Plugin) error { if method == "" { continue } + if u.Prefix != "" { + path = u.Prefix + path + } common := strings.TrimSpace(m.Comments.Leading.String()) if common != "" { t.P(` `, common) diff --git a/proto/buf.gen.yaml b/proto/buf.gen.yaml index 742a0c9..58e74ff 100644 --- a/proto/buf.gen.yaml +++ b/proto/buf.gen.yaml @@ -15,7 +15,7 @@ plugins: # opt: # - paths=source_relative - name: kit - path: ./kit +# path: ./kit out: v1 opt: - paths=source_relative diff --git a/proto/v1/user.pb.go b/proto/v1/user.pb.go new file mode 100644 index 0000000..a67a0fe --- /dev/null +++ b/proto/v1/user.pb.go @@ -0,0 +1,221 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v3.18.1 +// source: user.proto + +package user + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Request struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` + UserPassword string `protobuf:"bytes,2,opt,name=user_password,json=userPassword,proto3" json:"user_password,omitempty"` +} + +func (x *Request) Reset() { + *x = Request{} + if protoimpl.UnsafeEnabled { + mi := &file_user_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Request) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Request) ProtoMessage() {} + +func (x *Request) ProtoReflect() protoreflect.Message { + mi := &file_user_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Request.ProtoReflect.Descriptor instead. +func (*Request) Descriptor() ([]byte, []int) { + return file_user_proto_rawDescGZIP(), []int{0} +} + +func (x *Request) GetUserId() int64 { + if x != nil { + return x.UserId + } + return 0 +} + +func (x *Request) GetUserPassword() string { + if x != nil { + return x.UserPassword + } + return "" +} + +type Response struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // 密钥 + Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *Response) Reset() { + *x = Response{} + if protoimpl.UnsafeEnabled { + mi := &file_user_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Response) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Response) ProtoMessage() {} + +func (x *Response) ProtoReflect() protoreflect.Message { + mi := &file_user_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Response.ProtoReflect.Descriptor instead. +func (*Response) Descriptor() ([]byte, []int) { + return file_user_proto_rawDescGZIP(), []int{1} +} + +func (x *Response) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +var File_user_proto protoreflect.FileDescriptor + +var file_user_proto_rawDesc = []byte{ + 0x0a, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x63, 0x6f, + 0x6d, 0x2e, 0x64, 0x69, 0x75, 0x6c, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x22, 0x47, 0x0a, 0x07, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x23, 0x0a, 0x0d, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x75, 0x73, 0x65, 0x72, 0x50, 0x61, 0x73, 0x73, + 0x77, 0x6f, 0x72, 0x64, 0x22, 0x20, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x32, 0x41, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x39, + 0x0a, 0x04, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x16, 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x69, 0x75, + 0x6c, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, + 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x69, 0x75, 0x6c, 0x6f, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x72, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x3b, + 0x75, 0x73, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_user_proto_rawDescOnce sync.Once + file_user_proto_rawDescData = file_user_proto_rawDesc +) + +func file_user_proto_rawDescGZIP() []byte { + file_user_proto_rawDescOnce.Do(func() { + file_user_proto_rawDescData = protoimpl.X.CompressGZIP(file_user_proto_rawDescData) + }) + return file_user_proto_rawDescData +} + +var file_user_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_user_proto_goTypes = []interface{}{ + (*Request)(nil), // 0: com.diulo.api.request + (*Response)(nil), // 1: com.diulo.api.response +} +var file_user_proto_depIdxs = []int32{ + 0, // 0: com.diulo.api.user.list:input_type -> com.diulo.api.request + 1, // 1: com.diulo.api.user.list:output_type -> com.diulo.api.response + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_user_proto_init() } +func file_user_proto_init() { + if File_user_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_user_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Request); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Response); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_user_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_user_proto_goTypes, + DependencyIndexes: file_user_proto_depIdxs, + MessageInfos: file_user_proto_msgTypes, + }.Build() + File_user_proto = out.File + file_user_proto_rawDesc = nil + file_user_proto_goTypes = nil + file_user_proto_depIdxs = nil +} diff --git a/proto/v1/user.pb.validate.go b/proto/v1/user.pb.validate.go new file mode 100644 index 0000000..b62fee9 --- /dev/null +++ b/proto/v1/user.pb.validate.go @@ -0,0 +1,239 @@ +// Code generated by protoc-gen-validate. DO NOT EDIT. +// source: user.proto + +package user + +import ( + "bytes" + "errors" + "fmt" + "net" + "net/mail" + "net/url" + "regexp" + "sort" + "strings" + "time" + "unicode/utf8" + + "google.golang.org/protobuf/types/known/anypb" +) + +// ensure the imports are used +var ( + _ = bytes.MinRead + _ = errors.New("") + _ = fmt.Print + _ = utf8.UTFMax + _ = (*regexp.Regexp)(nil) + _ = (*strings.Reader)(nil) + _ = net.IPv4len + _ = time.Duration(0) + _ = (*url.URL)(nil) + _ = (*mail.Address)(nil) + _ = anypb.Any{} + _ = sort.Sort +) + +// Validate checks the field values on Request with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Request) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Request with the rules defined in the +// proto definition for this message. If any rules are violated, the result is +// a list of violation errors wrapped in RequestMultiError, or nil if none found. +func (m *Request) ValidateAll() error { + return m.validate(true) +} + +func (m *Request) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for UserId + + // no validation rules for UserPassword + + if len(errors) > 0 { + return RequestMultiError(errors) + } + + return nil +} + +// RequestMultiError is an error wrapping multiple validation errors returned +// by Request.ValidateAll() if the designated constraints aren't met. +type RequestMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m RequestMultiError) Error() string { + var msgs []string + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m RequestMultiError) AllErrors() []error { return m } + +// RequestValidationError is the validation error returned by Request.Validate +// if the designated constraints aren't met. +type RequestValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e RequestValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e RequestValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e RequestValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e RequestValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e RequestValidationError) ErrorName() string { return "RequestValidationError" } + +// Error satisfies the builtin error interface +func (e RequestValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sRequest.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = RequestValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = RequestValidationError{} + +// Validate checks the field values on Response with the rules defined in the +// proto definition for this message. If any rules are violated, the first +// error encountered is returned, or nil if there are no violations. +func (m *Response) Validate() error { + return m.validate(false) +} + +// ValidateAll checks the field values on Response with the rules defined in +// the proto definition for this message. If any rules are violated, the +// result is a list of violation errors wrapped in ResponseMultiError, or nil +// if none found. +func (m *Response) ValidateAll() error { + return m.validate(true) +} + +func (m *Response) validate(all bool) error { + if m == nil { + return nil + } + + var errors []error + + // no validation rules for Token + + if len(errors) > 0 { + return ResponseMultiError(errors) + } + + return nil +} + +// ResponseMultiError is an error wrapping multiple validation errors returned +// by Response.ValidateAll() if the designated constraints aren't met. +type ResponseMultiError []error + +// Error returns a concatenation of all the error messages it wraps. +func (m ResponseMultiError) Error() string { + var msgs []string + for _, err := range m { + msgs = append(msgs, err.Error()) + } + return strings.Join(msgs, "; ") +} + +// AllErrors returns a list of validation violation errors. +func (m ResponseMultiError) AllErrors() []error { return m } + +// ResponseValidationError is the validation error returned by +// Response.Validate if the designated constraints aren't met. +type ResponseValidationError struct { + field string + reason string + cause error + key bool +} + +// Field function returns field value. +func (e ResponseValidationError) Field() string { return e.field } + +// Reason function returns reason value. +func (e ResponseValidationError) Reason() string { return e.reason } + +// Cause function returns cause value. +func (e ResponseValidationError) Cause() error { return e.cause } + +// Key function returns key value. +func (e ResponseValidationError) Key() bool { return e.key } + +// ErrorName returns error name. +func (e ResponseValidationError) ErrorName() string { return "ResponseValidationError" } + +// Error satisfies the builtin error interface +func (e ResponseValidationError) Error() string { + cause := "" + if e.cause != nil { + cause = fmt.Sprintf(" | caused by: %v", e.cause) + } + + key := "" + if e.key { + key = "key for " + } + + return fmt.Sprintf( + "invalid %sResponse.%s: %s%s", + key, + e.field, + e.reason, + cause) +} + +var _ error = ResponseValidationError{} + +var _ interface { + Field() string + Reason() string + Key() bool + Cause() error + ErrorName() string +} = ResponseValidationError{} diff --git a/proto/v1/user.ts b/proto/v1/user.ts new file mode 100644 index 0000000..4e123fc --- /dev/null +++ b/proto/v1/user.ts @@ -0,0 +1,15 @@ +// http.prefix:/ +// @ts-ignore +import {Config,http} from "./http"; +export interface request { + userId: number + userPassword: string +} + +export interface response { + //密钥 + token: string +} + +export class userService{ +} diff --git a/proto/v1/user_grpc.pb.go b/proto/v1/user_grpc.pb.go new file mode 100644 index 0000000..dfc3b19 --- /dev/null +++ b/proto/v1/user_grpc.pb.go @@ -0,0 +1,109 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc v3.18.1 +// source: user.proto + +package user + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + User_List_FullMethodName = "/com.diulo.api.user/list" +) + +// UserClient is the client API for User service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type UserClient interface { + List(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) +} + +type userClient struct { + cc grpc.ClientConnInterface +} + +func NewUserClient(cc grpc.ClientConnInterface) UserClient { + return &userClient{cc} +} + +func (c *userClient) List(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) { + out := new(Response) + err := c.cc.Invoke(ctx, User_List_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// UserServer is the server API for User service. +// All implementations must embed UnimplementedUserServer +// for forward compatibility +type UserServer interface { + List(context.Context, *Request) (*Response, error) + mustEmbedUnimplementedUserServer() +} + +// UnimplementedUserServer must be embedded to have forward compatible implementations. +type UnimplementedUserServer struct { +} + +func (UnimplementedUserServer) List(context.Context, *Request) (*Response, error) { + return nil, status.Errorf(codes.Unimplemented, "method List not implemented") +} +func (UnimplementedUserServer) mustEmbedUnimplementedUserServer() {} + +// UnsafeUserServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to UserServer will +// result in compilation errors. +type UnsafeUserServer interface { + mustEmbedUnimplementedUserServer() +} + +func RegisterUserServer(s grpc.ServiceRegistrar, srv UserServer) { + s.RegisterService(&User_ServiceDesc, srv) +} + +func _User_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Request) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).List(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: User_List_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).List(ctx, req.(*Request)) + } + return interceptor(ctx, in, info, handler) +} + +// User_ServiceDesc is the grpc.ServiceDesc for User service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var User_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "com.diulo.api.user", + HandlerType: (*UserServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "list", + Handler: _User_List_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "user.proto", +} diff --git a/proto/v1/user_http.pb.go b/proto/v1/user_http.pb.go new file mode 100644 index 0000000..b81a416 --- /dev/null +++ b/proto/v1/user_http.pb.go @@ -0,0 +1,14 @@ +package user + +import ( + "context" + "git.diulo.com/mogfee/kit/transport/http" +) + +type UserHTTPServer interface { + List(context.Context, *Request) (*Response, error) +} + +func RegisterUserHTTPServer(s *http.Server, srv UserServer) { + r := s.Route("/") +} diff --git a/user.ts b/user.ts new file mode 100644 index 0000000..77f703c --- /dev/null +++ b/user.ts @@ -0,0 +1,15 @@ +//none +// @ts-ignore +import {Config,http} from "./http"; +export interface request { + userId: number + userPassword: string +} + +export interface response { + //密钥 + token: string +} + +export class userService{ +}