feat: Add new Resolver PathTableResolver (#440)

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:

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) {