Fix user search

Sources/src/main/kotlin/allin/data/postgres/PostgresFriendDataSource.kt

@@ -5,7 +5,7 @@ import allin.data.postgres.entities.FriendEntity
 import allin.data.postgres.entities.friends
 import allin.data.postgres.entities.users
 import allin.dto.UserDTO
-import allin.ext.levenshtein
+import allin.ext.levenshteinLessEq
 import allin.ext.toLowerCase
 import allin.model.FriendStatus
 import org.ktorm.database.Database
@@ -50,7 +50,7 @@ class PostgresFriendDataSource(private val database: Database) : FriendDataSourc
                 } else {
                     database.users.find { usr ->
                         usr.id eq it.sender
-                    }?.toUserDTO(database,friendStatus = FriendStatus.NOT_FRIEND)
+                    }?.toUserDTO(database, friendStatus = FriendStatus.NOT_FRIEND)
                 }
             }
     }
@@ -66,10 +66,25 @@ class PostgresFriendDataSource(private val database: Database) : FriendDataSourc
     override fun isFriend(firstUser: String, secondUser: String) =
         database.friends.any { (it.sender eq firstUser) and (it.receiver eq secondUser) }
 
-    override fun filterUsersByUsername(fromUserId: String, search: String): List<UserDTO> =
-        database.users
-            .filter { it.id notEq fromUserId }
-            .sortedBy { it.username.toLowerCase().levenshtein(search.lowercase()) }
-            .take(10)
-            .map { user -> user.toUserDTO(database,friendStatus = getFriendStatus(fromUserId, user.id)) }
+    override fun filterUsersByUsername(fromUserId: String, search: String): List<UserDTO> {
+        val maxSize = search.length / 2
+        return database.users
+            .filter { (it.id notEq fromUserId) }
+            .mapColumns {
+                tupleOf(
+                    it.id,
+                    it.username.toLowerCase().levenshteinLessEq(search.lowercase(), maxSize)
+                )
+            }
+            .filter { (_, distance) ->
+                distance?.let { it <= maxSize } ?: false
+            }
+            .sortedBy { it.second }
+            .mapNotNull { (id, _) ->
+                id?.let {
+                    val user = database.users.find { it.id eq id }
+                    user?.toUserDTO(database, friendStatus = getFriendStatus(fromUserId, user.id))
+                }
+            }
+    }
 }

Sources/src/main/kotlin/allin/ext/DatabaseExt.kt

@@ -1,6 +1,7 @@
 package allin.ext
 
 import org.ktorm.database.Database
+import org.ktorm.expression.ArgumentExpression
 import org.ktorm.expression.FunctionExpression
 import org.ktorm.schema.ColumnDeclaring
 import org.ktorm.schema.IntSqlType
@@ -48,13 +49,19 @@ fun ColumnDeclaring<String>.toUpperCase(): FunctionExpression<String> {
     )
 }
 
-fun ColumnDeclaring<String>.levenshtein(target: ColumnDeclaring<String>): FunctionExpression<Int> {
+fun ColumnDeclaring<String>.levenshteinLessEq(
+    target: ColumnDeclaring<String>,
+    max: ColumnDeclaring<Int>
+): FunctionExpression<Int> {
     return FunctionExpression(
-        functionName = "levenshtein",
-        arguments = listOf(this.asExpression(), target.asExpression()),
+        functionName = "levenshtein_less_equal",
+        arguments = listOf(this.asExpression(), target.asExpression(), max.asExpression()),
         sqlType = IntSqlType
     )
 }
 
-fun ColumnDeclaring<String>.levenshtein(target: String): FunctionExpression<Int> =
-    levenshtein(wrapArgument(target))
+fun ColumnDeclaring<String>.levenshteinLessEq(target: String, max: Int): FunctionExpression<Int> =
+    levenshteinLessEq(
+        wrapArgument(target),
+        ArgumentExpression(max, IntSqlType)
+    )