item_get: bring back support for using Find

If there are query predicates apart from `id`, use `resource.Find` instead of `resource.Get`.
This puts back ability add additional predicates apart from `id`.
Who needs that, anyway?

Author: Dragomir-Ivanov

rest/method_item_get.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"net/http"
 	"time"
+
+	"github.com/rs/rest-layer/resource"
+	"github.com/rs/rest-layer/schema/query"
 )
 
 // itemGet handles GET and HEAD resquests on an item URL.
@@ -13,12 +16,29 @@ func itemGet(ctx context.Context, r *http.Request, route *RouteMatch) (status in
 		return e.Code, nil, e
 	}
 	rsrc := route.Resource()
-	item, err := rsrc.Get(ctx, route.ResourceID())
-	if err != nil {
-		e, code := NewError(err)
-		return code, nil, e
-	} else if item == nil {
-		return ErrNotFound.Code, nil, ErrNotFound
+	var item *resource.Item
+
+	// See if there are additional predicates.
+	// There is already one predicate: id
+	if len(q.Predicate) > 1 {
+		q.Window = &query.Window{Limit: 1}
+		list, err := rsrc.Find(ctx, q)
+		if err != nil {
+			e, code := NewError(err)
+			return code, nil, e
+		} else if len(list.Items) == 0 {
+			return ErrNotFound.Code, nil, ErrNotFound
+		}
+		item = list.Items[0]
+	} else {
+		var err error
+		item, err = rsrc.Get(ctx, route.ResourceID())
+		if err != nil {
+			e, code := NewError(err)
+			return code, nil, e
+		} else if item == nil {
+			return ErrNotFound.Code, nil, ErrNotFound
+		}
 	}
 	// Handle conditional request: If-None-Match.
 	if compareEtag(r.Header.Get("If-None-Match"), item.ETag) {
@@ -34,6 +54,7 @@ func itemGet(ctx context.Context, r *http.Request, route *RouteMatch) (status in
 			return 304, nil, nil
 		}
 	}
+	var err error
 	item.Payload, err = q.Projection.Eval(ctx, item.Payload, restResource{rsrc})
 	if err != nil {
 		e, code := NewError(err)

rest/method_item_get_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/rs/rest-layer/resource"
 	"github.com/rs/rest-layer/resource/testing/mem"
 	"github.com/rs/rest-layer/schema"
+	"github.com/rs/rest-layer/schema/query"
 )
 
 func TestGetItem(t *testing.T) {
@@ -300,3 +301,104 @@ func TestHandlerGetItemNoStorage(t *testing.T) {
 	}
 	tc.Test(t)
 }
+
+type Hook struct {
+	Called map[string]bool
+}
+
+func (h *Hook) OnGet(ctx context.Context, id interface{}) error {
+	h.Called["OnGet"] = true
+	return nil
+}
+func (h *Hook) OnFind(ctx context.Context, q *query.Query) error {
+	h.Called["OnFind"] = true
+	return nil
+}
+
+func TestHandlerGetHook(t *testing.T) {
+	tests := map[string]requestTest{
+		"hooks:trigger - OnGet": {
+			Init: func() *requestTestVars {
+				s := mem.NewHandler()
+				s.Insert(context.TODO(), []*resource.Item{
+					{ID: "1", Payload: map[string]interface{}{"id": "1", "foo": "bar"}},
+				})
+
+				idx := resource.NewIndex()
+				foo := idx.Bind("foo", schema.Schema{
+					Fields: schema.Fields{
+						"id":  {Filterable: true},
+						"foo": {Filterable: true},
+					},
+				}, s, resource.DefaultConf)
+
+				hook := &Hook{
+					Called: make(map[string]bool),
+				}
+				foo.Use(hook)
+
+				return &requestTestVars{
+					Index:       idx,
+					CalledHooks: &hook.Called,
+				}
+			},
+			NewRequest: func() (*http.Request, error) {
+				return http.NewRequest("GET", "/foo/1", nil)
+			},
+			ResponseCode: http.StatusOK,
+			ResponseBody: `{"id": "1", "foo": "bar"}`,
+			ExtraTest: func(t *testing.T, v *requestTestVars) {
+				if !(*v.CalledHooks)["OnGet"] {
+					t.Errorf("Expected OnGet to be called")
+				}
+				if (*v.CalledHooks)["OnFind"] {
+					t.Errorf("Expected OnFind not to be called")
+				}
+			},
+		},
+		"hooks:trigger - OnFind": {
+			Init: func() *requestTestVars {
+				s := mem.NewHandler()
+				s.Insert(context.TODO(), []*resource.Item{
+					{ID: "1", Payload: map[string]interface{}{"id": "1", "foo": "bar"}},
+				})
+
+				idx := resource.NewIndex()
+				foo := idx.Bind("foo", schema.Schema{
+					Fields: schema.Fields{
+						"id":  {Filterable: true},
+						"foo": {Filterable: true},
+					},
+				}, s, resource.DefaultConf)
+
+				hook := &Hook{
+					Called: make(map[string]bool),
+				}
+				foo.Use(hook)
+
+				return &requestTestVars{
+					Index:       idx,
+					CalledHooks: &hook.Called,
+				}
+			},
+			NewRequest: func() (*http.Request, error) {
+				return http.NewRequest("GET", `/foo/1?filter={foo:"bar"}`, nil)
+			},
+			ResponseCode: http.StatusOK,
+			ResponseBody: `{"id": "1", "foo": "bar"}`,
+			ExtraTest: func(t *testing.T, v *requestTestVars) {
+				if (*v.CalledHooks)["OnGet"] {
+					t.Errorf("Expected OnGet not to be called")
+				}
+				if !(*v.CalledHooks)["OnFind"] {
+					t.Errorf("Expected OnFind to be called")
+				}
+			},
+		},
+	}
+
+	for n, tc := range tests {
+		tc := tc // capture range variable
+		t.Run(n, tc.Test)
+	}
+}

rest/method_test.go

@@ -12,7 +12,6 @@ import (
 )
 
 // requestTest is a reusable type for testing POST, PUT, PATCH or GET requests. Best used in a map, E.g.:
-//     go
 type requestTest struct {
 	Init           func() *requestTestVars
 	NewRequest     func() (*http.Request, error)
@@ -26,8 +25,9 @@ type requestCheckerFunc func(*testing.T, *requestTestVars)
 
 // requestTestVars provodes test runtime variables.
 type requestTestVars struct {
-	Index   resource.Index             // required
-	Storers map[string]resource.Storer // optional: may be used by ExtraTest function
+	Index       resource.Index             // required
+	Storers     map[string]resource.Storer // optional: may be used by ExtraTest function
+	CalledHooks *map[string]bool
 }
 
 // Test runs tt in parallel mode. It can be passed as a second parameter to