Extract constants instead of duplicating literals

api/handlers/collections.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
 
@@ -24,7 +25,7 @@ func (h *Handlers) GetAllCollections(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) GetCollection(c *gin.Context) {
@@ -38,11 +39,11 @@ func (h *Handlers) GetCollection(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DeleteCollection(c *gin.Context) {
@@ -56,11 +57,11 @@ func (h *Handlers) DeleteCollection(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) CreateCollection(c *gin.Context) {
@@ -73,13 +74,13 @@ func (h *Handlers) CreateCollection(c *gin.Context) {
 	}
 
 	if newCollection.ID == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"message": "BadRequest"})
+		c.JSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	createdCollection, status := h.dataStore.CreateCollection(databaseId, newCollection)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -88,5 +89,5 @@ func (h *Handlers) CreateCollection(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/databases.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
 
@@ -20,7 +21,7 @@ func (h *Handlers) GetAllDatabases(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) GetDatabase(c *gin.Context) {
@@ -33,11 +34,11 @@ func (h *Handlers) GetDatabase(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DeleteDatabase(c *gin.Context) {
@@ -50,11 +51,11 @@ func (h *Handlers) DeleteDatabase(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) CreateDatabase(c *gin.Context) {
@@ -66,13 +67,13 @@ func (h *Handlers) CreateDatabase(c *gin.Context) {
 	}
 
 	if newDatabase.ID == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"message": "BadRequest"})
+		c.JSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	createdDatabase, status := h.dataStore.CreateDatabase(newDatabase)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -81,5 +82,5 @@ func (h *Handlers) CreateDatabase(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/documents.go

@@ -35,7 +35,7 @@ func (h *Handlers) GetAllDocuments(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) GetDocument(c *gin.Context) {
@@ -50,11 +50,11 @@ func (h *Handlers) GetDocument(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DeleteDocument(c *gin.Context) {
@@ -69,11 +69,11 @@ func (h *Handlers) DeleteDocument(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 // TODO: Maybe move "replace" logic to data store
@@ -90,13 +90,13 @@ func (h *Handlers) ReplaceDocument(c *gin.Context) {
 
 	status := h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
 	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, requestBody)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -105,7 +105,7 @@ func (h *Handlers) ReplaceDocument(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) PatchDocument(c *gin.Context) {
@@ -115,7 +115,7 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 
 	document, status := h.dataStore.GetDocument(databaseId, collectionId, documentId)
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
@@ -166,13 +166,13 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 
 	status = h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
 	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, modifiedDocument)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -181,7 +181,7 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DocumentsPost(c *gin.Context) {
@@ -208,7 +208,7 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 	}
 
 	if requestBody["id"] == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"message": "BadRequest"})
+		c.JSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
@@ -219,7 +219,7 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 
 	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, requestBody)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -228,7 +228,7 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func parametersToMap(pairs []interface{}) map[string]interface{} {

api/handlers/partition_key_ranges.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/pikami/cosmium/internal/resourceid"
 )
@@ -42,9 +43,9 @@ func (h *Handlers) GetPartitionKeyRanges(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/stored_procedures.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
 
@@ -20,7 +21,7 @@ func (h *Handlers) GetAllStoredProcedures(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) GetStoredProcedure(c *gin.Context) {
@@ -36,11 +37,11 @@ func (h *Handlers) GetStoredProcedure(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DeleteStoredProcedure(c *gin.Context) {
@@ -55,11 +56,11 @@ func (h *Handlers) DeleteStoredProcedure(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) ReplaceStoredProcedure(c *gin.Context) {
@@ -69,19 +70,19 @@ func (h *Handlers) ReplaceStoredProcedure(c *gin.Context) {
 
 	var sp datastore.StoredProcedure
 	if err := c.BindJSON(&sp); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	status := h.dataStore.DeleteStoredProcedure(databaseId, collectionId, spId)
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
 	createdSP, status := h.dataStore.CreateStoredProcedure(databaseId, collectionId, sp)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -90,7 +91,7 @@ func (h *Handlers) ReplaceStoredProcedure(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) CreateStoredProcedure(c *gin.Context) {
@@ -99,13 +100,13 @@ func (h *Handlers) CreateStoredProcedure(c *gin.Context) {
 
 	var sp datastore.StoredProcedure
 	if err := c.BindJSON(&sp); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	createdSP, status := h.dataStore.CreateStoredProcedure(databaseId, collectionId, sp)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -114,5 +115,5 @@ func (h *Handlers) CreateStoredProcedure(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/triggers.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
 
@@ -20,7 +21,7 @@ func (h *Handlers) GetAllTriggers(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) GetTrigger(c *gin.Context) {
@@ -36,11 +37,11 @@ func (h *Handlers) GetTrigger(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DeleteTrigger(c *gin.Context) {
@@ -55,11 +56,11 @@ func (h *Handlers) DeleteTrigger(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) ReplaceTrigger(c *gin.Context) {
@@ -69,19 +70,19 @@ func (h *Handlers) ReplaceTrigger(c *gin.Context) {
 
 	var trigger datastore.Trigger
 	if err := c.BindJSON(&trigger); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	status := h.dataStore.DeleteTrigger(databaseId, collectionId, triggerId)
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
 	createdTrigger, status := h.dataStore.CreateTrigger(databaseId, collectionId, trigger)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -90,7 +91,7 @@ func (h *Handlers) ReplaceTrigger(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) CreateTrigger(c *gin.Context) {
@@ -99,13 +100,13 @@ func (h *Handlers) CreateTrigger(c *gin.Context) {
 
 	var trigger datastore.Trigger
 	if err := c.BindJSON(&trigger); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	createdTrigger, status := h.dataStore.CreateTrigger(databaseId, collectionId, trigger)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -114,5 +115,5 @@ func (h *Handlers) CreateTrigger(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/user_defined_functions.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
 
@@ -20,7 +21,7 @@ func (h *Handlers) GetAllUserDefinedFunctions(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) GetUserDefinedFunction(c *gin.Context) {
@@ -36,11 +37,11 @@ func (h *Handlers) GetUserDefinedFunction(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) DeleteUserDefinedFunction(c *gin.Context) {
@@ -55,11 +56,11 @@ func (h *Handlers) DeleteUserDefinedFunction(c *gin.Context) {
 	}
 
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) ReplaceUserDefinedFunction(c *gin.Context) {
@@ -69,19 +70,19 @@ func (h *Handlers) ReplaceUserDefinedFunction(c *gin.Context) {
 
 	var udf datastore.UserDefinedFunction
 	if err := c.BindJSON(&udf); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	status := h.dataStore.DeleteUserDefinedFunction(databaseId, collectionId, udfId)
 	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
 	}
 
 	createdUdf, status := h.dataStore.CreateUserDefinedFunction(databaseId, collectionId, udf)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -90,7 +91,7 @@ func (h *Handlers) ReplaceUserDefinedFunction(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }
 
 func (h *Handlers) CreateUserDefinedFunction(c *gin.Context) {
@@ -99,13 +100,13 @@ func (h *Handlers) CreateUserDefinedFunction(c *gin.Context) {
 
 	var udf datastore.UserDefinedFunction
 	if err := c.BindJSON(&udf); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, gin.H{"message": "Invalid body"})
+		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
 		return
 	}
 
 	createdUdf, status := h.dataStore.CreateUserDefinedFunction(databaseId, collectionId, udf)
 	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
+		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
 		return
 	}
 
@@ -114,5 +115,5 @@ func (h *Handlers) CreateUserDefinedFunction(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
+	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/tests/authentication_test.go

@@ -19,7 +19,7 @@ func Test_Authentication(t *testing.T) {
 	t.Run("Should get 200 when correct account key is used", func(t *testing.T) {
 		ts.DataStore.DeleteDatabase(testDatabaseName)
 		client, err := azcosmos.NewClientFromConnectionString(
-			fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.DefaultAccountKey),
+			formatConnectionString(ts.URL, config.DefaultAccountKey),
 			&azcosmos.ClientOptions{},
 		)
 		assert.Nil(t, err)
@@ -35,7 +35,7 @@ func Test_Authentication(t *testing.T) {
 	t.Run("Should get 401 when wrong account key is used", func(t *testing.T) {
 		ts.DataStore.DeleteDatabase(testDatabaseName)
 		client, err := azcosmos.NewClientFromConnectionString(
-			fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, "AAAA"),
+			formatConnectionString(ts.URL, "AAAA"),
 			&azcosmos.ClientOptions{},
 		)
 		assert.Nil(t, err)
@@ -72,7 +72,7 @@ func Test_Authentication_Disabled(t *testing.T) {
 	t.Run("Should get 200 when wrong account key is used, but authentication is dissabled", func(t *testing.T) {
 		ts.DataStore.DeleteDatabase(testDatabaseName)
 		client, err := azcosmos.NewClientFromConnectionString(
-			fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, "AAAA"),
+			formatConnectionString(ts.URL, "AAAA"),
 			&azcosmos.ClientOptions{},
 		)
 		assert.Nil(t, err)
@@ -85,3 +85,7 @@ func Test_Authentication_Disabled(t *testing.T) {
 		assert.Equal(t, createResponse.DatabaseProperties.ID, testDatabaseName)
 	})
 }
+
+func formatConnectionString(endpoint, key string) string {
+	return fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", endpoint, key)
+}

docs/COMPATIBILITY.md

@@ -79,7 +79,7 @@ Cosmium strives to support the core features of Cosmos DB, including:
 
 | Function | Implemented |
 | -------- | ----------- |
-| IIF      | No          |
+| IIF      | Yes         |
 
 ### Date and time Functions
 

internal/constants/responses.go

@@ -30,3 +30,8 @@ var QueryPlanResponse = gin.H{
 		},
 	},
 }
+
+var UnknownErrorResponse = gin.H{"message": "Unknown error"}
+var NotFoundResponse = gin.H{"message": "NotFound"}
+var ConflictResponse = gin.H{"message": "Conflict"}
+var BadRequestResponse = gin.H{"message": "BadRequest"}

parsers/models.go

@@ -134,6 +134,8 @@ const (
 	FunctionCallSetIntersect     FunctionCallType = "SetIntersect"
 	FunctionCallSetUnion         FunctionCallType = "SetUnion"
 
+	FunctionCallIif FunctionCallType = "Iif"
+
 	FunctionCallMathAbs              FunctionCallType = "MathAbs"
 	FunctionCallMathAcos             FunctionCallType = "MathAcos"
 	FunctionCallMathAsin             FunctionCallType = "MathAsin"

parsers/nosql/misc_test.go

@@ -163,4 +163,27 @@ func Test_Parse(t *testing.T) {
 			},
 		)
 	})
+
+	t.Run("Should parse IIF function", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT IIF(true, c.pk, c.id) FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Type: parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallIif,
+							Arguments: []interface{}{
+								testutils.SelectItem_Constant_Bool(true),
+								testutils.SelectItem_Path("c", "pk"),
+								testutils.SelectItem_Path("c", "id"),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+			},
+		)
+	})
 }

parsers/nosql/nosql.peg

@@ -289,6 +289,11 @@ SelectArray <- "[" ws columns:ColumnList ws "]" {
 
 SelectObject <- "{" ws field:SelectObjectField ws other_fields:(ws "," ws coll:SelectObjectField {return coll, nil })* ws "}" {
     return makeSelectObject(field, other_fields)
+} / "{" ws "}" {
+    return parsers.SelectItem{
+		SelectItems: []parsers.SelectItem{},
+		Type:        parsers.SelectItemTypeObject,
+	}, nil
 }
 
 SelectObjectField <- name:(Identifier / "\"" key:Identifier "\"" { return key, nil }) ws ":" ws selectItem:SelectItem {
@@ -442,6 +447,7 @@ BooleanLiteral <- ("true"i / "false"i) {
 FunctionCall <- StringFunctions
     / TypeCheckingFunctions
     / ArrayFunctions
+    / ConditionalFunctions
     / InFunction
     / AggregateFunctions
     / MathFunctions
@@ -489,6 +495,8 @@ ArrayFunctions <- ArrayConcatExpression
     / SetIntersectExpression
     / SetUnionExpression
 
+ConditionalFunctions <- IifExpression
+
 MathFunctions <- MathAbsExpression
     / MathAcosExpression
     / MathAsinExpression
@@ -681,6 +689,10 @@ SetUnionExpression <- "SetUnion"i ws "(" ws set1:SelectItem ws "," ws set2:Selec
     return createFunctionCall(parsers.FunctionCallSetUnion, []interface{}{set1, set2})
 }
 
+IifExpression <- "IIF"i ws "(" ws condition:SelectItem ws "," ws trueValue:SelectItem ws "," ws falseValue:SelectItem ws ")" {
+    return createFunctionCall(parsers.FunctionCallIif, []interface{}{condition, trueValue, falseValue})
+}
+
 MathAbsExpression <- "ABS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAbs, []interface{}{ex}) }
 MathAcosExpression <- "ACOS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAcos, []interface{}{ex}) }
 MathAsinExpression <- "ASIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAsin, []interface{}{ex}) }

parsers/nosql/select_test.go

@@ -178,4 +178,21 @@ func Test_Parse_Select(t *testing.T) {
 			},
 		)
 	})
+
+	t.Run("Should parse SELECT empty object", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT {} AS obj FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Alias:       "obj",
+						Type:        parsers.SelectItemTypeObject,
+						SelectItems: []parsers.SelectItem{},
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+			},
+		)
+	})
 }

query_executors/memory_executor/common.go

@@ -209,6 +209,9 @@ func (r rowContext) selectItem_SelectItemTypeFunctionCall(functionCall parsers.F
 	case parsers.FunctionCallSetUnion:
 		return r.set_Union(functionCall.Arguments)
 
+	case parsers.FunctionCallIif:
+		return r.misc_Iif(functionCall.Arguments)
+
 	case parsers.FunctionCallMathAbs:
 		return r.math_Abs(functionCall.Arguments)
 	case parsers.FunctionCallMathAcos:

query_executors/memory_executor/misc_functions.go

@@ -16,3 +16,16 @@ func (r rowContext) misc_In(arguments []interface{}) bool {
 
 	return false
 }
+
+func (r rowContext) misc_Iif(arguments []interface{}) interface{} {
+	if len(arguments) != 3 {
+		return nil
+	}
+
+	condition := r.resolveSelectItem(arguments[0].(parsers.SelectItem))
+	if condition != nil && condition == true {
+		return r.resolveSelectItem(arguments[1].(parsers.SelectItem))
+	}
+
+	return r.resolveSelectItem(arguments[2].(parsers.SelectItem))
+}

query_executors/memory_executor/misc_test.go

@@ -210,4 +210,35 @@ func Test_Execute(t *testing.T) {
 			},
 		)
 	})
+
+	t.Run("Should execute function IIF()", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					testutils.SelectItem_Path("c", "id"),
+					{
+						Alias: "coolness",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallIif,
+							Arguments: []interface{}{
+								testutils.SelectItem_Path("c", "isCool"),
+								testutils.SelectItem_Constant_String("real cool"),
+								testutils.SelectItem_Constant_String("not cool"),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": "12345", "coolness": "not cool"},
+				map[string]interface{}{"id": "67890", "coolness": "real cool"},
+				map[string]interface{}{"id": "456", "coolness": "real cool"},
+				map[string]interface{}{"id": "123", "coolness": "real cool"},
+			},
+		)
+	})
 }

query_executors/memory_executor/select_test.go

@@ -205,4 +205,27 @@ func Test_Execute_Select(t *testing.T) {
 			},
 		)
 	})
+
+	t.Run("Should execute SELECT empty object", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Alias:       "obj",
+						Type:        parsers.SelectItemTypeObject,
+						SelectItems: []parsers.SelectItem{},
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"obj": map[string]interface{}{}},
+				map[string]interface{}{"obj": map[string]interface{}{}},
+				map[string]interface{}{"obj": map[string]interface{}{}},
+				map[string]interface{}{"obj": map[string]interface{}{}},
+			},
+		)
+	})
 }