added better interoperability with Mongo's object id (#1344)

Author: YourTechBud

gateway/modules/crud/mgo/read.go

@@ -116,8 +116,10 @@ func (m *Mongo) Read(ctx context.Context, col string, req *model.ReadRequest) (i
 		results := []interface{}{}
 
 		if len(req.Aggregate) > 0 {
+			helpers.Logger.LogDebug(helpers.GetRequestID(ctx), "Mongo aggregate", map[string]interface{}{"pipeline": pipeline})
 			cur, err = collection.Aggregate(ctx, pipeline)
 		} else {
+			helpers.Logger.LogDebug(helpers.GetRequestID(ctx), "Mongo query", map[string]interface{}{"find": req.Find, "options": findOptions})
 			cur, err = collection.Find(ctx, req.Find, findOptions)
 		}
 		if err != nil {

gateway/utils/store.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/spaceuptech/helpers"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
 // Adjust loads value from state if referenced
@@ -77,6 +78,64 @@ func LoadValue(key string, state map[string]interface{}) (interface{}, error) {
 		pre := strings.IndexRune(function, '(')
 		post := strings.IndexRune(function, ')')
 		params := splitVariable(function[pre+1:len(function)-1], ',')
+
+		// Method check - stringToObjectId
+		if strings.HasPrefix(function, "stringToObjectId") {
+			value, err := LoadValue(function[pre+1:post], state)
+			if err != nil {
+				return nil, err
+			}
+
+			if v, ok := value.(primitive.A); ok {
+				value = []interface{}(v)
+			}
+
+			// The value can be a string or an array of string
+			switch v := value.(type) {
+			case primitive.ObjectID:
+				return v, nil
+			case string:
+				return primitive.ObjectIDFromHex(v)
+			case []interface{}:
+				array := make([]interface{}, len(v))
+				for i, item := range v {
+					s, ok := item.(string)
+					if !ok {
+						return nil, fmt.Errorf("value (%v) cannot be converted to ObjectID", item)
+					}
+
+					objID, err := primitive.ObjectIDFromHex(s)
+					if err != nil {
+						return nil, err
+					}
+
+					array[i] = objID
+				}
+				return array, nil
+			default:
+				return nil, fmt.Errorf("invalid type provided (%s) for object id conversion", reflect.TypeOf(value))
+			}
+		}
+
+		// Method check - objectIdToString
+		if strings.HasPrefix(function, "objectIdToString") {
+			value, err := LoadValue(function[pre+1:post], state)
+			if err != nil {
+				return nil, err
+			}
+
+			switch val := value.(type) {
+			case string:
+				return val, nil
+
+			case primitive.ObjectID:
+				return val.Hex(), nil
+
+			default:
+				return nil, fmt.Errorf("invalid type provided (%s) for object id conversion", reflect.TypeOf(value))
+			}
+		}
+
 		if strings.HasPrefix(function, "exists") {
 			_, err := LoadValue(function[pre+1:post], state)
 			return err == nil, nil

gateway/utils/store_test.go

@@ -5,6 +5,8 @@ import (
 	"reflect"
 	"testing"
 	"time"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
 func TestStoreValue(t *testing.T) {
@@ -599,6 +601,97 @@ func TestLoadNumber(t *testing.T) {
 	}
 }
 
+func TestLoadValueMongo(t *testing.T) {
+	objectID, _ := primitive.ObjectIDFromHex("5f7c4770582dc480c95ec67e")
+	type args struct {
+		key   string
+		state map[string]interface{}
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    interface{}
+		wantErr bool
+	}{
+		{
+			name: "string to object id",
+			args: args{
+				key:   "utils.stringToObjectId(args.string)",
+				state: map[string]interface{}{"string": "5f7c4770582dc480c95ec67e"},
+			},
+			want: objectID,
+		},
+		{
+			name: "string array to object id",
+			args: args{
+				key:   "utils.stringToObjectId(args.string)",
+				state: map[string]interface{}{"string": []interface{}{"5f7c4770582dc480c95ec67e", "5f7c4770582dc480c95ec67e"}},
+			},
+			want: []interface{}{objectID, objectID},
+		},
+		{
+			name: "string array (primitive.A) to object id",
+			args: args{
+				key:   "utils.stringToObjectId(args.string)",
+				state: map[string]interface{}{"string": primitive.A{"5f7c4770582dc480c95ec67e", "5f7c4770582dc480c95ec67e"}},
+			},
+			want: []interface{}{objectID, objectID},
+		},
+		{
+			name: "object id  to object id",
+			args: args{
+				key:   "utils.stringToObjectId(args.string)",
+				state: map[string]interface{}{"string": objectID},
+			},
+			want: objectID,
+		},
+		{
+			name: "invalid string to object id",
+			args: args{
+				key:   "utils.stringToObjectId(args.string)",
+				state: map[string]interface{}{"string": "5f7c4770582dc480c95ec67edd"},
+			},
+			wantErr: true,
+		},
+		{
+			name: "string to string",
+			args: args{
+				key:   "utils.objectIdToString(args.obj)",
+				state: map[string]interface{}{"obj": "5f7c4770582dc480c95ec67e"},
+			},
+			want: "5f7c4770582dc480c95ec67e",
+		},
+		{
+			name: "object id to string",
+			args: args{
+				key:   "utils.objectIdToString(args.obj)",
+				state: map[string]interface{}{"obj": objectID},
+			},
+			want: "5f7c4770582dc480c95ec67e",
+		},
+		{
+			name: "random stuff to string",
+			args: args{
+				key:   "utils.objectIdToString(args.obj)",
+				state: map[string]interface{}{"obj": 12},
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := LoadValue(tt.args.key, map[string]interface{}{"args": tt.args.state})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("LoadValue() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("LoadValue() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 func TestLoadValue(t *testing.T) {
 	type args struct {
 		key   string