Merge pull request #17 from kohkimakimoto/update-lazyprops

Update lazyprops

README.md

@@ -127,17 +127,23 @@ inertia.Render(c, http.StatusOK, "Index", map[string]interface{}{
 	// ALWAYS included on first visit...
 	// OPTIONALLY included on partial reloads...
 	// ONLY evaluated when needed...
-	"users": func() interface{} {
-		users := // get users...
+	"users": func() (interface{}, error) {
+    users, err := // get users...
+    if err != nil {
+        return nil, err
+    }
 		return users
 	},
 
 	// NEVER included on first visit
 	// OPTIONALLY included on partial reloads
 	// ONLY evaluated when needed
-	"users": inertia.Lazy(func() interface{} {
-		users := // get users...
-		return users
+	"users": inertia.Lazy(func() (interface{}, error) {
+		users, err := // get users...
+		if err != nil {
+      return nil, err
+    }
+		return users, nil
 	}),
 })
 ```

inertia.go

@@ -146,7 +146,9 @@ func (i *Inertia) render(code int, component string, props, viewData map[string]
 		props = filteredProps
 	}
 
-	evaluateProps(props)
+	if err := evaluateProps(props); err != nil {
+		return err
+	}
 
 	page := &Page{
 		Component: component,
@@ -179,13 +181,15 @@ func (i *Inertia) renderHTML(code int, name string, data map[string]interface{})
 	return i.c.HTMLBlob(code, buf.Bytes())
 }
 
+type LazyPropFunc func() (interface{}, error)
+
 type LazyProp struct {
-	callback func() interface{}
+	callback LazyPropFunc
 }
 
 // Lazy defines a lazy evaluated data.
 // see https://inertiajs.com/partial-reloads#lazy-data-evaluation
-func Lazy(callback func() interface{}) *LazyProp {
+func Lazy(callback LazyPropFunc) *LazyProp {
 	return &LazyProp{
 		callback: callback,
 	}

inertia_test.go

@@ -239,8 +239,8 @@ func TestInertia_Render(t *testing.T) {
 			"key2": func() interface{} {
 				return "value2"
 			},
-			"key3": Lazy(func() interface{} {
-				return "value3"
+			"key3": Lazy(func() (interface{}, error) {
+				return "value3", nil
 			}),
 		})
 		if err != nil {
@@ -288,8 +288,8 @@ func TestInertia_Render(t *testing.T) {
 			"key2": func() interface{} {
 				return "value2"
 			},
-			"key3": Lazy(func() interface{} {
-				return "value3"
+			"key3": Lazy(func() (interface{}, error) {
+				return "value3", nil
 			}),
 		})
 		if err != nil {

util.go

@@ -39,15 +39,28 @@ func splitAndRemoveEmpty(s string, sep string) []string {
 }
 
 // evaluateProps evaluates the given props and update it.
-func evaluateProps(values map[string]interface{}) {
+func evaluateProps(values map[string]interface{}) error {
 	for k, v := range values {
 		switch converted := v.(type) {
 		case map[string]interface{}:
-			evaluateProps(converted)
+			if err := evaluateProps(converted); err != nil {
+				return err
+			}
 		case *LazyProp:
-			values[k] = converted.callback()
+			vv, err := converted.callback()
+			if err != nil {
+				return err
+			}
+			values[k] = vv
+		case func() (interface{}, error):
+			vv, err := converted()
+			if err != nil {
+				return err
+			}
+			values[k] = vv
 		case func() interface{}:
 			values[k] = converted()
 		}
 	}
+	return nil
 }

util_test.go

@@ -1,6 +1,8 @@
 package inertia
 
 import (
+	"errors"
+	"reflect"
 	"testing"
 )
 
@@ -111,27 +113,71 @@ func TestSplitAndRemoveEmpty(t *testing.T) {
 }
 
 func TestEvaluateProps(t *testing.T) {
-	a := map[string]interface{}{
-		"a": "aaa",
-		"b": map[string]interface{}{
-			"b-a": "b-aaa",
-			"b-b": map[string]interface{}{
-				"b-b-a": "b-b-aaa",
+	tests := []struct {
+		values   map[string]interface{}
+		expected map[string]interface{}
+		error    bool
+	}{
+		{
+			values: map[string]interface{}{
+				"a": "aaa",
+				"b": map[string]interface{}{
+					"b-a": "b-aaa",
+					"b-b": map[string]interface{}{
+						"b-b-a": "b-b-aaa",
+					},
+				},
+				"c": Lazy(func() (interface{}, error) {
+					return "ccc", nil
+				}),
+				"d": func() interface{} {
+					return "ddd"
+				},
 			},
+			expected: map[string]interface{}{
+				"a": "aaa",
+				"b": map[string]interface{}{
+					"b-a": "b-aaa",
+					"b-b": map[string]interface{}{
+						"b-b-a": "b-b-aaa",
+					},
+				},
+				"c": "ccc",
+				"d": "ddd",
+			},
+			error: false,
 		},
-		"c": Lazy(func() interface{} {
-			return "ccc"
-		}),
-		"d": func() interface{} {
-			return "ddd"
+		{
+			values: map[string]interface{}{
+				"a": func() (interface{}, error) {
+					return nil, errors.New("error")
+				},
+			},
+			error: true,
+		},
+		{
+			values: map[string]interface{}{
+				"a": Lazy(func() (interface{}, error) {
+					return nil, errors.New("error")
+				},
+				),
+			},
+			error: true,
 		},
 	}
 
-	evaluateProps(a)
-	if a["c"] != "ccc" {
-		t.Errorf("expected 'ccc' but %v", a["c"])
-	}
-	if a["d"] != "ddd" {
-		t.Errorf("expected 'ddd' but %v", a["d"])
+	for _, tt := range tests {
+		err := evaluateProps(tt.values)
+		if tt.error && err == nil {
+			t.Errorf("expected error but nil")
+		}
+		if !tt.error {
+			if err != nil {
+				t.Errorf("expected nil but %v", err)
+			}
+			if !reflect.DeepEqual(tt.expected, tt.values) {
+				t.Errorf("expected %v but %v", tt.expected, tt.values)
+			}
+		}
 	}
 }