Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

Refactor Swift passkey logic to use centralized db repository pattern for queries (#1404)

Leendert de Borstc25944b588db
diff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/BaseRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swift
similarity index 100%
rename from apps/mobile-app/ios/VaultStoreKit/Repository/BaseRepository.swift
rename to apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swift
diff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/DatabaseClient.swift b/apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swift
similarity index 100%
rename from apps/mobile-app/ios/VaultStoreKit/Repository/DatabaseClient.swift
rename to apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swift
diff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/FieldMapper.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/FieldMapper.swift
similarity index 100%
rename from apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/FieldMapper.swift
rename to apps/mobile-app/ios/VaultStoreKit/Database/Mappers/FieldMapper.swift
diff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/ItemMapper.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/ItemMapper.swift
similarity index 100%
rename from apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/ItemMapper.swift
rename to apps/mobile-app/ios/VaultStoreKit/Database/Mappers/ItemMapper.swift
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/PasskeyMapper.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/PasskeyMapper.swift
new file mode 100644
index 000000000..6a207576c
--- /dev/null
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/PasskeyMapper.swift
@@ -0,0 +1,160 @@
+import Foundation
+import VaultModels
+import VaultUtils
+
+/// Row structure for passkey database results.
+public struct PasskeyRow {
+ public let id: String
+ public let itemId: String
+ public let rpId: String
+ public let userHandle: Data?
+ public let publicKey: String
+ public let privateKey: String
+ public let prfKey: Data?
+ public let displayName: String
+ public let createdAt: String
+ public let updatedAt: String
+ public let isDeleted: Int64
+
+ /// Initialize from a database row dictionary.
+ public init?(from row: [String: Any]) {
+ guard let id = row["Id"] as? String,
+ let itemId = row["ItemId"] as? String,
+ let rpId = row["RpId"] as? String,
+ let publicKey = row["PublicKey"] as? String,
+ let privateKey = row["PrivateKey"] as? String,
+ let displayName = row["DisplayName"] as? String,
+ let createdAt = row["CreatedAt"] as? String,
+ let updatedAt = row["UpdatedAt"] as? String,
+ let isDeleted = row["IsDeleted"] as? Int64 else {
+ return nil
+ }
+
+ self.id = id
+ self.itemId = itemId
+ self.rpId = rpId
+ self.publicKey = publicKey
+ self.privateKey = privateKey
+ self.displayName = displayName
+ self.createdAt = createdAt
+ self.updatedAt = updatedAt
+ self.isDeleted = isDeleted
+
+ // Handle optional blob fields
+ if let userHandleBase64 = row["UserHandle"] as? String {
+ self.userHandle = Data(base64Encoded: userHandleBase64)
+ } else {
+ self.userHandle = nil
+ }
+
+ if let prfKeyBase64 = row["PrfKey"] as? String {
+ self.prfKey = Data(base64Encoded: prfKeyBase64)
+ } else {
+ self.prfKey = nil
+ }
+ }
+}
+
+/// Row structure for passkey with item info (joined query).
+public struct PasskeyWithItemInfoRow {
+ public let passkeyRow: PasskeyRow
+ public let serviceName: String?
+ public let username: String?
+
+ /// Initialize from a database row dictionary.
+ public init?(from row: [String: Any]) {
+ guard let passkeyRow = PasskeyRow(from: row) else {
+ return nil
+ }
+
+ self.passkeyRow = passkeyRow
+ self.serviceName = row["ServiceName"] as? String
+ self.username = row["Username"] as? String
+ }
+}
+
+/// Result type for passkey with item info.
+public struct PasskeyWithItemInfo {
+ public let passkey: Passkey
+ public let serviceName: String?
+ public let username: String?
+
+ public init(passkey: Passkey, serviceName: String?, username: String?) {
+ self.passkey = passkey
+ self.serviceName = serviceName
+ self.username = username
+ }
+}
+
+/// Mapper for converting database rows to Passkey model objects.
+public struct PasskeyMapper {
+ /// Map a single passkey row to a Passkey object.
+ /// - Parameter row: The passkey row from the database
+ /// - Returns: Passkey object or nil if mapping fails
+ public static func mapRow(_ row: PasskeyRow) -> Passkey? {
+ // Parse UUIDs
+ guard let id = UUID(uuidString: row.id),
+ let parentCredentialId = UUID(uuidString: row.itemId) else {
+ print("PasskeyMapper: Invalid UUID - id=\(row.id), itemId=\(row.itemId)")
+ return nil
+ }
+
+ // Parse dates
+ guard let createdAt = DateHelpers.parseDateString(row.createdAt),
+ let updatedAt = DateHelpers.parseDateString(row.updatedAt) else {
+ print("PasskeyMapper: Invalid date - created=\(row.createdAt), updated=\(row.updatedAt)")
+ return nil
+ }
+
+ // Parse keys - stored as UTF-8 strings
+ guard let publicKeyData = row.publicKey.data(using: .utf8),
+ let privateKeyData = row.privateKey.data(using: .utf8) else {
+ print("PasskeyMapper: Invalid key data")
+ return nil
+ }
+
+ return Passkey(
+ id: id,
+ parentCredentialId: parentCredentialId,
+ rpId: row.rpId,
+ userHandle: row.userHandle,
+ userName: nil, // userName not stored in DB, derived from parent credential
+ publicKey: publicKeyData,
+ privateKey: privateKeyData,
+ prfKey: row.prfKey,
+ displayName: row.displayName,
+ createdAt: createdAt,
+ updatedAt: updatedAt,
+ isDeleted: row.isDeleted == 1
+ )
+ }
+
+ /// Map multiple passkey rows to Passkey objects.
+ /// - Parameter rows: Array of passkey rows
+ /// - Returns: Array of Passkey objects
+ public static func mapRows(_ rows: [PasskeyRow]) -> [Passkey] {
+ return rows.compactMap { mapRow($0) }
+ }
+
+ /// Map a passkey with item info row to PasskeyWithItemInfo.
+ /// - Parameter row: The joined row from the database
+ /// - Returns: PasskeyWithItemInfo or nil if mapping fails
+ public static func mapRowWithItemInfo(_ row: PasskeyWithItemInfoRow) -> PasskeyWithItemInfo? {
+ guard let passkey = mapRow(row.passkeyRow) else {
+ return nil
+ }
+
+ return PasskeyWithItemInfo(
+ passkey: passkey,
+ serviceName: row.serviceName,
+ username: row.username
+ )
+ }
+
+ /// Map multiple joined rows to PasskeyWithItemInfo objects.
+ /// - Parameter rows: Array of joined rows
+ /// - Returns: Array of PasskeyWithItemInfo objects
+ public static func mapRowsWithItemInfo(_ rows: [PasskeyWithItemInfoRow]) -> [PasskeyWithItemInfo] {
+ return rows.compactMap { mapRowWithItemInfo($0) }
+ }
+}
diff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/Queries/ItemQueries.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swift
similarity index 100%
rename from apps/mobile-app/ios/VaultStoreKit/Repository/Queries/ItemQueries.swift
rename to apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swift
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift
new file mode 100644
index 000000000..12de6476c
--- /dev/null
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift
@@ -0,0 +1,105 @@
+import Foundation
+
+/// SQL query constants for Passkey operations.
+/// Centralizes all passkey-related queries to avoid duplication.
+public struct PasskeyQueries {
+ /// Base SELECT for passkeys with common fields.
+ public static let baseSelect = """
+ SELECT
+ p.Id,
+ p.ItemId,
+ p.RpId,
+ p.UserHandle,
+ p.PublicKey,
+ p.PrivateKey,
+ p.PrfKey,
+ p.DisplayName,
+ p.CreatedAt,
+ p.UpdatedAt,
+ p.IsDeleted
+ FROM Passkeys p
+ """
+
+ /// Get a passkey by its ID (credential ID).
+ public static let getById = """
+ \(baseSelect)
+ WHERE p.Id = ? AND p.IsDeleted = 0
+ """
+
+ /// Get all passkeys for an item.
+ public static let getByItemId = """
+ \(baseSelect)
+ WHERE p.ItemId = ? AND p.IsDeleted = 0
+ ORDER BY p.CreatedAt DESC
+ """
+
+ /// Get all passkeys for a relying party (rpId).
+ public static let getByRpId = """
+ \(baseSelect)
+ WHERE p.RpId = ? AND p.IsDeleted = 0
+ ORDER BY p.CreatedAt DESC
+ """
+
+ /// Get passkeys with item info for a specific rpId.
+ /// Joins with Items and FieldValues to get display info.
+ public static let getWithItemInfoByRpId = """
+ SELECT
+ p.Id,
+ p.ItemId,
+ p.RpId,
+ p.UserHandle,
+ p.PublicKey,
+ p.PrivateKey,
+ p.PrfKey,
+ p.DisplayName,
+ p.CreatedAt,
+ p.UpdatedAt,
+ p.IsDeleted,
+ i.Name as ServiceName,
+ fv.Value as Username
+ FROM Passkeys p
+ INNER JOIN Items i ON p.ItemId = i.Id
+ LEFT JOIN FieldValues fv ON fv.ItemId = i.Id AND fv.FieldKey = 'login.username' AND fv.IsDeleted = 0
+ WHERE p.RpId = ? AND p.IsDeleted = 0 AND i.IsDeleted = 0
+ ORDER BY p.CreatedAt DESC
+ """
+
+ /// Insert a new passkey.
+ public static let insert = """
+ INSERT INTO Passkeys (Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey, DisplayName, CreatedAt, UpdatedAt, IsDeleted)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """
+
+ /// Soft delete a passkey.
+ public static let softDelete = """
+ UPDATE Passkeys
+ SET IsDeleted = 1,
+ UpdatedAt = ?
+ WHERE Id = ?
+ """
+
+ /// Update passkey display name.
+ public static let updateDisplayName = """
+ UPDATE Passkeys
+ SET DisplayName = ?,
+ UpdatedAt = ?
+ WHERE Id = ? AND IsDeleted = 0
+ """
+}
+
+/// SQL query constants for Logo operations used during passkey/item creation.
+public struct LogoQueries {
+ /// Insert a new logo.
+ public static let insert = """
+ INSERT INTO Logos (Id, Source, FileData, MimeType, FetchedAt, CreatedAt, UpdatedAt, IsDeleted)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ """
+
+ /// Update logo file data.
+ public static let updateFileData = """
+ UPDATE Logos
+ SET FileData = ?,
+ UpdatedAt = ?
+ WHERE Id = ?
+ """
+}
diff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/ItemRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swift
similarity index 100%
rename from apps/mobile-app/ios/VaultStoreKit/Repository/ItemRepository.swift
rename to apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swift
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift
new file mode 100644
index 000000000..e796ae407
--- /dev/null
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift
@@ -0,0 +1,338 @@
+import Foundation
+import VaultModels
+import VaultUtils
+
+/// Repository for Passkey CRUD operations.
+/// Handles fetching, creating, updating, and deleting passkeys.
+public class PasskeyRepository: BaseRepository {
+
+ // MARK: - Read Operations
+
+ /// Get a passkey by its credential ID.
+ /// - Parameter credentialId: The passkey credential ID (UUID string)
+ /// - Returns: Passkey object or nil if not found
+ public func getById(_ credentialId: String) throws -> Passkey? {
+ let results = try client.executeQuery(PasskeyQueries.getById, params: [credentialId])
+ guard let row = results.first.flatMap({ PasskeyRow(from: $0) }) else {
+ return nil
+ }
+ return PasskeyMapper.mapRow(row)
+ }
+
+ /// Get all passkeys for an item.
+ /// - Parameter itemId: The item ID (UUID string)
+ /// - Returns: Array of Passkey objects
+ public func getByItemId(_ itemId: String) throws -> [Passkey] {
+ let results = try client.executeQuery(PasskeyQueries.getByItemId, params: [itemId])
+ let rows = results.compactMap { PasskeyRow(from: $0) }
+ return PasskeyMapper.mapRows(rows)
+ }
+
+ /// Get all passkeys for a relying party (rpId).
+ /// - Parameter rpId: The relying party identifier (domain)
+ /// - Returns: Array of Passkey objects
+ public func getByRpId(_ rpId: String) throws -> [Passkey] {
+ let results = try client.executeQuery(PasskeyQueries.getByRpId, params: [rpId])
+ let rows = results.compactMap { PasskeyRow(from: $0) }
+ return PasskeyMapper.mapRows(rows)
+ }
+
+ /// Get passkeys with item info for a specific rpId.
+ /// - Parameters:
+ /// - rpId: The relying party identifier (domain)
+ /// - userName: Optional username to filter by
+ /// - userId: Optional user handle to filter by
+ /// - Returns: Array of PasskeyWithItemInfo objects
+ public func getWithItemInfo(forRpId rpId: String, userName: String? = nil, userId: Data? = nil) throws -> [PasskeyWithItemInfo] {
+ let results = try client.executeQuery(PasskeyQueries.getWithItemInfoByRpId, params: [rpId])
+ let rows = results.compactMap { PasskeyWithItemInfoRow(from: $0) }
+ var mappedResults = PasskeyMapper.mapRowsWithItemInfo(rows)
+
+ // Apply optional filters
+ if let userName = userName {
+ mappedResults = mappedResults.filter { $0.username == userName }
+ }
+ if let userId = userId {
+ mappedResults = mappedResults.filter { $0.passkey.userHandle == userId }
+ }
+
+ return mappedResults
+ }
+
+ // MARK: - Write Operations
+
+ /// Create a new passkey.
+ /// - Parameter passkey: The passkey to create
+ @discardableResult
+ public func create(_ passkey: Passkey) throws -> String {
+ return try withTransaction {
+ let passkeyId = passkey.id.uuidString.uppercased()
+ let now = self.now()
+
+ // Convert keys to string for storage
+ guard let publicKeyString = String(data: passkey.publicKey, encoding: .utf8),
+ let privateKeyString = String(data: passkey.privateKey, encoding: .utf8) else {
+ throw PasskeyRepositoryError.invalidKeyData
+ }
+
+ // Convert blob data to base64 with prefix for VaultStore+Query processing
+ let userHandleParam: SqliteBindValue = passkey.userHandle.map { "av-base64-to-blob:\($0.base64EncodedString())" }
+ let prfKeyParam: SqliteBindValue = passkey.prfKey.map { "av-base64-to-blob:\($0.base64EncodedString())" }
+
+ try client.executeUpdate(PasskeyQueries.insert, params: [
+ passkeyId,
+ passkey.parentCredentialId.uuidString.uppercased(),
+ passkey.rpId,
+ userHandleParam,
+ publicKeyString,
+ privateKeyString,
+ prfKeyParam,
+ passkey.displayName,
+ now,
+ now,
+ 0
+ ])
+
+ return passkeyId
+ }
+ }
+
+ /// Soft delete a passkey.
+ /// - Parameter passkeyId: The ID of the passkey to delete
+ /// - Returns: Number of rows affected
+ @discardableResult
+ public func delete(_ passkeyId: String) throws -> Int {
+ return try withTransaction {
+ let now = self.now()
+ return try client.executeUpdate(PasskeyQueries.softDelete, params: [now, passkeyId])
+ }
+ }
+
+ /// Update a passkey's display name.
+ /// - Parameters:
+ /// - passkeyId: The ID of the passkey to update
+ /// - displayName: The new display name
+ /// - Returns: Number of rows affected
+ @discardableResult
+ public func updateDisplayName(_ passkeyId: String, displayName: String) throws -> Int {
+ return try withTransaction {
+ let now = self.now()
+ return try client.executeUpdate(PasskeyQueries.updateDisplayName, params: [displayName, now, passkeyId])
+ }
+ }
+
+ /// Replace an existing passkey with a new one.
+ /// Deletes the old passkey and creates a new one linked to the same item.
+ /// - Parameters:
+ /// - oldPasskeyId: The ID of the passkey to replace
+ /// - newPasskey: The new passkey to create
+ /// - displayName: The display name for the new passkey
+ /// - Returns: The ID of the new passkey
+ @discardableResult
+ public func replace(oldPasskeyId: String, with newPasskey: Passkey, displayName: String) throws -> String {
+ return try withTransaction {
+ let now = self.now()
+
+ // Delete the old passkey
+ try client.executeUpdate(PasskeyQueries.softDelete, params: [now, oldPasskeyId])
+
+ // Create the new passkey
+ let newPasskeyId = newPasskey.id.uuidString.uppercased()
+
+ guard let publicKeyString = String(data: newPasskey.publicKey, encoding: .utf8),
+ let privateKeyString = String(data: newPasskey.privateKey, encoding: .utf8) else {
+ throw PasskeyRepositoryError.invalidKeyData
+ }
+
+ let userHandleParam: SqliteBindValue = newPasskey.userHandle.map { "av-base64-to-blob:\($0.base64EncodedString())" }
+ let prfKeyParam: SqliteBindValue = newPasskey.prfKey.map { "av-base64-to-blob:\($0.base64EncodedString())" }
+
+ try client.executeUpdate(PasskeyQueries.insert, params: [
+ newPasskeyId,
+ newPasskey.parentCredentialId.uuidString.uppercased(),
+ newPasskey.rpId,
+ userHandleParam,
+ publicKeyString,
+ privateKeyString,
+ prfKeyParam,
+ displayName,
+ now,
+ now,
+ 0
+ ])
+
+ return newPasskeyId
+ }
+ }
+
+ // MARK: - Item + Passkey Creation
+
+ /// Create an item with a passkey (for passkey registration).
+ /// This creates an Item record with field values and links the passkey to it.
+ /// - Parameters:
+ /// - rpId: The relying party identifier (domain)
+ /// - userName: Optional username
+ /// - displayName: Display name for the item
+ /// - passkey: The passkey to create
+ /// - logo: Optional logo data
+ /// - Returns: The created item ID
+ @discardableResult
+ public func createItemWithPasskey(
+ rpId: String,
+ userName: String?,
+ displayName: String,
+ passkey: Passkey,
+ logo: Data? = nil
+ ) throws -> String {
+ return try withTransaction {
+ let itemId = passkey.parentCredentialId.uuidString.uppercased()
+ let now = self.now()
+
+ // Create logo if provided
+ var logoId: String?
+ if let logo = logo {
+ logoId = generateId()
+ let source = rpId.lowercased().replacingOccurrences(of: "www.", with: "")
+ let logoDataParam = "av-base64-to-blob:\(logo.base64EncodedString())"
+
+ try client.executeUpdate(LogoQueries.insert, params: [
+ logoId!,
+ source,
+ logoDataParam,
+ "image/png",
+ nil,
+ now,
+ now,
+ 0
+ ])
+ }
+
+ // Create the Item
+ try client.executeUpdate(ItemQueries.insertItem, params: [
+ itemId,
+ displayName as SqliteBindValue,
+ ItemType.login,
+ logoId as SqliteBindValue,
+ nil, // FolderId
+ now,
+ now,
+ 0
+ ])
+
+ // Create field values - login.url
+ let urlFieldId = generateId()
+ try client.executeUpdate(FieldValueQueries.insert, params: [
+ urlFieldId,
+ itemId,
+ nil, // FieldDefinitionId
+ FieldKey.loginUrl,
+ "https://\(rpId)",
+ 0, // Weight
+ now,
+ now,
+ 0
+ ])
+
+ // Create field values - login.username if provided
+ if let userName = userName, !userName.isEmpty {
+ let usernameFieldId = generateId()
+ try client.executeUpdate(FieldValueQueries.insert, params: [
+ usernameFieldId,
+ itemId,
+ nil, // FieldDefinitionId
+ FieldKey.loginUsername,
+ userName,
+ 0, // Weight
+ now,
+ now,
+ 0
+ ])
+ }
+
+ // Create the passkey
+ guard let publicKeyString = String(data: passkey.publicKey, encoding: .utf8),
+ let privateKeyString = String(data: passkey.privateKey, encoding: .utf8) else {
+ throw PasskeyRepositoryError.invalidKeyData
+ }
+
+ let userHandleParam: SqliteBindValue = passkey.userHandle.map { "av-base64-to-blob:\($0.base64EncodedString())" }
+ let prfKeyParam: SqliteBindValue = passkey.prfKey.map { "av-base64-to-blob:\($0.base64EncodedString())" }
+
+ try client.executeUpdate(PasskeyQueries.insert, params: [
+ passkey.id.uuidString.uppercased(),
+ itemId,
+ passkey.rpId,
+ userHandleParam,
+ publicKeyString,
+ privateKeyString,
+ prfKeyParam,
+ passkey.displayName,
+ now,
+ now,
+ 0
+ ])
+
+ return itemId
+ }
+ }
+
+ /// Update item logo when replacing a passkey.
+ /// - Parameters:
+ /// - itemId: The item ID
+ /// - logo: The new logo data
+ /// - displayName: The new display name
+ public func updateItemLogo(itemId: String, logo: Data, displayName: String) throws {
+ try withTransaction {
+ let now = self.now()
+
+ // Get current logo ID from item
+ let itemResults = try client.executeQuery(
+ "SELECT LogoId FROM Items WHERE Id = ?",
+ params: [itemId]
+ )
+
+ let logoDataParam = "av-base64-to-blob:\(logo.base64EncodedString())"
+
+ if let existingLogoId = itemResults.first?["LogoId"] as? String {
+ // Update existing logo
+ try client.executeUpdate(LogoQueries.updateFileData, params: [
+ logoDataParam,
+ now,
+ existingLogoId
+ ])
+ } else {
+ // Create new logo and link to item
+ let newLogoId = generateId()
+ try client.executeUpdate(LogoQueries.insert, params: [
+ newLogoId,
+ "", // Source not needed for update
+ logoDataParam,
+ "image/png",
+ nil,
+ now,
+ now,
+ 0
+ ])
+
+ // Update item with new logo ID
+ try client.executeUpdate(
+ "UPDATE Items SET LogoId = ?, UpdatedAt = ? WHERE Id = ?",
+ params: [newLogoId, now, itemId]
+ )
+ }
+
+ // Update item name
+ try client.executeUpdate(
+ "UPDATE Items SET Name = ?, UpdatedAt = ? WHERE Id = ?",
+ params: [displayName, now, itemId]
+ )
+ }
+ }
+}
+
+/// Errors that can occur in PasskeyRepository operations.
+public enum PasskeyRepositoryError: Error {
+ case invalidKeyData
+ case passkeyNotFound
+ case itemNotFound
+}
diff --git a/apps/mobile-app/ios/VaultStoreKit/VaultStore+DatabaseClient.swift b/apps/mobile-app/ios/VaultStoreKit/VaultStore+DatabaseClient.swift
index c6eaed69c..a1577f5f3 100644
--- a/apps/mobile-app/ios/VaultStoreKit/VaultStore+DatabaseClient.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/VaultStore+DatabaseClient.swift
@@ -9,4 +9,10 @@ extension VaultStore: DatabaseClient {
public var itemRepository: ItemRepository {
return ItemRepository(client: self)
}
+
+ /// The PasskeyRepository instance for this VaultStore.
+ /// Lazily initialized to use self as the database client.
+ public var passkeyRepository: PasskeyRepository {
+ return PasskeyRepository(client: self)
+ }
}
diff --git a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Passkey.swift b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Passkey.swift
index e020c3ea2..cbb2b3536 100644
--- a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Passkey.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Passkey.swift
@@ -5,78 +5,30 @@ import VaultUtils
/**
* VaultStore+Passkey
- * Extension to VaultStore for passkey operations
+ * Extension to VaultStore for passkey operations.
+ * Delegates to PasskeyRepository for database operations.
*/
extension VaultStore {
- // MARK: - Column Expressions
-
- private static let passkeysTable = Table("Passkeys")
-
- private static let colId = Expression<String>("Id")
- private static let colItemId = Expression<String>("ItemId")
- private static let colRpId = Expression<String>("RpId")
- private static let colUserHandle = Expression<Blob?>("UserHandle")
- private static let colPublicKey = Expression<String>("PublicKey")
- private static let colPrivateKey = Expression<String>("PrivateKey")
- private static let colPrfKey = Expression<Blob?>("PrfKey")
- private static let colDisplayName = Expression<String>("DisplayName")
- private static let colAdditionalData = Expression<Blob?>("AdditionalData")
- private static let colCreatedAt = Expression<String>("CreatedAt")
- private static let colUpdatedAt = Expression<String>("UpdatedAt")
- private static let colIsDeleted = Expression<Int64>("IsDeleted")
-
- // MARK: - Passkey Queries
+ // MARK: - Passkey Queries (Public API)
/**
* Get a passkey by its credential ID (the WebAuthn credential ID, not the parent Credential UUID)
*/
public func getPasskey(byCredentialId credentialId: Data) throws -> Passkey? {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
-
- // The Passkeys.Id column is a string UUID (not a blob), so we need to convert the credentialId bytes to a UUID string.
- // Use PasskeyHelper to convert the credentialId (Data) to a UUID string for lookup.
+ // Convert credentialId bytes to a UUID string for lookup
guard let credentialIdString = try? PasskeyHelper.bytesToGuid(credentialId) else {
print("VaultStore+Passkey: Failed to convert credentialId bytes to UUID string")
return nil
}
- let query = Self.passkeysTable
- .filter(Self.colId == credentialIdString)
- .filter(Self.colIsDeleted == 0)
- .limit(1)
-
- for row in try dbConn.prepare(query) {
- if let passkey = try parsePasskeyRow(row) {
- return passkey
- }
- }
-
- return nil
+ return try passkeyRepository.getById(credentialIdString)
}
/**
* Get all passkeys for an item (new model)
*/
public func getPasskeys(forItemId itemId: UUID) throws -> [Passkey] {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
-
- let query = Self.passkeysTable
- .filter(Self.colItemId == itemId.uuidString)
- .filter(Self.colIsDeleted == 0)
- .order(Self.colCreatedAt.desc)
-
- var passkeys: [Passkey] = []
- for row in try dbConn.prepare(query) {
- if let passkey = try parsePasskeyRow(row) {
- passkeys.append(passkey)
- }
- }
-
- return passkeys
+ return try passkeyRepository.getByItemId(itemId.uuidString.uppercased())
}
/**
@@ -90,23 +42,7 @@ extension VaultStore {
* Get all passkeys for a specific relying party identifier (RP ID)
*/
public func getPasskeys(forRpId rpId: String) throws -> [Passkey] {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
-
- let query = Self.passkeysTable
- .filter(Self.colRpId == rpId)
- .filter(Self.colIsDeleted == 0)
- .order(Self.colCreatedAt.desc)
-
- var passkeys: [Passkey] = []
- for row in try dbConn.prepare(query) {
- if let passkey = try parsePasskeyRow(row) {
- passkeys.append(passkey)
- }
- }
-
- return passkeys
+ return try passkeyRepository.getByRpId(rpId)
}
/**
@@ -114,146 +50,11 @@ extension VaultStore {
* Used for finding existing passkeys that might be replaced during registration
*/
public func getPasskeysWithCredentialInfo(forRpId rpId: String, userName: String? = nil, userId: Data? = nil) throws -> [(passkey: Passkey, serviceName: String?, username: String?)] {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
-
- // Join passkeys with items and field values to get display info
- let passkeysTable = Table("Passkeys")
- let itemsTable = Table("Items")
- let fieldValuesTable = Table("FieldValues")
-
- // First get passkeys joined with items
- let query = passkeysTable
- .select(passkeysTable[*], itemsTable[Expression<String?>("Name")])
- .join(itemsTable, on: passkeysTable[Expression<String>("ItemId")] == itemsTable[Expression<String>("Id")])
- .filter(passkeysTable[Expression<String>("RpId")] == rpId)
- .filter(passkeysTable[Expression<Int64>("IsDeleted")] == 0)
- .filter(itemsTable[Expression<Int64>("IsDeleted")] == 0)
- .order(passkeysTable[Expression<String>("CreatedAt")].desc)
-
- var results: [(passkey: Passkey, serviceName: String?, username: String?)] = []
-
- for row in try dbConn.prepare(query) {
- if let passkey = try parsePasskeyRow(row) {
- let serviceName = try? row.get(Expression<String?>("Name"))
-
- // Get username from field values (login.username)
- let usernameQuery = fieldValuesTable
- .filter(Expression<String>("ItemId") == passkey.parentCredentialId.uuidString)
- .filter(Expression<String?>("FieldKey") == FieldKey.loginUsername)
- .filter(Expression<Int64>("IsDeleted") == 0)
- .limit(1)
-
- var credUsername: String?
- if let usernameRow = try? dbConn.pluck(usernameQuery) {
- credUsername = try? usernameRow.get(Expression<String?>("Value"))
- }
-
- // Filter by username or userId if provided
- var matches = true
- if let userName = userName {
- if credUsername != userName {
- matches = false
- }
- }
- if let userId = userId {
- if passkey.userHandle != userId {
- matches = false
- }
- }
-
- if matches {
- results.append((passkey: passkey, serviceName: serviceName, username: credUsername))
- }
- }
- }
-
- return results
- }
-
- // MARK: - Helper Methods
-
- /**
- * Parse a passkey row from database query using type-safe column expressions
- */
- private func parsePasskeyRow(_ row: Row) throws -> Passkey? {
- // Extract required fields using column expressions
- let idString = try row.get(Self.colId)
- let parentCredentialIdString = try row.get(Self.colItemId)
- let rpId = try row.get(Self.colRpId)
- let userHandleBlob = try? row.get(Self.colUserHandle)
- let publicKeyString = try row.get(Self.colPublicKey)
- let privateKeyString = try row.get(Self.colPrivateKey)
- let displayName = try row.get(Self.colDisplayName)
- let createdAtString = try row.get(Self.colCreatedAt)
- let updatedAtString = try row.get(Self.colUpdatedAt)
- let isDeletedInt64 = try row.get(Self.colIsDeleted)
-
- // Parse UUIDs
- guard let id = UUID(uuidString: idString),
- let parentCredentialId = UUID(uuidString: parentCredentialIdString) else {
- print("VaultStore+Passkey: Invalid UUID in passkey row - id=\(idString), credentialId=\(parentCredentialIdString)")
- return nil
- }
-
- // Parse dates
- guard let createdAt = DateHelpers.parseDateString(createdAtString),
- let updatedAt = DateHelpers.parseDateString(updatedAtString) else {
- print("VaultStore+Passkey: Invalid date in passkey row - created=\(createdAtString), updated=\(updatedAtString)")
- return nil
- }
-
- // Parse public/private keys
- guard let publicKeyData = publicKeyString.data(using: .utf8),
- let privateKeyData = privateKeyString.data(using: .utf8) else {
- print("VaultStore+Passkey: Invalid key data in passkey row")
- return nil
- }
-
- // Parse userHandle (stored as blob - raw bytes)
- let userHandle: Data?
- if let userHandleBlob = userHandleBlob {
- userHandle = Data(userHandleBlob.bytes)
- } else {
- userHandle = nil
- }
-
- // Parse PrfKey (stored as blob)
- let prfKey: Data?
- if let prfKeyBlob = try? row.get(Self.colPrfKey) {
- prfKey = Data(prfKeyBlob.bytes)
- } else {
- prfKey = nil
- }
-
- let isDeleted = isDeletedInt64 == 1
-
- return Passkey(
- id: id,
- parentCredentialId: parentCredentialId, // Parent Credential UUID
- rpId: rpId,
- userHandle: userHandle,
- userName: nil, // userName not stored in DB, derived from parent credential
- publicKey: publicKeyData,
- privateKey: privateKeyData,
- prfKey: prfKey,
- displayName: displayName,
- createdAt: createdAt,
- updatedAt: updatedAt,
- isDeleted: isDeleted
- )
+ let results = try passkeyRepository.getWithItemInfo(forRpId: rpId, userName: userName, userId: userId)
+ return results.map { (passkey: $0.passkey, serviceName: $0.serviceName, username: $0.username) }
}
- // MARK: - Passkey Storage
-
- /**
- * Format a date for database insertion
- * Format: yyyy-MM-dd HH:mm:ss
- */
- private func formatDateForDatabase(_ date: Date) -> String {
- return DateHelpers.toStandardFormat(date)
- }
+ // MARK: - Passkey Storage (Public API)
/**
* Create an item with a passkey (for passkey registration)
@@ -266,91 +67,18 @@ extension VaultStore {
passkey: Passkey,
logo: Data? = nil
) throws -> Credential {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
+ _ = try passkeyRepository.createItemWithPasskey(
+ rpId: rpId,
+ userName: userName,
+ displayName: displayName,
+ passkey: passkey,
+ logo: logo
+ )
+ // Return the credential (legacy format for backwards compatibility)
let itemId = passkey.parentCredentialId
let now = Date()
- let timestamp = formatDateForDatabase(now)
- // Create logo if provided
- var logoId: UUID?
- if let logo = logo {
- logoId = UUID()
- let logosTable = Table("Logos")
- let logoBlob = Blob(bytes: [UInt8](logo))
-
- // Extract normalized domain from rpId for source
- let source = rpId.lowercased().replacingOccurrences(of: "www.", with: "")
-
- let logoInsert = logosTable.insert(
- Expression<String>("Id") <- logoId!.uuidString,
- Expression<String>("Source") <- source,
- Expression<SQLite.Blob?>("FileData") <- logoBlob,
- Expression<String?>("MimeType") <- "image/png",
- Expression<String?>("FetchedAt") <- nil,
- Expression<String>("CreatedAt") <- timestamp,
- Expression<String>("UpdatedAt") <- timestamp,
- Expression<Int64>("IsDeleted") <- 0
- )
- try dbConn.run(logoInsert)
- }
-
- // Create the Item
- let itemsTable = Table("Items")
- let itemInsert = itemsTable.insert(
- Expression<String>("Id") <- itemId.uuidString,
- Expression<String?>("Name") <- displayName,
- Expression<String>("ItemType") <- ItemType.login,
- Expression<String?>("LogoId") <- logoId?.uuidString,
- Expression<String?>("FolderId") <- nil,
- Expression<String?>("DeletedAt") <- nil,
- Expression<String>("CreatedAt") <- timestamp,
- Expression<String>("UpdatedAt") <- timestamp,
- Expression<Int64>("IsDeleted") <- 0
- )
- try dbConn.run(itemInsert)
-
- // Create field values
- let fieldValuesTable = Table("FieldValues")
-
- // Add login.url field
- let urlFieldId = UUID()
- let urlFieldInsert = fieldValuesTable.insert(
- Expression<String>("Id") <- urlFieldId.uuidString,
- Expression<String>("ItemId") <- itemId.uuidString,
- Expression<String?>("FieldDefinitionId") <- nil,
- Expression<String?>("FieldKey") <- FieldKey.loginUrl,
- Expression<String?>("Value") <- "https://\(rpId)",
- Expression<Int64>("Weight") <- 0,
- Expression<String>("CreatedAt") <- timestamp,
- Expression<String>("UpdatedAt") <- timestamp,
- Expression<Int64>("IsDeleted") <- 0
- )
- try dbConn.run(urlFieldInsert)
-
- // Add login.username field if provided
- if let userName = userName, !userName.isEmpty {
- let usernameFieldId = UUID()
- let usernameFieldInsert = fieldValuesTable.insert(
- Expression<String>("Id") <- usernameFieldId.uuidString,
- Expression<String>("ItemId") <- itemId.uuidString,
- Expression<String?>("FieldDefinitionId") <- nil,
- Expression<String?>("FieldKey") <- FieldKey.loginUsername,
- Expression<String?>("Value") <- userName,
- Expression<Int64>("Weight") <- 0,
- Expression<String>("CreatedAt") <- timestamp,
- Expression<String>("UpdatedAt") <- timestamp,
- Expression<Int64>("IsDeleted") <- 0
- )
- try dbConn.run(usernameFieldInsert)
- }
-
- // Insert the passkey
- try insertPasskey(passkey)
-
- // Return the credential (legacy format for backwards compatibility)
let service = Service(
id: itemId,
name: displayName,
@@ -379,25 +107,7 @@ extension VaultStore {
* Insert a new passkey into the database
*/
public func insertPasskey(_ passkey: Passkey) throws {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
-
- let insert = Self.passkeysTable.insert(
- Self.colId <- passkey.id.uuidString,
- Self.colItemId <- passkey.parentCredentialId.uuidString,
- Self.colRpId <- passkey.rpId,
- Self.colUserHandle <- passkey.userHandle.map { Blob(bytes: [UInt8]($0)) },
- Self.colPublicKey <- String(data: passkey.publicKey, encoding: .utf8)!,
- Self.colPrivateKey <- String(data: passkey.privateKey, encoding: .utf8)!,
- Self.colPrfKey <- passkey.prfKey.map { Blob(bytes: [UInt8]($0)) },
- Self.colDisplayName <- passkey.displayName,
- Self.colCreatedAt <- formatDateForDatabase(passkey.createdAt),
- Self.colUpdatedAt <- formatDateForDatabase(passkey.updatedAt),
- Self.colIsDeleted <- Int64(passkey.isDeleted ? 1 : 0)
- )
-
- try dbConn.run(insert)
+ try passkeyRepository.create(passkey)
}
/**
@@ -405,95 +115,21 @@ extension VaultStore {
* This deletes the old passkey and creates a new one with the same item
*/
public func replacePasskey(oldPasskeyId: UUID, newPasskey: Passkey, displayName: String, logo: Data? = nil) throws {
- guard let dbConn = dbConnection else {
- throw VaultStoreError.vaultNotUnlocked
- }
-
// Get the old passkey to find its item
- let oldPasskeyQuery = Self.passkeysTable
- .filter(Self.colId == oldPasskeyId.uuidString)
- .filter(Self.colIsDeleted == 0)
- .limit(1)
-
- guard let oldPasskeyRow = try dbConn.pluck(oldPasskeyQuery),
- let oldPasskey = try parsePasskeyRow(oldPasskeyRow) else {
- throw VaultStoreError.databaseError("Passkey not found")
+ guard let oldPasskey = try passkeyRepository.getById(oldPasskeyId.uuidString.uppercased()) else {
+ throw VaultStoreError.passkeyNotFound
}
let itemId = oldPasskey.parentCredentialId
- let now = Date()
- let timestamp = formatDateForDatabase(now)
- // Update the item's logo if provided
+ // Update logo if provided
if let logo = logo {
- let itemsTable = Table("Items")
- let logosTable = Table("Logos")
-
- // Get the current logo ID from the item
- let itemQuery = itemsTable
- .filter(Expression<String>("Id") == itemId.uuidString)
- .limit(1)
-
- if let itemRow = try dbConn.pluck(itemQuery) {
- let existingLogoId = try? itemRow.get(Expression<String?>("LogoId"))
-
- let logoBlob = Blob(bytes: [UInt8](logo))
-
- if let logoIdString = existingLogoId, let logoId = UUID(uuidString: logoIdString) {
- // Update existing logo
- let logoUpdate = logosTable
- .filter(Expression<String>("Id") == logoId.uuidString)
- .update(
- Expression<SQLite.Blob?>("FileData") <- logoBlob,
- Expression<String>("UpdatedAt") <- timestamp
- )
- try dbConn.run(logoUpdate)
- } else {
- // Create new logo
- let newLogoId = UUID()
- let source = newPasskey.rpId.lowercased().replacingOccurrences(of: "www.", with: "")
- let logoInsert = logosTable.insert(
- Expression<String>("Id") <- newLogoId.uuidString,
- Expression<String>("Source") <- source,
- Expression<SQLite.Blob?>("FileData") <- logoBlob,
- Expression<String?>("MimeType") <- "image/png",
- Expression<String?>("FetchedAt") <- nil,
- Expression<String>("CreatedAt") <- timestamp,
- Expression<String>("UpdatedAt") <- timestamp,
- Expression<Int64>("IsDeleted") <- 0
- )
- try dbConn.run(logoInsert)
-
- // Update item with new logo ID
- let itemUpdate = itemsTable
- .filter(Expression<String>("Id") == itemId.uuidString)
- .update(
- Expression<String?>("LogoId") <- newLogoId.uuidString,
- Expression<String>("UpdatedAt") <- timestamp
- )
- try dbConn.run(itemUpdate)
- }
-
- // Update item name with displayName
- let nameUpdate = itemsTable
- .filter(Expression<String>("Id") == itemId.uuidString)
- .update(
- Expression<String?>("Name") <- displayName,
- Expression<String>("UpdatedAt") <- timestamp
- )
- try dbConn.run(nameUpdate)
- }
- }
-
- // Delete the old passkey
- let deleteQuery = Self.passkeysTable
- .filter(Self.colId == oldPasskeyId.uuidString)
- .update(
- Self.colIsDeleted <- 1,
- Self.colUpdatedAt <- timestamp
+ try passkeyRepository.updateItemLogo(
+ itemId: itemId.uuidString.uppercased(),
+ logo: logo,
+ displayName: displayName
)
-
- try dbConn.run(deleteQuery)
+ }
// Create the new passkey with the same item ID
let updatedPasskey = Passkey(
@@ -506,12 +142,16 @@ extension VaultStore {
privateKey: newPasskey.privateKey,
prfKey: newPasskey.prfKey,
displayName: displayName,
- createdAt: now,
- updatedAt: now,
+ createdAt: Date(),
+ updatedAt: Date(),
isDeleted: false
)
- try insertPasskey(updatedPasskey)
+ try passkeyRepository.replace(
+ oldPasskeyId: oldPasskeyId.uuidString.uppercased(),
+ with: updatedPasskey,
+ displayName: displayName
+ )
}
}