added convertToLowerCamel option in proto udf

shared/meta/deployment/go.json

@@ -4,7 +4,8 @@
   "Targets": [
     {
       "MinReleaseVersion": {
-        "1.14": "1",
+        "1.15": "1",
+        "1.14": "3",
         "1.13": "2",
         "1.12": "7",
         "1.11": "5",

shared/static/version.go

@@ -7,9 +7,9 @@ import (
 )
 
 func init() {
-	var memStorage = storage.NewMemoryService()
+	var memStorage = storage.NewMemoryService();
 	{
-		err := memStorage.Upload("mem://github.com/viant/endly/Version", bytes.NewReader([]byte{48, 46, 52, 57, 46, 49, 10}))
+		err := memStorage.Upload("mem://github.com/viant/endly/Version", bytes.NewReader([]byte{48,46,52,57,46,49,10}))
 		if err != nil {
 			log.Printf("failed to upload: mem://github.com/viant/endly/Version %v", err)
 		}

shared/workflow/req/tomcat_start.json

@@ -10,7 +10,7 @@
   "Directory": "$appDirectory",
   "Commands": [
     {
-      "Command": "tomcat/bin/catalina.sh jpda start",
+        "Command": "tomcat/bin/catalina.sh jpda start",
       "Success": [
         "Tomcat started."
       ],

testing/runner/http/service.go

@@ -165,18 +165,26 @@ func (s *service) handleRequest(client *http.Client, metric *runtimeMetric, trip
 		trip.timeout = true
 		atomic.AddUint32(&metric.timeouts, 1)
 	} else if err != nil {
+		fmt.Printf("%v\n", err)
 		trip.err = err
 		metric.err = err
 		atomic.AddUint32(&metric.errors, 1)
+		return
 	}
-	defer response.Body.Close()
-	if trip.err != nil || trip.timeout {
+	defer func() {
+		if response != nil && response.Body != nil {
+			response.Body.Close()
+		}
+	}()
+
+	if trip.err != nil || trip.timeout || response == nil {
 		return
 	}
 	var content []byte
 	if response.ContentLength > 0 {
 		content, err = ioutil.ReadAll(response.Body)
 	}
+
 	if trip.expected {
 		trip.response = &http.Response{
 			Header:        response.Header,

udf/protobuf.go

@@ -2,10 +2,12 @@ package udf
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"github.com/jhump/protoreflect/desc/protoparse"
 	"github.com/jhump/protoreflect/dynamic"
 	"github.com/jhump/protoreflect/dynamic/msgregistry"
+	"github.com/pkg/errors"
 	"github.com/viant/toolbox"
 	"github.com/viant/toolbox/data"
 	"io"
@@ -16,8 +18,9 @@ import (
 
 //ProtoCodec represent a proto codec
 type ProtoCodec struct {
-	registry *msgregistry.MessageRegistry
-	msgType  string
+	registry            *msgregistry.MessageRegistry
+	msgType             string
+	convertToLowerCamel bool
 }
 
 func (c *ProtoCodec) AsMessage(msgType string, data []byte) (interface{}, error) {
@@ -60,15 +63,45 @@ func (c *ProtoCodec) AsBinary(msgType string, msg interface{}) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
+	if c.convertToLowerCamel {
+		data, err = c.toLowerCamel(err, data)
+		if err != nil {
+			err = errors.Wrapf(err, "failed to convert to lowerCase fields")
+			return nil, err
+		}
+	}
 	protoMsg := dynamic.NewMessage(msgDescriptor)
-	if err = protoMsg.UnmarshalJSON(data); err != nil {
+	err = protoMsg.UnmarshalJSON(data)
+	if err != nil {
+		err = errors.Wrapf(err, "failed to UnmarshalJSON")
 		return nil, err
 	}
 	return protoMsg.Marshal()
 }
 
+
+func (c *ProtoCodec) toLowerCamel(err error, data []byte) ([]byte, error) {
+	aMap := map[string]interface{}{}
+	err = json.Unmarshal(data, &aMap)
+	if err != nil {
+		return nil, errors.Wrapf(err, "invalid JSON")
+	}
+	transformed := map[string]interface{}{}
+	err = toolbox.CopyMap(aMap, transformed, func(key, value interface{}) (interface{}, interface{}, bool) {
+		if value == nil || toolbox.AsString(value) == "" || key == nil {
+			return nil, nil, false
+		}
+		return toolbox.ToCaseFormat(toolbox.AsString(key), toolbox.CaseUpperCamel, toolbox.CaseLowerCamel), value, true
+	})
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(transformed)
+}
+
+
 //NewProtoCodec creates a new protobuf codec
-func NewProtoCodec(schemaFile, importPath string, msgType string) (*ProtoCodec, error) {
+func NewProtoCodec(schemaFile, importPath string, msgType string, lowercaseKey bool) (*ProtoCodec, error) {
 	parser := protoparse.Parser{ImportPaths: []string{importPath}, IncludeSourceCodeInfo: true}
 	descriptors, err := parser.ParseFiles(schemaFile)
 	if err != nil {
@@ -80,8 +113,9 @@ func NewProtoCodec(schemaFile, importPath string, msgType string) (*ProtoCodec,
 		registry.AddFile(baseURL, desc)
 	}
 	return &ProtoCodec{
-		registry: registry,
-		msgType:  msgType,
+		registry:            registry,
+		msgType:             msgType,
+		convertToLowerCamel: lowercaseKey,
 	}, nil
 
 }
@@ -93,12 +127,16 @@ func getProtoCodec(source string, args []interface{}) (*ProtoCodec, error) {
 	schemaFile := toolbox.AsString(args[0])
 	messageType := toolbox.AsString(args[1])
 	importPath, filename := path.Split(schemaFile)
-	if len(args) > 2 {
+	if len(args) > 2 && args[2] != nil  {
 		importPath = toolbox.AsString(args[2])
 	} else {
 		schemaFile = filename
 	}
-	return NewProtoCodec(schemaFile, importPath, messageType)
+	lowercaseKey := false
+	if len(args) > 3 {
+		lowercaseKey = toolbox.AsBoolean(args[3])
+	}
+	return NewProtoCodec(schemaFile, importPath, messageType, lowercaseKey)
 }
 
 //NewProtoWriter creates a new proto writer provider
@@ -108,7 +146,8 @@ func NewProtoWriter(args ...interface{}) (func(source interface{}, state data.Ma
 		return nil, err
 	}
 	return func(source interface{}, state data.Map) (interface{}, error) {
-		return codec.AsBinary(codec.msgType, source)
+		data, err := codec.AsBinary(codec.msgType, source)
+		return data, err
 	}, nil
 }