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.swiftsimilarity index 100%rename from apps/mobile-app/ios/VaultStoreKit/Repository/BaseRepository.swiftrename to apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swiftdiff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/DatabaseClient.swift b/apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swiftsimilarity index 100%rename from apps/mobile-app/ios/VaultStoreKit/Repository/DatabaseClient.swiftrename to apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swiftdiff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/FieldMapper.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/FieldMapper.swiftsimilarity index 100%rename from apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/FieldMapper.swiftrename to apps/mobile-app/ios/VaultStoreKit/Database/Mappers/FieldMapper.swiftdiff --git a/apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/ItemMapper.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/ItemMapper.swiftsimilarity index 100%rename from apps/mobile-app/ios/VaultStoreKit/Repository/Mappers/ItemMapper.swiftrename to apps/mobile-app/ios/VaultStoreKit/Database/Mappers/ItemMapper.swiftdiff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/PasskeyMapper.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Mappers/PasskeyMapper.swiftnew file mode 100644index 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.swiftsimilarity index 100%rename from apps/mobile-app/ios/VaultStoreKit/Repository/Queries/ItemQueries.swiftrename to apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swiftdiff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swiftnew file mode 100644index 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.swiftsimilarity index 100%rename from apps/mobile-app/ios/VaultStoreKit/Repository/ItemRepository.swiftrename to apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swiftdiff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swiftnew file mode 100644index 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.swiftindex 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.swiftindex 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 lookupguard 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.parentCredentialIdlet 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 providedif 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 IDlet 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+ )}}