feat(metadata): impl endpoint for updating metadata (#9)

Author: Zaba505

http/api.go

@@ -4,6 +4,7 @@ package http
 import (
 	"bytes"
 	"fmt"
+	"strings"
 
 	"github.com/z5labs/sakuin"
 	"github.com/z5labs/sakuin/http/middleware/logger"
@@ -57,6 +58,7 @@ func NewServer(s *sakuin.Service, cfg ...fiber.Config) *fiber.App {
 
 	// Metadata
 	app.Get("/index/:id/metadata", NewGetMetadataHandler(s))
+	app.Put("/index/:id/metadata", NewUpdateMetadataHandler(s))
 
 	// Indexing
 	app.Post("/index", NewIndexHandler(s))
@@ -163,6 +165,56 @@ func NewGetMetadataHandler(s *sakuin.Service) fiber.Handler {
 	}
 }
 
+// NewUpdateMetadataHandler godoc
+// @Summary  Update object metadata by id. This will override and merge metadata fields.
+// @Tags     Metadata
+// @Accept   json
+// @Success  200  "Successfully updated object metadata."
+// @Failure  500  {object}  APIError
+// @Param    id   path      string  true  "Object ID"
+// @Router   /index/{id}/metadata [put]
+func NewUpdateMetadataHandler(s *sakuin.Service) fiber.Handler {
+	return func(c *fiber.Ctx) error {
+		if contentType := c.Get("Content-Type"); !strings.Contains(contentType, "application/json") {
+			zap.L().Warn("received invalid content type", zap.String("content-type", contentType))
+
+			return c.Status(fiber.StatusBadRequest).
+				JSON(APIError{
+					Message: "content type must be: application/json",
+				})
+		}
+
+		var m map[string]interface{}
+		err := c.BodyParser(&m)
+		if err != nil {
+			zap.L().Error("unexpected error when unmarshalling request body", zap.Error(err))
+			return c.Status(fiber.StatusInternalServerError).
+				JSON(APIError{
+					Message: err.Error(),
+				})
+		}
+
+		id := c.Params("id")
+
+		_, err = s.UpdateMetadata(c.Context(), &sakuin.UpdateMetadataRequest{
+			ID:       id,
+			Metadata: m,
+		})
+		if _, ok := err.(sakuin.DocumentDoesNotExistErr); ok {
+			zap.L().Error("metadata does not exist", zap.String("id", id))
+			return c.SendStatus(fiber.StatusNotFound)
+		}
+		if err != nil {
+			zap.L().Error("unexpected error when updating metadata", zap.Error(err))
+			return c.Status(fiber.StatusInternalServerError).JSON(APIError{
+				Message: err.Error(),
+			})
+		}
+
+		return c.SendStatus(fiber.StatusOK)
+	}
+}
+
 // NewIndexHandler godoc
 // @Summary  index a new object along with its metadata
 // @Tags     Index

http/metadata_test.go

@@ -1,11 +1,14 @@
 package http
 
 import (
+	"bytes"
 	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/z5labs/sakuin"
+
+	"github.com/stretchr/testify/assert"
 )
 
 const getMetadataEndpointFmt = "http://%s/index/%s/metadata"
@@ -77,3 +80,82 @@ func TestGetMetadataHandler(t *testing.T) {
 		}
 	})
 }
