Skip to content

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.kt
index 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.Context
import android.content.SharedPreferences
import android.util.Log
import net.aliasvault.app.utils.Helpers
-import net.aliasvault.app.vaultstore.models.Credential
+import net.aliasvault.app.vaultstore.models.Item
import net.aliasvault.app.vaultstore.models.Passkey
import net.aliasvault.app.vaultstore.passkey.PasskeyHelper
import 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.kt
index 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 createItemWithPasskey
rpId = 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.kt
index 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.Cursor
import android.util.Log
import 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.Item
import 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.PasskeyRepository
import java.util.Calendar
import java.util.Date
import 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 schema
val 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 Username
FROM 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 NULL
ORDER 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 provided
var 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 Email
FROM 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 NULL
ORDER 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 null
val publicKeyString = cursor.getString(4)
@@ -549,7 +259,7 @@ class VaultPasskey(
val isDeleted = cursor.getInt(10) == 1
val id = UUID.fromString(idString)
- val parentCredentialId = UUID.fromString(parentCredentialIdString)
+ val itemId = UUID.fromString(itemIdString)
val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATE
val 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 ItemId
rpId = 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 null
val publicKeyString = cursor.getString(4)
@@ -595,7 +305,7 @@ class VaultPasskey(
val isDeleted = cursor.getInt(10) == 1
val id = UUID.fromString(idString)
- val parentCredentialId = UUID.fromString(parentCredentialIdString)
+ val itemId = UUID.fromString(itemIdString)
val createdAt = DateHelpers.parseDateString(createdAtString) ?: MIN_DATE
val 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 ItemId
rpId = 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.kt
index 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.kt
index 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 Passkey
if (id != other.id) return false
- if (parentCredentialId != other.parentCredentialId) return false
+ if (parentItemId != other.parentItemId) return false
if (rpId != other.rpId) return false
if (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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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
+ }
+ }
+}