Skip to content

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

Update iOS app swift queries and models for updated datamodel (#2159)

Leendert de Borstb43fa9aa4e05
diff --git a/apps/mobile-app/ios/VaultModels/VaultSql.swift b/apps/mobile-app/ios/VaultModels/VaultSql.swift
index 1a5d78749..16bf25db6 100644
--- a/apps/mobile-app/ios/VaultModels/VaultSql.swift
+++ b/apps/mobile-app/ios/VaultModels/VaultSql.swift
@@ -1426,13 +1426,14 @@ public struct VaultSql {
CREATE TABLE \"ef_temp_Attachments\" (
\"ManifestId\" TEXT COLLATE NOCASE NOT NULL,
\"Id\" TEXT COLLATE NOCASE NOT NULL,
- \"Blob\" BLOB NOT NULL,
+ \"Blob\" BLOB NULL,
\"CreatedAt\" TEXT NOT NULL,
\"Filename\" TEXT NOT NULL,
\"IsDeleted\" INTEGER NOT NULL,
\"ItemId\" TEXT COLLATE NOCASE NOT NULL,
\"UpdatedAt\" TEXT NOT NULL,
CONSTRAINT \"PK_Attachments\" PRIMARY KEY (\"ManifestId\", \"Id\"),
+ CONSTRAINT \"CK_Attachments_Blob_Tombstone\" CHECK (\"IsDeleted\" = 1 OR \"Blob\" IS NOT NULL),
CONSTRAINT \"FK_Attachments_Items_ManifestId_ItemId\" FOREIGN KEY (\"ManifestId\", \"ItemId\") REFERENCES \"Items\" (\"ManifestId\", \"Id\") ON DELETE CASCADE
);
@@ -1778,7 +1779,7 @@ public struct VaultSql {
COMMIT;
INSERT INTO \"__EFMigrationsHistory\" (\"MigrationId\", \"ProductVersion\")
- VALUES ('20260910094359_2.1.0-ManifestScopedStorage', '10.0.10');
+ VALUES ('20260913090000_2.1.0-ManifestScopedStorage', '10.0.10');
BEGIN TRANSACTION;
CREATE TRIGGER IF NOT EXISTS \"TR_Items_ResyncChildManifestIds\"
@@ -1799,7 +1800,7 @@ public struct VaultSql {
PRAGMA foreign_keys = ON;
INSERT INTO \"__EFMigrationsHistory\" (\"MigrationId\", \"ProductVersion\")
- VALUES ('20260910094449_2.1.1-ItemChildManifestTrigger', '10.0.10');
+ VALUES ('20260913090100_2.1.1-ItemChildManifestTrigger', '10.0.10');
"""
/// Migration SQL scripts indexed by migration number.
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swift
index 12c34e5d8..4be863300 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/BaseRepository.swift
@@ -13,6 +13,12 @@ public class BaseRepository {
self.client = client
}
+ /// The manifest new rows outside any folder or item are stamped with: the personal manifest. Rows inside a
+ /// folder or item take that parent's manifest through the SQL instead.
+ public func activeManifestId() -> String {
+ return client.personalManifestId() ?? ""
+ }
+
// MARK: - Transaction Helpers
/// Execute a function within a transaction.
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swift b/apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swift
index f168c670d..aee6c8f27 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/DatabaseClient.swift
@@ -29,4 +29,7 @@ public protocol DatabaseClient: AnyObject {
/// Rollback a database transaction.
func rollbackTransaction() throws
+
+ /// The id of the user's personal manifest, or nil before the first pull recorded one.
+ func personalManifestId() -> String?
}
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swift
index b8ead84fb..35f84e30e 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/ItemQueries.swift
@@ -148,8 +148,8 @@ public struct ItemQueries {
/// Insert a new item.
public static let insertItem = """
- INSERT INTO Items (Id, Name, ItemType, LogoId, FolderId, CreatedAt, UpdatedAt, IsDeleted)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ INSERT INTO Items (Id, Name, ItemType, LogoId, FolderId, CreatedAt, UpdatedAt, IsDeleted, ManifestId)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, COALESCE((SELECT ManifestId FROM Folders WHERE Id = ?), ?))
"""
/// Update an existing item.
@@ -219,8 +219,8 @@ public struct FieldValueQueries {
/// Insert a new field value.
public static let insert = """
- INSERT INTO FieldValues (Id, ItemId, FieldDefinitionId, FieldKey, Value, Weight, CreatedAt, UpdatedAt, IsDeleted)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+ INSERT INTO FieldValues (Id, ItemId, FieldDefinitionId, FieldKey, Value, Weight, CreatedAt, UpdatedAt, IsDeleted, ManifestId)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, COALESCE((SELECT ManifestId FROM Items WHERE Id = ?), ?))
"""
/// Update an existing field value.
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift
index 94d5f73aa..c45c4b777 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Queries/PasskeyQueries.swift
@@ -86,8 +86,8 @@ public struct PasskeyQueries {
/// Insert a new passkey.
public static let insert = """
- INSERT INTO Passkeys (Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey, DisplayName, CreatedAt, UpdatedAt, IsDeleted)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ INSERT INTO Passkeys (Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey, DisplayName, CreatedAt, UpdatedAt, IsDeleted, ManifestId)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, COALESCE((SELECT ManifestId FROM Items WHERE Id = ?), ?))
"""
/// Soft delete a passkey.
@@ -178,8 +178,8 @@ public struct PasskeyQueries {
public struct LogoQueries {
/// Insert a new logo.
public static let insert = """
- INSERT INTO Logos (Id, Source, FileData, MimeType, FetchedAt, CreatedAt, UpdatedAt, IsDeleted)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ INSERT INTO Logos (Id, Kind, Source, ManifestId, FileData, MimeType, FetchedAt, CreatedAt, UpdatedAt, IsDeleted)
+ VALUES (?, 'favicon', ?, ?, ?, ?, ?, ?, ?, ?)
"""
/// Update logo file data.
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swift
index 61355eb7a..cc41224f8 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/ItemRepository.swift
@@ -254,7 +254,7 @@ public class ItemRepository: BaseRepository {
// Soft delete attachments AND zero their blob bytes so storage is reclaimed
// immediately while the row remains as a tombstone for LWW sync.
try client.executeUpdate(
- "UPDATE Attachments SET IsDeleted = 1, Blob = X'', UpdatedAt = ? WHERE ItemId = ? AND IsDeleted = 0",
+ "UPDATE Attachments SET IsDeleted = 1, Blob = NULL, UpdatedAt = ? WHERE ItemId = ? AND IsDeleted = 0",
params: [now, itemId]
)
@@ -290,7 +290,9 @@ public class ItemRepository: BaseRepository {
item.folderId?.uuidString.lowercased() as SqliteBindValue,
now,
now,
- 0
+ 0,
+ item.folderId?.uuidString.lowercased() as SqliteBindValue,
+ activeManifestId()
])
// 2. Insert FieldValues
@@ -353,7 +355,9 @@ public class ItemRepository: BaseRepository {
9999,
now,
now,
- 0
+ 0,
+ itemId,
+ activeManifestId()
])
// Bump the parent Item's UpdatedAt so the change is picked up by
@@ -381,7 +385,9 @@ public class ItemRepository: BaseRepository {
index * 100, // Weight for ordering
now,
now,
- 0
+ 0,
+ itemId,
+ activeManifestId()
])
}
}
@@ -451,7 +457,9 @@ public class ItemRepository: BaseRepository {
index * 100,
now,
now,
- 0
+ 0,
+ itemId,
+ activeManifestId()
])
}
}
diff --git a/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift
index be57ad555..d2b495e26 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Database/Repositories/PasskeyRepository.swift
@@ -1,4 +1,5 @@
import Foundation
+import RustCoreFramework
import VaultModels
import VaultUtils
@@ -182,7 +183,9 @@ public class PasskeyRepository: BaseRepository {
passkey.displayName,
now,
now,
- 0
+ 0,
+ passkey.parentItemId.uuidString.lowercased(),
+ activeManifestId()
])
return passkeyId
@@ -261,7 +264,9 @@ public class PasskeyRepository: BaseRepository {
displayName,
now,
now,
- 0
+ 0,
+ newPasskey.parentItemId.uuidString.lowercased(),
+ activeManifestId()
])
return newPasskeyId
@@ -307,7 +312,9 @@ public class PasskeyRepository: BaseRepository {
nil, // FolderId
now,
now,
- 0
+ 0,
+ nil,
+ activeManifestId()
])
// Create field values - login.url
@@ -321,7 +328,9 @@ public class PasskeyRepository: BaseRepository {
0, // Weight
now,
now,
- 0
+ 0,
+ itemId,
+ activeManifestId()
])
// Create field values - login.username if provided
@@ -336,7 +345,9 @@ public class PasskeyRepository: BaseRepository {
0, // Weight
now,
now,
- 0
+ 0,
+ itemId,
+ activeManifestId()
])
}
@@ -360,7 +371,9 @@ public class PasskeyRepository: BaseRepository {
passkey.displayName,
now,
now,
- 0
+ 0,
+ itemId,
+ activeManifestId()
])
return itemId
@@ -464,7 +477,9 @@ public class PasskeyRepository: BaseRepository {
passkey.displayName,
now,
now,
- 0
+ 0,
+ itemIdString,
+ activeManifestId()
])
return passkeyId
@@ -497,13 +512,15 @@ public class PasskeyRepository: BaseRepository {
return existingLogoId
}
- // Create new logo entry
- let logoId = generateId()
+ // Create new logo entry. The id is derived from (manifest, kind, source) by the Rust core.
+ let manifestId = activeManifestId()
+ let logoId = RustCoreFramework.vaultCodecLogoIdFor(manifestId: manifestId, kind: "favicon", source: source)
let logoDataParam = "av-base64-to-blob:\(logoData.base64EncodedString())"
try client.executeUpdate(LogoQueries.insert, params: [
logoId,
source,
+ manifestId,
logoDataParam,
"image/png",
nil,
diff --git a/apps/mobile-app/ios/VaultStoreKit/Enums/AppError.swift b/apps/mobile-app/ios/VaultStoreKit/Enums/AppError.swift
index 7d7e518a4..ffd344ca1 100644
--- a/apps/mobile-app/ios/VaultStoreKit/Enums/AppError.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/Enums/AppError.swift
@@ -12,6 +12,7 @@ public enum AppError: Error {
case serverUnavailable(statusCode: Int)
case networkError(underlyingError: Error)
case timeout
+ case serverError(message: String)
// Version/compatibility errors
case clientVersionNotSupported
@@ -21,6 +22,7 @@ public enum AppError: Error {
// Vault status errors
case vaultMergeRequired
case vaultOutdated
+ case syncVaultFetchFailed(message: String)
// Decryption errors
case vaultDecryptFailed
@@ -41,6 +43,9 @@ public enum AppError: Error {
// Storage errors
case encryptionKeyNotFound
+ case storageReadFailed(message: String)
+ case storageWriteFailed(message: String)
+ case databaseInitFailed(message: String)
case vaultStoreFailed(message: String)
// Merge errors
@@ -56,11 +61,17 @@ public enum AppError: Error {
// Retry errors
case maxRetriesReached
+ case migrationCheckFailed(message: String)
// Generic errors
case unknownError(message: String)
case parseError(message: String)
+ // Sync engine failures that name their cause in the message
+ case syncResponseInvalid(message: String)
+ case syncCodecFailed(message: String)
+ case syncEngineFailed(message: String)
+
/// Get the error code string for React Native bridge
///
/// Error codes use the E-XXX format for easy user reporting:
@@ -88,6 +99,8 @@ public enum AppError: Error {
return "E-202"
case .timeout:
return "E-203"
+ case .serverError:
+ return "E-204"
case .clientVersionNotSupported:
return "E-301"
case .serverVersionNotSupported:
@@ -98,6 +111,8 @@ public enum AppError: Error {
return "E-401"
case .vaultOutdated:
return "E-402"
+ case .syncVaultFetchFailed:
+ return "E-404"
case .vaultDecryptFailed:
return "E-501"
case .encryptionKeyNotFound:
@@ -130,6 +145,12 @@ public enum AppError: Error {
return "E-515"
case .biometricLockout:
return "E-516"
+ case .storageReadFailed:
+ return "E-601"
+ case .storageWriteFailed:
+ return "E-602"
+ case .databaseInitFailed:
+ return "E-603"
case .vaultStoreFailed:
return "E-604"
case .vaultMergeFailed:
@@ -142,10 +163,18 @@ public enum AppError: Error {
return "E-804"
case .maxRetriesReached:
return "E-901"
+ case .migrationCheckFailed:
+ return "E-903"
case .unknownError:
return "E-001"
case .parseError:
return "E-002"
+ case .syncResponseInvalid:
+ return "E-003"
+ case .syncCodecFailed:
+ return "E-004"
+ case .syncEngineFailed:
+ return "E-005"
}
}
@@ -164,6 +193,8 @@ public enum AppError: Error {
return "Network error: \(error.localizedDescription)"
case .timeout:
return "Request timeout"
+ case .serverError(let message):
+ return "Server error: \(message)"
case .clientVersionNotSupported:
return "Client version not supported"
case .serverVersionNotSupported:
@@ -174,6 +205,8 @@ public enum AppError: Error {
return "Vault merge required"
case .vaultOutdated:
return "Vault outdated"
+ case .syncVaultFetchFailed(let message):
+ return "Server vault could not be assembled: \(message)"
case .vaultDecryptFailed:
return "Failed to decrypt vault"
case .encryptionKeyNotFound:
@@ -206,6 +239,12 @@ public enum AppError: Error {
return "No biometrics enrolled on device"
case .biometricLockout:
return "Biometric authentication locked out"
+ case .storageReadFailed(let message):
+ return "Storage read failed: \(message)"
+ case .storageWriteFailed(let message):
+ return "Storage write failed: \(message)"
+ case .databaseInitFailed(let message):
+ return "Database init failed: \(message)"
case .vaultStoreFailed(let message):
return "Failed to store vault: \(message)"
case .vaultMergeFailed(let message):
@@ -218,10 +257,18 @@ public enum AppError: Error {
return "Vault too large for server"
case .maxRetriesReached:
return "Max sync retries reached"
+ case .migrationCheckFailed(let message):
+ return "Migration check failed: \(message)"
case .unknownError(let message):
return "Unknown error: \(message)"
case .parseError(let message):
return "Parse error: \(message)"
+ case .syncResponseInvalid(let message):
+ return "Invalid server response: \(message)"
+ case .syncCodecFailed(let message):
+ return "Vault codec failed: \(message)"
+ case .syncEngineFailed(let message):
+ return "Sync engine failed: \(message)"
}
}
diff --git a/apps/mobile-app/ios/VaultStoreKit/Models/SyncModels.swift b/apps/mobile-app/ios/VaultStoreKit/Models/SyncModels.swift
new file mode 100644
index 000000000..7db834a44
--- /dev/null
+++ b/apps/mobile-app/ios/VaultStoreKit/Models/SyncModels.swift
@@ -0,0 +1,78 @@
+import Foundation
+
+/// The vault's local sync bookkeeping.
+public struct SyncStateResult {
+ public let isDirty: Bool
+ public let mutationSequence: Int
+ public let serverRevision: Int
+ public let isSyncing: Bool
+
+ public init(isDirty: Bool, mutationSequence: Int, serverRevision: Int, isSyncing: Bool) {
+ self.isDirty = isDirty
+ self.mutationSequence = mutationSequence
+ self.serverRevision = serverRevision
+ self.isSyncing = isSyncing
+ }
+}
+
+/// Outcome of a status check: whether the server holds newer state than this device.
+public struct VaultVersionCheckResult {
+ public let isNewVersionAvailable: Bool
+ public let syncState: SyncStateResult
+}
+
+/// What a sync did.
+public enum SyncAction: String {
+ case uploaded = "uploaded"
+ case downloaded = "downloaded"
+ case merged = "merged"
+ case alreadyInSync = "already_in_sync"
+ case error = "error"
+}
+
+/// Result of a full vault sync, the shape the React Native app and the autofill extension act on.
+public struct VaultSyncResult {
+ public let success: Bool
+ public let action: SyncAction
+ public let newRevision: Int
+ public let wasOffline: Bool
+ public let error: String?
+ public let errorMessage: String?
+ public let sqliteBlobUpgradeRequired: Bool
+ public let manifestMigrationRequired: Bool
+
+ public init(
+ success: Bool,
+ action: SyncAction,
+ newRevision: Int,
+ wasOffline: Bool,
+ error: String? = nil,
+ errorMessage: String? = nil,
+ sqliteBlobUpgradeRequired: Bool = false,
+ manifestMigrationRequired: Bool = false
+ ) {
+ self.success = success
+ self.action = action
+ self.newRevision = newRevision
+ self.wasOffline = wasOffline
+ self.error = error
+ self.errorMessage = errorMessage
+ self.sqliteBlobUpgradeRequired = sqliteBlobUpgradeRequired
+ self.manifestMigrationRequired = manifestMigrationRequired
+ }
+}
+
+/// Result of the manifest migration the app's upgrade page drives.
+public struct VaultMigrationResult {
+ public let success: Bool
+ public let pushed: Bool
+ public let error: String?
+ public let errorMessage: String?
+
+ public init(success: Bool, pushed: Bool, error: String? = nil, errorMessage: String? = nil) {
+ self.success = success
+ self.pushed = pushed
+ self.error = error
+ self.errorMessage = errorMessage
+ }
+}
diff --git a/apps/mobile-app/ios/VaultStoreKit/Services/VaultMergeService.swift b/apps/mobile-app/ios/VaultStoreKit/Services/VaultMergeService.swift
deleted file mode 100644
index 307d7d8d1..000000000
--- a/apps/mobile-app/ios/VaultStoreKit/Services/VaultMergeService.swift
+++ /dev/null
@@ -1,434 +0,0 @@
-import Foundation
-import SQLite3
-import CryptoKit
-import RustCoreFramework
-
-/// Service for vault merge operations using the Rust core library.
-/// Wraps UniFFI-generated bindings for LWW merge operations on SQLite vault databases.
-public class VaultMergeService {
- public static let shared = VaultMergeService()
-
- private init() {}
-
- /// Error types for vault merge operations.
- public enum VaultMergeError: Error, LocalizedError {
- case jsonError(String)
- case rustError(String)
- case databaseError(String)
- case invalidInput(String)
- case encryptionError(String)
-
- public var errorDescription: String? {
- switch self {
- case .jsonError(let msg): return "JSON error: \(msg)"
- case .rustError(let msg): return "Rust error: \(msg)"
- case .databaseError(let msg): return "Database error: \(msg)"
- case .invalidInput(let msg): return "Invalid input: \(msg)"
- case .encryptionError(let msg): return "Encryption error: \(msg)"
- }
- }
- }
-
- /// Get the list of syncable table names from Rust.
- public func getTableNames() -> [String] {
- // Calls UniFFI-generated function from aliasvault_core.swift
- return getSyncableTableNames()
- }
-
- /// Merge local and server vaults using LWW strategy.
- ///
- /// - Parameters:
- /// - localVaultBase64: Base64-encoded encrypted local vault (format: base64(encrypted(base64(sqlite))))
- /// - serverVaultBase64: Base64-encoded encrypted server vault (format: base64(encrypted(base64(sqlite))))
- /// - encryptionKey: The encryption key for decrypting vaults
- /// - Returns: Base64-encoded merged vault blob (same format as input)
- public func mergeVaults(
- localVaultBase64: String,
- serverVaultBase64: String,
- encryptionKey: Data
- ) throws -> String {
- // Decrypt both vaults
- // Format is: base64(encrypted(base64(rawSqlite)))
- // Step 1: Decode outer base64 to get encrypted bytes
- guard let localVaultData = Data(base64Encoded: localVaultBase64),
- let serverVaultData = Data(base64Encoded: serverVaultBase64) else {
- print("[VaultMergeService] Failed to decode outer base64")
- throw VaultMergeError.invalidInput("Invalid base64 vault data")
- }
-
- // Step 2: Decrypt to get inner base64 string
- let localDecryptedBase64 = try decrypt(data: localVaultData, using: encryptionKey)
- let serverDecryptedBase64 = try decrypt(data: serverVaultData, using: encryptionKey)
-
- // Step 3: Decode inner base64 to get raw SQLite bytes
- guard let localDecryptedString = String(data: localDecryptedBase64, encoding: .utf8),
- let localDecrypted = Data(base64Encoded: localDecryptedString) else {
- throw VaultMergeError.invalidInput("Invalid inner base64 in local vault")
- }
- guard let serverDecryptedString = String(data: serverDecryptedBase64, encoding: .utf8),
- let serverDecrypted = Data(base64Encoded: serverDecryptedString) else {
- throw VaultMergeError.invalidInput("Invalid inner base64 in server vault")
- }
-
- // Open both SQLite databases
- let localDb = try openDatabase(from: localDecrypted)
- let serverDb = try openDatabase(from: serverDecrypted)
- defer {
- sqlite3_close(localDb)
- sqlite3_close(serverDb)
- }
-
- // Read all syncable tables from both databases
- let tableNames = getTableNames()
- var localTables: [[String: Any]] = []
- var serverTables: [[String: Any]] = []
-
- for tableName in tableNames {
- let localRecords = try readTable(from: localDb, tableName: tableName)
- localTables.append([
- "name": tableName,
- "records": localRecords
- ])
-
- let serverRecords = try readTable(from: serverDb, tableName: tableName)
- serverTables.append([
- "name": tableName,
- "records": serverRecords
- ])
- }
-
- // Create merge input and call Rust
- let mergeInput: [String: Any] = [
- "local_tables": localTables,
- "server_tables": serverTables
- ]
-
- let inputJson = try serializeToJson(mergeInput)
- // Call UniFFI-generated function from aliasvault_core.swift
- let outputJson = try mergeVaultsJson(inputJson: inputJson)
- let output = try parseOutput(outputJson)
-
-
- // Apply SQL statements to the SERVER database (the merge base). The exported server DB carries
- // the newest codec overflow carrier untouched.
- for (index, statement) in output.statements.enumerated() {
- try executeStatement(on: serverDb, sql: statement.sql, params: statement.params)
- }
-
- // Export, encrypt, and return in same format: base64(encrypted(base64(sqlite)))
- let mergedData = try exportDatabase(from: serverDb)
- // Step 1: Base64 encode raw SQLite bytes
- let innerBase64 = mergedData.base64EncodedString()
- // Step 2: Encrypt the base64 string
- let encryptedData = try encrypt(data: Data(innerBase64.utf8), using: encryptionKey)
- // Step 3: Base64 encode the encrypted data
- return encryptedData.base64EncodedString()
- }
-
- /// Prune expired items from trash.
- ///
- /// - Parameters:
- /// - vaultBase64: Base64-encoded encrypted vault (format: base64(encrypted(base64(sqlite))))
- /// - retentionDays: Number of days to keep items in trash (default: 30)
- /// - encryptionKey: The encryption key for decrypting vault
- /// - Returns: Tuple of (prunedVaultBase64, prunedCount) - same format as input
- public func pruneVault(
- vaultBase64: String,
- retentionDays: Int = 30,
- encryptionKey: Data
- ) throws -> (vaultBase64: String, prunedCount: Int) {
- // Decrypt vault: base64(encrypted(base64(sqlite)))
- // Step 1: Decode outer base64 to get encrypted bytes
- guard let vaultData = Data(base64Encoded: vaultBase64) else {
- throw VaultMergeError.invalidInput("Invalid base64 vault data")
- }
-
- // Step 2: Decrypt to get inner base64 string
- let decryptedBase64 = try decrypt(data: vaultData, using: encryptionKey)
-
- // Step 3: Decode inner base64 to get raw SQLite bytes
- guard let decryptedString = String(data: decryptedBase64, encoding: .utf8),
- let decrypted = Data(base64Encoded: decryptedString) else {
- throw VaultMergeError.invalidInput("Invalid inner base64 in vault")
- }
-
- let db = try openDatabase(from: decrypted)
- defer { sqlite3_close(db) }
-
- // Get the per-table SELECT queries clients should run to build `PruneInput`.
- let pruneTableQueries = getPruneTableQueries()
- var tables: [[String: Any]] = []
-
- for entry in pruneTableQueries {
- tables.append([
- "name": entry.name,
- "records": try readQuery(from: db, tableName: entry.name, sql: entry.query)
- ])
- }
-
- // Call Rust prune - use ISO8601 format: YYYY-MM-DDTHH:MM:SS.sssZ
- let dateFormatter = ISO8601DateFormatter()
- dateFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
- let currentTime = dateFormatter.string(from: Date())
-
- let pruneInput: [String: Any] = [
- "tables": tables,
- "retention_days": retentionDays,
- "current_time": currentTime
- ]
-
- let inputJson = try serializeToJson(pruneInput)
- // Call UniFFI-generated function from aliasvault_core.swift
- let outputJson = try pruneVaultJson(inputJson: inputJson)
- let output = try parseOutput(outputJson)
-
- // Apply SQL statements
- for statement in output.statements {
- try executeStatement(on: db, sql: statement.sql, params: statement.params)
- }
-
- // Export, encrypt, and return in same format: base64(encrypted(base64(sqlite)))
- let prunedData = try exportDatabase(from: db)
- // Step 1: Base64 encode raw SQLite bytes
- let innerBase64 = prunedData.base64EncodedString()
- // Step 2: Encrypt the base64 string
- let encryptedData = try encrypt(data: Data(innerBase64.utf8), using: encryptionKey)
- // Step 3: Base64 encode the encrypted data
- return (encryptedData.base64EncodedString(), output.statements.count)
- }
-
- // MARK: - Encryption Helpers
-
- private func encrypt(data: Data, using key: Data) throws -> Data {
- let symmetricKey = SymmetricKey(data: key)
- guard let sealedBox = try? AES.GCM.seal(data, using: symmetricKey),
- let combined = sealedBox.combined else {
- throw VaultMergeError.encryptionError("Encryption failed")
- }
- return combined
- }
-
- private func decrypt(data: Data, using key: Data) throws -> Data {
- let symmetricKey = SymmetricKey(data: key)
- guard let sealedBox = try? AES.GCM.SealedBox(combined: data),
- let decrypted = try? AES.GCM.open(sealedBox, using: symmetricKey) else {
- throw VaultMergeError.encryptionError("Decryption failed")
- }
- return decrypted
- }
-
- // MARK: - Database Helpers
-
- private struct ParsedOutput {
- let statements: [(sql: String, params: [Any])]
- }
-
- private func openDatabase(from data: Data) throws -> OpaquePointer {
- var db: OpaquePointer?
- guard sqlite3_open(":memory:", &db) == SQLITE_OK else {
- throw VaultMergeError.databaseError("Failed to open in-memory database")
- }
-
- let count = Int32(data.count)
- let result = data.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) -> Int32 in
- guard let baseAddress = ptr.baseAddress else { return SQLITE_ERROR }
- let pData = sqlite3_malloc(count)
- memcpy(pData, baseAddress, Int(count))
- return sqlite3_deserialize(
- db,
- "main",
- pData?.assumingMemoryBound(to: UInt8.self),
- Int64(count),
- Int64(count),
- UInt32(SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE)
- )
- }
-
- guard result == SQLITE_OK else {
- sqlite3_close(db)
- print("[VaultMergeService] Failed to deserialize database: \(result)")
- throw VaultMergeError.databaseError("Failed to deserialize database: \(result)")
- }
-
- return db!
- }
-
- private func exportDatabase(from db: OpaquePointer) throws -> Data {
- var size: sqlite3_int64 = 0
- guard let serialized = sqlite3_serialize(db, "main", &size, 0) else {
- throw VaultMergeError.databaseError("Failed to serialize database")
- }
- let data = Data(bytes: serialized, count: Int(size))
- sqlite3_free(serialized)
- return data
- }
-
- private func readTable(from db: OpaquePointer, tableName: String) throws -> [[String: Any]] {
- return try readQuery(from: db, tableName: tableName, sql: "SELECT * FROM \(tableName)")
- }
-
- private func readQuery(from db: OpaquePointer, tableName: String, sql: String) throws -> [[String: Any]] {
- var records: [[String: Any]] = []
-
- // Check if table exists
- let checkSql = "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
- var checkStmt: OpaquePointer?
- let prepareResult = sqlite3_prepare_v2(db, checkSql, -1, &checkStmt, nil)
- guard prepareResult == SQLITE_OK else {
- let errorMsg = String(cString: sqlite3_errmsg(db))
- print("[VaultMergeService] Failed to prepare table check for \(tableName): \(errorMsg) (code: \(prepareResult))")
- return records
- }
- defer { sqlite3_finalize(checkStmt) }
-
- // Use SQLITE_TRANSIENT to ensure SQLite copies the string data
- let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
- sqlite3_bind_text(checkStmt, 1, tableName, -1, sqliteTransient)
-
- let stepResult = sqlite3_step(checkStmt)
- if stepResult != SQLITE_ROW {
- print("[VaultMergeService] Table '\(tableName)' does not exist (step result: \(stepResult))")
- return records
- }
-
- // Read all records
- var stmt: OpaquePointer?
- let selectPrepareResult = sqlite3_prepare_v2(db, sql, -1, &stmt, nil)
- guard selectPrepareResult == SQLITE_OK else {
- let errorMsg = String(cString: sqlite3_errmsg(db))
- print("[VaultMergeService] Failed to prepare SELECT for \(tableName): \(errorMsg) (code: \(selectPrepareResult))")
- throw VaultMergeError.databaseError("Failed to prepare statement for \(tableName): \(errorMsg)")
- }
- defer { sqlite3_finalize(stmt) }
-
- let columnCount = sqlite3_column_count(stmt)
-
- while sqlite3_step(stmt) == SQLITE_ROW {
- var record: [String: Any] = [:]
- for iVal in 0..<columnCount {
- let columnName = String(cString: sqlite3_column_name(stmt, iVal))
- switch sqlite3_column_type(stmt, iVal) {
- case SQLITE_INTEGER:
- record[columnName] = sqlite3_column_int64(stmt, iVal)
- case SQLITE_FLOAT:
- record[columnName] = sqlite3_column_double(stmt, iVal)
- case SQLITE_TEXT:
- if let text = sqlite3_column_text(stmt, iVal) {
- record[columnName] = String(cString: text)
- }
- case SQLITE_BLOB:
- if let blob = sqlite3_column_blob(stmt, iVal) {
- let size = sqlite3_column_bytes(stmt, iVal)
- record[columnName] = Data(bytes: blob, count: Int(size)).base64EncodedString()
- }
- case SQLITE_NULL:
- record[columnName] = NSNull()
- default:
- break
- }
- }
- records.append(record)
- }
-
- return records
- }
-
- private func executeStatement(on db: OpaquePointer, sql: String, params: [Any]) throws {
- var stmt: OpaquePointer?
- guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
- let error = String(cString: sqlite3_errmsg(db))
- throw VaultMergeError.databaseError("Failed to prepare statement: \(error)")
- }
- defer { sqlite3_finalize(stmt) }
-
- // Use SQLITE_TRANSIENT to ensure SQLite copies string data
- let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
-
- for (index, param) in params.enumerated() {
- let bindIndex = Int32(index + 1)
- switch param {
- case let intValue as Int:
- sqlite3_bind_int64(stmt, bindIndex, Int64(intValue))
- case let int64Value as Int64:
- sqlite3_bind_int64(stmt, bindIndex, int64Value)
- case let doubleValue as Double:
- sqlite3_bind_double(stmt, bindIndex, doubleValue)
- case let stringValue as String:
- sqlite3_bind_text(stmt, bindIndex, stringValue, -1, sqliteTransient)
- case is NSNull:
- sqlite3_bind_null(stmt, bindIndex)
- default:
- sqlite3_bind_text(stmt, bindIndex, "\(param)", -1, sqliteTransient)
- }
- }
-
- guard sqlite3_step(stmt) == SQLITE_DONE else {
- let error = String(cString: sqlite3_errmsg(db))
- throw VaultMergeError.databaseError("Failed to execute statement: \(error)")
- }
- }
-
- private func serializeToJson(_ dictionary: [String: Any]) throws -> String {
- let data = try JSONSerialization.data(withJSONObject: dictionary, options: [])
- guard let json = String(data: data, encoding: .utf8) else {
- throw VaultMergeError.jsonError("Failed to convert to UTF-8 string")
- }
- return json
- }
-
- private func parseOutput(_ json: String) throws -> ParsedOutput {
- guard let data = json.data(using: .utf8),
- let rawOutput = try JSONSerialization.jsonObject(with: data) as? [String: Any],
- let statementsArray = rawOutput["statements"] as? [[String: Any]] else {
- throw VaultMergeError.jsonError("Failed to parse output JSON")
- }
-
- let statements = try statementsArray.map { stmt -> (sql: String, params: [Any]) in
- guard let sql = stmt["sql"] as? String,
- let params = stmt["params"] as? [Any] else {
- throw VaultMergeError.jsonError("Invalid statement format")
- }
- return (sql: sql, params: params)
- }
-
- return ParsedOutput(statements: statements)
- }
-
- // MARK: - Debug Helpers
-
- /// Debug record for FieldValue comparison
- private struct DebugFieldValue {
- let id: String
- let itemId: String
- let value: String
- let updatedAt: String
- }
-
- /// Query FieldValues for a specific FieldKey
- private func queryFieldValues(from db: OpaquePointer, fieldKey: String) throws -> [DebugFieldValue] {
- var results: [DebugFieldValue] = []
-
- let sql = "SELECT Id, ItemId, Value, UpdatedAt FROM FieldValues WHERE FieldKey = ? AND IsDeleted = 0 ORDER BY UpdatedAt DESC"
- var stmt: OpaquePointer?
-
- guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
- let error = String(cString: sqlite3_errmsg(db))
- print("[VaultMergeService] Failed to prepare debug query: \(error)")
- return results
- }
- defer { sqlite3_finalize(stmt) }
-
- let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
- sqlite3_bind_text(stmt, 1, fieldKey, -1, sqliteTransient)
-
- while sqlite3_step(stmt) == SQLITE_ROW {
- let id = sqlite3_column_text(stmt, 0).map { String(cString: $0) } ?? ""
- let itemId = sqlite3_column_text(stmt, 1).map { String(cString: $0) } ?? ""
- let value = sqlite3_column_text(stmt, 2).map { String(cString: $0) } ?? ""
- let updatedAt = sqlite3_column_text(stmt, 3).map { String(cString: $0) } ?? ""
- results.append(DebugFieldValue(id: id, itemId: itemId, value: value, updatedAt: updatedAt))
- }
-
- return results
- }
-}
diff --git a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Cache.swift b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Cache.swift
index 916e6b01d..a349a1682 100644
--- a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Cache.swift
+++ b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Cache.swift
@@ -8,6 +8,7 @@ extension VaultStore {
public func clearCache() {
print("Clearing cache - removing encryption key and decrypted database from memory")
self.encryptionKey = nil
+ self.accountPrivateKey = nil
self.dbConnection = nil
clearLastSuccessfulAuth()
}
@@ -21,6 +22,7 @@ extension VaultStore {
// Clear in-memory data only
self.encryptionKey = nil
+ self.accountPrivateKey = nil
self.dbConnection = nil
clearLastSuccessfulAuth()
@@ -58,6 +60,7 @@ extension VaultStore {
self.userDefaults.removeObject(forKey: VaultConstants.authMethodsKey)
self.userDefaults.removeObject(forKey: VaultConstants.autoLockTimeoutKey)
self.userDefaults.removeObject(forKey: VaultConstants.encryptionKeyDerivationParamsKey)
+ self.userDefaults.removeObject(forKey: VaultConstants.accountKeyChainKey)
self.userDefaults.removeObject(forKey: VaultConstants.usernameKey)
self.userDefaults.removeObject(forKey: VaultConstants.offlineModeKey)
self.userDefaults.removeObject(forKey: VaultConstants.pinEnabledKey)
@@ -67,6 +70,7 @@ extension VaultStore {
self.userDefaults.removeObject(forKey: VaultConstants.isDirtyKey)
self.userDefaults.removeObject(forKey: VaultConstants.mutationSequenceKey)
self.userDefaults.removeObject(forKey: VaultConstants.isSyncingKey)
+ VaultSyncEngine.clearPersistedState(in: self.userDefaults)
// Clear WebApiService keys
self.userDefaults.removeObject(forKey: "accessToken")
@@ -77,6 +81,7 @@ extension VaultStore {
// Clear the cache to remove all in-memory data
self.encryptionKey = nil
+ self.accountPrivateKey = nil
self.dbConnection = nil
self.enabledAuthMethods = []
self.autoLockTimeout = VaultConstants.defaultAutoLockTimeout
@@ -84,6 +89,12 @@ extension VaultStore {
clearLastSuccessfulAuth()
}
+ /// Clear engine state.
+ public func clearSyncEngineState() {
+ VaultSyncEngine.clearPersistedState(in: self.userDefaults)
+ storeAccountKeyChain(nil)
+ }
+
/// Set the auto-lock timeout - the number of seconds after which the vault will be locked automatically
public func setAutoLockTimeout(_ timeout: Int) {
print("Setting auto-lock timeout to \(timeout) seconds")