From be51dd5139b7e5e6d990d3e2a3e55452ffe2521e Mon Sep 17 00:00:00 2001 From: azykophus Date: Thu, 20 Mar 2025 15:03:11 +0530 Subject: [PATCH 1/5] Added support for custom API annotations --- .DS_Store | Bin 0 -> 8196 bytes cmd/protoc-gen-doc/main.go | 3 +- examples/.DS_Store | Bin 0 -> 6148 bytes extensions/.DS_Store | Bin 0 -> 8196 bytes extensions/extensions.go | 57 ++++++++--- extensions/extensions_register.go | 153 ++++++++++++++++++++++++++++++ extensions/generic/generic.go | 46 +++++++++ plugin.go | 6 +- template.go | 54 ++++++++--- thirdparty/.DS_Store | Bin 0 -> 6148 bytes thirdparty/github.com/.DS_Store | Bin 0 -> 6148 bytes 11 files changed, 291 insertions(+), 28 deletions(-) create mode 100644 .DS_Store create mode 100644 examples/.DS_Store create mode 100644 extensions/.DS_Store create mode 100644 extensions/extensions_register.go create mode 100644 extensions/generic/generic.go create mode 100644 thirdparty/.DS_Store create mode 100644 thirdparty/github.com/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..26877d8c671f5e627ddcff3669f63c5d2407145a GIT binary patch literal 8196 zcmeI1PcH*O7{=eJMv4ed8YK1;NF+{9OX?zVa^Z#+m9)0eO1SOWS$qc~5eEl=p0ypbh)B)uRwjvxL{va!9qdDsQh1zeqU3DP z7*rvjCKt<5y^)BM4sk#n5C_BoaX=jSJq}>c=2FPm_syuZ;($2tFCF0ThX9o|v>F@L zUma-l5dfM;w=TFI=8qmbo2){F0>jOHR+`6;X~P#l|7*- zy*lO(bU3NdsI=mMIFNLJ&+c7RraDz>o9_92^sqfrk4mMrTC|3q!o&IH$?MhKj5}KC zFxsfPvxZ2+lfF)Sw2CzwRKs=CTRGSNlosPM+#e6j_g`y<#9Z~LP17mPAjdB-{>s=Ts`#&2ZMI87;4s;pTBA@@~vfuyz zp`S=l#Q|~PyAG&)X|XhmEWN9zWb-Z`pst{D;kekSPC?`SA%M>x|1iXLfKbi}t;R;t QgCZ{iv<=dT13&7(8?*)tXaE2J literal 0 HcmV?d00001 diff --git a/cmd/protoc-gen-doc/main.go b/cmd/protoc-gen-doc/main.go index 56e42ce4..eecc5d62 100644 --- a/cmd/protoc-gen-doc/main.go +++ b/cmd/protoc-gen-doc/main.go @@ -20,6 +20,7 @@ import ( "os" gendoc "github.com/pseudomuto/protoc-gen-doc" + _ "github.com/pseudomuto/protoc-gen-doc/extensions/generic" // imports the generic extension handler _ "github.com/pseudomuto/protoc-gen-doc/extensions/google_api_http" // imported for side effects _ "github.com/pseudomuto/protoc-gen-doc/extensions/lyft_validate" // imported for side effects _ "github.com/pseudomuto/protoc-gen-doc/extensions/validator_field" // imported for side effects @@ -50,4 +51,4 @@ func HandleFlags(f *Flags) bool { } return true -} +} \ No newline at end of file diff --git a/examples/.DS_Store b/examples/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..4327e78c1d70762a426b629b9fdc6b92118b910b GIT binary patch literal 6148 zcmeHKJ5B>J5FIBA37;YrqQfUZ$_GuQ_9DoCG0YnZ!#f{SN z#&!~$Y*J7l6wOHX^UlXJe$wu&iAeRHMqQ!~5w$TGlYLAz!gd}j((oD%R=h{IKQu*Y zwRjd0284ls&H%r=O&XD*VLl1p->=rvQkX0o&+Te7w zOB1@M8)VIC9A%}}=}&u@`|e~q&mHYim}Ld)e4;w&lIz%^5_K4QBokM0#9y|+8rJZ9 zv8W;PSXNN)5$8`i{~j`rsX!Gu*x>a;T*u*iy;oSz%hjTun*Bm%HhaePX|7LXyBY93 zx_z+S$CT3v1H!;B7~t=N#$Zf6Ru1i_1CzZ1028RKU~PLmP_qJzI8;Y{oq1V=(RO(P>VL%v&8ECr44)_1__4ofcNS=fN zVPLBmP)XL$dN`8rtt*G)UaK*#F<98Ia%e*^`F3m<+=`DetiYyu0Zcts4xxd_kAS5? KCSl-D8TbZ|aF8hg literal 0 HcmV?d00001 diff --git a/extensions/.DS_Store b/extensions/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..71b6c17f8e5b6dd5110eae719a3230bb10a89c77 GIT binary patch literal 8196 zcmeHMzi$&U7=4BcB4|}4B-D-DnA)iP1xFP&Ku7`BkY6OJF1@3>t z6%Z3Ee+&!nv#sQkOL9R-2(_Op`}yqe+5VoLJAEzyb1-b}13Lgp%!0RWvRII$Uve&8 z@hx|VhJ0Xz1jmSR!kQ*kKow90Q~^~$75E<&;5S=RX~}or^=hdKr~;Q#0eL?J%z~lE zu|xanU|~Z5;s%>-Vx4h-k7I|H$}wH^U_90M5W_e+`vWm2h91Wb9UaEeVf@U- zM<~Y5PF`TmVM2#mssgG&UIB^SZ=;PPykXp)jo)i*sUt!UEn*=()P z?8lW#BZ?bjl+F&%Km9uY_TW$0t-oL=-R!CZPKz!2dmjC|XE$*R%I7u6ihJ*B& zR_LItSWWZp7XiQdk<-?qk%5RJY;QTtztAi>xg5C%~NkJ z^NPY{JhNk_womR)Qs$a3A9JRuMUR{g?&n&{{^muPP3+P}yxZm8$#a=cd5_D5T0HSu ztWb<&T=%ny20b)q&&iFCd5i3M_-+-kx8Zp%*cuS0Fy)Ui%& zdc-ajO_9v5Z}SV+SHQ@w_ujk7`7LBk*S|h%fj?XHV}w^+d%XG?0(F?d*&EfKYo6g_)#!V_B^f6n)N5( z;xwrO7eaxn&Wjz1{~s>D|GyBvsuQY!DzI1qvr(y54%p{o>ztLu+5z)RW=UcMLqxk literal 0 HcmV?d00001 diff --git a/extensions/extensions.go b/extensions/extensions.go index 5e48c72a..909a4227 100644 --- a/extensions/extensions.go +++ b/extensions/extensions.go @@ -1,35 +1,70 @@ // Package extensions implements a system for working with extended options. package extensions +import ( + "strings" + "github.com/golang/protobuf/proto" + "fmt" + "github.com/golang/protobuf/protoc-gen-go/descriptor" +) + // Transformer functions for transforming payloads of an extension option into // something that can be rendered by a template. type Transformer func(payload interface{}) interface{} var transformers = make(map[string]Transformer) +var defaultTransformer Transformer +var transformNameAliases = make(map[string]string) // SetTransformer sets the transformer function for the given extension name func SetTransformer(extensionName string, f Transformer) { transformers[extensionName] = f } -// Transform the extensions using the registered transformers. +// SetNameAlias sets an alias for an extension name, allowing different keys +// to map to the same transformer +func SetNameAlias(fullName, aliasTo string) { + transformNameAliases[fullName] = aliasTo +} + +// SetDefaultTransformer sets the default transformer function for any +// extension that doesn't have a specific transformer registered +func SetDefaultTransformer(f Transformer) { + defaultTransformer = f +} + +// Explicitly fixed Transform function (fully generic) func Transform(extensions map[string]interface{}) map[string]interface{} { if extensions == nil { return nil } + out := make(map[string]interface{}, len(extensions)) - for name, payload := range extensions { - transform, ok := transformers[name] - if !ok { - // No transformer registered, skip. - continue + + for originalKey, payload := range extensions { + transformedName := originalKey // fallback + + // Resolve registered extensions explicitly + if extDescs, err := proto.ExtensionDescs((*descriptor.MethodOptions)(nil)); err == nil { + for _, extDesc := range extDescs { + protoKey := fmt.Sprintf(".google.protobuf.MethodOptions.%s", extDesc.Name[strings.LastIndex(extDesc.Name, ".")+1:]) + if protoKey == originalKey { + transformedName = extDesc.Name + break + } + } } - transformedPayload := transform(payload) - if transformedPayload == nil { - // Transformer returned nothing, skip. - continue + + // Apply the transformer if one exists + transform, ok := transformers[transformedName] + if ok { + out[transformedName] = transform(payload) + } else if defaultTransformer != nil { + out[transformedName] = defaultTransformer(payload) + } else { + out[transformedName] = payload } - out[name] = transformedPayload } + return out } diff --git a/extensions/extensions_register.go b/extensions/extensions_register.go new file mode 100644 index 00000000..57a6baf0 --- /dev/null +++ b/extensions/extensions_register.go @@ -0,0 +1,153 @@ +package extensions + +import ( + "fmt" + "github.com/golang/protobuf/proto" + "github.com/golang/protobuf/protoc-gen-go/descriptor" + "github.com/pseudomuto/protokit" +) + +func RegisterAllExtensions(files []*protokit.FileDescriptor) { + for _, file := range files { + for _, ext := range file.GetExtensions() { + registerExtension(ext) + } + + for _, msg := range file.GetMessages() { + registerMessageExtensions(msg) + } + } +} + +func registerMessageExtensions(msg *protokit.Descriptor) { + for _, ext := range msg.GetExtensions() { + registerExtension(ext) + } + for _, nestedMsg := range msg.GetMessages() { + registerMessageExtensions(nestedMsg) + } +} +func registerExtension(ext *protokit.ExtensionDescriptor) { + extendedType := determineExtendedType(ext.GetExtendee()) + extType := determineExtensionType(ext) + if extType == nil { + return + } + + correctFullName := fmt.Sprintf("%s.%s", ext.GetFile().GetPackage(), ext.GetName()) + + proto.RegisterExtension(&proto.ExtensionDesc{ + ExtendedType: extendedType, + ExtensionType: extType, + Field: int32(ext.GetNumber()), + Name: correctFullName, // explicitly correct now + Tag: generateTag(ext), + }) +} + + + + + + +// Helper functions: + +func determineExtendedType(typeName string) proto.Message { + switch typeName { + case ".google.protobuf.MethodOptions": + return (*descriptor.MethodOptions)(nil) + case ".google.protobuf.FieldOptions": + return (*descriptor.FieldOptions)(nil) + case ".google.protobuf.MessageOptions": + return (*descriptor.MessageOptions)(nil) + case ".google.protobuf.FileOptions": + return (*descriptor.FileOptions)(nil) + case ".google.protobuf.EnumOptions": + return (*descriptor.EnumOptions)(nil) + case ".google.protobuf.EnumValueOptions": + return (*descriptor.EnumValueOptions)(nil) + case ".google.protobuf.ServiceOptions": + return (*descriptor.ServiceOptions)(nil) + default: + panic(fmt.Sprintf("Unsupported extendee type: %s", typeName)) + } +} + + +func determineExtensionType(ext *protokit.ExtensionDescriptor) interface{} { + isRepeated := ext.GetLabel() == descriptor.FieldDescriptorProto_LABEL_REPEATED + + switch ext.GetType() { + case descriptor.FieldDescriptorProto_TYPE_STRING: + if isRepeated { + return ([]string)(nil) + } + return (*string)(nil) + case descriptor.FieldDescriptorProto_TYPE_BOOL: + if isRepeated { + return ([]bool)(nil) + } + return (*bool)(nil) + case descriptor.FieldDescriptorProto_TYPE_INT32, descriptor.FieldDescriptorProto_TYPE_SINT32: + if isRepeated { + return ([]int32)(nil) + } + return (*int32)(nil) + case descriptor.FieldDescriptorProto_TYPE_INT64, descriptor.FieldDescriptorProto_TYPE_SINT64: + if isRepeated { + return ([]int64)(nil) + } + return (*int64)(nil) + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + if isRepeated { + return ([]float32)(nil) + } + return (*float32)(nil) + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + if isRepeated { + return ([]float64)(nil) + } + return (*float64)(nil) + case descriptor.FieldDescriptorProto_TYPE_ENUM: + if isRepeated { + return ([]int32)(nil) // enums represented as repeated []int32 + } + return (*int32)(nil) // single enum represented as *int32 + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + // Skip temporarily, as we discussed before + return nil + default: + panic(fmt.Sprintf("Unsupported extension field type: %s", ext.GetType().String())) + } +} + + + +func generateTag(ext *protokit.ExtensionDescriptor) string { + var wireType string + switch ext.GetType() { + case descriptor.FieldDescriptorProto_TYPE_STRING: + wireType = "bytes" + case descriptor.FieldDescriptorProto_TYPE_BOOL, + descriptor.FieldDescriptorProto_TYPE_INT32, + descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SINT64, + descriptor.FieldDescriptorProto_TYPE_ENUM: + wireType = "varint" + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + wireType = "fixed32" + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + wireType = "fixed64" + default: + panic(fmt.Sprintf("Unsupported tag type for extension: %s", ext.GetType().String())) + } + + label := "opt" + if ext.GetLabel() == descriptor.FieldDescriptorProto_LABEL_REPEATED { + label = "rep" + } + + fieldName := ext.GetName() + return fmt.Sprintf("%s,%d,%s,name=%s", wireType, ext.GetNumber(), label, fieldName) +} diff --git a/extensions/generic/generic.go b/extensions/generic/generic.go new file mode 100644 index 00000000..034dbc28 --- /dev/null +++ b/extensions/generic/generic.go @@ -0,0 +1,46 @@ +// Package generic provides a mechanism to register and transform any extension +// without knowing its specifics in advance +package generic + +import ( + "fmt" + "github.com/golang/protobuf/proto" + "github.com/pseudomuto/protoc-gen-doc/extensions" + "regexp" +) + +// ExtensionPattern defines a pattern for registering multiple extensions at once +type ExtensionPattern struct { + Name string + Number int32 + Type proto.Message +} + +// Initialize extension patterns - can be extended for more types +func init() { + // Register a generic transformer for all extensions + extensions.SetDefaultTransformer(identityTransformer) +} + + +// formatFieldNumber formats a field number for use in extension names +func formatFieldNumber(num int32) string { + return fmt.Sprintf("field_%d", num) +} + +// identityTransformer returns the extension value as-is +func identityTransformer(payload interface{}) interface{} { + return payload +} + +// ExtractOptionName extracts a cleaner name from a full extension name +// For example: "custom.method.option.xxxx_yyy_50001" -> "custom.method.option" +func ExtractOptionName(fullName string) string { + // Match the base name pattern (everything before the last dot and numbers) + re := regexp.MustCompile(`(.*?)\.[\w_]+\d+$`) + matches := re.FindStringSubmatch(fullName) + if len(matches) > 1 { + return matches[1] + } + return fullName +} diff --git a/plugin.go b/plugin.go index 5fbabe6d..7b4281e5 100644 --- a/plugin.go +++ b/plugin.go @@ -7,7 +7,7 @@ import ( "path/filepath" "regexp" "strings" - + "github.com/pseudomuto/protoc-gen-doc/extensions" "github.com/golang/protobuf/proto" plugin_go "github.com/golang/protobuf/protoc-gen-go/plugin" "github.com/pseudomuto/protokit" @@ -40,6 +40,10 @@ func (p *Plugin) Generate(r *plugin_go.CodeGeneratorRequest) (*plugin_go.CodeGen result := excludeUnwantedProtos(protokit.ParseCodeGenRequest(r), options.ExcludePatterns) + // Dynamically register extensions + extensions.RegisterAllExtensions(result) + + customTemplate := "" if options.TemplateFile != "" { diff --git a/template.go b/template.go index ee0d933f..cffa1bae 100644 --- a/template.go +++ b/template.go @@ -6,10 +6,12 @@ import ( "sort" "strings" "unicode" - - "github.com/golang/protobuf/protoc-gen-go/descriptor" + "github.com/golang/protobuf/proto" "github.com/pseudomuto/protoc-gen-doc/extensions" "github.com/pseudomuto/protokit" + descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor" + + ) // Template is a type for encapsulating all the parsed files, messages, fields, enums, services, extensions, etc. into @@ -541,22 +543,44 @@ func parseService(ps *protokit.ServiceDescriptor) *Service { return service } + + + + func parseServiceMethod(pm *protokit.MethodDescriptor) *ServiceMethod { - return &ServiceMethod{ - Name: pm.GetName(), - Description: description(pm.GetComments().String()), - RequestType: baseName(pm.GetInputType()), - RequestLongType: strings.TrimPrefix(pm.GetInputType(), "."+pm.GetPackage()+"."), - RequestFullType: strings.TrimPrefix(pm.GetInputType(), "."), - RequestStreaming: pm.GetClientStreaming(), - ResponseType: baseName(pm.GetOutputType()), - ResponseLongType: strings.TrimPrefix(pm.GetOutputType(), "."+pm.GetPackage()+"."), - ResponseFullType: strings.TrimPrefix(pm.GetOutputType(), "."), - ResponseStreaming: pm.GetServerStreaming(), - Options: mergeOptions(extractOptions(pm.GetOptions()), extensions.Transform(pm.OptionExtensions)), - } + methodOptions := extractOptions(pm.GetOptions()) + methodExtensionOptions := make(map[string]interface{}) + + methodOpts := pm.GetOptions() // ✅ Already *descriptor.MethodOptions (no type assertion needed) + + if methodOpts != nil { + // ✅ Using registered extensions to get correct names dynamically + for _, extDesc := range proto.RegisteredExtensions(methodOpts) { + if extValue, err := proto.GetExtension(methodOpts, extDesc); err == nil && extValue != nil { + methodExtensionOptions[extDesc.Name] = extValue + } + } + } + + return &ServiceMethod{ + Name: pm.GetName(), + Description: description(pm.GetComments().String()), + RequestType: baseName(pm.GetInputType()), + RequestLongType: strings.TrimPrefix(pm.GetInputType(), "."+pm.GetPackage()+"."), + RequestFullType: strings.TrimPrefix(pm.GetInputType(), "."), + RequestStreaming: pm.GetClientStreaming(), + ResponseType: baseName(pm.GetOutputType()), + ResponseLongType: strings.TrimPrefix(pm.GetOutputType(), "."+pm.GetPackage()+"."), + ResponseFullType: strings.TrimPrefix(pm.GetOutputType(), "."), + ResponseStreaming: pm.GetServerStreaming(), + Options: mergeOptions( + methodOptions, + methodExtensionOptions, + ), + } } + func baseName(name string) string { parts := strings.Split(name, ".") return parts[len(parts)-1] diff --git a/thirdparty/.DS_Store b/thirdparty/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..24b89a7eca30583ba0a759ef8f53e565ec3f95bf GIT binary patch literal 6148 zcmeHKu}T9$5PhR54sB9e?iUF8gEL&dAU`0NKqBP06sEslu=WqE(%5Kk`>zp3$$nkCi;s* zy7x1zaD!W{aj^f*YBFE6&DJ)3_j)X@X{)NDU?Oqk}4!07QL8XQ8dNgytm2 z(y=q7ha#3rv{dmDLoA)+$>U1L&d|~!UVMnJ{879}UY+x&91bZBLk9!FK%aqA>yGvQ zpYfL&Eb{v)(F+EGfq%w;jH-DxqrxW8LkO>JD4EzEE?;5K$x&QzG literal 0 HcmV?d00001 diff --git a/thirdparty/github.com/.DS_Store b/thirdparty/github.com/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..0cf4dc84c6d4ba9b459bafe045056d91bef133c3 GIT binary patch literal 6148 zcmeHKF;2rU6n$=s2$Z2CW3JE}geokoy#OjjKxs$>Eu~vVZonNnup+_Ed6-yOc;B|t zgfxN)A@sjwKj-J!etA~n7=Rhf$9P8^=u2wZiYX8+3|R4Rt^rPzTBmaL<+qx(>Bg2h;&|pm0FG4 zKOL;>5rEiX+6LS9--sAWf*5(s9Wui(t}D@XHU5ZUTzBR}&x<_f4qbN`J2S`eGaG+G zF?M$5LraH=9BQo&r~_38+U~L^`~P9{`M=spuhao`;9oglI`J?b@R9u9T6;LzYeSY} q775|y4vQ{q*sYjc*^2jBY%m{6gBW?t9Wukv9|3EFR_eg7I`9c*WrUjm literal 0 HcmV?d00001 From 3e3487ec0e5ca68224a0dac0cd99c8c6535b1c22 Mon Sep 17 00:00:00 2001 From: Abhijay Singh <98527223+azykophus@users.noreply.github.com> Date: Thu, 20 Mar 2025 15:15:18 +0530 Subject: [PATCH 2/5] Update template.go --- template.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/template.go b/template.go index cffa1bae..d8a57924 100644 --- a/template.go +++ b/template.go @@ -551,10 +551,10 @@ func parseServiceMethod(pm *protokit.MethodDescriptor) *ServiceMethod { methodOptions := extractOptions(pm.GetOptions()) methodExtensionOptions := make(map[string]interface{}) - methodOpts := pm.GetOptions() // ✅ Already *descriptor.MethodOptions (no type assertion needed) + methodOpts := pm.GetOptions() if methodOpts != nil { - // ✅ Using registered extensions to get correct names dynamically + // Using registered extensions to get correct names dynamically for _, extDesc := range proto.RegisteredExtensions(methodOpts) { if extValue, err := proto.GetExtension(methodOpts, extDesc); err == nil && extValue != nil { methodExtensionOptions[extDesc.Name] = extValue From b72198825dd23f690c898cd31651b54cce98ee37 Mon Sep 17 00:00:00 2001 From: Abhijay Singh <98527223+azykophus@users.noreply.github.com> Date: Thu, 20 Mar 2025 15:17:03 +0530 Subject: [PATCH 3/5] Update extensions.go --- extensions/extensions.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extensions/extensions.go b/extensions/extensions.go index 909a4227..345f9718 100644 --- a/extensions/extensions.go +++ b/extensions/extensions.go @@ -33,7 +33,7 @@ func SetDefaultTransformer(f Transformer) { defaultTransformer = f } -// Explicitly fixed Transform function (fully generic) +// Generic Transform function func Transform(extensions map[string]interface{}) map[string]interface{} { if extensions == nil { return nil From 6d80ea4524eb7e59ca99103614765a26a7324d83 Mon Sep 17 00:00:00 2001 From: Abhijay Singh <98527223+azykophus@users.noreply.github.com> Date: Thu, 20 Mar 2025 16:06:34 +0530 Subject: [PATCH 4/5] Update extensions_register.go --- extensions/extensions_register.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/extensions/extensions_register.go b/extensions/extensions_register.go index 57a6baf0..5c777276 100644 --- a/extensions/extensions_register.go +++ b/extensions/extensions_register.go @@ -40,7 +40,7 @@ func registerExtension(ext *protokit.ExtensionDescriptor) { ExtendedType: extendedType, ExtensionType: extType, Field: int32(ext.GetNumber()), - Name: correctFullName, // explicitly correct now + Name: correctFullName, Tag: generateTag(ext), }) } @@ -114,7 +114,6 @@ func determineExtensionType(ext *protokit.ExtensionDescriptor) interface{} { } return (*int32)(nil) // single enum represented as *int32 case descriptor.FieldDescriptorProto_TYPE_MESSAGE: - // Skip temporarily, as we discussed before return nil default: panic(fmt.Sprintf("Unsupported extension field type: %s", ext.GetType().String())) From 0939748bdb011e1e19ad4333f9c3b314b84453c8 Mon Sep 17 00:00:00 2001 From: Abhijay Singh <98527223+azykophus@users.noreply.github.com> Date: Thu, 20 Mar 2025 16:07:16 +0530 Subject: [PATCH 5/5] Update generic.go --- extensions/generic/generic.go | 1 - 1 file changed, 1 deletion(-) diff --git a/extensions/generic/generic.go b/extensions/generic/generic.go index 034dbc28..01316d69 100644 --- a/extensions/generic/generic.go +++ b/extensions/generic/generic.go @@ -34,7 +34,6 @@ func identityTransformer(payload interface{}) interface{} { } // ExtractOptionName extracts a cleaner name from a full extension name -// For example: "custom.method.option.xxxx_yyy_50001" -> "custom.method.option" func ExtractOptionName(fullName string) string { // Match the base name pattern (everything before the last dot and numbers) re := regexp.MustCompile(`(.*?)\.[\w_]+\d+$`)