Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Add Kotlin item repository scaffolding (#1404)
Leendert de Borst520b956f3a41
diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/CredentialIdentityStore.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/CredentialIdentityStore.ktindex df694568f..32ec62273 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/CredentialIdentityStore.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/CredentialIdentityStore.kt@@ -4,7 +4,7 @@ import android.content.Contextimport android.content.SharedPreferencesimport android.util.Logimport net.aliasvault.app.utils.Helpers-import net.aliasvault.app.vaultstore.models.Credential+import net.aliasvault.app.vaultstore.models.Itemimport net.aliasvault.app.vaultstore.models.Passkeyimport net.aliasvault.app.vaultstore.passkey.PasskeyHelperimport org.json.JSONArray@@ -94,13 +94,13 @@ class CredentialIdentityStore private constructor(context: Context) {try {val passkeyIdentities = mutableListOf<PasskeyIdentity>()- // Get all passkeys with their credentials in a single efficient query- // This replaces the N+1 query pattern that was calling getPasskeysForCredential() for each credential- val passkeysWithCredentials = vaultStore.getAllPasskeysWithCredentials()+ // Get all passkeys with their items in a single efficient query+ // This replaces the N+1 query pattern that was calling getPasskeysForItem() for each item+ val passkeysWithItems = vaultStore.getAllPasskeysWithItems()- passkeysWithCredentials.forEach { (passkey, credential) ->+ passkeysWithItems.forEach { (passkey, item) ->if (!passkey.isDeleted) {- passkeyIdentities.add(createPasskeyIdentity(passkey, credential))+ passkeyIdentities.add(createPasskeyIdentity(passkey, item))}}@@ -178,11 +178,11 @@ class CredentialIdentityStore private constructor(context: Context) {}/**- * Create a PasskeyIdentity from a Passkey and its parent Credential.+ * Create a PasskeyIdentity from a Passkey and its parent Item.*/- private fun createPasskeyIdentity(passkey: Passkey, credential: Credential): PasskeyIdentity {- // Get userName - prefer passkey's userName, fallback to credential's username or email- val userName = passkey.userName ?: credential.username ?: credential.alias?.email+ private fun createPasskeyIdentity(passkey: Passkey, item: Item): PasskeyIdentity {+ // Get userName - prefer passkey's userName, fallback to item's username or email fields+ val userName = passkey.userName ?: item.username ?: item.email// Convert passkey ID to credential ID (base64url-encoded bytes)val credentialIdBytes = PasskeyHelper.guidToBytes(passkey.id.toString())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 d45fc0b1c..bf4f589b2 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@@ -271,7 +271,7 @@ class PasskeyFormFragment : Fragment() {val now = Date()val passkey = Passkey(id = passkeyId,- parentCredentialId = UUID.randomUUID(), // Will be set by createCredentialWithPasskey+ parentItemId = UUID.randomUUID(), // Will be set by createItemWithPasskeyrpId = viewModel.rpId,userHandle = viewModel.userId,userName = viewModel.userName,@@ -289,7 +289,7 @@ class PasskeyFormFragment : Fragment() {showLoading(getString(R.string.passkey_saving))}- vaultStore.createCredentialWithPasskey(+ vaultStore.createItemWithPasskey(rpId = viewModel.rpId,userName = viewModel.userName,displayName = displayName,@@ -463,7 +463,7 @@ class PasskeyFormFragment : Fragment() {val now = Date()val newPasskey = Passkey(id = newPasskeyId,- parentCredentialId = passkeyToReplace.passkey.parentCredentialId,+ parentItemId = passkeyToReplace.passkey.parentItemId,rpId = viewModel.rpId,userHandle = viewModel.userId,userName = viewModel.userName,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 30988da15..18faa9501 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,14 +1,11 @@package net.aliasvault.app.vaultstore-import android.content.ContentValues-import android.database.Cursorimport android.util.Logimport net.aliasvault.app.utils.DateHelpers-import net.aliasvault.app.vaultstore.models.Alias-import net.aliasvault.app.vaultstore.models.Credential+import net.aliasvault.app.vaultstore.models.FieldKey+import net.aliasvault.app.vaultstore.models.Itemimport net.aliasvault.app.vaultstore.models.Passkey-import net.aliasvault.app.vaultstore.models.Service-import net.aliasvault.app.vaultstore.passkey.PasskeyHelper+import net.aliasvault.app.vaultstore.repositories.PasskeyRepositoryimport java.util.Calendarimport java.util.Dateimport java.util.TimeZone@@ -17,15 +14,13 @@ import java.util.UUID/*** Handles passkey operations for the vault.* This class uses composition to organize passkey-specific functionality.- *- * This is a Kotlin port of the iOS Swift implementation:- * - Reference: apps/mobile-app/ios/VaultStoreKit/VaultStore+Passkey.swift- *+ * ** 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,) {companion object {private const val TAG = "VaultPasskey"@@ -44,98 +39,33 @@ class VaultPasskey(}.time}+ private val passkeyRepository = PasskeyRepository(database)+// region Passkey Queries/**- * Get a passkey by its credential ID (the WebAuthn credential ID, not the parent Credential UUID).+ * Get a passkey by its credential ID (the WebAuthn credential ID, not the parent Item UUID).*/fun getPasskeyByCredentialId(credentialId: ByteArray): Passkey? {- val db = database.dbConnection ?: return null-- // Convert credentialId bytes to UUID string for lookup- val credentialIdString = try {- PasskeyHelper.bytesToGuid(credentialId)- } catch (e: Exception) {- Log.e(TAG, "Failed to convert credentialId bytes to UUID string", e)- return null- }-- val query = """- SELECT Id, CredentialId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,- DisplayName, CreatedAt, UpdatedAt, IsDeleted- FROM Passkeys- WHERE Id = ? AND IsDeleted = 0- LIMIT 1- """.trimIndent()-- val cursor = db.query(query, arrayOf(credentialIdString.uppercase()))- cursor.use {- if (it.moveToFirst()) {- return parsePasskeyRow(it)- }- }-- return null+ return passkeyRepository.getByCredentialId(credentialId)}/**- * Get all passkeys for a credential.+ * Get all passkeys for an item.*/- fun getPasskeysForCredential(credentialId: UUID): List<Passkey> {- val db = database.dbConnection ?: return emptyList()-- val query = """- SELECT Id, CredentialId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,- DisplayName, CreatedAt, UpdatedAt, IsDeleted- FROM Passkeys- WHERE CredentialId = ? AND IsDeleted = 0- ORDER BY CreatedAt DESC- """.trimIndent()-- val passkeys = mutableListOf<Passkey>()- val cursor = db.query(query, arrayOf(credentialId.toString().uppercase()))-- cursor.use {- while (it.moveToNext()) {- parsePasskeyRow(it)?.let { passkey ->- passkeys.add(passkey)- }- }- }-- return passkeys+ fun getPasskeysForItem(itemId: UUID): List<Passkey> {+ return passkeyRepository.getForItem(itemId)}/*** Get all passkeys for a specific relying party identifier (RP ID).*/fun getPasskeysForRpId(rpId: String): List<Passkey> {- val db = database.dbConnection ?: return emptyList()-- val query = """- SELECT Id, CredentialId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,- DisplayName, CreatedAt, UpdatedAt, IsDeleted- FROM Passkeys- WHERE RpId = ? AND IsDeleted = 0- ORDER BY CreatedAt DESC- """.trimIndent()-- val passkeys = mutableListOf<Passkey>()- val cursor = db.query(query, arrayOf(rpId))-- cursor.use {- while (it.moveToNext()) {- parsePasskeyRow(it)?.let { passkey ->- passkeys.add(passkey)- }- }- }-- return passkeys+ return passkeyRepository.getForRpId(rpId)}/**- * Get passkeys with credential info for a specific rpId and optionally username.+ * Get passkeys with item info for a specific rpId and optionally username.* Used for finding existing passkeys that might be replaced during registration.*/fun getPasskeysWithCredentialInfo(@@ -145,29 +75,33 @@ class VaultPasskey(): List<PasskeyWithCredentialInfo> {val db = database.dbConnection ?: return emptyList()+ // Query passkeys with associated item data using the new schemaval query = """- SELECT p.Id, p.CredentialId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,+ SELECT p.Id, p.ItemId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,p.DisplayName, p.CreatedAt, p.UpdatedAt, p.IsDeleted,- c.Username, s.Name+ i.Name,+ fv_username.Value as UsernameFROM Passkeys p- JOIN Credentials c ON p.CredentialId = c.Id- JOIN Services s ON c.ServiceId = s.Id- WHERE p.RpId = ? AND p.IsDeleted = 0 AND c.IsDeleted = 0+ 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 NULLORDER BY p.CreatedAt DESC""".trimIndent()val results = mutableListOf<PasskeyWithCredentialInfo>()- val cursor = db.query(query, arrayOf(rpId))+ val cursor = db.query(query, arrayOf(FieldKey.LOGIN_USERNAME, rpId))cursor.use {while (it.moveToNext()) {val passkey = parsePasskeyRow(it) ?: continue- val credUsername = if (!it.isNull(11)) it.getString(11) else null- val serviceName = if (!it.isNull(12)) it.getString(12) else null+ 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 providedvar matches = true- if (userName != null && credUsername != userName) {+ if (userName != null && itemUsername != userName) {matches = false}if (userId != null && passkey.userHandle != null && !userId.contentEquals(passkey.userHandle)) {@@ -178,8 +112,8 @@ class VaultPasskey(results.add(PasskeyWithCredentialInfo(passkey = passkey,- serviceName = serviceName,- username = credUsername,+ serviceName = itemName,+ username = itemUsername,),)}@@ -190,27 +124,34 @@ class VaultPasskey(}/**- * Get all passkeys with their associated credentials in a single query.- * This is much more efficient than calling getPasskeysForCredential() for each credential.- * Uses a JOIN to get passkeys and their credentials in one database query.+ * Get all passkeys with their associated items in a single query.+ * This is much more efficient than calling getPasskeysForItem() for each item.+ * Uses a JOIN to get passkeys and their items in one database query.*/- fun getAllPasskeysWithCredentials(): List<PasskeyWithCredential> {+ fun getAllPasskeysWithItems(): List<PasskeyWithItem> {val db = database.dbConnection ?: return emptyList()val query = """SELECT- p.Id, p.CredentialId, p.RpId, p.UserHandle, p.PublicKey, p.PrivateKey, p.PrfKey,+ 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,- c.Id as CredId, c.Username, s.Name as ServiceName, c.CreatedAt as CredCreatedAt, c.UpdatedAt as CredUpdatedAt+ i.Id as ItemId, i.Name, i.CreatedAt as ItemCreatedAt, i.UpdatedAt as ItemUpdatedAt,+ fv_username.Value as Username,+ fv_email.Value as EmailFROM Passkeys p- INNER JOIN Credentials c ON p.CredentialId = c.Id- INNER JOIN Services s ON c.ServiceId = s.Id- WHERE p.IsDeleted = 0 AND c.IsDeleted = 0+ 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 NULLORDER BY p.CreatedAt DESC""".trimIndent()- val results = mutableListOf<PasskeyWithCredential>()- val cursor = db.query(query)+ val results = mutableListOf<PasskeyWithItem>()+ val cursor = db.query(query, arrayOf(FieldKey.LOGIN_USERNAME, FieldKey.LOGIN_EMAIL))cursor.use {while (it.moveToNext()) {@@ -218,35 +159,34 @@ class VaultPasskey(// Parse passkey (columns 0-10)val passkey = parsePasskeyRowFromJoin(it) ?: continue- // Parse credential info (columns 11-15)- val credentialId = UUID.fromString(it.getString(11))- val username = if (!it.isNull(12)) it.getString(12) else null- val serviceName = if (!it.isNull(13)) it.getString(13) else null-- // Create a minimal Credential object with the data we have- val credential = Credential(- id = credentialId,- username = username,- service = Service(- id = UUID.randomUUID(),- name = serviceName,- url = null,- logo = null,- createdAt = Date(),- updatedAt = Date(),- isDeleted = false,- ),- alias = null,- notes = null,- password = null,- createdAt = DateHelpers.parseDateString(it.getString(14)) ?: MIN_DATE,- updatedAt = DateHelpers.parseDateString(it.getString(15)) ?: MIN_DATE,- isDeleted = false,+ // 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+ val username = if (!it.isNull(15)) it.getString(15) else null+ 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(PasskeyWithCredential(passkey, credential))+ results.add(PasskeyWithItem(passkey, item))} catch (e: Exception) {- Log.e(TAG, "Error parsing passkey with credential row", e)+ Log.e(TAG, "Error parsing passkey with item row", e)}}}@@ -258,24 +198,7 @@ class VaultPasskey(* Get a passkey by its ID.*/fun getPasskeyById(passkeyId: UUID): Passkey? {- val db = database.dbConnection ?: return null-- val query = """- SELECT Id, CredentialId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,- DisplayName, CreatedAt, UpdatedAt, IsDeleted- FROM Passkeys- WHERE Id = ? AND IsDeleted = 0- LIMIT 1- """.trimIndent()-- val cursor = db.query(query, arrayOf(passkeyId.toString().uppercase()))- cursor.use {- if (it.moveToFirst()) {- return parsePasskeyRow(it)- }- }-- return null+ return passkeyRepository.getById(passkeyId)}// endregion@@ -283,173 +206,23 @@ class VaultPasskey(// region Passkey Storage/**- * Insert a new passkey into the database.- */- fun insertPasskey(passkey: Passkey) {- val db = database.dbConnection ?: error("Vault not unlocked")-- val insert = """- INSERT INTO Passkeys (Id, CredentialId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,- DisplayName, CreatedAt, UpdatedAt, IsDeleted)- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)- """.trimIndent()-- val publicKeyString = String(passkey.publicKey, Charsets.UTF_8)- val privateKeyString = String(passkey.privateKey, Charsets.UTF_8)-- val statement = db.compileStatement(insert)- statement.use {- it.bindString(1, passkey.id.toString().uppercase())- it.bindString(2, passkey.parentCredentialId.toString().uppercase())- it.bindString(3, passkey.rpId)- if (passkey.userHandle != null) {- it.bindBlob(4, passkey.userHandle)- } else {- it.bindNull(4)- }- it.bindString(5, publicKeyString)- it.bindString(6, privateKeyString)- if (passkey.prfKey != null) {- it.bindBlob(7, passkey.prfKey)- } else {- it.bindNull(7)- }- it.bindString(8, passkey.displayName)- it.bindString(9, DateHelpers.toStandardFormat(passkey.createdAt))- it.bindString(10, DateHelpers.toStandardFormat(passkey.updatedAt))- it.bindLong(11, if (passkey.isDeleted) 1 else 0)- it.executeInsert()- }- }-- /**- * Create a new credential with an associated passkey.+ * Create a new item with an associated passkey.*/- fun createCredentialWithPasskey(+ fun createItemWithPasskey(rpId: String,userName: String?,displayName: String,passkey: Passkey,logo: ByteArray? = null,- ): Credential {- val db = database.dbConnection ?: error("Vault not unlocked")-- db.beginTransaction()- try {- val credentialId = passkey.parentCredentialId- val now = Date()- val timestamp = DateHelpers.toStandardFormat(now)-- // Create a minimal service for the RP- val serviceId = UUID.randomUUID()-- val serviceValues = ContentValues().apply {- put("Id", serviceId.toString().uppercase())- put("Name", displayName)- put("Url", "https://$rpId")- if (logo != null) {- put("Logo", logo)- } else {- putNull("Logo")- }- put("CreatedAt", timestamp)- put("UpdatedAt", timestamp)- put("IsDeleted", 0)- }- db.insert("Services", null, serviceValues)-- // Create a minimal alias with empty fields and default birthdate- // TODO: when birthdate field is made optional, this can be removed- val aliasId = UUID.randomUUID()- val aliasInsert = """- INSERT INTO Aliases (Id, FirstName, LastName, NickName, BirthDate, Gender, Email,- CreatedAt, UpdatedAt, IsDeleted)- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)- """.trimIndent()-- val aliasStatement = db.compileStatement(aliasInsert)- aliasStatement.use {- it.bindString(1, aliasId.toString().uppercase())- it.bindString(2, "")- it.bindString(3, "")- it.bindString(4, "")- it.bindString(5, DateHelpers.toStandardFormat(MIN_DATE))- it.bindString(6, "")- it.bindString(7, "")- it.bindString(8, timestamp)- it.bindString(9, timestamp)- it.bindLong(10, 0)- it.executeInsert()- }-- // Create the credential with the alias- val credentialInsert = """- INSERT INTO Credentials (Id, ServiceId, AliasId, Username, Notes, CreatedAt, UpdatedAt, IsDeleted)- VALUES (?, ?, ?, ?, ?, ?, ?, ?)- """.trimIndent()-- val credentialStatement = db.compileStatement(credentialInsert)- credentialStatement.use {- it.bindString(1, credentialId.toString().uppercase())- it.bindString(2, serviceId.toString().uppercase())- it.bindString(3, aliasId.toString().uppercase())- if (userName != null) {- it.bindString(4, userName)- } else {- it.bindNull(4)- }- it.bindNull(5) // Notes- it.bindString(6, timestamp)- it.bindString(7, timestamp)- it.bindLong(8, 0)- it.executeInsert()- }-- // Insert the passkey- insertPasskey(passkey)-- // Commit transaction- database.commitTransaction()-- // Return the credential- val service = Service(- id = serviceId,- name = displayName,- url = "https://$rpId",- logo = logo,- createdAt = now,- updatedAt = now,- isDeleted = false,- )-- val alias = Alias(- id = aliasId,- gender = "",- firstName = "",- lastName = "",- nickName = "",- birthDate = MIN_DATE,- email = "",- createdAt = now,- updatedAt = now,- isDeleted = false,- )+ ): Item {+ return passkeyRepository.createItemWithPasskey(rpId, userName, displayName, passkey, logo)+ }- return Credential(- id = credentialId,- alias = alias,- service = service,- username = userName,- notes = null,- password = null,- createdAt = now,- updatedAt = now,- isDeleted = false,- )- } catch (e: Exception) {- db.endTransaction()- throw e- }+ /**+ * Insert a new passkey into the database.+ */+ fun insertPasskey(passkey: Passkey) {+ passkeyRepository.insert(passkey)}/**@@ -461,70 +234,7 @@ class VaultPasskey(displayName: String,logo: ByteArray? = null,) {- val db = database.dbConnection ?: error("Vault not unlocked")-- val now = Date()- val timestamp = DateHelpers.toStandardFormat(now)-- // Get the old passkey to find its credential- val oldPasskey = getPasskeyById(oldPasskeyId)- ?: throw VaultPasskeyError.PasskeyNotFound("Passkey not found: $oldPasskeyId")-- val credentialId = oldPasskey.parentCredentialId-- // Update the credential's service with new logo if provided- if (logo != null) {- val credQuery = """- SELECT ServiceId FROM Credentials WHERE Id = ? LIMIT 1- """.trimIndent()-- val cursor = db.query(credQuery, arrayOf(credentialId.toString().uppercase()))- cursor.use {- if (it.moveToFirst()) {- val serviceId = it.getString(0)-- val serviceUpdate = """- UPDATE Services- SET Logo = ?, Name = ?, UpdatedAt = ?- WHERE Id = ?- """.trimIndent()-- val updateStatement = db.compileStatement(serviceUpdate)- updateStatement.use { stmt ->- stmt.bindBlob(1, logo)- stmt.bindString(2, displayName)- stmt.bindString(3, timestamp)- stmt.bindString(4, serviceId)- stmt.executeUpdateDelete()- }- }- }- }-- // Delete the old passkey- val deleteQuery = """- UPDATE Passkeys- SET IsDeleted = 1, UpdatedAt = ?- WHERE Id = ?- """.trimIndent()-- val deleteStatement = db.compileStatement(deleteQuery)- deleteStatement.use {- it.bindString(1, timestamp)- it.bindString(2, oldPasskeyId.toString().uppercase())- it.executeUpdateDelete()- }-- // Create the new passkey with the same credential ID- val updatedPasskey = newPasskey.copy(- parentCredentialId = credentialId,- displayName = displayName,- createdAt = now,- updatedAt = now,- isDeleted = false,- )-- insertPasskey(updatedPasskey)+ passkeyRepository.replace(oldPasskeyId, newPasskey, displayName, logo)}// endregion@@ -534,10 +244,10 @@ class VaultPasskey(/*** Parse a passkey row from database query.*/- private fun parsePasskeyRow(cursor: Cursor): Passkey? {+ private fun parsePasskeyRow(cursor: android.database.Cursor): Passkey? {try {val idString = cursor.getString(0)- val parentCredentialIdString = cursor.getString(1)+ val itemIdString = cursor.getString(1)val rpId = cursor.getString(2)val userHandle = if (!cursor.isNull(3)) cursor.getBlob(3) else nullval publicKeyString = cursor.getString(4)@@ -549,7 +259,7 @@ class VaultPasskey(val isDeleted = cursor.getInt(10) == 1val id = UUID.fromString(idString)- val parentCredentialId = UUID.fromString(parentCredentialIdString)+ val itemId = UUID.fromString(itemIdString)val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATEval updatedAt = DateHelpers.parseDateString(updatedAtString) ?: MIN_DATE@@ -559,7 +269,7 @@ class VaultPasskey(return Passkey(id = id,- parentCredentialId = parentCredentialId,+ parentItemId = itemId, // Note: field name still parentItemId but refers to ItemIdrpId = rpId,userHandle = userHandle,userName = null,@@ -580,10 +290,10 @@ class VaultPasskey(/*** Parse a passkey row from a JOIN query.*/- private fun parsePasskeyRowFromJoin(cursor: Cursor): Passkey? {+ private fun parsePasskeyRowFromJoin(cursor: android.database.Cursor): Passkey? {try {val idString = cursor.getString(0)- val parentCredentialIdString = cursor.getString(1)+ val itemIdString = cursor.getString(1)val rpId = cursor.getString(2)val userHandle = if (!cursor.isNull(3)) cursor.getBlob(3) else nullval publicKeyString = cursor.getString(4)@@ -595,7 +305,7 @@ class VaultPasskey(val isDeleted = cursor.getInt(10) == 1val id = UUID.fromString(idString)- val parentCredentialId = UUID.fromString(parentCredentialIdString)+ val itemId = UUID.fromString(itemIdString)val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATEval updatedAt = DateHelpers.parseDateString(updatedAtString) ?: MIN_DATE@@ -605,7 +315,7 @@ class VaultPasskey(return Passkey(id = id,- parentCredentialId = parentCredentialId,+ parentItemId = itemId, // Note: field name still parentItemId but refers to ItemIdrpId = rpId,userHandle = userHandle,userName = null,@@ -627,25 +337,25 @@ class VaultPasskey(}/**- * Data class to hold passkey with credential info.+ * Data class to hold passkey with item info.*/data class PasskeyWithCredentialInfo(/** The passkey. */val passkey: Passkey,- /** The service name from the credential. */+ /** The service name from the item. */val serviceName: String?,- /** The username from the credential. */+ /** The username from the item. */val username: String?,)/**- * Data class to hold passkey with its associated credential.+ * Data class to hold passkey with its associated item.*/-data class PasskeyWithCredential(+data class PasskeyWithItem(/** The passkey. */val passkey: Passkey,- /** The credential this passkey belongs to. */- val credential: Credential,+ /** The item this passkey belongs to. */+ val item: Item,)/**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 dbb81b8bd..85161adfe 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@@ -74,7 +74,7 @@ class VaultStore(private val sync = VaultSync(databaseComponent, metadata, crypto)private val mutate = VaultMutate(databaseComponent, query, metadata)private val cache = VaultCache(crypto, databaseComponent, keystoreProvider, storageProvider)- private val passkey = VaultPasskey(databaseComponent)+ private val passkey = VaultPasskey(databaseComponent, query)private val pin by lazy {val androidProvider = storageProvider as net.aliasvault.app.vaultstore.storageprovider.AndroidStorageProvider// Use reflection to access private context field@@ -589,14 +589,14 @@ class VaultStore(}/**- * Get all passkeys for a credential.+ * Get all passkeys for an item.*/@Suppress("UnusedParameter")- fun getPasskeysForCredential(- credentialId: java.util.UUID,+ fun getPasskeysForItem(+ itemId: java.util.UUID,db: io.requery.android.database.sqlite.SQLiteDatabase,): List<net.aliasvault.app.vaultstore.models.Passkey> {- return passkey.getPasskeysForCredential(credentialId)+ return passkey.getPasskeysForItem(itemId)}/**@@ -620,10 +620,10 @@ class VaultStore(}/**- * Get all passkeys with their associated credentials in a single query.+ * Get all passkeys with their associated items in a single query.*/- fun getAllPasskeysWithCredentials(): List<PasskeyWithCredential> {- return passkey.getAllPasskeysWithCredentials()+ fun getAllPasskeysWithItems(): List<PasskeyWithItem> {+ return passkey.getAllPasskeysWithItems()}/**@@ -646,16 +646,16 @@ class VaultStore(}/**- * Create a credential with a passkey.+ * Create an item with a passkey.*/- fun createCredentialWithPasskey(+ fun createItemWithPasskey(rpId: String,userName: String?,displayName: String,passkeyObj: net.aliasvault.app.vaultstore.models.Passkey,logo: ByteArray? = null,- ): net.aliasvault.app.vaultstore.models.Credential {- return passkey.createCredentialWithPasskey(rpId, userName, displayName, passkeyObj, logo)+ ): net.aliasvault.app.vaultstore.models.Item {+ return passkey.createItemWithPasskey(rpId, userName, displayName, passkeyObj, logo)}/**diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/models/Passkey.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/models/Passkey.ktindex b9d4383a6..6021e2729 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/models/Passkey.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/models/Passkey.kt@@ -5,7 +5,7 @@ import java.util.UUID/*** Passkey model representing a WebAuthn credential.- * Linked to a parent Credential for UI display (service name, logo, etc.).+ * Linked to a parent Item for UI display (service name, logo, etc.).** This is a Kotlin port of the iOS Swift implementation:* - Reference: apps/mobile-app/ios/VaultModels/Passkey.swift@@ -17,9 +17,9 @@ data class Passkey(val id: UUID,/**- * Parent Credential UUID (AliasVault internal ID).+ * Parent Item UUID (AliasVault internal ID).*/- val parentCredentialId: UUID,+ val parentItemId: UUID,/*** Relying party identifier (domain).@@ -78,7 +78,7 @@ data class Passkey(other as Passkeyif (id != other.id) return false- if (parentCredentialId != other.parentCredentialId) return false+ if (parentItemId != other.parentItemId) return falseif (rpId != other.rpId) return falseif (userHandle != null) {if (other.userHandle == null) return false@@ -101,7 +101,7 @@ data class Passkey(override fun hashCode(): Int {var result = id.hashCode()- result = 31 * result + parentCredentialId.hashCode()+ result = 31 * result + parentItemId.hashCode()result = 31 * result + rpId.hashCode()result = 31 * result + (userHandle?.contentHashCode() ?: 0)result = 31 * result + (userName?.hashCode() ?: 0)diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/BaseRepository.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/BaseRepository.ktnew file mode 100644index 000000000..1f76bb235--- /dev/null+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/BaseRepository.kt@@ -0,0 +1,207 @@+package net.aliasvault.app.vaultstore.repositories++import net.aliasvault.app.utils.DateHelpers+import net.aliasvault.app.vaultstore.VaultDatabase+import java.util.UUID++/**+ * Base repository class with common database operations.+ * Provides transaction handling, soft delete, and other shared functionality.+ */+open class BaseRepository(+ /** The database component used for executing queries. */+ protected val database: VaultDatabase,+) {+ // MARK: - Transaction Helpers++ /**+ * Execute a function within a transaction.+ * Automatically handles begin, commit, and rollback.+ * @param operation The function to execute within the transaction+ * @return The result of the function+ */+ fun <T> withTransaction(operation: () -> T): T {+ database.beginTransaction()+ return try {+ val result = operation()+ database.commitTransaction()+ result+ } catch (e: Exception) {+ database.rollbackTransaction()+ throw e+ }+ }++ // MARK: - Soft Delete Helpers++ /**+ * Soft delete a record by setting IsDeleted = 1.+ * @param table The table name+ * @param id The record ID+ * @return Number of rows affected+ */+ fun softDelete(table: String, id: String): Int {+ val timestamp = now()+ return executeUpdate(+ "UPDATE $table SET IsDeleted = 1, UpdatedAt = ? WHERE Id = ?",+ arrayOf(timestamp, id),+ )+ }++ /**+ * Soft delete records by a foreign key.+ * @param table The table name+ * @param foreignKey The foreign key column name+ * @param foreignKeyValue The foreign key value+ * @return Number of rows affected+ */+ fun softDeleteByForeignKey(table: String, foreignKey: String, foreignKeyValue: String): Int {+ val timestamp = now()+ return executeUpdate(+ "UPDATE $table SET IsDeleted = 1, UpdatedAt = ? WHERE $foreignKey = ?",+ arrayOf(timestamp, foreignKeyValue),+ )+ }++ // MARK: - Hard Delete Helpers++ /**+ * Hard delete a record permanently.+ * @param table The table name+ * @param id The record ID+ * @return Number of rows affected+ */+ fun hardDelete(table: String, id: String): Int {+ return executeUpdate(+ "DELETE FROM $table WHERE Id = ?",+ arrayOf(id),+ )+ }++ /**+ * Hard delete records by a foreign key.+ * @param table The table name+ * @param foreignKey The foreign key column name+ * @param foreignKeyValue The foreign key value+ * @return Number of rows affected+ */+ fun hardDeleteByForeignKey(table: String, foreignKey: String, foreignKeyValue: String): Int {+ return executeUpdate(+ "DELETE FROM $table WHERE $foreignKey = ?",+ arrayOf(foreignKeyValue),+ )+ }++ // MARK: - Utility Methods++ /**+ * Check if a table exists in the database.+ * @param tableName The name of the table to check+ * @return True if the table exists+ */+ fun tableExists(tableName: String): Boolean {+ val results = executeQuery(+ "SELECT name FROM sqlite_master WHERE type='table' AND name=?",+ arrayOf(tableName),+ )+ return results.isNotEmpty()+ }++ /**+ * Generate a new UUID in uppercase format.+ * @return A new UUID string+ */+ fun generateId(): String {+ return UUID.randomUUID().toString().uppercase()+ }++ /**+ * Get the current timestamp in the standard format.+ * @return Current timestamp string+ */+ fun now(): String {+ return DateHelpers.now()+ }++ /**+ * Build a parameterized IN clause for SQL queries.+ * @param values Array of values for the IN clause+ * @return Pair with placeholders string and values array+ */+ fun buildInClause(values: List<String>): Pair<String, Array<String>> {+ val placeholders = values.joinToString(",") { "?" }+ return Pair(placeholders, values.toTypedArray())+ }++ // MARK: - Database Operation Helpers++ /**+ * Execute a SELECT query on the database.+ */+ protected fun executeQuery(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+ }++ /**+ * Execute an UPDATE, INSERT, or DELETE query on the database.+ */+ protected fun executeUpdate(query: String, params: Array<Any?>): Int {+ val db = database.dbConnection ?: error("Database not initialized")++ val statement = db.compileStatement(query)+ try {+ // Bind parameters+ params.forEachIndexed { index, param ->+ when (param) {+ null -> statement.bindNull(index + 1)+ is ByteArray -> statement.bindBlob(index + 1, param)+ is Long -> statement.bindLong(index + 1, param)+ is Double -> statement.bindDouble(index + 1, param)+ else -> statement.bindString(index + 1, param.toString())+ }+ }+ statement.execute()+ } finally {+ statement.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+ }+}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.ktnew file mode 100644index 000000000..306855ced--- /dev/null+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/ItemRepository.kt@@ -0,0 +1,186 @@+package net.aliasvault.app.vaultstore.repositories++import net.aliasvault.app.vaultstore.VaultDatabase+import net.aliasvault.app.vaultstore.models.FieldKey+import net.aliasvault.app.vaultstore.models.Item+import java.util.Calendar+import java.util.Date+import java.util.TimeZone++/**+ * Repository for Item CRUD operations.+ * Handles fetching, creating, updating, and deleting items with their related data.+ */+class ItemRepository(database: VaultDatabase) : BaseRepository(database) {+ companion object {+ private const val TAG = "ItemRepository"++ 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+ }++ // MARK: - Read Operations++ /**+ * Fetch all active items (not deleted, not in trash) with their fields.+ * @return List of Item objects+ */+ 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")+ }++ /**+ * Fetch a single item by ID with its fields.+ * @param itemId The ID of the item to fetch+ * @return Item object or null if not found+ */+ fun getById(itemId: String): Item? {+ error("Use VaultQuery.getItemById() directly - repository pattern under construction")+ }++ /**+ * Fetch all unique email addresses from field values.+ * @return List of email addresses+ */+ fun getAllEmailAddresses(): List<String> {+ val results = executeQuery(+ """+ SELECT DISTINCT fv.Value as Email+ FROM FieldValues fv+ INNER JOIN Items i ON fv.ItemId = i.Id+ WHERE fv.FieldKey = ?+ AND fv.IsDeleted = 0+ AND i.IsDeleted = 0+ AND i.DeletedAt IS NULL+ """.trimIndent(),+ arrayOf(FieldKey.LOGIN_EMAIL),+ )+ return results.mapNotNull { it["Email"] as? String }+ }++ /**+ * Get recently deleted items (in trash).+ * @return List of items+ */+ fun getRecentlyDeleted(): List<Item> {+ error("Use VaultQuery.getRecentlyDeletedItems() directly - repository pattern under construction")+ }++ /**+ * Get count of items in trash.+ * @return Number of items in trash+ */+ fun getRecentlyDeletedCount(): Int {+ val results = executeQuery(+ """+ SELECT COUNT(*) as count+ FROM Items+ WHERE IsDeleted = 0 AND DeletedAt IS NOT NULL+ """.trimIndent(),+ emptyArray(),+ )+ return (results.firstOrNull()?.get("count") as? Long)?.toInt() ?: 0+ }++ // MARK: - Write Operations++ /**+ * Move an item to trash (set DeletedAt timestamp).+ * @param itemId The ID of the item to trash+ * @return Number of rows affected+ */+ fun trash(itemId: String): Int {+ return withTransaction {+ val now = now()+ executeUpdate(+ "UPDATE Items SET DeletedAt = ?, UpdatedAt = ? WHERE Id = ?",+ arrayOf(now, now, itemId),+ )+ }+ }++ /**+ * Restore an item from trash (clear DeletedAt).+ * @param itemId The ID of the item to restore+ * @return Number of rows affected+ */+ fun restore(itemId: String): Int {+ return withTransaction {+ val now = now()+ executeUpdate(+ "UPDATE Items SET DeletedAt = NULL, UpdatedAt = ? WHERE Id = ?",+ arrayOf(now, itemId),+ )+ }+ }++ /**+ * Permanently delete an item (tombstone).+ * Converts item to tombstone and soft deletes all related data.+ * @param itemId The ID of the item to permanently delete+ * @return Number of rows affected+ */+ fun permanentlyDelete(itemId: String): Int {+ return withTransaction {+ val now = now()++ // Soft delete related FieldValues+ softDeleteByForeignKey("FieldValues", "ItemId", itemId)++ // Soft delete related data+ softDeleteByForeignKey("TotpCodes", "ItemId", itemId)+ softDeleteByForeignKey("Attachments", "ItemId", itemId)+ softDeleteByForeignKey("Passkeys", "ItemId", itemId)++ if (tableExists("ItemTags")) {+ softDeleteByForeignKey("ItemTags", "ItemId", itemId)+ }+ if (tableExists("FieldHistories")) {+ softDeleteByForeignKey("FieldHistories", "ItemId", itemId)+ }++ // Convert item to tombstone+ executeUpdate(+ """+ UPDATE Items+ SET Name = NULL,+ ItemType = NULL,+ LogoId = NULL,+ FolderId = NULL,+ DeletedAt = NULL,+ IsDeleted = 1,+ UpdatedAt = ?+ WHERE Id = ?+ """.trimIndent(),+ arrayOf(now, itemId),+ )+ }+ }++ /**+ * Create a new item with its fields.+ * @param item The item to create+ * @return The ID of the created item+ */+ fun create(item: Item): String {+ error("Create operations should use VaultMutate - repository pattern under construction")+ }++ /**+ * Update an existing item with its fields.+ * @param item The item to update+ * @return Number of rows affected+ */+ fun update(item: Item): Int {+ error("Update operations should use VaultMutate - repository pattern under construction")+ }+}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.ktnew file mode 100644index 000000000..2f8752245--- /dev/null+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/repositories/PasskeyRepository.kt@@ -0,0 +1,371 @@+package net.aliasvault.app.vaultstore.repositories++import android.util.Log+import net.aliasvault.app.utils.DateHelpers+import net.aliasvault.app.vaultstore.VaultDatabase+import net.aliasvault.app.vaultstore.models.FieldKey+import net.aliasvault.app.vaultstore.models.Item+import net.aliasvault.app.vaultstore.models.Passkey+import net.aliasvault.app.vaultstore.passkey.PasskeyHelper+import java.util.Calendar+import java.util.Date+import java.util.TimeZone+import java.util.UUID++/**+ * Repository for Passkey operations on Items.+ * Handles fetching, creating, updating, and deleting passkeys with their parent items.+ */+class PasskeyRepository(database: VaultDatabase) : BaseRepository(database) {+ companion object {+ private const val TAG = "PasskeyRepository"++ 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+ }++ // MARK: - Read Operations++ /**+ * Get a passkey by its credential ID (the WebAuthn credential ID, not the parent Item UUID).+ * @param credentialId The WebAuthn credential ID bytes+ * @return Passkey object or null if not found+ */+ fun getByCredentialId(credentialId: ByteArray): Passkey? {+ val credentialIdString = try {+ PasskeyHelper.bytesToGuid(credentialId)+ } catch (e: Exception) {+ Log.e(TAG, "Failed to convert credentialId bytes to UUID string", e)+ return null+ }++ val results = executeQuery(+ """+ SELECT Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,+ DisplayName, CreatedAt, UpdatedAt, IsDeleted+ FROM Passkeys+ WHERE Id = ? AND IsDeleted = 0+ LIMIT 1+ """.trimIndent(),+ arrayOf(credentialIdString.uppercase()),+ )++ return results.firstOrNull()?.let { parsePasskeyRow(it) }+ }++ /**+ * Get all passkeys for an item.+ * @param itemId The UUID of the parent item+ * @return List of Passkey objects+ */+ fun getForItem(itemId: UUID): List<Passkey> {+ val results = executeQuery(+ """+ SELECT Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,+ DisplayName, CreatedAt, UpdatedAt, IsDeleted+ FROM Passkeys+ WHERE ItemId = ? AND IsDeleted = 0+ ORDER BY CreatedAt DESC+ """.trimIndent(),+ arrayOf(itemId.toString().uppercase()),+ )++ return results.mapNotNull { parsePasskeyRow(it) }+ }++ /**+ * Get all passkeys for a specific relying party identifier (RP ID).+ * @param rpId The relying party identifier+ * @return List of Passkey objects+ */+ fun getForRpId(rpId: String): List<Passkey> {+ val results = executeQuery(+ """+ SELECT Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,+ DisplayName, CreatedAt, UpdatedAt, IsDeleted+ FROM Passkeys+ WHERE RpId = ? AND IsDeleted = 0+ ORDER BY CreatedAt DESC+ """.trimIndent(),+ arrayOf(rpId),+ )++ return results.mapNotNull { parsePasskeyRow(it) }+ }++ /**+ * Get a passkey by its ID.+ * @param passkeyId The UUID of the passkey+ * @return Passkey object or null if not found+ */+ fun getById(passkeyId: UUID): Passkey? {+ val results = executeQuery(+ """+ SELECT Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,+ DisplayName, CreatedAt, UpdatedAt, IsDeleted+ FROM Passkeys+ WHERE Id = ? AND IsDeleted = 0+ LIMIT 1+ """.trimIndent(),+ arrayOf(passkeyId.toString().uppercase()),+ )++ return results.firstOrNull()?.let { parsePasskeyRow(it) }+ }++ // MARK: - Write Operations++ /**+ * Insert a new passkey into the database.+ * @param passkey The passkey to insert+ */+ fun insert(passkey: Passkey) {+ val db = database.dbConnection ?: error("Vault not unlocked")++ val publicKeyString = String(passkey.publicKey, Charsets.UTF_8)+ val privateKeyString = String(passkey.privateKey, Charsets.UTF_8)++ val statement = db.compileStatement(+ """+ INSERT INTO Passkeys (Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey,+ DisplayName, CreatedAt, UpdatedAt, IsDeleted)+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ """.trimIndent(),+ )+ statement.use {+ it.bindString(1, passkey.id.toString().uppercase())+ it.bindString(2, passkey.parentItemId.toString().uppercase()) // Note: still called parentItemId but references ItemId+ it.bindString(3, passkey.rpId)+ if (passkey.userHandle != null) {+ it.bindBlob(4, passkey.userHandle)+ } else {+ it.bindNull(4)+ }+ it.bindString(5, publicKeyString)+ it.bindString(6, privateKeyString)+ if (passkey.prfKey != null) {+ it.bindBlob(7, passkey.prfKey)+ } else {+ it.bindNull(7)+ }+ it.bindString(8, passkey.displayName)+ it.bindString(9, DateHelpers.toStandardFormat(passkey.createdAt))+ it.bindString(10, DateHelpers.toStandardFormat(passkey.updatedAt))+ it.bindLong(11, if (passkey.isDeleted) 1 else 0)+ it.executeInsert()+ }+ }++ /**+ * Create a new item with an associated passkey.+ * @param rpId The relying party identifier+ * @param userName The username (optional)+ * @param displayName The display name+ * @param passkey The passkey to associate+ * @param logo The logo bytes (optional)+ * @return The created Item+ */+ fun createItemWithPasskey(+ rpId: String,+ userName: String?,+ displayName: String,+ passkey: Passkey,+ logo: ByteArray? = null,+ ): Item {+ return withTransaction {+ val itemId = passkey.parentItemId+ val now = Date()+ val timestamp = DateHelpers.toStandardFormat(now)++ // Create the item+ val logoId = if (logo != null) {+ val logoIdGen = generateId()+ // TODO: Insert logo into Logos table with deduplication+ logoIdGen+ } else {+ null+ }++ executeUpdate(+ """+ INSERT INTO Items (Id, Name, ItemType, LogoId, FolderId, CreatedAt, UpdatedAt, IsDeleted, DeletedAt)+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)+ """.trimIndent(),+ arrayOf(+ itemId.toString().uppercase(),+ displayName,+ "Login", // Passkey items are Login type+ logoId,+ null, // FolderId+ timestamp,+ timestamp,+ 0,+ null,+ ),+ )++ // Insert URL field value+ if (rpId.isNotEmpty()) {+ executeUpdate(+ """+ INSERT INTO FieldValues (Id, ItemId, FieldDefinitionId, FieldKey, Value, Weight, CreatedAt, UpdatedAt, IsDeleted)+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)+ """.trimIndent(),+ arrayOf(+ generateId(),+ itemId.toString().uppercase(),+ null, // FieldDefinitionId for system fields+ FieldKey.LOGIN_URL,+ "https://$rpId",+ 0,+ timestamp,+ timestamp,+ 0,+ ),+ )+ }++ // Insert username field value if provided+ if (userName != null) {+ executeUpdate(+ """+ INSERT INTO FieldValues (Id, ItemId, FieldDefinitionId, FieldKey, Value, Weight, CreatedAt, UpdatedAt, IsDeleted)+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)+ """.trimIndent(),+ arrayOf(+ generateId(),+ itemId.toString().uppercase(),+ null,+ FieldKey.LOGIN_USERNAME,+ userName,+ 100,+ timestamp,+ timestamp,+ 0,+ ),+ )+ }++ // Insert the passkey+ insert(passkey)++ // Return a minimal Item object+ // Full item will be loaded via getAllItems() or getItemById()+ Item(+ id = itemId,+ name = displayName,+ itemType = "Login",+ logo = logo,+ folderId = null,+ folderPath = null,+ fields = emptyList(), // Will be populated when loaded from DB+ hasPasskey = true,+ hasAttachment = false,+ hasTotp = false,+ createdAt = now,+ updatedAt = now,+ )+ }+ }++ /**+ * Replace an existing passkey with a new one.+ * @param oldPasskeyId The UUID of the passkey to replace+ * @param newPasskey The new passkey+ * @param displayName The updated display name+ * @param logo The updated logo bytes (optional)+ */+ fun replace(+ oldPasskeyId: UUID,+ newPasskey: Passkey,+ displayName: String,+ logo: ByteArray? = null,+ ) {+ withTransaction {+ val now = Date()+ val timestamp = DateHelpers.toStandardFormat(now)++ // Get the old passkey to find its item+ val oldPasskey = getById(oldPasskeyId)+ ?: error("Passkey not found: $oldPasskeyId")++ val itemId = oldPasskey.parentItemId++ // Update the item's name+ executeUpdate(+ "UPDATE Items SET Name = ?, UpdatedAt = ? WHERE Id = ?",+ arrayOf(displayName, timestamp, itemId.toString().uppercase()),+ )++ // TODO: Update logo if provided++ // Soft delete the old passkey+ softDelete("Passkeys", oldPasskeyId.toString().uppercase())++ // Create the new passkey with the same item ID+ val updatedPasskey = newPasskey.copy(+ parentItemId = itemId,+ displayName = displayName,+ createdAt = now,+ updatedAt = now,+ isDeleted = false,+ )++ insert(updatedPasskey)+ }+ }++ // MARK: - Helper Methods++ /**+ * Parse a passkey row from database query results.+ */+ private fun parsePasskeyRow(row: Map<String, Any?>): Passkey? {+ return try {+ val idString = row["Id"] as? String ?: return null+ val itemIdString = row["ItemId"] as? String ?: return null+ val rpId = row["RpId"] as? String ?: return null+ val userHandle = row["UserHandle"] as? ByteArray+ val publicKeyString = row["PublicKey"] as? String ?: return null+ val privateKeyString = row["PrivateKey"] as? String ?: return null+ val prfKey = row["PrfKey"] as? ByteArray+ val displayName = row["DisplayName"] as? String ?: return null+ val createdAtString = row["CreatedAt"] as? String ?: return null+ val updatedAtString = row["UpdatedAt"] as? String ?: return null+ val isDeleted = (row["IsDeleted"] as? Long) == 1L++ 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, // Note: field name still parentItemId but now 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)+ null+ }+ }+}