feat: implement filters on collection level via query params

Author: cheetahbyte

docs/ContentModel.md

@@ -141,7 +141,55 @@ Returns:
 }
 ```
 
+### Filtering Collections based on Metadata
+Since metadata gets exposed on collection level, you can use http query params to filter the collection results.
+
+#### Example
+
+**first.md**
+
+```yaml
 
+author: leo
+title: This is the first blog post
+state: released
+ 
+# This is my stuff.
+```
+
+**second.md**
+
+```yaml
+ 
+author: maik
+title: My deep-dive into monitors
+state: not-released
+ 
+# This is my stuff.
+```
+
+If you go to `/api/blogs?author=maik`, you shall receive:
+```json
+{
+  "collection": "blogs",
+  "items": [
+    {
+      "slug": "blogs/second",
+      "meta": {
+        "author": "maik",
+        "contentType": "application/json",
+        "kind": "markdown",
+        "size": 108,
+        "state": "not-released",
+        "title": "My deep-dive into monitors"
+      }
+    }
+  ]
+}
+```
+
+> [!NOTE]
+> If no matching entries are found, the items array will just be empty.
 
 ### What Are Collections Used For?
 

internal/handlers/content.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/cheetahbyte/centra/internal/cache"
+	"github.com/cheetahbyte/centra/internal/helper"
 	"github.com/go-chi/chi/v5"
 )
 
@@ -31,12 +32,20 @@ func HandleContent(w http.ResponseWriter, r *http.Request) {
 	if !node.IsLeaf() {
 		items := node.GetChildren()
 		collectionItems := make([]CollectionItem, 0, len(items))
+		q := helper.ParseQueryParams(r)
 		for p, child := range items {
+			meta := child.GetMetadata()
+			// this is probably not ideal but it works for now.
+			if !helper.MatchesQuery(meta, q) {
+				continue
+			}
+
 			collectionItems = append(collectionItems, CollectionItem{
 				Slug: path + "/" + p,
 				Meta: child.GetMetadata(),
 			})
 		}
+
 		writeJSON(w, http.StatusOK, map[string]any{
 			"collection": path,
 			"items":      collectionItems,

internal/helper/query.go

@@ -0,0 +1,78 @@
+package helper
+
+import (
+	"fmt"
+	"net/http"
+	"slices"
+	"strings"
+)
+
+func ParseQueryParams(r *http.Request) map[string][]string {
+	q := r.URL.Query()
+	result := make(map[string][]string)
+
+	for key, values := range q {
+		for _, v := range values {
+			split := strings.Split(v, ",")
+			for _, s := range split {
+				result[key] = append(result[key], strings.TrimSpace(s))
+			}
+		}
+	}
+
+	return result
+}
+
+func matchesValue(metaValue any, allowed []string) bool {
+	switch v := metaValue.(type) {
+	case string:
+		ms := strings.ToLower(v)
+		for _, a := range allowed {
+			if strings.Contains(ms, strings.ToLower(a)) {
+				return true
+			}
+		}
+		return false
+
+	case []string:
+		return slices.ContainsFunc(v, func(tag string) bool {
+			ts := strings.ToLower(tag)
+			for _, a := range allowed {
+				if strings.Contains(ts, strings.ToLower(a)) {
+					return true
+				}
+			}
+			return false
+		})
+
+	case bool, int, int64, float64:
+		s := fmt.Sprintf("%v", v)
+		ss := strings.ToLower(s)
+		for _, a := range allowed {
+			if strings.Contains(ss, strings.ToLower(a)) {
+				return true
+			}
+		}
+		return false
+
+	default:
+		s := fmt.Sprint(v)
+		ss := strings.ToLower(s)
+		for _, a := range allowed {
+			if strings.Contains(ss, strings.ToLower(a)) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+func MatchesQuery(meta map[string]any, query map[string][]string) bool {
+	for key, allowed := range query {
+		val, ok := meta[key]
+		if !ok || !matchesValue(val, allowed) {
+			return false
+		}
+	}
+	return true
+}