New lint rules

backend/internal/util/interfaces.go

@@ -1,9 +1,9 @@
 package util
 
 // FindItemInInterface Find key in interface (recursively) and return value as interface
-func FindItemInInterface(key string, obj interface{}) (interface{}, bool) {
+func FindItemInInterface(key string, obj any) (any, bool) {
 	// if the argument is not a map, ignore it
-	mobj, ok := obj.(map[string]interface{})
+	mobj, ok := obj.(map[string]any)
 	if !ok {
 		return nil, false
 	}
@@ -15,14 +15,14 @@ func FindItemInInterface(key string, obj interface{}) (interface{}, bool) {
 		}
 
 		// if the value is a map, search recursively
-		if m, ok := v.(map[string]interface{}); ok {
+		if m, ok := v.(map[string]any); ok {
 			if res, ok := FindItemInInterface(key, m); ok {
 				return res, true
 			}
 		}
 		// if the value is an array, search recursively
 		// from each element
-		if va, ok := v.([]interface{}); ok {
+		if va, ok := v.([]any); ok {
 			for _, a := range va {
 				if res, ok := FindItemInInterface(key, a); ok {
 					return res, true

backend/internal/util/interfaces_test.go

@@ -11,13 +11,13 @@ func TestFindItemInInterface(t *testing.T) {
 	// goleak is used to detect goroutine leaks
 	defer goleak.VerifyNone(t, goleak.IgnoreAnyFunction("database/sql.(*DB).connectionOpener"))
 
-	obj := map[string]interface{}{
+	obj := map[string]any{
 		"key1": "value1",
 		"key2": 10,
-		"key3": map[string]interface{}{
+		"key3": map[string]any{
 			"nestedKey": "nestedValue",
 		},
-		"key4": []interface{}{"item1", "item2"},
+		"key4": []any{"item1", "item2"},
 	}
 
 	// Test case 1: Key exists at the top level

backend/internal/util/maps.go

@@ -1,7 +1,7 @@
 package util
 
 // MapContainsKey is fairly self explanatory
-func MapContainsKey(dict map[string]interface{}, key string) bool {
+func MapContainsKey(dict map[string]any, key string) bool {
 	if _, ok := dict[key]; ok {
 		return true
 	}

backend/internal/util/maps_test.go

@@ -19,7 +19,7 @@ func TestMapContainsKey(t *testing.T) {
 	var r rect
 	r.width = 5
 	r.height = 5
-	m := map[string]interface{}{
+	m := map[string]any{
 		"rect_width":  r.width,
 		"rect_height": r.height,
 	}

backend/internal/util/slices.go

@@ -35,8 +35,8 @@ func ConvertIntSliceToString(slice []int) string {
 }
 
 // ConvertStringSliceToInterface is required in some special cases
-func ConvertStringSliceToInterface(slice []string) []interface{} {
-	res := make([]interface{}, len(slice))
+func ConvertStringSliceToInterface(slice []string) []any {
+	res := make([]any, len(slice))
 	for i := range slice {
 		res[i] = slice[i]
 	}

backend/internal/util/slices_test.go

@@ -99,11 +99,11 @@ func TestConvertIntSliceToString(t *testing.T) {
 func TestConvertStringSliceToInterface(t *testing.T) {
 	testCases := []struct {
 		input    []string
-		expected []interface{}
+		expected []any
 	}{
-		{[]string{"hello", "world"}, []interface{}{"hello", "world"}},
-		{[]string{"apple", "banana", "cherry"}, []interface{}{"apple", "banana", "cherry"}},
-		{[]string{}, []interface{}{}}, // Empty slice should return an empty slice
+		{[]string{"hello", "world"}, []any{"hello", "world"}},
+		{[]string{"apple", "banana", "cherry"}, []any{"apple", "banana", "cherry"}},
+		{[]string{}, []any{}}, // Empty slice should return an empty slice
 	}
 
 	for _, tc := range testCases {