Add a protomongo package which exports a Go MongoDB codec for encoding/decoding protobuf objects (with protobuf field numbers as keys). (dataform-co#542)

* Add a protomongo package which exports a Go MongoDB codec for encoding/decoding protobuf objects (with protobuf field numbers as keys).

* cleanup and comments

* lewis comments

* add missing file

Author: BenBirt

WORKSPACE

@@ -81,7 +81,7 @@ go_rules_dependencies()
 
 go_register_toolchains()
 
-load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
+load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies", "go_repository")
 
 gazelle_dependencies()
 
@@ -119,3 +119,24 @@ load(
 )
 
 _nodejs_image_repos()
+
+go_repository(
+    name = "com_github_go_stack_stack",
+    importpath = "github.com/go-stack/stack",
+    sum = "h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=",
+    version = "v1.8.0",
+)
+
+go_repository(
+    name = "com_github_golang_protobuf",
+    importpath = "github.com/golang/protobuf",
+    sum = "h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=",
+    version = "v1.3.2",
+)
+
+go_repository(
+    name = "org_mongodb_go_mongo_driver",
+    importpath = "go.mongodb.org/mongo-driver",
+    sum = "h1:6fhXjXSzzXRQdqtFKOI1CDw6Gw5x6VflovRpfbrlVi0=",
+    version = "v1.2.0",
+)

go.mod

@@ -0,0 +1,9 @@
+module github.com/dataform-co/dataform
+
+go 1.13
+
+require (
+	github.com/go-stack/stack v1.8.0 // indirect
+	github.com/golang/protobuf v1.3.2
+	go.mongodb.org/mongo-driver v1.2.0
+)

go.sum

@@ -0,0 +1,6 @@
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+go.mongodb.org/mongo-driver v1.2.0 h1:6fhXjXSzzXRQdqtFKOI1CDw6Gw5x6VflovRpfbrlVi0=
+go.mongodb.org/mongo-driver v1.2.0/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM=

protomongo/BUILD

@@ -0,0 +1,41 @@
+load("@io_bazel_rules_go//proto:def.bzl", "go_proto_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_test(
+    name = "go_default_test",
+    srcs = ["protomongo_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        ":example_go_proto",
+        "@com_github_golang_protobuf//proto:go_default_library",
+        "@org_mongodb_go_mongo_driver//bson:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["protomongo.go"],
+    importpath = "github.com/dataform-co/dataform/protomongo",
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_golang_protobuf//descriptor:go_default_library_gen",
+        "@com_github_golang_protobuf//proto:go_default_library",
+        "@org_mongodb_go_mongo_driver//bson/bsoncodec:go_default_library",
+        "@org_mongodb_go_mongo_driver//bson/bsonrw:go_default_library",
+    ],
+)
+
+proto_library(
+    name = "example_proto",
+    testonly = 1,
+    srcs = ["example.proto"],
+    visibility = ["//visibility:public"],
+)
+
+go_proto_library(
+    name = "example_go_proto",
+    testonly = 1,
+    importpath = "github.com/dataform-co/dataform/protomongo/example",
+    proto = ":example_proto",
+    visibility = ["//visibility:public"],
+)

protomongo/example.proto

@@ -0,0 +1,49 @@
+syntax="proto3";
+
+package protomongo.example;
+
+option go_package = "github.com/dataform-co/dataform/protomongo/example";
+
+enum Enum {
+  VAL_0 = 0;
+  VAL_1 = 17;
+  VAL_2 = 364;
+}
+
+message SimpleMessage {
+  string string_field = 1;
+  int32 int32_field = 2;
+  int64 int64_field = 3;
+  float float_field = 4;
+  double double_field = 5;
+  bool bool_field = 6;
+  Enum enum_field = 7;
+}
+
+message RepeatedFieldMessage {
+  repeated string string_field = 1;
+  repeated int32 int32_field = 2;
+  repeated int64 int64_field = 3;
+  repeated float float_field = 4;
+  repeated double double_field = 5;
+  repeated bool bool_field = 6;
+  repeated Enum enum_field = 7;
+}
+
+message MessageWithSubMessage {
+  string string_field = 1;
+  SimpleMessage simple_message = 2;
+}
+
+message MessageWithRepeatedSubMessage {
+  string string_field = 1;
+  repeated SimpleMessage simple_message = 2;
+}
+
+message MessageWithOneof {
+    string string_field = 1;
+    oneof oneof_field {
+        int32 int32_oneof_field = 2;
+        int64 int64_oneof_field = 3;
+    }
+}

protomongo/protomongo.go

@@ -0,0 +1,134 @@
+package protomongo
+
+import (
+	"reflect"
+	"strconv"
+
+	"github.com/golang/protobuf/descriptor"
+	"github.com/golang/protobuf/proto"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
+)
+
+// ProtobufCodec is a MongoDB codec. It encodes protobuf objects using the protobuf field numbers as document
+// keys. This means that stored protobufs can survive normal protobuf definition changes, e.g. renaming a field.
+type ProtobufCodec struct {
+}
+
+func (pc *ProtobufCodec) EncodeValue(ectx bsoncodec.EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error {
+	oneofs := oneofNames(val.Interface().(descriptor.Message))
+	for val.Kind() != reflect.Struct {
+		val = val.Elem()
+	}
+	props := proto.GetProperties(val.Type())
+
+	dw, err := vw.WriteDocument()
+	if err != nil {
+		return err
+	}
+
+	for _, prop := range props.Prop {
+		fVal := val.FieldByName(prop.Name)
+		if !fVal.IsZero() {
+			// Figure out what tag and what value we are encoding.
+			tag := prop.Tag
+			if oneofs[prop.OrigName] {
+				// If this field is a oneof, we need to get the single Go value stored inside its oneof struct,
+				// instead of simply using the value as-is.
+				oneof := fVal.Elem().Elem()
+				singleProp := proto.GetProperties(oneof.Type()).Prop[0]
+				tag = singleProp.Tag
+				fVal = oneof.Field(0)
+			}
+
+			// Actually encode the tag/value.
+			fvw, err := dw.WriteDocumentElement(strconv.Itoa(tag))
+			if err != nil {
+				return err
+			}
+			enc, err := ectx.LookupEncoder(fVal.Type())
+			if err != nil {
+				return err
+			}
+			if err = enc.EncodeValue(ectx, fvw, fVal); err != nil {
+				return err
+			}
+		}
+	}
+
+	return dw.WriteDocumentEnd()
+}
+
+func (pc *ProtobufCodec) DecodeValue(ectx bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
+	oneofs := oneofNames(val.Interface().(descriptor.Message))
+	if val.IsNil() {
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+	for val.Kind() != reflect.Struct {
+		val = val.Elem()
+	}
+	props := proto.GetProperties(val.Type())
+
+	dr, err := vr.ReadDocument()
+	if err != nil {
+		return err
+	}
+
+	indexedProps := make(map[string]*proto.Properties)
+	indexedOneofProps := make(map[string]*proto.OneofProperties)
+	for _, prop := range props.Prop {
+		if !oneofs[prop.OrigName] {
+			indexedProps[strconv.Itoa(prop.Tag)] = prop
+		}
+	}
+	for _, oneof := range props.OneofTypes {
+		indexedOneofProps[strconv.Itoa(oneof.Prop.Tag)] = oneof
+	}
+
+	for f, fvr, err := dr.ReadElement(); err != bsonrw.ErrEOD; f, fvr, err = dr.ReadElement() {
+		if err != nil {
+			return err
+		}
+
+		prop, isProp := indexedProps[f]
+		oneof, isOneof := indexedOneofProps[f]
+
+		// Skip any field that we don't recognize.
+		if !isProp && !isOneof {
+			if err = vr.Skip(); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// Figure out what field we need to decode into.
+		var fVal reflect.Value
+		if isProp {
+			fVal = val.FieldByName(prop.Name)
+		} else if isOneof {
+			oneofVal := reflect.New(oneof.Type.Elem())
+			val.Field(oneof.Field).Set(oneofVal)
+			fVal = oneofVal.Elem().Field(0)
+		}
+
+		// Actually decode the value.
+		enc, err := ectx.LookupDecoder(fVal.Type())
+		if err != nil {
+			return err
+		}
+		if err = enc.DecodeValue(ectx, fvr, fVal); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func oneofNames(pb descriptor.Message) map[string]bool {
+	_, msgDescriptor := descriptor.ForMessage(pb)
+	names := make(map[string]bool)
+	for _, oneof := range msgDescriptor.OneofDecl {
+		names[*oneof.Name] = true
+	}
+	return names
+}