added natural string sort for in memory database

Signed-off-by: Jeeva Kandasamy <jkandasa@gmail.com>

Author: jkandasa

pkg/utils/filter_sort/utils_sort.go

@@ -4,6 +4,7 @@ import (
 	"reflect"
 	"sort"
 	"time"
+	"unicode"
 
 	storageTY "github.com/mycontroller-org/server/v2/plugin/database/storage/types"
 )
@@ -40,6 +41,46 @@ func Sort(entities []interface{}, pagination *storageTY.Pagination) ([]interface
 	return entities, entitiesCount
 }
 
+// naturalStringLess compares strings using natural sort order
+// Numbers within strings are compared numerically
+func naturalStringLess(a, b string) bool {
+	aRunes := []rune(a)
+	bRunes := []rune(b)
+	i, j := 0, 0
+
+	for i < len(aRunes) && j < len(bRunes) {
+		// Check if both are digits
+		if unicode.IsDigit(aRunes[i]) && unicode.IsDigit(bRunes[j]) {
+			// Extract numbers
+			aNum, aEnd := extractNumber(aRunes, i)
+			bNum, bEnd := extractNumber(bRunes, j)
+
+			if aNum != bNum {
+				return aNum < bNum
+			}
+			i = aEnd
+			j = bEnd
+		} else {
+			if aRunes[i] != bRunes[j] {
+				return aRunes[i] < bRunes[j]
+			}
+			i++
+			j++
+		}
+	}
+	return len(aRunes) < len(bRunes)
+}
+
+// extractNumber extracts a number from rune slice starting at pos
+func extractNumber(runes []rune, pos int) (int, int) {
+	num := 0
+	for pos < len(runes) && unicode.IsDigit(runes[pos]) {
+		num = num*10 + int(runes[pos]-'0')
+		pos++
+	}
+	return num, pos
+}
+
 // GetSortByKeyPath returns the slice in order
 func GetSortByKeyPath(keyPath, orderBy string, data []interface{}) []interface{} {
 	sort.Slice(data, func(a, b int) bool {
@@ -64,9 +105,9 @@ func GetSortByKeyPath(keyPath, orderBy string, data []interface{}) []interface{}
 				return false
 			}
 			if orderBy == storageTY.SortByASC {
-				return aFinalValue < bFinalValue
+				return naturalStringLess(aFinalValue, bFinalValue)
 			}
-			return aFinalValue > bFinalValue
+			return naturalStringLess(bFinalValue, aFinalValue)
 
 		case reflect.Int:
 			aFinalValue, aOK := aValue.(int)

pkg/utils/filter_sort/utils_sort_test.go

@@ -0,0 +1,144 @@
+package helper
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNaturalStringLess(t *testing.T) {
+	testCases := []struct {
+		name     string
+		a        string
+		b        string
+		expected bool
+	}{
+		{
+			name:     "simple numeric comparison",
+			a:        "file2",
+			b:        "file10",
+			expected: true,
+		},
+		{
+			name:     "simple numeric comparison reversed",
+			a:        "file10",
+			b:        "file2",
+			expected: false,
+		},
+		{
+			name:     "equal strings",
+			a:        "file1",
+			b:        "file1",
+			expected: false,
+		},
+		{
+			name:     "no numbers - alphabetical",
+			a:        "apple",
+			b:        "banana",
+			expected: true,
+		},
+		{
+			name:     "no numbers - alphabetical reversed",
+			a:        "banana",
+			b:        "apple",
+			expected: false,
+		},
+		{
+			name:     "multiple digits",
+			a:        "item100",
+			b:        "item99",
+			expected: false,
+		},
+		{
+			name:     "multiple numbers in string",
+			a:        "version2.10.5",
+			b:        "version2.9.5",
+			expected: false,
+		},
+		{
+			name:     "prefix with numbers",
+			a:        "10file",
+			b:        "2file",
+			expected: false,
+		},
+		{
+			name:     "mixed alphanumeric",
+			a:        "test1abc2",
+			b:        "test1abc10",
+			expected: true,
+		},
+		{
+			name:     "one with number one without",
+			a:        "file",
+			b:        "file2",
+			expected: true,
+		},
+		{
+			name:     "different lengths same prefix",
+			a:        "test",
+			b:        "test123",
+			expected: true,
+		},
+		{
+			name:     "zero padding",
+			a:        "file001",
+			b:        "file2",
+			expected: true,
+		},
+		{
+			name:     "large numbers",
+			a:        "item999",
+			b:        "item1000",
+			expected: true,
+		},
+		{
+			name:     "unicode characters",
+			a:        "文件2",
+			b:        "文件10",
+			expected: true,
+		},
+		{
+			name:     "spaces in string",
+			a:        "file 2",
+			b:        "file 10",
+			expected: true,
+		},
+		{
+			name:     "dash separator with numbers",
+			a:        "file-2",
+			b:        "file-10",
+			expected: true, // compares 'file-' prefix, then 2 < 10 numerically
+		},
+		{
+			name:     "empty strings",
+			a:        "",
+			b:        "file",
+			expected: true,
+		},
+		{
+			name:     "both empty strings",
+			a:        "",
+			b:        "",
+			expected: false,
+		},
+		{
+			name:     "only numbers",
+			a:        "123",
+			b:        "45",
+			expected: false,
+		},
+		{
+			name:     "special characters",
+			a:        "file#2",
+			b:        "file#10",
+			expected: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := naturalStringLess(tc.a, tc.b)
+			assert.Equal(t, tc.expected, result, "naturalStringLess(%q, %q) should return %v", tc.a, tc.b, tc.expected)
+		})
+	}
+}