+
+func TestUpdateMetadataHandler(t *testing.T) {
+	t.Run("should fail if req content type isn't json", func(subT *testing.T) {
+		addr, err := startTestServer(subT)
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		uri := fmt.Sprintf(getMetadataEndpointFmt, addr, "metadataDoesNotExistID")
+		req, err := http.NewRequest(http.MethodPut, uri, bytes.NewReader([]byte("{}")))
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		assert.Equal(subT, http.StatusBadRequest, resp.StatusCode)
+	})
+
+	t.Run("should fail if metadata doesn't exist", func(subT *testing.T) {
+		addr, err := startTestServer(subT)
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		uri := fmt.Sprintf(getMetadataEndpointFmt, addr, "metadataDoesNotExistID")
+		req, err := http.NewRequest(http.MethodPut, uri, bytes.NewReader([]byte("{}")))
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+		req.Header.Set("Content-Type", "application/json")
+
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		assert.Equal(subT, http.StatusNotFound, resp.StatusCode)
+	})
+
+	t.Run("should succeed if metadata does exist", func(subT *testing.T) {
+		testDocID := "test"
+		testMetadata := map[string]interface{}{"hello": "world"}
+
+		docStore := sakuin.NewInMemoryDocumentStore().
+			WithDocument(testDocID, testMetadata)
+
+		addr, err := startTestServer(subT, withDocumentStore(docStore))
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		uri := fmt.Sprintf(getMetadataEndpointFmt, addr, testDocID)
+		req, err := http.NewRequest(http.MethodPut, uri, bytes.NewReader([]byte(`{"good": "bye"}`)))
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+		req.Header.Set("Content-Type", "application/json")
+
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			subT.Error(err)
+			return
+		}
+
+		assert.Equal(subT, http.StatusOK, resp.StatusCode)
+	})
+}

http/object_test.go

@@ -6,8 +6,9 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/z5labs/sakuin"
+
+	"github.com/stretchr/testify/assert"
 )
 
 const getObjectEndpointFmt = "http://%s/index/%s/object"

index.go

@@ -76,6 +76,25 @@ func (s *Service) GetMetadata(ctx context.Context, req *GetMetadataRequest) (*Ge
 	return &GetMetadataResponse{Metadata: doc}, nil
 }
 
+type UpdateMetadataRequest struct {
+	ID       string
+	Metadata map[string]interface{}
+}
+
+type UpdateMetadataResponse struct{}
+
+func (s *Service) UpdateMetadata(ctx context.Context, req *UpdateMetadataRequest) (*UpdateMetadataResponse, error) {
+	stats, err := s.docDB.Stat(ctx, req.ID)
+	if err != nil {
+		return nil, err
+	}
+	if !stats.Exists {
+		return nil, DocumentDoesNotExistErr{ID: req.ID}
+	}
+
+	return nil, s.docDB.Upsert(ctx, req.ID, req.Metadata)
+}
+
 type IndexRequest struct {
 	Metadata map[string]interface{}
 	Object   []byte

storage.go

@@ -58,20 +58,6 @@ func RunObjectStorageTests(t TestingT, objStore ObjectStore) {
 	})
 }
 
-type DocumentStore interface {
-	Stat(ctx context.Context, id string) (*StatInfo, error)
-	Get(ctx context.Context, id string) (map[string]interface{}, error)
-	Upsert(ctx context.Context, id string, b map[string]interface{}) error
-}
-
-func RunDocumentStorageTests(t TestingT, docStore DocumentStore) {
-	t.Run("should fail with DocumentDoesNotExistErr if document doesn't exist", func(subT TestingT) {
-		var docErr DocumentDoesNotExistErr
-		_, err := docStore.Get(context.Background(), "")
-		assert.ErrorAs(subT, err, &docErr, "expected and DocumentDoesNotExistErr")
-	})
-}
-
 type InMemoryObjectStore struct {
 	mu      sync.Mutex
 	objects map[string][]byte
@@ -137,6 +123,20 @@ func (s *InMemoryObjectStore) NumOfObects() int {
 	return len(s.objects)
 }
 
+type DocumentStore interface {
+	Stat(ctx context.Context, id string) (*StatInfo, error)
+	Get(ctx context.Context, id string) (map[string]interface{}, error)
+	Upsert(ctx context.Context, id string, b map[string]interface{}) error
+}
+
+func RunDocumentStorageTests(t TestingT, docStore DocumentStore) {
+	t.Run("should fail with DocumentDoesNotExistErr if document doesn't exist", func(subT TestingT) {
+		var docErr DocumentDoesNotExistErr
+		_, err := docStore.Get(context.Background(), "")
+		assert.ErrorAs(subT, err, &docErr, "expected and DocumentDoesNotExistErr")
+	})
+}
+
 type InMemoryDocumentStore struct {
 	mu   sync.Mutex
 	docs map[string]map[string]interface{}