From 90e9c01c6518082b7bb4f61263c716fab86297cf Mon Sep 17 00:00:00 2001
From: bbernays <ben@bernays.me>
Date: Thu, 28 Jul 2022 08:32:30 -0400
Subject: [PATCH] feat: Add new Resolver PathTableResolver (#440)

---
 provider/schema/resolvers.go      | 13 +++++
 provider/schema/resolvers_test.go | 85 +++++++++++++++++++++++++------
 2 files changed, 83 insertions(+), 15 deletions(-)

diff --git a/provider/schema/resolvers.go b/provider/schema/resolvers.go
index 90098c92..ab3cfbd0 100644
--- a/provider/schema/resolvers.go
+++ b/provider/schema/resolvers.go
@@ -12,6 +12,19 @@ import (
 	"github.com/thoas/go-funk"
 )
 
+// PathTableResolver resolves a table in the parent.Item
+//
+// Examples:
+// PathTableResolver("Field")
+// PathTableResolver("InnerStruct.Field")
+// PathTableResolver("InnerStruct.InnerInnerStruct.Field")
+func PathTableResolver(path string) TableResolver {
+	return func(ctx context.Context, meta ClientMeta, parent *Resource, res chan<- interface{}) error {
+		res <- funk.Get(parent.Item, path, funk.WithAllowZero())
+		return nil
+	}
+}
+
 // PathResolver resolves a field in the Resource.Item
 //
 // Examples:
diff --git a/provider/schema/resolvers_test.go b/provider/schema/resolvers_test.go
index 69d0ca5e..a526c309 100644
--- a/provider/schema/resolvers_test.go
+++ b/provider/schema/resolvers_test.go
@@ -15,6 +15,7 @@ type innerStruct struct {
 }
 
 type testStruct struct {
+	NilInner   *innerStruct
 	Inner      innerStruct
 	Value      int
 	unexported bool
@@ -130,24 +131,78 @@ var UUIDTestTable = &Table{
 	},
 }
 
-func TestPathResolver(t *testing.T) {
-	r1 := PathResolver("Inner.Value")
-	r2 := PathResolver("Value")
-	r3 := PathResolver("unexported")
-	resource := NewResourceData(PostgresDialect{}, pathTestTable, nil, testStruct{Inner: innerStruct{Value: "bla"}, Value: 5, unexported: false}, nil, time.Now())
-	err := r1(context.TODO(), nil, resource, Column{Name: "test"})
-
-	assert.Nil(t, err)
-	assert.Equal(t, resource.Get("test"), "bla")
+func TestPathTableResolver(t *testing.T) {
+	results := make(chan interface{})
+	pathTableTests := []struct {
+		path          string
+		isNil         bool
+		expectedValue interface{}
+	}{
+		{
+			path:          "Inner",
+			expectedValue: innerStruct{Value: "bla"},
+		},
+		{
+			path:          "Inner.Value",
+			expectedValue: "bla",
+		},
+		{
+			path:          "NilInner.Value",
+			expectedValue: "",
+		}, {
+			path:          "unexported",
+			expectedValue: nil,
+		},
+	}
 
-	err = r2(context.TODO(), nil, resource, Column{Name: "int_value"})
+	resource := NewResourceData(PostgresDialect{}, pathTestTable, nil, testStruct{Inner: innerStruct{Value: "bla"}, Value: 5, unexported: false}, nil, time.Now())
+	for _, test := range pathTableTests {
+		r1 := PathTableResolver(test.path)
+		go func() {
+			err := r1(context.TODO(), nil, resource, results)
+			assert.Nil(t, err)
+		}()
+		result := <-results
+		assert.Equal(t, test.expectedValue, result, "path: %s", test.path)
+	}
+}
 
-	assert.Nil(t, err)
-	assert.Equal(t, resource.Get("int_value"), 5)
+func TestPathResolver(t *testing.T) {
+	pathTableTests := []struct {
+		path       string
+		getterPath string
+		isNil      bool
+		value      interface{}
+	}{
+		{
+			path:       "Inner.Value",
+			getterPath: "test",
+			value:      "bla",
+		},
+		{
+			path:       "Value",
+			getterPath: "int_value",
+			value:      5,
+		},
+		{
+			path:       "unexported",
+			getterPath: "unexported",
+			isNil:      true,
+			value:      nil,
+		},
+	}
 
-	err = r3(context.TODO(), nil, resource, Column{Name: "unexported"})
-	assert.Nil(t, err)
-	assert.Nil(t, resource.Get("unexported"))
+	resource := NewResourceData(PostgresDialect{}, pathTestTable, nil, testStruct{Inner: innerStruct{Value: "bla"}, Value: 5, unexported: false}, nil, time.Now())
+	for _, test := range pathTableTests {
+		r1 := PathResolver(test.path)
+		err := r1(context.TODO(), nil, resource, Column{Name: test.getterPath})
+		assert.Nil(t, err)
+		if test.isNil {
+			assert.Nil(t, resource.Get(test.getterPath))
+		} else {
+			assert.Equal(t, test.value, resource.Get(test.getterPath))
+		}
+	}
 }
 
 func TestInterfaceSlice(t *testing.T) {