Expose serialization functions for alternative transports

Author: haiyuwang

gremlin-go/driver/client.go

@@ -149,7 +149,7 @@ func (client *Client) Close() {
 // SubmitWithOptions submits a Gremlin script to the server with specified RequestOptions and returns a ResultSet.
 func (client *Client) SubmitWithOptions(traversalString string, requestOptions RequestOptions) (ResultSet, error) {
 	client.logHandler.logf(Debug, submitStartedString, traversalString)
-	request := makeStringRequest(traversalString, client.traversalSource, client.session, requestOptions)
+	request := MakeStringRequest(traversalString, client.traversalSource, client.session, requestOptions)
 	result, err := client.connections.write(&request)
 	if err != nil {
 		client.logHandler.logf(Error, logErrorGeneric, "Client.Submit()", err.Error())
@@ -171,7 +171,7 @@ func (client *Client) Submit(traversalString string, bindings ...map[string]inte
 // submitBytecode submits Bytecode to the server to execute and returns a ResultSet.
 func (client *Client) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
 	client.logHandler.logf(Debug, submitStartedBytecode, *bytecode)
-	request := makeBytecodeRequest(bytecode, client.traversalSource, client.session)
+	request := MakeBytecodeRequest(bytecode, client.traversalSource, client.session)
 	return client.connections.write(&request)
 }
 

gremlin-go/driver/connection_test.go

@@ -382,7 +382,7 @@ func TestConnection(t *testing.T) {
 		assert.NotNil(t, connection)
 		assert.Equal(t, established, connection.state)
 		defer deferredCleanup(t, connection)
-		request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
+		request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
 		resultSet, err := connection.write(&request)
 		assert.Nil(t, err)
 		assert.NotNil(t, resultSet)
@@ -400,7 +400,7 @@ func TestConnection(t *testing.T) {
 		assert.NotNil(t, connection)
 		assert.Equal(t, established, connection.state)
 		defer deferredCleanup(t, connection)
-		request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
+		request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
 		resultSet, err := connection.write(&request)
 		assert.Nil(t, err)
 		assert.NotNil(t, resultSet)
@@ -436,7 +436,7 @@ func TestConnection(t *testing.T) {
 		err = connection.close()
 		assert.Nil(t, err)
 		assert.Equal(t, closed, connection.state)
-		request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
+		request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
 		resultSet, err := connection.write(&request)
 		assert.Nil(t, resultSet)
 		assert.Equal(t, newError(err0102WriteConnectionClosedError), err)
@@ -452,7 +452,7 @@ func TestConnection(t *testing.T) {
 		assert.Equal(t, established, connection.state)
 		assert.Nil(t, err)
 		time.Sleep(120 * time.Second)
-		request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
+		request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
 		resultSet, err := connection.write(&request)
 		assert.Nil(t, resultSet)
 		assert.NotNil(t, err)

gremlin-go/driver/protocol.go

@@ -72,7 +72,7 @@ func (protocol *gremlinServerWSProtocol) readLoop(resultSets *synchronizedMap, e
 		}
 
 		// Deserialize message and unpack.
-		resp, err := protocol.serializer.deserializeMessage(msg)
+		resp, err := protocol.serializer.DeserializeMessage(msg)
 		if err != nil {
 			protocol.logHandler.logf(Error, logErrorGeneric, "gremlinServerWSProtocol.readLoop()", err.Error())
 			readErrorHandler(resultSets, errorCallback, err, protocol.logHandler)
@@ -149,7 +149,7 @@ func (protocol *gremlinServerWSProtocol) responseHandler(resultSets *synchronize
 }
 
 func (protocol *gremlinServerWSProtocol) write(request *request) error {
-	bytes, err := protocol.serializer.serializeMessage(request)
+	bytes, err := protocol.serializer.SerializeMessage(request)
 	if err != nil {
 		return err
 	}

gremlin-go/driver/request.go

@@ -36,7 +36,28 @@ const sessionProcessor = "session"
 const stringOp = "eval"
 const stringProcessor = ""
 
-func makeStringRequest(stringGremlin string, traversalSource string, sessionId string, requestOptions RequestOptions) (req request) {
+// MakeStringRequest creates a request from a Gremlin string query for submission to a Gremlin server.
+//
+// This function is exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.)
+// to construct properly formatted requests outside the standard WebSocket client. The returned
+// request can then be serialized using SerializeMessage().
+//
+// Parameters:
+//   - stringGremlin: The Gremlin query string to execute
+//   - traversalSource: The name of the traversal source (typically "g")
+//   - sessionId: Optional session ID for stateful requests (use "" for stateless)
+//   - requestOptions: Options such as bindings, timeout, batch size, etc.
+//
+// Returns:
+//   - request: A request structure ready for serialization
+//
+// Example for alternative transports:
+//
+//	req := MakeStringRequest("g.V().count()", "g", "", RequestOptions{})
+//	serializer := newGraphBinarySerializer(nil)
+//	bytes, _ := serializer.(graphBinarySerializer).SerializeMessage(&req)
+//	// Send bytes over gRPC, HTTP/2, etc.
+func MakeStringRequest(stringGremlin string, traversalSource string, sessionId string, requestOptions RequestOptions) (req request) {
 	newProcessor := stringProcessor
 	newArgs := map[string]interface{}{
 		"gremlin": stringGremlin,
@@ -88,7 +109,28 @@ const bytecodeProcessor = "traversal"
 const authOp = "authentication"
 const authProcessor = "traversal"
 
-func makeBytecodeRequest(bytecodeGremlin *Bytecode, traversalSource string, sessionId string) (req request) {
+// MakeBytecodeRequest creates a request from Gremlin bytecode for submission to a Gremlin server.
+//
+// This function is exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.)
+// to construct properly formatted requests outside the standard WebSocket client. The returned
+// request can then be serialized using SerializeMessage().
+//
+// Parameters:
+//   - bytecodeGremlin: The Gremlin bytecode to execute
+//   - traversalSource: The name of the traversal source (typically "g")
+//   - sessionId: Optional session ID for stateful requests (use "" for stateless)
+//
+// Returns:
+//   - request: A request structure ready for serialization
+//
+// Example for alternative transports:
+//
+//	bytecode := g.V().HasLabel("person").Bytecode
+//	req := MakeBytecodeRequest(bytecode, "g", "")
+//	serializer := newGraphBinarySerializer(nil)
+//	bytes, _ := serializer.(graphBinarySerializer).SerializeMessage(&req)
+//	// Send bytes over gRPC, HTTP/2, etc.
+func MakeBytecodeRequest(bytecodeGremlin *Bytecode, traversalSource string, sessionId string) (req request) {
 	newProcessor := bytecodeProcessor
 	newArgs := map[string]interface{}{
 		"gremlin": *bytecodeGremlin,

gremlin-go/driver/request_test.go

@@ -20,44 +20,45 @@ under the License.
 package gremlingo
 
 import (
-	"github.com/google/uuid"
 	"testing"
 
+	"github.com/google/uuid"
+
 	"github.com/stretchr/testify/assert"
 )
 
 func TestRequest(t *testing.T) {
 	t.Run("Test makeStringRequest() with custom requestID", func(t *testing.T) {
 		requestId := uuid.New()
-		r := makeStringRequest("g.V()", "g", "",
+		r := MakeStringRequest("g.V()", "g", "",
 			new(RequestOptionsBuilder).SetRequestId(requestId).Create())
 		assert.Equal(t, requestId, r.requestID)
 	})
 
 	t.Run("Test makeStringRequest() with no bindings", func(t *testing.T) {
-		r := makeStringRequest("g.V()", "g", "", *new(RequestOptions))
+		r := MakeStringRequest("g.V()", "g", "", *new(RequestOptions))
 		assert.NotNil(t, r.requestID)
 		assert.NotEqual(t, uuid.Nil, r.requestID)
 	})
 
 	t.Run("Test makeStringRequest() with custom evaluationTimeout", func(t *testing.T) {
-		r := makeStringRequest("g.V()", "g", "",
+		r := MakeStringRequest("g.V()", "g", "",
 			new(RequestOptionsBuilder).SetEvaluationTimeout(1234).Create())
 		assert.NotNil(t, r.requestID)
 		assert.NotEqual(t, uuid.Nil, r.requestID)
 		assert.Equal(t, 1234, r.args["evaluationTimeout"])
 	})
 
 	t.Run("Test makeStringRequest() with custom batchSize", func(t *testing.T) {
-		r := makeStringRequest("g.V()", "g", "",
+		r := MakeStringRequest("g.V()", "g", "",
 			new(RequestOptionsBuilder).SetBatchSize(123).Create())
 		assert.NotNil(t, r.requestID)
 		assert.NotEqual(t, uuid.Nil, r.requestID)
 		assert.Equal(t, 123, r.args["batchSize"])
 	})
 
 	t.Run("Test makeStringRequest() with custom userAgent", func(t *testing.T) {
-		r := makeStringRequest("g.V()", "g", "",
+		r := MakeStringRequest("g.V()", "g", "",
 			new(RequestOptionsBuilder).SetUserAgent("TestUserAgent").Create())
 		assert.NotNil(t, r.requestID)
 		assert.NotEqual(t, uuid.Nil, r.requestID)

gremlin-go/driver/serializer.go

@@ -34,8 +34,8 @@ const graphBinaryMimeType = "application/vnd.graphbinary-v1.0"
 
 // serializer interface for serializers.
 type serializer interface {
-	serializeMessage(request *request) ([]byte, error)
-	deserializeMessage(message []byte) (response, error)
+	SerializeMessage(request *request) ([]byte, error)
+	DeserializeMessage(message []byte) (response, error)
 }
 
 // graphBinarySerializer serializes/deserializes message to/from GraphBinary.
@@ -95,8 +95,28 @@ func convertArgs(request *request, gs graphBinarySerializer) (map[string]interfa
 	}
 }
 
-// serializeMessage serializes a request message into GraphBinary.
-func (gs graphBinarySerializer) serializeMessage(request *request) ([]byte, error) {
+// SerializeMessage serializes a request message into GraphBinary format.
+//
+// This method is part of the serializer interface and is used internally by the WebSocket driver.
+// It is also exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.) to
+// serialize requests created with MakeBytecodeRequest() or MakeStringRequest().
+//
+// The serialized bytes can be transmitted over any transport protocol that supports binary data.
+//
+// Parameters:
+//   - request: The request to serialize (created via MakeBytecodeRequest or MakeStringRequest)
+//
+// Returns:
+//   - []byte: The GraphBinary-encoded request ready for transmission
+//   - error: Any serialization error encountered
+//
+// Example for alternative transports:
+//
+//	req := MakeBytecodeRequest(bytecode, "g", "")
+//	serializer := newGraphBinarySerializer(nil)
+//	bytes, err := serializer.(graphBinarySerializer).SerializeMessage(&req)
+//	// Send bytes over custom transport
+func (gs graphBinarySerializer) SerializeMessage(request *request) ([]byte, error) {
 	args, err := convertArgs(request, gs)
 	if err != nil {
 		return nil, err
@@ -184,8 +204,26 @@ func uuidToBigInt(requestID uuid.UUID) big.Int {
 	return bigInt
 }
 
-// deserializeMessage deserializes a response message.
-func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, error) {
+// DeserializeMessage deserializes a GraphBinary-encoded response message.
+//
+// This method is part of the serializer interface and is used internally by the WebSocket driver.
+// It is also exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.) to
+// deserialize responses received from a Gremlin server.
+//
+// Parameters:
+//   - message: The GraphBinary-encoded response bytes
+//
+// Returns:
+//   - response: The deserialized response containing results and metadata
+//   - error: Any deserialization error encountered
+//
+// Example for alternative transports:
+//
+//	// Receive bytes from custom transport
+//	serializer := newGraphBinarySerializer(nil)
+//	resp, err := serializer.(graphBinarySerializer).DeserializeMessage(responseBytes)
+//	results := resp.responseResult.data
+func (gs graphBinarySerializer) DeserializeMessage(message []byte) (response, error) {
 	var msg response
 
 	if message == nil || len(message) == 0 {

gremlin-go/driver/serializer_test.go

@@ -42,7 +42,7 @@ func TestSerializer(t *testing.T) {
 			args:      map[string]interface{}{"gremlin": "g.V().count()", "aliases": map[string]interface{}{"g": "g"}},
 		}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		serialized, _ := serializer.serializeMessage(&testRequest)
+		serialized, _ := serializer.SerializeMessage(&testRequest)
 		stringified := fmt.Sprintf("%v", serialized)
 		if stringified != mapDataOrder1 && stringified != mapDataOrder2 {
 			assert.Fail(t, "Error, expected serialized map data to match one of the provided binary arrays. Can vary based on ordering of keyset, but must map to one of two.")
@@ -52,7 +52,7 @@ func TestSerializer(t *testing.T) {
 	t.Run("test serialized response message", func(t *testing.T) {
 		responseByteArray := []byte{129, 0, 251, 37, 42, 74, 117, 221, 71, 191, 183, 78, 86, 53, 0, 12, 132, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 16, 47, 49, 50, 55, 46, 48, 46, 48, 46, 49, 58, 54, 50, 48, 51, 53, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		response, err := serializer.deserializeMessage(responseByteArray)
+		response, err := serializer.DeserializeMessage(responseByteArray)
 		assert.Nil(t, err)
 		assert.Equal(t, "fb252a4a-75dd-47bf-b74e-5635000c8464", response.responseID.String())
 		assert.Equal(t, uint16(200), response.responseStatus.code)
@@ -69,7 +69,7 @@ func TestSerializer(t *testing.T) {
 		}()
 		responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62, 75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48, 46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117, 115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 0, 0, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 16, 240, 0, 0, 0, 0, 0, 0, 100, 21, 0, 0, 0, 0, 0, 0, 24, 30, 0, 0, 0, 0, 0, 0, 0, 32, 56}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		response, err := serializer.deserializeMessage(responseByteArray)
+		response, err := serializer.DeserializeMessage(responseByteArray)
 		assert.Nil(t, err)
 		assert.Equal(t, "45de2837-5f3e-4bf9-8685-9b852b97dd44", response.responseID.String())
 		assert.Equal(t, uint16(200), response.responseStatus.code)
@@ -91,7 +91,7 @@ func TestSerializerFailures(t *testing.T) {
 			args: map[string]interface{}{"invalidInput": "invalidInput", "aliases": map[string]interface{}{"g": "g"}},
 		}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		resp, err := serializer.serializeMessage(&testRequest)
+		resp, err := serializer.SerializeMessage(&testRequest)
 		assert.Nil(t, resp)
 		assert.NotNil(t, err)
 		assert.True(t, isSameErrorCode(newError(err0704ConvertArgsNoSerializerError), err))
@@ -100,7 +100,7 @@ func TestSerializerFailures(t *testing.T) {
 	t.Run("test unkownCustomType failure", func(t *testing.T) {
 		responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62, 75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48, 46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117, 115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 0, 0, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 16, 240, 0, 0, 0, 0, 0, 0, 100, 21, 0, 0, 0, 0, 0, 0, 24, 30, 0, 0, 0, 0, 0, 0, 0, 32, 56}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		resp, err := serializer.deserializeMessage(responseByteArray)
+		resp, err := serializer.DeserializeMessage(responseByteArray)
 		// a partial message will still be returned
 		assert.NotNil(t, resp)
 		assert.NotNil(t, err)