Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Refactor Kotlin queries to use repository pattern (#1404)
Leendert de Borst57a5f3203872
diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.ktindex 3c7ef001f..c1a621b8f 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.kt@@ -25,11 +25,12 @@ import net.aliasvault.app.credentialprovider.models.PasskeyRegistrationViewModelimport net.aliasvault.app.exceptions.PasskeyOperationExceptionimport net.aliasvault.app.exceptions.VaultOperationExceptionimport net.aliasvault.app.utils.Helpers-import net.aliasvault.app.vaultstore.PasskeyWithCredentialInfoimport net.aliasvault.app.vaultstore.VaultStoreimport net.aliasvault.app.vaultstore.models.Passkeyimport net.aliasvault.app.vaultstore.passkey.PasskeyAuthenticatorimport net.aliasvault.app.vaultstore.passkey.PasskeyHelper+import net.aliasvault.app.vaultstore.repositories.ItemWithCredentialInfo+import net.aliasvault.app.vaultstore.repositories.PasskeyWithCredentialInfoimport net.aliasvault.app.webapi.WebApiServiceimport org.json.JSONObjectimport java.util.Date@@ -71,7 +72,7 @@ class PasskeyFormFragment : Fragment() {private var isReplace: Boolean = falseprivate var isMerge: Boolean = falseprivate var passkeyToReplace: PasskeyWithCredentialInfo? = null- private var itemToMerge: net.aliasvault.app.vaultstore.ItemWithCredentialInfo? = null+ private var itemToMerge: ItemWithCredentialInfo? = null// UI elementsprivate lateinit var headerSubtitle: TextView@@ -628,7 +629,7 @@ class PasskeyFormFragment : Fragment() {*/private suspend fun mergePasskeyFlow(displayName: String,- item: net.aliasvault.app.vaultstore.ItemWithCredentialInfo,+ item: ItemWithCredentialInfo,) = withContext(Dispatchers.IO) {try {// Step 1: Sync vault before adding passkey to ensure we have latest datadiff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/models/PasskeyRegistrationViewModel.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/models/PasskeyRegistrationViewModel.ktindex acfd99a66..c7567ca77 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/models/PasskeyRegistrationViewModel.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/models/PasskeyRegistrationViewModel.kt@@ -1,8 +1,8 @@package net.aliasvault.app.credentialprovider.modelsimport androidx.lifecycle.ViewModel-import net.aliasvault.app.vaultstore.ItemWithCredentialInfo-import net.aliasvault.app.vaultstore.PasskeyWithCredentialInfo+import net.aliasvault.app.vaultstore.repositories.ItemWithCredentialInfo+import net.aliasvault.app.vaultstore.repositories.PasskeyWithCredentialInfoimport java.util.UUID/**diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultMutate.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultMutate.ktindex 750885d5c..92e94ed0d 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultMutate.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultMutate.kt@@ -3,6 +3,7 @@ package net.aliasvault.app.vaultstoreimport android.util.Logimport net.aliasvault.app.exceptions.SerializationExceptionimport net.aliasvault.app.exceptions.VaultOperationException+import net.aliasvault.app.vaultstore.repositories.ItemRepositoryimport org.json.JSONArrayimport org.json.JSONObject@@ -11,7 +12,7 @@ import org.json.JSONObject*/class VaultMutate(private val database: VaultDatabase,- private val query: VaultQuery,+ private val itemRepository: ItemRepository,private val metadata: VaultMetadataManager,) {companion object {@@ -190,7 +191,7 @@ class VaultMutate(}// Get all items to count them and extract private email addresses- val items = query.getAllItems()+ val items = itemRepository.getAll()val metadataObj = metadata.getVaultMetadataObject()val privateEmailDomains = metadataObj?.privateEmailDomains ?: emptyList()@@ -205,7 +206,7 @@ class VaultMutate(}.distinct()- val dbVersion = query.getDatabaseVersion()+ val dbVersion = itemRepository.getDatabaseVersion()@Suppress("SwallowedException")val version = try {diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPasskey.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPasskey.ktindex d63506ff4..91d45f922 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPasskey.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPasskey.kt@@ -1,44 +1,23 @@package net.aliasvault.app.vaultstore-import android.util.Log-import net.aliasvault.app.utils.DateHelpers-import net.aliasvault.app.vaultstore.models.FieldKeyimport net.aliasvault.app.vaultstore.models.Itemimport net.aliasvault.app.vaultstore.models.Passkey+import net.aliasvault.app.vaultstore.repositories.ItemWithCredentialInfoimport net.aliasvault.app.vaultstore.repositories.PasskeyRepository-import java.util.Calendar-import java.util.Date-import java.util.TimeZone+import net.aliasvault.app.vaultstore.repositories.PasskeyWithCredentialInfo+import net.aliasvault.app.vaultstore.repositories.PasskeyWithItemimport java.util.UUID/*** Handles passkey operations for the vault.* This class uses composition to organize passkey-specific functionality.- * *+ ** IMPORTANT: Keep all implementations synchronized. Changes to the public interface must be* reflected in all ports. Method names, parameters, and behavior should remain consistent.*/class VaultPasskey(- private val database: VaultDatabase,- private val query: VaultQuery,+ database: VaultDatabase,) {- companion object {- private const val TAG = "VaultPasskey"-- /**- * Minimum date definition for default values.- */- private val MIN_DATE: Date = Calendar.getInstance(TimeZone.getTimeZone("UTC")).apply {- set(Calendar.YEAR, 1)- set(Calendar.MONTH, Calendar.JANUARY)- set(Calendar.DAY_OF_MONTH, 1)- set(Calendar.HOUR_OF_DAY, 0)- set(Calendar.MINUTE, 0)- set(Calendar.SECOND, 0)- set(Calendar.MILLISECOND, 0)- }.time- }-private val passkeyRepository = PasskeyRepository(database)// region Passkey Queries@@ -73,54 +52,7 @@ class VaultPasskey(userName: String? = null,userId: ByteArray? = null,): List<PasskeyWithCredentialInfo> {- val db = database.dbConnection ?: return emptyList()-- // Query passkeys with associated item data using the new schema- val query = """- SELECT p.Id, p.ItemId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,- p.DisplayName, p.CreatedAt, p.UpdatedAt, p.IsDeleted,- i.Name,- fv_username.Value as Username- FROM Passkeys p- INNER JOIN Items i ON p.ItemId = i.Id- LEFT JOIN FieldValues fv_username ON fv_username.ItemId = i.Id- AND fv_username.FieldKey = ?- AND fv_username.IsDeleted = 0- WHERE p.RpId = ? AND p.IsDeleted = 0 AND i.IsDeleted = 0 AND i.DeletedAt IS NULL- ORDER BY p.CreatedAt DESC- """.trimIndent()-- val results = mutableListOf<PasskeyWithCredentialInfo>()- val cursor = db.query(query, arrayOf(FieldKey.LOGIN_USERNAME, rpId))-- cursor.use {- while (it.moveToNext()) {- val passkey = parsePasskeyRow(it) ?: continue- val itemName = if (!it.isNull(11)) it.getString(11) else null- val itemUsername = if (!it.isNull(12)) it.getString(12) else null-- // Filter by username or userId if provided- var matches = true- if (userName != null && itemUsername != userName) {- matches = false- }- if (userId != null && passkey.userHandle != null && !userId.contentEquals(passkey.userHandle)) {- matches = false- }-- if (matches) {- results.add(- PasskeyWithCredentialInfo(- passkey = passkey,- serviceName = itemName,- username = itemUsername,- ),- )- }- }- }-- return results+ return passkeyRepository.getWithCredentialInfo(rpId, userName, userId)}/**@@ -135,92 +67,7 @@ class VaultPasskey(rpId: String,userName: String? = null,): List<ItemWithCredentialInfo> {- val db = database.dbConnection ?: return emptyList()-- // Query Items that:- // 1. Have a URL containing the rpId- // 2. Don't have an associated passkey- // 3. Are not deleted- val query = """- SELECT i.Id, i.Name, i.CreatedAt, i.UpdatedAt,- fv_url.Value as Url,- fv_username.Value as Username,- fv_password.Value as Password- FROM Items i- INNER JOIN FieldValues fv_url ON fv_url.ItemId = i.Id- AND fv_url.FieldKey = ?- AND fv_url.IsDeleted = 0- LEFT JOIN FieldValues fv_username ON fv_username.ItemId = i.Id- AND fv_username.FieldKey = ?- AND fv_username.IsDeleted = 0- LEFT JOIN FieldValues fv_password ON fv_password.ItemId = i.Id- AND fv_password.FieldKey = ?- AND fv_password.IsDeleted = 0- WHERE i.IsDeleted = 0- AND i.DeletedAt IS NULL- AND i.ItemType = 'Login'- AND (LOWER(fv_url.Value) LIKE ? OR LOWER(fv_url.Value) LIKE ?)- AND NOT EXISTS (- SELECT 1 FROM Passkeys p- WHERE p.ItemId = i.Id AND p.IsDeleted = 0- )- ORDER BY i.UpdatedAt DESC- """.trimIndent()-- val rpIdLower = rpId.lowercase()- val urlPattern1 = "%$rpIdLower%"- val urlPattern2 = "%${rpIdLower.replace("www.", "")}%"-- val results = mutableListOf<ItemWithCredentialInfo>()- val cursor = db.query(- query,- arrayOf(- FieldKey.LOGIN_URL,- FieldKey.LOGIN_USERNAME,- FieldKey.LOGIN_PASSWORD,- urlPattern1,- urlPattern2,- ),- )-- cursor.use {- while (it.moveToNext()) {- val itemIdString = it.getString(0)- val itemName = if (!it.isNull(1)) it.getString(1) else null- val itemCreatedAt = if (!it.isNull(2)) it.getString(2) else null- val itemUpdatedAt = if (!it.isNull(3)) it.getString(3) else null- val url = if (!it.isNull(4)) it.getString(4) else null- val itemUsername = if (!it.isNull(5)) it.getString(5) else null- val hasPassword = !it.isNull(6) && it.getString(6).isNotEmpty()-- // Filter by username if provided- if (userName != null && itemUsername != userName) {- continue- }-- try {- val itemId = UUID.fromString(itemIdString)- val createdAt = DateHelpers.parseDateString(itemCreatedAt ?: "") ?: MIN_DATE- val updatedAt = DateHelpers.parseDateString(itemUpdatedAt ?: "") ?: MIN_DATE-- results.add(- ItemWithCredentialInfo(- itemId = itemId,- serviceName = itemName,- url = url,- username = itemUsername,- hasPassword = hasPassword,- createdAt = createdAt,- updatedAt = updatedAt,- ),- )- } catch (e: Exception) {- Log.e(TAG, "Error parsing item row", e)- }- }- }-- return results+ return passkeyRepository.getItemsWithoutPasskeyForRpId(rpId, userName)}/**@@ -229,73 +76,7 @@ class VaultPasskey(* Uses a JOIN to get passkeys and their items in one database query.*/fun getAllPasskeysWithItems(): List<PasskeyWithItem> {- val db = database.dbConnection ?: return emptyList()-- val query = """- SELECT- p.Id, p.ItemId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,- p.DisplayName, p.CreatedAt as PasskeyCreatedAt, p.UpdatedAt as PasskeyUpdatedAt, p.IsDeleted as PasskeyIsDeleted,- i.Id as ItemId, i.Name, i.CreatedAt as ItemCreatedAt, i.UpdatedAt as ItemUpdatedAt,- fv_username.Value as Username,- fv_email.Value as Email- FROM Passkeys p- INNER JOIN Items i ON p.ItemId = i.Id- LEFT JOIN FieldValues fv_username ON fv_username.ItemId = i.Id- AND fv_username.FieldKey = ?- AND fv_username.IsDeleted = 0- LEFT JOIN FieldValues fv_email ON fv_email.ItemId = i.Id- AND fv_email.FieldKey = ?- AND fv_email.IsDeleted = 0- WHERE p.IsDeleted = 0 AND i.IsDeleted = 0 AND i.DeletedAt IS NULL- ORDER BY p.CreatedAt DESC- """.trimIndent()-- val results = mutableListOf<PasskeyWithItem>()- val cursor = db.query(query, arrayOf(FieldKey.LOGIN_USERNAME, FieldKey.LOGIN_EMAIL))-- cursor.use {- while (it.moveToNext()) {- try {- // Parse passkey (columns 0-10)- val passkey = parsePasskeyRowFromJoin(it) ?: continue-- // Parse item info (columns 11-15)- val itemId = UUID.fromString(it.getString(11))- val itemName = if (!it.isNull(12)) it.getString(12) else null- val itemCreatedAt = DateHelpers.parseDateString(it.getString(13)) ?: MIN_DATE- val itemUpdatedAt = DateHelpers.parseDateString(it.getString(14)) ?: MIN_DATE-- @Suppress("UNUSED_VARIABLE") // Username field loaded for potential future use- val username = if (!it.isNull(15)) it.getString(15) else null-- @Suppress("UNUSED_VARIABLE") // Email field loaded for potential future use- val email = if (!it.isNull(16)) it.getString(16) else null-- // Create a minimal Item object with the data we have- // Full items should be loaded via query.getAllItems() when needed- val item = Item(- id = itemId,- name = itemName,- itemType = "Login",- logo = null,- folderId = null,- folderPath = null,- fields = emptyList(), // Not loading all fields for performance- hasPasskey = true,- hasAttachment = false,- hasTotp = false,- createdAt = itemCreatedAt,- updatedAt = itemUpdatedAt,- )-- results.add(PasskeyWithItem(passkey, item))- } catch (e: Exception) {- Log.e(TAG, "Error parsing passkey with item row", e)- }- }- }-- return results+ return passkeyRepository.getAllWithItems()}/**@@ -357,150 +138,8 @@ class VaultPasskey(}// endregion-- // region Helper Methods-- /**- * Parse a passkey row from database query.- */- private fun parsePasskeyRow(cursor: android.database.Cursor): Passkey? {- try {- val idString = cursor.getString(0)- val itemIdString = cursor.getString(1)- val rpId = cursor.getString(2)- val userHandle = if (!cursor.isNull(3)) cursor.getBlob(3) else null- val publicKeyString = cursor.getString(4)- val privateKeyString = cursor.getString(5)- val prfKey = if (!cursor.isNull(6)) cursor.getBlob(6) else null- val displayName = cursor.getString(7)- val createdAtString = cursor.getString(8)- val updatedAtString = cursor.getString(9)- val isDeleted = cursor.getInt(10) == 1-- val id = UUID.fromString(idString)- val itemId = UUID.fromString(itemIdString)-- val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATE- val updatedAt = DateHelpers.parseDateString(updatedAtString) ?: MIN_DATE-- val publicKeyData = publicKeyString.toByteArray(Charsets.UTF_8)- val privateKeyData = privateKeyString.toByteArray(Charsets.UTF_8)-- return Passkey(- id = id,- parentItemId = itemId, // Note: field name still parentItemId but refers to ItemId- rpId = rpId,- userHandle = userHandle,- userName = null,- publicKey = publicKeyData,- privateKey = privateKeyData,- prfKey = prfKey,- displayName = displayName,- createdAt = createdAt,- updatedAt = updatedAt,- isDeleted = isDeleted,- )- } catch (e: Exception) {- Log.e(TAG, "Error parsing passkey row", e)- return null- }- }-- /**- * Parse a passkey row from a JOIN query.- */- private fun parsePasskeyRowFromJoin(cursor: android.database.Cursor): Passkey? {- try {- val idString = cursor.getString(0)- val itemIdString = cursor.getString(1)- val rpId = cursor.getString(2)- val userHandle = if (!cursor.isNull(3)) cursor.getBlob(3) else null- val publicKeyString = cursor.getString(4)- val privateKeyString = cursor.getString(5)- val prfKey = if (!cursor.isNull(6)) cursor.getBlob(6) else null- val displayName = cursor.getString(7)- val createdAtString = cursor.getString(8)- val updatedAtString = cursor.getString(9)- val isDeleted = cursor.getInt(10) == 1-- val id = UUID.fromString(idString)- val itemId = UUID.fromString(itemIdString)-- val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATE- val updatedAt = DateHelpers.parseDateString(updatedAtString) ?: MIN_DATE-- val publicKeyData = publicKeyString.toByteArray(Charsets.UTF_8)- val privateKeyData = privateKeyString.toByteArray(Charsets.UTF_8)-- return Passkey(- id = id,- parentItemId = itemId, // Note: field name still parentItemId but refers to ItemId- rpId = rpId,- userHandle = userHandle,- userName = null,- publicKey = publicKeyData,- privateKey = privateKeyData,- prfKey = prfKey,- displayName = displayName,- createdAt = createdAt,- updatedAt = updatedAt,- isDeleted = isDeleted,- )- } catch (e: Exception) {- Log.e(TAG, "Error parsing passkey row from JOIN", e)- return null- }- }-- // endregion}-/**- * Data class to hold passkey with item info.- *- * @property passkey The passkey.- * @property serviceName The service name from the item.- * @property username The username from the item.- */-data class PasskeyWithCredentialInfo(- val passkey: Passkey,- val serviceName: String?,- val username: String?,-)--/**- * Data class to hold passkey with its associated item.- *- * @property passkey The passkey.- * @property item The item this passkey belongs to.- */-data class PasskeyWithItem(- val passkey: Passkey,- val item: Item,-)--/**- * Data class to hold Item info for Items without passkeys.- * Used for showing existing credentials that can have a passkey added.- *- * @property itemId The UUID of the item.- * @property serviceName The service name (Item.Name).- * @property url The login URL.- * @property username The username from field values.- * @property hasPassword Whether the item has a password.- * @property createdAt When the item was created.- * @property updatedAt When the item was last updated.- */-data class ItemWithCredentialInfo(- val itemId: UUID,- val serviceName: String?,- val url: String?,- val username: String?,- val hasPassword: Boolean,- val createdAt: Date,- val updatedAt: Date,-)-/*** VaultPasskey-specific errors.*/diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultQuery.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultQuery.ktdeleted file mode 100644index 9ce812b7d..000000000--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultQuery.kt+++ /dev/null@@ -1,431 +0,0 @@-package net.aliasvault.app.vaultstore--import android.util.Base64-import android.util.Log-import net.aliasvault.app.utils.DateHelpers-import net.aliasvault.app.vaultstore.interfaces.ItemOperationCallback-import net.aliasvault.app.vaultstore.models.FieldKey-import net.aliasvault.app.vaultstore.models.FieldType-import net.aliasvault.app.vaultstore.models.Item-import net.aliasvault.app.vaultstore.models.ItemField-import java.util.Calendar-import java.util.Date-import java.util.TimeZone-import java.util.UUID--/**- * Handles SQL query operations on the vault database.- */-class VaultQuery(- private val database: VaultDatabase,-) {- companion object {- private const val TAG = "VaultQuery"-- private val MIN_DATE: Date = Calendar.getInstance(TimeZone.getTimeZone("UTC")).apply {- set(Calendar.YEAR, 1)- set(Calendar.MONTH, Calendar.JANUARY)- set(Calendar.DAY_OF_MONTH, 1)- set(Calendar.HOUR_OF_DAY, 0)- set(Calendar.MINUTE, 0)- set(Calendar.SECOND, 0)- set(Calendar.MILLISECOND, 0)- }.time- }-- // region SQL Query Execution-- /**- * Execute a read-only SQL query (SELECT) on the vault.- */- @Suppress("NestedBlockDepth")- fun executeQuery(query: String, params: Array<Any?>): List<Map<String, Any?>> {- val results = mutableListOf<Map<String, Any?>>()-- database.dbConnection?.let { db ->- val convertedParams = params.map { param ->- if (param is String && param.startsWith("av-base64-to-blob:")) {- val base64 = param.substring("av-base64-to-blob:".length)- Base64.decode(base64, Base64.NO_WRAP)- } else {- param- }- }.toTypedArray()-- val cursor = db.query(query, convertedParams.map { it?.toString() }.toTypedArray())-- cursor.use {- val columnNames = it.columnNames- while (it.moveToNext()) {- val row = mutableMapOf<String, Any?>()- for (columnName in columnNames) {- when (it.getType(it.getColumnIndexOrThrow(columnName))) {- android.database.Cursor.FIELD_TYPE_NULL -> row[columnName] = null- android.database.Cursor.FIELD_TYPE_INTEGER -> row[columnName] = it.getLong(- it.getColumnIndexOrThrow(columnName),- )- android.database.Cursor.FIELD_TYPE_FLOAT -> row[columnName] = it.getDouble(- it.getColumnIndexOrThrow(columnName),- )- android.database.Cursor.FIELD_TYPE_STRING -> row[columnName] = it.getString(- it.getColumnIndexOrThrow(columnName),- )- android.database.Cursor.FIELD_TYPE_BLOB -> row[columnName] = it.getBlob(- it.getColumnIndexOrThrow(columnName),- )- }- }- results.add(row)- }- }- }-- return results- }-- /**- * Execute an SQL update on the vault that mutates it.- */- fun executeUpdate(query: String, params: Array<Any?>): Int {- database.dbConnection?.let { db ->- val convertedParams = params.map { param ->- if (param is String && param.startsWith("av-base64-to-blob:")) {- val base64 = param.substring("av-base64-to-blob:".length)- Base64.decode(base64, Base64.NO_WRAP)- } else {- param- }- }.toTypedArray()-- // Execute the statement using compileStatement for non-SELECT queries- val stmt = db.compileStatement(query)- try {- // Bind parameters- convertedParams.forEachIndexed { index, param ->- when (param) {- null -> stmt.bindNull(index + 1)- is ByteArray -> stmt.bindBlob(index + 1, param)- is Long -> stmt.bindLong(index + 1, param)- is Double -> stmt.bindDouble(index + 1, param)- else -> stmt.bindString(index + 1, param.toString())- }- }- stmt.execute()- } finally {- stmt.close()- }-- // Get the number of affected rows- val cursor = db.rawQuery("SELECT changes()", null)- cursor.use {- if (it.moveToFirst()) {- return it.getInt(0)- }- }- }- return 0- }-- /**- * Execute a raw SQL command on the vault without parameters.- */- fun executeRaw(query: String) {- database.dbConnection?.let { db ->- val statements = query.split(";")-- for (statement in statements) {- val trimmedStatement = statement.smartTrim()-- if (trimmedStatement.isEmpty() ||- trimmedStatement.uppercase().startsWith("BEGIN") ||- trimmedStatement.uppercase().startsWith("COMMIT") ||- trimmedStatement.uppercase().startsWith("ROLLBACK")- ) {- continue- }-- // Use compileStatement and execute for all non-SELECT statements- val stmt = db.compileStatement(trimmedStatement)- try {- stmt.execute()- } finally {- stmt.close()- }- }- }- }-- // endregion-- // region Item Operations (New Field-Based Model)-- /**- * Get all items from the vault using the new field-based model.- */- @Suppress("LongMethod", "NestedBlockDepth")- fun getAllItems(): List<Item> {- if (database.dbConnection == null) {- error("Database not initialized")- }-- val itemQuery = """- SELECT DISTINCT- i.Id,- i.Name,- i.ItemType,- i.FolderId,- f.Name as FolderPath,- l.FileData as Logo,- CASE WHEN EXISTS (SELECT 1 FROM Passkeys pk WHERE pk.ItemId = i.Id AND pk.IsDeleted = 0) THEN 1 ELSE 0 END as HasPasskey,- CASE WHEN EXISTS (SELECT 1 FROM Attachments att WHERE att.ItemId = i.Id AND att.IsDeleted = 0) THEN 1 ELSE 0 END as HasAttachment,- CASE WHEN EXISTS (SELECT 1 FROM TotpCodes tc WHERE tc.ItemId = i.Id AND tc.IsDeleted = 0) THEN 1 ELSE 0 END as HasTotp,- i.CreatedAt,- i.UpdatedAt- FROM Items i- LEFT JOIN Logos l ON i.LogoId = l.Id- LEFT JOIN Folders f ON i.FolderId = f.Id- WHERE i.IsDeleted = 0 AND i.DeletedAt IS NULL- ORDER BY i.CreatedAt DESC- """-- val items = mutableListOf<Item>()- val itemIds = mutableListOf<String>()-- database.dbConnection?.query(itemQuery)?.use { cursor ->- while (cursor.moveToNext()) {- try {- val idString = cursor.getString(0)- val name = if (cursor.isNull(1)) null else cursor.getString(1)- val itemType = cursor.getString(2)- val folderId = if (cursor.isNull(3)) null else cursor.getString(3)- val folderPath = if (cursor.isNull(4)) null else cursor.getString(4)- val logo = if (cursor.isNull(5)) null else cursor.getBlob(5)- val hasPasskey = cursor.getInt(6) == 1- val hasAttachment = cursor.getInt(7) == 1- val hasTotp = cursor.getInt(8) == 1- val createdAt = DateHelpers.parseDateString(cursor.getString(9)) ?: MIN_DATE- val updatedAt = DateHelpers.parseDateString(cursor.getString(10)) ?: MIN_DATE-- val item = Item(- id = UUID.fromString(idString),- name = name,- itemType = itemType,- logo = logo,- folderId = folderId?.let { UUID.fromString(it) },- folderPath = folderPath,- fields = emptyList(), // Will be populated below- hasPasskey = hasPasskey,- hasAttachment = hasAttachment,- hasTotp = hasTotp,- createdAt = createdAt,- updatedAt = updatedAt,- )- items.add(item)- itemIds.add(idString)- } catch (e: Exception) {- Log.e(TAG, "Error parsing item row", e)- }- }- }-- // If no items, return empty list- if (items.isEmpty()) {- return emptyList()- }-- // Get all field values for these items- val placeholders = itemIds.joinToString(",") { "?" }- val fieldQuery = """- SELECT- fv.ItemId,- fv.FieldKey,- fv.FieldDefinitionId,- fd.Label as CustomLabel,- fd.FieldType as CustomFieldType,- fd.IsHidden as CustomIsHidden,- fd.EnableHistory as CustomEnableHistory,- fv.Value,- fv.Weight as DisplayOrder- FROM FieldValues fv- LEFT JOIN FieldDefinitions fd ON fv.FieldDefinitionId = fd.Id- WHERE fv.ItemId IN ($placeholders)- AND fv.IsDeleted = 0- ORDER BY fv.ItemId, fv.Weight- """-- // Build a map of itemId -> [ItemField]- val fieldsByItemId = mutableMapOf<String, MutableList<ItemField>>()-- database.dbConnection?.query(fieldQuery, itemIds.toTypedArray())?.use { cursor ->- while (cursor.moveToNext()) {- try {- val itemIdString = cursor.getString(0)- val fieldKey = if (cursor.isNull(1)) null else cursor.getString(1)- val fieldDefinitionId = if (cursor.isNull(2)) null else cursor.getString(2)- val customLabel = if (cursor.isNull(3)) null else cursor.getString(3)- val customFieldType = if (cursor.isNull(4)) null else cursor.getString(4)- val customIsHidden = if (cursor.isNull(5)) false else cursor.getInt(5) == 1- val customEnableHistory = if (cursor.isNull(6)) false else cursor.getInt(6) == 1- val value = if (cursor.isNull(7)) "" else cursor.getString(7)- val displayOrder = if (cursor.isNull(8)) 0 else cursor.getInt(8)-- // Determine if this is a custom field- val isCustomField = fieldDefinitionId != null && fieldKey == null-- // Resolve the effective field key- val effectiveFieldKey = fieldKey ?: fieldDefinitionId ?: ""-- // Resolve field metadata- val metadata = resolveFieldMetadata(- fieldKey = effectiveFieldKey,- customLabel = customLabel,- customFieldType = customFieldType,- customIsHidden = customIsHidden,- customEnableHistory = customEnableHistory,- isCustomField = isCustomField,- )-- val field = ItemField(- fieldKey = effectiveFieldKey,- label = metadata.label,- fieldType = metadata.fieldType,- value = value,- isHidden = metadata.isHidden,- displayOrder = displayOrder,- isCustomField = isCustomField,- enableHistory = metadata.enableHistory,- )-- fieldsByItemId.getOrPut(itemIdString) { mutableListOf() }.add(field)- } catch (e: Exception) {- Log.e(TAG, "Error parsing field row", e)- }- }- }-- // Assign fields to items- return items.map { item ->- val fields = fieldsByItemId[item.id.toString().uppercase()] ?: emptyList()- item.copy(fields = fields)- }- }-- /**- * Helper class to hold resolved field metadata.- */- private data class FieldMetadata(- val label: String,- val fieldType: String,- val isHidden: Boolean,- val enableHistory: Boolean,- )-- /**- * Resolve field metadata for system fields and custom fields.- */- @Suppress("CyclomaticComplexMethod", "LongParameterList")- // LongParameterList suppressed: All parameters are needed to determine field metadata- private fun resolveFieldMetadata(- fieldKey: String,- customLabel: String?,- customFieldType: String?,- customIsHidden: Boolean,- customEnableHistory: Boolean,- isCustomField: Boolean,- ): FieldMetadata {- if (isCustomField) {- return FieldMetadata(- label = customLabel ?: fieldKey,- fieldType = customFieldType ?: FieldType.TEXT,- isHidden = customIsHidden,- enableHistory = customEnableHistory,- )- }-- // System field metadata based on FieldKey constants- return when (fieldKey) {- FieldKey.LOGIN_USERNAME -> FieldMetadata("Username", FieldType.TEXT, false, false)- FieldKey.LOGIN_PASSWORD -> FieldMetadata("Password", FieldType.PASSWORD, true, true)- FieldKey.LOGIN_EMAIL -> FieldMetadata("Email", FieldType.EMAIL, false, false)- FieldKey.LOGIN_URL -> FieldMetadata("URL", FieldType.U_R_L, false, false)- FieldKey.CARD_NUMBER -> FieldMetadata("Card Number", FieldType.TEXT, true, false)- FieldKey.CARD_CARDHOLDER_NAME -> FieldMetadata("Cardholder Name", FieldType.TEXT, false, false)- FieldKey.CARD_EXPIRY_MONTH -> FieldMetadata("Expiry Month", FieldType.TEXT, false, false)- FieldKey.CARD_EXPIRY_YEAR -> FieldMetadata("Expiry Year", FieldType.TEXT, false, false)- FieldKey.CARD_CVV -> FieldMetadata("CVV", FieldType.PASSWORD, true, false)- FieldKey.CARD_PIN -> FieldMetadata("PIN", FieldType.PASSWORD, true, false)- FieldKey.ALIAS_FIRST_NAME -> FieldMetadata("First Name", FieldType.TEXT, false, false)- FieldKey.ALIAS_LAST_NAME -> FieldMetadata("Last Name", FieldType.TEXT, false, false)- FieldKey.ALIAS_GENDER -> FieldMetadata("Gender", FieldType.TEXT, false, false)- FieldKey.ALIAS_BIRTHDATE -> FieldMetadata("Birth Date", FieldType.DATE, false, false)- FieldKey.NOTES_CONTENT -> FieldMetadata("Notes", FieldType.TEXT_AREA, false, false)- else -> FieldMetadata(fieldKey, FieldType.TEXT, false, false)- }- }-- // endregion-- // region Item Operations-- /**- * Attempts to get all items using only the cached encryption key.- */- fun tryGetAllItems(callback: ItemOperationCallback, crypto: VaultCrypto, unlockVault: () -> Unit): Boolean {- if (crypto.encryptionKey == null) {- Log.d(TAG, "Encryption key not in memory, authentication required")- return false- }-- try {- if (!database.isVaultUnlocked()) {- unlockVault()- }-- callback.onSuccess(getAllItems())- return true- } catch (e: Exception) {- Log.e(TAG, "Error retrieving items", e)- callback.onError(e)- return false- }- }-- /**- * Get the database version from the __EFMigrationsHistory table.- */- fun getDatabaseVersion(): String {- val query = "SELECT MigrationId FROM __EFMigrationsHistory ORDER BY MigrationId DESC LIMIT 1"- val results = executeQuery(query, emptyArray())-- if (results.isEmpty()) {- Log.d(TAG, "No migrations found in database, returning default version")- return "0.0.0"- }-- val migrationId = results[0]["MigrationId"] as? String- if (migrationId == null) {- return "0.0.0"- }-- val versionRegex = Regex("_(\\d+\\.\\d+\\.\\d+)-")- val match = versionRegex.find(migrationId)-- return if (match != null && match.groupValues.size > 1) {- match.groupValues[1]- } else {- Log.d(TAG, "Could not extract version from migration ID '$migrationId', returning default")- "0.0.0"- }- }-- // endregion-- // region Helper Functions-- private fun String.smartTrim(): String {- val invisible = "[\\uFEFF\\u200B\\u00A0\\u202A-\\u202E\\u2060\\u180E]"- return this.replace(Regex("^($invisible)+|($invisible)+$"), "").trim()- }-- // endregion-}diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.ktindex e4c264c4d..399f9f158 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.kt@@ -21,7 +21,7 @@ import kotlin.coroutines.resume* This class uses composition to organize functionality into specialized components:* - VaultCrypto: Handles encryption, decryption, and key management* - VaultDatabase: Handles database storage and operations- * - VaultQuery: Handles SQL query execution and credential retrieval+ * - ItemRepository: Handles item queries through the repository pattern* - VaultMetadataManager: Handles metadata and settings storage* - VaultAuth: Handles authentication methods and auto-lock* - VaultSync: Handles vault synchronization with server@@ -70,13 +70,13 @@ class VaultStore(private val crypto = VaultCrypto(keystoreProvider, storageProvider)private val databaseComponent = VaultDatabase(storageProvider, crypto)- private val query = VaultQuery(databaseComponent)+ private val itemRepository = net.aliasvault.app.vaultstore.repositories.ItemRepository(databaseComponent)internal val metadata = VaultMetadataManager(storageProvider)private val auth = VaultAuth(storageProvider) { cache.clearCache() }- private val sync = VaultSync(databaseComponent, metadata, crypto, storageProvider, query)- private val mutate = VaultMutate(databaseComponent, query, metadata)+ private val sync = VaultSync(databaseComponent, metadata, crypto, storageProvider, itemRepository)+ private val mutate = VaultMutate(databaseComponent, itemRepository, metadata)private val cache = VaultCache(crypto, databaseComponent, keystoreProvider, storageProvider)- private val passkey = VaultPasskey(databaseComponent, query)+ private val passkey = VaultPasskey(databaseComponent)private val pin by lazy {val androidProvider = storageProvider as net.aliasvault.app.vaultstore.storageprovider.AndroidStorageProvider// Use reflection to access private context field@@ -256,21 +256,89 @@ class VaultStore(* Execute a read-only SQL query (SELECT) on the vault.*/fun executeQuery(queryString: String, params: Array<Any?>): List<Map<String, Any?>> {- return query.executeQuery(queryString, params)+ val db = databaseComponent.dbConnection ?: error("Database not initialized")++ // Convert params to strings for SQLite+ val convertedParams = params.map { param ->+ when (param) {+ null -> null+ is ByteArray -> String(param, Charsets.UTF_8)+ else -> param.toString()+ }+ }.toTypedArray()++ val cursor = db.query(queryString, convertedParams)+ val results = mutableListOf<Map<String, Any?>>()++ cursor.use {+ val columnNames = it.columnNames+ while (it.moveToNext()) {+ val row = mutableMapOf<String, Any?>()+ for (columnName in columnNames) {+ when (it.getType(it.getColumnIndexOrThrow(columnName))) {+ android.database.Cursor.FIELD_TYPE_NULL -> row[columnName] = null+ android.database.Cursor.FIELD_TYPE_INTEGER -> row[columnName] = it.getLong(+ it.getColumnIndexOrThrow(columnName),+ )+ android.database.Cursor.FIELD_TYPE_FLOAT -> row[columnName] = it.getDouble(+ it.getColumnIndexOrThrow(columnName),+ )+ android.database.Cursor.FIELD_TYPE_STRING -> row[columnName] = it.getString(+ it.getColumnIndexOrThrow(columnName),+ )+ android.database.Cursor.FIELD_TYPE_BLOB -> row[columnName] = it.getBlob(+ it.getColumnIndexOrThrow(columnName),+ )+ }+ }+ results.add(row)+ }+ }++ return results}/*** Execute an SQL update on the vault that mutates it.*/fun executeUpdate(queryString: String, params: Array<Any?>): Int {- return query.executeUpdate(queryString, params)+ val db = databaseComponent.dbConnection ?: error("Database not initialized")++ val convertedParams = params.map { param ->+ when (param) {+ null -> null+ is ByteArray -> String(param, Charsets.UTF_8)+ else -> param.toString()+ }+ }.toTypedArray()++ val stmt = db.compileStatement(queryString)+ convertedParams.forEachIndexed { index, value ->+ if (value == null) {+ stmt.bindNull(index + 1)+ } else {+ stmt.bindString(index + 1, value)+ }+ }+ stmt.execute()++ // Get the number of affected rows+ val affectedCursor = db.rawQuery("SELECT changes()", null)+ affectedCursor.use {+ if (it.moveToFirst()) {+ return it.getInt(0)+ }+ }+ return 0}/*** Execute a raw SQL command on the vault without parameters.*/fun executeRaw(queryString: String) {- query.executeRaw(queryString)+ val db = databaseComponent.dbConnection ?: error("Database not initialized")+ val stmt = db.compileStatement(queryString)+ stmt.execute()}/**@@ -305,14 +373,30 @@ class VaultStore(* Get all items from the vault.*/fun getAllItems(): List<Item> {- return query.getAllItems()+ return itemRepository.getAll()}/*** Attempts to get all items using only the cached encryption key.*/fun tryGetAllItems(callback: ItemOperationCallback): Boolean {- return query.tryGetAllItems(callback, crypto) { unlockVault() }+ if (crypto.encryptionKey == null) {+ android.util.Log.d("VaultStore", "Encryption key not in memory, authentication required")+ return false+ }++ try {+ if (!databaseComponent.isVaultUnlocked()) {+ unlockVault()+ }++ callback.onSuccess(itemRepository.getAll())+ return true+ } catch (e: Exception) {+ android.util.Log.e("VaultStore", "Error retrieving items", e)+ callback.onError(e)+ return false+ }}// endregion@@ -617,14 +701,14 @@ class VaultStore(rpId: String,userName: String? = null,userId: ByteArray? = null,- ): List<PasskeyWithCredentialInfo> {+ ): List<net.aliasvault.app.vaultstore.repositories.PasskeyWithCredentialInfo> {return passkey.getPasskeysWithCredentialInfo(rpId, userName, userId)}/*** Get all passkeys with their associated items in a single query.*/- fun getAllPasskeysWithItems(): List<PasskeyWithItem> {+ fun getAllPasskeysWithItems(): List<net.aliasvault.app.vaultstore.repositories.PasskeyWithItem> {return passkey.getAllPasskeysWithItems()}@@ -679,7 +763,7 @@ class VaultStore(fun getItemsWithoutPasskeyForRpId(rpId: String,userName: String? = null,- ): List<ItemWithCredentialInfo> {+ ): List<net.aliasvault.app.vaultstore.repositories.ItemWithCredentialInfo> {return passkey.getItemsWithoutPasskeyForRpId(rpId, userName)}diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.ktindex b38fe87a6..cad6e8728 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.kt@@ -5,6 +5,7 @@ import net.aliasvault.app.exceptions.SerializationExceptionimport net.aliasvault.app.exceptions.VaultOperationExceptionimport net.aliasvault.app.rustcore.VaultMergeServiceimport net.aliasvault.app.utils.AppInfo+import net.aliasvault.app.vaultstore.repositories.ItemRepositoryimport net.aliasvault.app.vaultstore.storageprovider.StorageProviderimport net.aliasvault.app.vaultstore.utils.VersionComparisonimport org.json.JSONArray@@ -18,7 +19,7 @@ class VaultSync(private val metadata: VaultMetadataManager,private val crypto: VaultCrypto,private val storageProvider: StorageProvider,- private val query: VaultQuery,+ private val itemRepository: ItemRepository,) {companion object {private const val TAG = "VaultSync"@@ -503,7 +504,7 @@ class VaultSync(}// Get all items to count them and extract private email addresses- val items = query.getAllItems()+ val items = itemRepository.getAll()val metadataObj = metadata.getVaultMetadataObject()val privateEmailDomains = metadataObj?.privateEmailDomains ?: emptyList()@@ -518,7 +519,7 @@ class VaultSync(}.distinct()- val dbVersion = query.getDatabaseVersion()+ val dbVersion = itemRepository.getDatabaseVersion()@Suppress("SwallowedException")val version = try {diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/ItemRepository.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/ItemRepository.ktindex 94208976e..39350a60d 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/ItemRepository.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/ItemRepository.kt@@ -1,17 +1,21 @@package net.aliasvault.app.vaultstore.repositories+import android.util.Log+import net.aliasvault.app.utils.DateHelpersimport net.aliasvault.app.vaultstore.VaultDatabaseimport net.aliasvault.app.vaultstore.models.FieldKey+import net.aliasvault.app.vaultstore.models.FieldTypeimport net.aliasvault.app.vaultstore.models.Item+import net.aliasvault.app.vaultstore.models.ItemFieldimport java.util.Calendarimport java.util.Dateimport java.util.TimeZone+import java.util.UUID/*** Repository for Item CRUD operations.* Handles fetching, creating, updating, and deleting items with their related data.*/-@Suppress("UnusedPrivateProperty") // TAG and MIN_DATE reserved for future useclass ItemRepository(database: VaultDatabase) : BaseRepository(database) {companion object {private const val TAG = "ItemRepository"@@ -34,10 +38,146 @@ class ItemRepository(database: VaultDatabase) : BaseRepository(database) {** @return List of Item objects.*/+ @Suppress("LongMethod", "NestedBlockDepth", "LoopWithTooManyJumpStatements")fun getAll(): List<Item> {- // Implementation delegated to VaultQuery.getAllItems() for now- // This maintains existing tested behavior- error("Use VaultQuery.getAllItems() directly - repository pattern under construction")+ val itemQuery = """+ SELECT DISTINCT+ i.Id,+ i.Name,+ i.ItemType,+ i.FolderId,+ f.Name as FolderPath,+ l.FileData as Logo,+ CASE WHEN EXISTS (SELECT 1 FROM Passkeys pk WHERE pk.ItemId = i.Id AND pk.IsDeleted = 0) THEN 1 ELSE 0 END as HasPasskey,+ CASE WHEN EXISTS (SELECT 1 FROM Attachments att WHERE att.ItemId = i.Id AND att.IsDeleted = 0) THEN 1 ELSE 0 END as HasAttachment,+ CASE WHEN EXISTS (SELECT 1 FROM TotpCodes tc WHERE tc.ItemId = i.Id AND tc.IsDeleted = 0) THEN 1 ELSE 0 END as HasTotp,+ i.CreatedAt,+ i.UpdatedAt+ FROM Items i+ LEFT JOIN Logos l ON i.LogoId = l.Id+ LEFT JOIN Folders f ON i.FolderId = f.Id+ WHERE i.IsDeleted = 0 AND i.DeletedAt IS NULL+ ORDER BY i.CreatedAt DESC+ """.trimIndent()++ val items = mutableListOf<Item>()+ val itemIds = mutableListOf<String>()++ val itemResults = executeQueryWithBlobs(itemQuery, emptyArray())+ for (row in itemResults) {+ try {+ val idString = row["Id"] as? String ?: continue+ val name = row["Name"] as? String+ val itemType = row["ItemType"] as? String ?: continue+ val folderId = row["FolderId"] as? String+ val folderPath = row["FolderPath"] as? String+ val logo = row["Logo"] as? ByteArray+ val hasPasskey = (row["HasPasskey"] as? Long) == 1L+ val hasAttachment = (row["HasAttachment"] as? Long) == 1L+ val hasTotp = (row["HasTotp"] as? Long) == 1L+ val createdAt = DateHelpers.parseDateString(row["CreatedAt"] as? String ?: "") ?: MIN_DATE+ val updatedAt = DateHelpers.parseDateString(row["UpdatedAt"] as? String ?: "") ?: MIN_DATE++ val item = Item(+ id = UUID.fromString(idString),+ name = name,+ itemType = itemType,+ logo = logo,+ folderId = folderId?.let { UUID.fromString(it) },+ folderPath = folderPath,+ fields = emptyList(), // Will be populated below+ hasPasskey = hasPasskey,+ hasAttachment = hasAttachment,+ hasTotp = hasTotp,+ createdAt = createdAt,+ updatedAt = updatedAt,+ )+ items.add(item)+ itemIds.add(idString)+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing item row", e)+ }+ }++ // If no items, return empty list+ if (items.isEmpty()) {+ return emptyList()+ }++ // Get all field values for these items+ val (placeholders, _) = buildInClause(itemIds)+ val fieldQuery = """+ SELECT+ fv.ItemId,+ fv.FieldKey,+ fv.FieldDefinitionId,+ fd.Label as CustomLabel,+ fd.FieldType as CustomFieldType,+ fd.IsHidden as CustomIsHidden,+ fd.EnableHistory as CustomEnableHistory,+ fv.Value,+ fv.Weight as DisplayOrder+ FROM FieldValues fv+ LEFT JOIN FieldDefinitions fd ON fv.FieldDefinitionId = fd.Id+ WHERE fv.ItemId IN ($placeholders)+ AND fv.IsDeleted = 0+ ORDER BY fv.ItemId, fv.Weight+ """.trimIndent()++ // Build a map of itemId -> [ItemField]+ val fieldsByItemId = mutableMapOf<String, MutableList<ItemField>>()++ val fieldResults = executeQuery(fieldQuery, itemIds.toTypedArray())+ for (row in fieldResults) {+ try {+ val itemIdString = row["ItemId"] as? String ?: continue+ val fieldKey = row["FieldKey"] as? String+ val fieldDefinitionId = row["FieldDefinitionId"] as? String+ val customLabel = row["CustomLabel"] as? String+ val customFieldType = row["CustomFieldType"] as? String+ val customIsHidden = (row["CustomIsHidden"] as? Long) == 1L+ val customEnableHistory = (row["CustomEnableHistory"] as? Long) == 1L+ val value = row["Value"] as? String ?: ""+ val displayOrder = (row["DisplayOrder"] as? Long)?.toInt() ?: 0++ // Determine if this is a custom field+ val isCustomField = fieldDefinitionId != null && fieldKey == null++ // Resolve the effective field key+ val effectiveFieldKey = fieldKey ?: fieldDefinitionId ?: ""++ // Resolve field metadata+ val metadata = resolveFieldMetadata(+ fieldKey = effectiveFieldKey,+ customLabel = customLabel,+ customFieldType = customFieldType,+ customIsHidden = customIsHidden,+ customEnableHistory = customEnableHistory,+ isCustomField = isCustomField,+ )++ val field = ItemField(+ fieldKey = effectiveFieldKey,+ label = metadata.label,+ fieldType = metadata.fieldType,+ value = value,+ isHidden = metadata.isHidden,+ displayOrder = displayOrder,+ isCustomField = isCustomField,+ enableHistory = metadata.enableHistory,+ )++ fieldsByItemId.getOrPut(itemIdString) { mutableListOf() }.add(field)+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing field row", e)+ }+ }++ // Assign fields to items+ return items.map { item ->+ val fields = fieldsByItemId[item.id.toString().uppercase()] ?: emptyList()+ item.copy(fields = fields)+ }}/**@@ -46,9 +186,115 @@ class ItemRepository(database: VaultDatabase) : BaseRepository(database) {* @param itemId The ID of the item to fetch.* @return Item object or null if not found.*/- @Suppress("UNUSED_PARAMETER") // Method under construction, will be implementedfun getById(itemId: String): Item? {- error("Use VaultQuery.getItemById() directly - repository pattern under construction")+ val itemQuery = """+ SELECT DISTINCT+ i.Id,+ i.Name,+ i.ItemType,+ i.FolderId,+ f.Name as FolderPath,+ l.FileData as Logo,+ CASE WHEN EXISTS (SELECT 1 FROM Passkeys pk WHERE pk.ItemId = i.Id AND pk.IsDeleted = 0) THEN 1 ELSE 0 END as HasPasskey,+ CASE WHEN EXISTS (SELECT 1 FROM Attachments att WHERE att.ItemId = i.Id AND att.IsDeleted = 0) THEN 1 ELSE 0 END as HasAttachment,+ CASE WHEN EXISTS (SELECT 1 FROM TotpCodes tc WHERE tc.ItemId = i.Id AND tc.IsDeleted = 0) THEN 1 ELSE 0 END as HasTotp,+ i.CreatedAt,+ i.UpdatedAt+ FROM Items i+ LEFT JOIN Logos l ON i.LogoId = l.Id+ LEFT JOIN Folders f ON i.FolderId = f.Id+ WHERE i.Id = ? AND i.IsDeleted = 0 AND i.DeletedAt IS NULL+ """.trimIndent()++ val itemResults = executeQueryWithBlobs(itemQuery, arrayOf(itemId.uppercase()))+ val row = itemResults.firstOrNull() ?: return null++ return try {+ val idString = row["Id"] as? String ?: return null+ val name = row["Name"] as? String+ val itemType = row["ItemType"] as? String ?: return null+ val folderId = row["FolderId"] as? String+ val folderPath = row["FolderPath"] as? String+ val logo = row["Logo"] as? ByteArray+ val hasPasskey = (row["HasPasskey"] as? Long) == 1L+ val hasAttachment = (row["HasAttachment"] as? Long) == 1L+ val hasTotp = (row["HasTotp"] as? Long) == 1L+ val createdAt = DateHelpers.parseDateString(row["CreatedAt"] as? String ?: "") ?: MIN_DATE+ val updatedAt = DateHelpers.parseDateString(row["UpdatedAt"] as? String ?: "") ?: MIN_DATE++ // Get field values for this item+ val fieldQuery = """+ SELECT+ fv.FieldKey,+ fv.FieldDefinitionId,+ fd.Label as CustomLabel,+ fd.FieldType as CustomFieldType,+ fd.IsHidden as CustomIsHidden,+ fd.EnableHistory as CustomEnableHistory,+ fv.Value,+ fv.Weight as DisplayOrder+ FROM FieldValues fv+ LEFT JOIN FieldDefinitions fd ON fv.FieldDefinitionId = fd.Id+ WHERE fv.ItemId = ? AND fv.IsDeleted = 0+ ORDER BY fv.Weight+ """.trimIndent()++ val fields = mutableListOf<ItemField>()+ val fieldResults = executeQuery(fieldQuery, arrayOf(idString))+ for (fieldRow in fieldResults) {+ val fieldKey = fieldRow["FieldKey"] as? String+ val fieldDefinitionId = fieldRow["FieldDefinitionId"] as? String+ val customLabel = fieldRow["CustomLabel"] as? String+ val customFieldType = fieldRow["CustomFieldType"] as? String+ val customIsHidden = (fieldRow["CustomIsHidden"] as? Long) == 1L+ val customEnableHistory = (fieldRow["CustomEnableHistory"] as? Long) == 1L+ val value = fieldRow["Value"] as? String ?: ""+ val displayOrder = (fieldRow["DisplayOrder"] as? Long)?.toInt() ?: 0++ val isCustomField = fieldDefinitionId != null && fieldKey == null+ val effectiveFieldKey = fieldKey ?: fieldDefinitionId ?: ""++ val metadata = resolveFieldMetadata(+ fieldKey = effectiveFieldKey,+ customLabel = customLabel,+ customFieldType = customFieldType,+ customIsHidden = customIsHidden,+ customEnableHistory = customEnableHistory,+ isCustomField = isCustomField,+ )++ fields.add(+ ItemField(+ fieldKey = effectiveFieldKey,+ label = metadata.label,+ fieldType = metadata.fieldType,+ value = value,+ isHidden = metadata.isHidden,+ displayOrder = displayOrder,+ isCustomField = isCustomField,+ enableHistory = metadata.enableHistory,+ ),+ )+ }++ Item(+ id = UUID.fromString(idString),+ name = name,+ itemType = itemType,+ logo = logo,+ folderId = folderId?.let { UUID.fromString(it) },+ folderPath = folderPath,+ fields = fields,+ hasPasskey = hasPasskey,+ hasAttachment = hasAttachment,+ hasTotp = hasTotp,+ createdAt = createdAt,+ updatedAt = updatedAt,+ )+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing item by ID", e)+ null+ }}/**@@ -74,11 +320,102 @@ class ItemRepository(database: VaultDatabase) : BaseRepository(database) {/*** Get recently deleted items (in trash).+ * Note: This returns minimal Item objects without fields for performance.*- * @return List of items.+ * @return List of items in trash.*/+ @Suppress("LongMethod", "LoopWithTooManyJumpStatements")fun getRecentlyDeleted(): List<Item> {- error("Use VaultQuery.getRecentlyDeletedItems() directly - repository pattern under construction")+ val query = """+ SELECT DISTINCT+ i.Id,+ i.Name,+ i.ItemType,+ i.FolderId,+ f.Name as FolderPath,+ l.FileData as Logo,+ CASE WHEN EXISTS (SELECT 1 FROM Passkeys pk WHERE pk.ItemId = i.Id AND pk.IsDeleted = 0) THEN 1 ELSE 0 END as HasPasskey,+ CASE WHEN EXISTS (SELECT 1 FROM Attachments att WHERE att.ItemId = i.Id AND att.IsDeleted = 0) THEN 1 ELSE 0 END as HasAttachment,+ CASE WHEN EXISTS (SELECT 1 FROM TotpCodes tc WHERE tc.ItemId = i.Id AND tc.IsDeleted = 0) THEN 1 ELSE 0 END as HasTotp,+ i.CreatedAt,+ i.UpdatedAt,+ i.DeletedAt+ FROM Items i+ LEFT JOIN Logos l ON i.LogoId = l.Id+ LEFT JOIN Folders f ON i.FolderId = f.Id+ WHERE i.IsDeleted = 0 AND i.DeletedAt IS NOT NULL+ ORDER BY i.DeletedAt DESC+ """.trimIndent()++ val items = mutableListOf<Item>()+ val results = executeQueryWithBlobs(query, emptyArray())++ for (row in results) {+ try {+ val idString = row["Id"] as? String ?: continue+ val name = row["Name"] as? String+ val itemType = row["ItemType"] as? String ?: continue+ val folderId = row["FolderId"] as? String+ val folderPath = row["FolderPath"] as? String+ val logo = row["Logo"] as? ByteArray+ val hasPasskey = (row["HasPasskey"] as? Long) == 1L+ val hasAttachment = (row["HasAttachment"] as? Long) == 1L+ val hasTotp = (row["HasTotp"] as? Long) == 1L+ val createdAt = DateHelpers.parseDateString(row["CreatedAt"] as? String ?: "") ?: MIN_DATE+ val updatedAt = DateHelpers.parseDateString(row["UpdatedAt"] as? String ?: "") ?: MIN_DATE++ items.add(+ Item(+ id = UUID.fromString(idString),+ name = name,+ itemType = itemType,+ logo = logo,+ folderId = folderId?.let { UUID.fromString(it) },+ folderPath = folderPath,+ fields = emptyList(), // Not loading fields for trash items+ hasPasskey = hasPasskey,+ hasAttachment = hasAttachment,+ hasTotp = hasTotp,+ createdAt = createdAt,+ updatedAt = updatedAt,+ ),+ )+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing recently deleted item row", e)+ }+ }++ return items+ }++ /**+ * Get the database version from the __EFMigrationsHistory table.+ *+ * @return Database version string (e.g., "1.0.0").+ */+ fun getDatabaseVersion(): String {+ val query = "SELECT MigrationId FROM __EFMigrationsHistory ORDER BY MigrationId DESC LIMIT 1"+ val results = executeQuery(query, emptyArray())++ if (results.isEmpty()) {+ Log.d(TAG, "No migrations found in database, returning default version")+ return "0.0.0"+ }++ val migrationId = results[0]["MigrationId"] as? String+ if (migrationId == null) {+ return "0.0.0"+ }++ val versionRegex = Regex("_(\\d+\\.\\d+\\.\\d+)-")+ val match = versionRegex.find(migrationId)++ return if (match != null && match.groupValues.size > 1) {+ match.groupValues[1]+ } else {+ Log.d(TAG, "Could not extract version from migration ID '$migrationId', returning default")+ "0.0.0"+ }}/**@@ -197,4 +534,96 @@ class ItemRepository(database: VaultDatabase) : BaseRepository(database) {fun update(item: Item): Int {error("Update operations should use VaultMutate - repository pattern under construction")}++ // MARK: - Helper Methods++ /**+ * Helper class to hold resolved field metadata.+ */+ private data class FieldMetadata(+ val label: String,+ val fieldType: String,+ val isHidden: Boolean,+ val enableHistory: Boolean,+ )++ /**+ * Resolve field metadata for system fields and custom fields.+ */+ @Suppress("CyclomaticComplexMethod", "LongParameterList")+ // LongParameterList suppressed: All parameters are needed to determine field metadata+ private fun resolveFieldMetadata(+ fieldKey: String,+ customLabel: String?,+ customFieldType: String?,+ customIsHidden: Boolean,+ customEnableHistory: Boolean,+ isCustomField: Boolean,+ ): FieldMetadata {+ if (isCustomField) {+ return FieldMetadata(+ label = customLabel ?: fieldKey,+ fieldType = customFieldType ?: FieldType.TEXT,+ isHidden = customIsHidden,+ enableHistory = customEnableHistory,+ )+ }++ // System field metadata based on FieldKey constants+ return when (fieldKey) {+ FieldKey.LOGIN_USERNAME -> FieldMetadata("Username", FieldType.TEXT, false, false)+ FieldKey.LOGIN_PASSWORD -> FieldMetadata("Password", FieldType.PASSWORD, true, true)+ FieldKey.LOGIN_EMAIL -> FieldMetadata("Email", FieldType.EMAIL, false, false)+ FieldKey.LOGIN_URL -> FieldMetadata("URL", FieldType.U_R_L, false, false)+ FieldKey.CARD_NUMBER -> FieldMetadata("Card Number", FieldType.TEXT, true, false)+ FieldKey.CARD_CARDHOLDER_NAME -> FieldMetadata("Cardholder Name", FieldType.TEXT, false, false)+ FieldKey.CARD_EXPIRY_MONTH -> FieldMetadata("Expiry Month", FieldType.TEXT, false, false)+ FieldKey.CARD_EXPIRY_YEAR -> FieldMetadata("Expiry Year", FieldType.TEXT, false, false)+ FieldKey.CARD_CVV -> FieldMetadata("CVV", FieldType.PASSWORD, true, false)+ FieldKey.CARD_PIN -> FieldMetadata("PIN", FieldType.PASSWORD, true, false)+ FieldKey.ALIAS_FIRST_NAME -> FieldMetadata("First Name", FieldType.TEXT, false, false)+ FieldKey.ALIAS_LAST_NAME -> FieldMetadata("Last Name", FieldType.TEXT, false, false)+ FieldKey.ALIAS_GENDER -> FieldMetadata("Gender", FieldType.TEXT, false, false)+ FieldKey.ALIAS_BIRTHDATE -> FieldMetadata("Birth Date", FieldType.DATE, false, false)+ FieldKey.NOTES_CONTENT -> FieldMetadata("Notes", FieldType.TEXT_AREA, false, false)+ else -> FieldMetadata(fieldKey, FieldType.TEXT, false, false)+ }+ }++ /**+ * Execute a SELECT query that may return BLOB columns.+ * Unlike executeQuery which converts all params to strings, this preserves ByteArray types.+ */+ private fun executeQueryWithBlobs(query: String, params: Array<Any?>): List<Map<String, Any?>> {+ val db = database.dbConnection ?: error("Database not initialized")+ val cursor = db.query(query, params.map { it?.toString() }.toTypedArray())++ val results = mutableListOf<Map<String, Any?>>()+ cursor.use {+ val columnNames = it.columnNames+ while (it.moveToNext()) {+ val row = mutableMapOf<String, Any?>()+ for (columnName in columnNames) {+ when (it.getType(it.getColumnIndexOrThrow(columnName))) {+ android.database.Cursor.FIELD_TYPE_NULL -> row[columnName] = null+ android.database.Cursor.FIELD_TYPE_INTEGER -> row[columnName] = it.getLong(+ it.getColumnIndexOrThrow(columnName),+ )+ android.database.Cursor.FIELD_TYPE_FLOAT -> row[columnName] = it.getDouble(+ it.getColumnIndexOrThrow(columnName),+ )+ android.database.Cursor.FIELD_TYPE_STRING -> row[columnName] = it.getString(+ it.getColumnIndexOrThrow(columnName),+ )+ android.database.Cursor.FIELD_TYPE_BLOB -> row[columnName] = it.getBlob(+ it.getColumnIndexOrThrow(columnName),+ )+ }+ }+ results.add(row)+ }+ }++ return results+ }}diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/PasskeyRepository.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/PasskeyRepository.ktindex 7aeb40682..1b95fdd29 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/PasskeyRepository.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/PasskeyRepository.kt@@ -1,5 +1,6 @@package net.aliasvault.app.vaultstore.repositories+import android.database.Cursorimport android.util.Logimport net.aliasvault.app.utils.DateHelpersimport net.aliasvault.app.vaultstore.VaultDatabase@@ -423,6 +424,242 @@ class PasskeyRepository(database: VaultDatabase) : BaseRepository(database) {}}+ // MARK: - Complex Query Operations++ /**+ * Get passkeys with item info for a specific rpId and optionally username.+ * Used for finding existing passkeys that might be replaced during registration.+ *+ * @param rpId The relying party identifier.+ * @param userName Optional username to filter by.+ * @param userId Optional user ID bytes to filter by.+ * @return List of PasskeyWithCredentialInfo objects.+ */+ fun getWithCredentialInfo(+ rpId: String,+ userName: String? = null,+ userId: ByteArray? = null,+ ): List<PasskeyWithCredentialInfo> {+ val db = database.dbConnection ?: return emptyList()++ val query = """+ SELECT p.Id, p.ItemId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,+ p.DisplayName, p.CreatedAt, p.UpdatedAt, p.IsDeleted,+ i.Name,+ fv_username.Value as Username+ FROM Passkeys p+ INNER JOIN Items i ON p.ItemId = i.Id+ LEFT JOIN FieldValues fv_username ON fv_username.ItemId = i.Id+ AND fv_username.FieldKey = ?+ AND fv_username.IsDeleted = 0+ WHERE p.RpId = ? AND p.IsDeleted = 0 AND i.IsDeleted = 0 AND i.DeletedAt IS NULL+ ORDER BY p.CreatedAt DESC+ """.trimIndent()++ val results = mutableListOf<PasskeyWithCredentialInfo>()+ val cursor = db.query(query, arrayOf(FieldKey.LOGIN_USERNAME, rpId))++ cursor.use {+ while (it.moveToNext()) {+ val passkey = parsePasskeyFromCursor(it) ?: continue+ val itemName = if (!it.isNull(11)) it.getString(11) else null+ val itemUsername = if (!it.isNull(12)) it.getString(12) else null++ // Filter by username or userId if provided+ var matches = true+ if (userName != null && itemUsername != userName) {+ matches = false+ }+ if (userId != null && passkey.userHandle != null && !userId.contentEquals(passkey.userHandle)) {+ matches = false+ }++ if (matches) {+ results.add(+ PasskeyWithCredentialInfo(+ passkey = passkey,+ serviceName = itemName,+ username = itemUsername,+ ),+ )+ }+ }+ }++ return results+ }++ /**+ * Get Items that match an rpId but don't have a passkey yet.+ * Used for finding existing credentials that could have a passkey added to them.+ *+ * @param rpId The relying party identifier to match against the login URL.+ * @param userName Optional username to filter by.+ * @return List of ItemWithCredentialInfo objects representing Items without passkeys.+ */+ fun getItemsWithoutPasskeyForRpId(+ rpId: String,+ userName: String? = null,+ ): List<ItemWithCredentialInfo> {+ val db = database.dbConnection ?: return emptyList()++ val query = """+ SELECT i.Id, i.Name, i.CreatedAt, i.UpdatedAt,+ fv_url.Value as Url,+ fv_username.Value as Username,+ fv_password.Value as Password+ FROM Items i+ INNER JOIN FieldValues fv_url ON fv_url.ItemId = i.Id+ AND fv_url.FieldKey = ?+ AND fv_url.IsDeleted = 0+ LEFT JOIN FieldValues fv_username ON fv_username.ItemId = i.Id+ AND fv_username.FieldKey = ?+ AND fv_username.IsDeleted = 0+ LEFT JOIN FieldValues fv_password ON fv_password.ItemId = i.Id+ AND fv_password.FieldKey = ?+ AND fv_password.IsDeleted = 0+ WHERE i.IsDeleted = 0+ AND i.DeletedAt IS NULL+ AND i.ItemType = 'Login'+ AND (LOWER(fv_url.Value) LIKE ? OR LOWER(fv_url.Value) LIKE ?)+ AND NOT EXISTS (+ SELECT 1 FROM Passkeys p+ WHERE p.ItemId = i.Id AND p.IsDeleted = 0+ )+ ORDER BY i.UpdatedAt DESC+ """.trimIndent()++ val rpIdLower = rpId.lowercase()+ val urlPattern1 = "%$rpIdLower%"+ val urlPattern2 = "%${rpIdLower.replace("www.", "")}%"++ val results = mutableListOf<ItemWithCredentialInfo>()+ val cursor = db.query(+ query,+ arrayOf(+ FieldKey.LOGIN_URL,+ FieldKey.LOGIN_USERNAME,+ FieldKey.LOGIN_PASSWORD,+ urlPattern1,+ urlPattern2,+ ),+ )++ cursor.use {+ while (it.moveToNext()) {+ val itemIdString = it.getString(0)+ val itemName = if (!it.isNull(1)) it.getString(1) else null+ val itemCreatedAt = if (!it.isNull(2)) it.getString(2) else null+ val itemUpdatedAt = if (!it.isNull(3)) it.getString(3) else null+ val url = if (!it.isNull(4)) it.getString(4) else null+ val itemUsername = if (!it.isNull(5)) it.getString(5) else null+ val hasPassword = !it.isNull(6) && it.getString(6).isNotEmpty()++ // Filter by username if provided+ if (userName != null && itemUsername != userName) {+ continue+ }++ try {+ val itemId = UUID.fromString(itemIdString)+ val createdAt = DateHelpers.parseDateString(itemCreatedAt ?: "") ?: MIN_DATE+ val updatedAt = DateHelpers.parseDateString(itemUpdatedAt ?: "") ?: MIN_DATE++ results.add(+ ItemWithCredentialInfo(+ itemId = itemId,+ serviceName = itemName,+ url = url,+ username = itemUsername,+ hasPassword = hasPassword,+ createdAt = createdAt,+ updatedAt = updatedAt,+ ),+ )+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing item row", e)+ }+ }+ }++ return results+ }++ /**+ * Get all passkeys with their associated items in a single query.+ * This is much more efficient than calling getForItem() for each item.+ *+ * @return List of PasskeyWithItem objects.+ */+ fun getAllWithItems(): List<PasskeyWithItem> {+ val db = database.dbConnection ?: return emptyList()++ val query = """+ SELECT+ p.Id, p.ItemId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,+ p.DisplayName, p.CreatedAt as PasskeyCreatedAt, p.UpdatedAt as PasskeyUpdatedAt, p.IsDeleted as PasskeyIsDeleted,+ i.Id as ItemId, i.Name, i.CreatedAt as ItemCreatedAt, i.UpdatedAt as ItemUpdatedAt,+ fv_username.Value as Username,+ fv_email.Value as Email+ FROM Passkeys p+ INNER JOIN Items i ON p.ItemId = i.Id+ LEFT JOIN FieldValues fv_username ON fv_username.ItemId = i.Id+ AND fv_username.FieldKey = ?+ AND fv_username.IsDeleted = 0+ LEFT JOIN FieldValues fv_email ON fv_email.ItemId = i.Id+ AND fv_email.FieldKey = ?+ AND fv_email.IsDeleted = 0+ WHERE p.IsDeleted = 0 AND i.IsDeleted = 0 AND i.DeletedAt IS NULL+ ORDER BY p.CreatedAt DESC+ """.trimIndent()++ val results = mutableListOf<PasskeyWithItem>()+ val cursor = db.query(query, arrayOf(FieldKey.LOGIN_USERNAME, FieldKey.LOGIN_EMAIL))++ cursor.use {+ while (it.moveToNext()) {+ try {+ // Parse passkey (columns 0-10)+ val passkey = parsePasskeyFromJoinCursor(it) ?: continue++ // Parse item info (columns 11-14)+ val itemId = UUID.fromString(it.getString(11))+ val itemName = if (!it.isNull(12)) it.getString(12) else null+ val itemCreatedAt = DateHelpers.parseDateString(it.getString(13)) ?: MIN_DATE+ val itemUpdatedAt = DateHelpers.parseDateString(it.getString(14)) ?: MIN_DATE++ @Suppress("UNUSED_VARIABLE") // Username field loaded for potential future use+ val username = if (!it.isNull(15)) it.getString(15) else null++ @Suppress("UNUSED_VARIABLE") // Email field loaded for potential future use+ val email = if (!it.isNull(16)) it.getString(16) else null++ // Create a minimal Item object with the data we have+ val item = Item(+ id = itemId,+ name = itemName,+ itemType = "Login",+ logo = null,+ folderId = null,+ folderPath = null,+ fields = emptyList(), // Not loading all fields for performance+ hasPasskey = true,+ hasAttachment = false,+ hasTotp = false,+ createdAt = itemCreatedAt,+ updatedAt = itemUpdatedAt,+ )++ results.add(PasskeyWithItem(passkey, item))+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing passkey with item row", e)+ }+ }+ }++ return results+ }+// MARK: - Helper Methods/**@@ -470,4 +707,146 @@ class PasskeyRepository(database: VaultDatabase) : BaseRepository(database) {null}}++ /**+ * Parse a passkey from a cursor (for direct database queries).+ * Expects columns 0-10 to be passkey fields.+ */+ private fun parsePasskeyFromCursor(cursor: Cursor): Passkey? {+ return try {+ val idString = cursor.getString(0)+ val itemIdString = cursor.getString(1)+ val rpId = cursor.getString(2)+ val userHandle = if (!cursor.isNull(3)) cursor.getBlob(3) else null+ val publicKeyString = cursor.getString(4)+ val privateKeyString = cursor.getString(5)+ val prfKey = if (!cursor.isNull(6)) cursor.getBlob(6) else null+ val displayName = cursor.getString(7)+ val createdAtString = cursor.getString(8)+ val updatedAtString = cursor.getString(9)+ val isDeleted = cursor.getInt(10) == 1++ val id = UUID.fromString(idString)+ val itemId = UUID.fromString(itemIdString)++ val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATE+ val updatedAt = DateHelpers.parseDateString(updatedAtString) ?: MIN_DATE++ val publicKeyData = publicKeyString.toByteArray(Charsets.UTF_8)+ val privateKeyData = privateKeyString.toByteArray(Charsets.UTF_8)++ Passkey(+ id = id,+ parentItemId = itemId,+ rpId = rpId,+ userHandle = userHandle,+ userName = null,+ publicKey = publicKeyData,+ privateKey = privateKeyData,+ prfKey = prfKey,+ displayName = displayName,+ createdAt = createdAt,+ updatedAt = updatedAt,+ isDeleted = isDeleted,+ )+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing passkey from cursor", e)+ null+ }+ }++ /**+ * Parse a passkey from a JOIN query cursor.+ * Expects columns 0-10 to be passkey fields.+ */+ private fun parsePasskeyFromJoinCursor(cursor: Cursor): Passkey? {+ return try {+ val idString = cursor.getString(0)+ val itemIdString = cursor.getString(1)+ val rpId = cursor.getString(2)+ val userHandle = if (!cursor.isNull(3)) cursor.getBlob(3) else null+ val publicKeyString = cursor.getString(4)+ val privateKeyString = cursor.getString(5)+ val prfKey = if (!cursor.isNull(6)) cursor.getBlob(6) else null+ val displayName = cursor.getString(7)+ val createdAtString = cursor.getString(8)+ val updatedAtString = cursor.getString(9)+ val isDeleted = cursor.getInt(10) == 1++ val id = UUID.fromString(idString)+ val itemId = UUID.fromString(itemIdString)++ val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATE+ val updatedAt = DateHelpers.parseDateString(updatedAtString) ?: MIN_DATE++ val publicKeyData = publicKeyString.toByteArray(Charsets.UTF_8)+ val privateKeyData = privateKeyString.toByteArray(Charsets.UTF_8)++ Passkey(+ id = id,+ parentItemId = itemId,+ rpId = rpId,+ userHandle = userHandle,+ userName = null,+ publicKey = publicKeyData,+ privateKey = privateKeyData,+ prfKey = prfKey,+ displayName = displayName,+ createdAt = createdAt,+ updatedAt = updatedAt,+ isDeleted = isDeleted,+ )+ } catch (e: Exception) {+ Log.e(TAG, "Error parsing passkey from JOIN cursor", e)+ null+ }+ }}++// MARK: - Data Classes++/**+ * Data class to hold passkey with item info.+ *+ * @property passkey The passkey.+ * @property serviceName The service name from the item.+ * @property username The username from the item.+ */+data class PasskeyWithCredentialInfo(+ val passkey: Passkey,+ val serviceName: String?,+ val username: String?,+)++/**+ * Data class to hold passkey with its associated item.+ *+ * @property passkey The passkey.+ * @property item The item this passkey belongs to.+ */+data class PasskeyWithItem(+ val passkey: Passkey,+ val item: Item,+)++/**+ * Data class to hold Item info for Items without passkeys.+ * Used for showing existing credentials that can have a passkey added.+ *+ * @property itemId The UUID of the item.+ * @property serviceName The service name (Item.Name).+ * @property url The login URL.+ * @property username The username from field values.+ * @property hasPassword Whether the item has a password.+ * @property createdAt When the item was created.+ * @property updatedAt When the item was last updated.+ */+data class ItemWithCredentialInfo(+ val itemId: UUID,+ val serviceName: String?,+ val url: String?,+ val username: String?,+ val hasPassword: Boolean,+ val createdAt: Date,+ val updatedAt: Date,+)