Skip to content

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

Add vault prune logic to Rust core, add recently deleted items to aliasvault.client (#1404)

Leendert de Borst54cf479f6f76
diff --git a/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts b/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts
index 87de0a6e3..44df51999 100644
--- a/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts
+++ b/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts
@@ -597,15 +597,40 @@ export async function handleClearPersistedFormValues(): Promise<void> {
/**
* Upload a new version of the vault to the server using the provided sqlite client.
+ * Prunes expired trash items (older than 30 days) before uploading.
*/
async function uploadNewVaultToServer(sqliteClient: SqliteClient) : Promise<VaultPostResponse> {
- const updatedVaultData = sqliteClient.exportToBase64();
+ let updatedVaultData = sqliteClient.exportToBase64();
const encryptionKey = await handleGetEncryptionKey();
if (!encryptionKey) {
throw new Error(await t('common.errors.vaultIsLocked'));
}
+ /**
+ * Prune expired items from trash before uploading.
+ * Items that have been in trash (DeletedAt set) for more than 30 days
+ * are permanently deleted (IsDeleted = true) as part of the sync process.
+ */
+ try {
+ const { vaultMergeService } = await import('@/utils/VaultMergeService');
+ const pruneResult = await vaultMergeService.prune(updatedVaultData, 30);
+ if (pruneResult.success && pruneResult.statementCount > 0) {
+ console.info(`[VaultSync] Pruned expired items from trash (${pruneResult.statementCount} statements)`);
+ updatedVaultData = pruneResult.prunedVaultBase64;
+
+ /**
+ * Reload the sqlite client with the pruned vault so the UI reflects the change.
+ * Clear the cache to force re-initialization.
+ */
+ cachedSqliteClient = null;
+ cachedVaultBlob = null;
+ await sqliteClient.initializeFromBase64(updatedVaultData);
+ }
+ } catch (pruneError) {
+ console.warn('[VaultSync] Failed to prune vault, continuing with upload:', pruneError);
+ }
+
const encryptedVault = await EncryptionUtility.symmetricEncrypt(
updatedVaultData,
encryptionKey
diff --git a/apps/browser-extension/src/utils/VaultMergeService.ts b/apps/browser-extension/src/utils/VaultMergeService.ts
index ab85747a0..c6b740b53 100644
--- a/apps/browser-extension/src/utils/VaultMergeService.ts
+++ b/apps/browser-extension/src/utils/VaultMergeService.ts
@@ -1,7 +1,7 @@
import initSqlJs, { Database, SqlJsStatic, SqlValue } from 'sql.js';
import { browser } from 'wxt/browser';
-import init, { getSyncableTableNames, mergeVaults } from './dist/core/rust/aliasvault_core.js';
+import init, { getSyncableTableNames, mergeVaults, pruneVault } from './dist/core/rust/aliasvault_core.js';
/**
* Record type for JSON data passed to/from Rust.
@@ -53,6 +53,22 @@ type MergeOutput = {
stats: RustMergeStats;
}
+/**
+ * Input structure for Rust prune function.
+ */
+type PruneInput = {
+ tables: TableData[];
+ retention_days: number;
+}
+
+/**
+ * Output structure from Rust prune function.
+ */
+type PruneOutput = {
+ success: boolean;
+ statements: SqlStatement[];
+}
+
/**
* Result of a merge operation.
*/
@@ -73,6 +89,15 @@ export type MergeStats = {
conflicts: number;
}
+/**
+ * Result of a prune operation.
+ */
+export type PruneResult = {
+ success: boolean;
+ prunedVaultBase64: string;
+ statementCount: number;
+}
+
/**
* Service for merging two vault SQLite databases using Last-Write-Wins (LWW) strategy.
*
@@ -203,6 +228,88 @@ export class VaultMergeService {
}
}
+ /**
+ * Prune expired items from trash in a vault.
+ *
+ * This permanently deletes (sets IsDeleted = true) items that have been in the trash
+ * (DeletedAt set) for longer than the retention period.
+ *
+ * Uses Rust WASM for the prune logic:
+ * 1. Load SQLite database with sql.js
+ * 2. Read relevant tables as JSON
+ * 3. Call Rust prune (returns SQL statements)
+ * 4. Execute SQL statements on database
+ * 5. Export pruned database
+ *
+ * @param vaultBase64 - The vault as base64 SQLite
+ * @param retentionDays - Number of days to keep items in trash (default: 30)
+ * @returns PruneResult with the pruned vault as base64
+ */
+ public async prune(vaultBase64: string, retentionDays: number = 30): Promise<PruneResult> {
+ try {
+ // Initialize Rust WASM
+ await this.initRust();
+
+ // Use injected SQL.js instance or initialize a new one
+ const SQL = this.sqlJsInstance ?? await initSqlJs({
+ /**
+ * Locate the SQL.js WASM file.
+ * @param file - The file name to locate
+ * @returns The path to the file
+ */
+ locateFile: (file: string) => `src/${file}`
+ });
+
+ // Load the database
+ const db = this.loadDatabase(SQL, vaultBase64);
+
+ try {
+ // Tables needed for pruning
+ const tableNames = ['Items', 'FieldValues', 'Attachments', 'TotpCodes', 'Passkeys'];
+
+ // Read tables as JSON
+ const tables: TableData[] = tableNames.map(name => ({
+ name,
+ records: this.readTableAsJson(db, name),
+ }));
+
+ // Call Rust WASM prune
+ const pruneInput: PruneInput = JSON.parse(JSON.stringify({
+ tables,
+ retention_days: retentionDays,
+ })) as PruneInput;
+
+ const pruneOutput = pruneVault(pruneInput) as PruneOutput;
+
+ // Execute SQL statements from Rust on database
+ for (const stmt of pruneOutput.statements) {
+ const sanitizedParams = stmt.params.map(p => p === undefined ? null : p);
+ db.run(stmt.sql, sanitizedParams);
+ }
+
+ // Export the pruned database
+ const prunedVaultBase64 = this.exportDatabase(db);
+ const statementCount = pruneOutput.statements.length;
+
+ if (statementCount > 0) {
+ console.info(`[VaultMerge] Pruned expired items from trash (${statementCount} SQL statements executed)`);
+ }
+
+ return {
+ success: pruneOutput.success,
+ prunedVaultBase64,
+ statementCount,
+ };
+ } finally {
+ // Clean up database
+ db.close();
+ }
+ } catch (error) {
+ console.error('Vault prune failed:', error);
+ throw error;
+ }
+ }
+
/**
* Load a SQLite database from base64 string.
* @param SQL - The SQL.js instance
diff --git a/apps/server/AliasVault.Client/Main/Pages/Items/Delete.razor b/apps/server/AliasVault.Client/Main/Pages/Items/Delete.razor
index 06312b5b4..412af1364 100644
--- a/apps/server/AliasVault.Client/Main/Pages/Items/Delete.razor
+++ b/apps/server/AliasVault.Client/Main/Pages/Items/Delete.razor
@@ -19,8 +19,7 @@
else
{
<div class="mx-4 p-4 mb-4 bg-white border border-gray-200 rounded-lg shadow-sm 2xl:col-span-2 dark:border-gray-700 sm:p-6 dark:bg-gray-800">
- <AlertMessageError HasTopMargin="false" Message="@Localizer["DeleteWarningMessage"]" />
- <h3 class="mt-4 mb-4 text-xl font-semibold dark:text-white">@Localizer["ItemEntrySection"]</h3>
+ <h3 class="mb-4 text-xl font-semibold dark:text-white">@Localizer["ItemEntrySection"]</h3>
<div class="mb-4">
<label class="block mb-2 text-sm font-medium text-gray-900 dark:text-white">@Localizer["IdLabel"]</label>
<div class="text-gray-900 dark:text-white">@Id</div>
@@ -85,16 +84,8 @@ else
return;
}
- GlobalLoadingSpinner.Show(Localizer["DeletingItemMessage"]);
- if (await ItemService.TrashItemAsync(Id))
- {
- GlobalNotificationService.AddSuccessMessage(Localizer["DeleteSuccessMessage"]);
- }
- else {
- GlobalNotificationService.AddErrorMessage(Localizer["DeleteDatabaseError"], true);
- }
-
- GlobalLoadingSpinner.Hide();
+ await ItemService.TrashItemInBackgroundAsync(Id);
+ GlobalNotificationService.AddSuccessMessage(Localizer["DeleteSuccessMessage"]);
NavigationManager.NavigateTo("/items");
}
diff --git a/apps/server/AliasVault.Client/Main/Pages/Items/Home.razor b/apps/server/AliasVault.Client/Main/Pages/Items/Home.razor
index f2b0cdbe7..4356ce622 100644
--- a/apps/server/AliasVault.Client/Main/Pages/Items/Home.razor
+++ b/apps/server/AliasVault.Client/Main/Pages/Items/Home.razor
@@ -89,6 +89,17 @@
<button @onclick="() => SetFilter(ItemFilterType.Attachments)" class="w-full text-left px-4 py-2 text-sm hover:bg-gray-100 dark:hover:bg-gray-600 @(FilterType == ItemFilterType.Attachments ? "bg-orange-50 dark:bg-orange-900/20 text-orange-600 dark:text-orange-400" : "text-gray-700 dark:text-gray-300")">
@Localizer["FilterAttachmentsOption"]
</button>
+
+ <div class="border-t border-gray-200 dark:border-gray-600 my-1"></div>
+
+ @* Recently deleted link *@
+ <button @onclick="NavigateToRecentlyDeleted" class="w-full text-left px-4 py-2 text-sm hover:bg-gray-100 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 flex items-center justify-between">
+ <span>@Localizer["FilterRecentlyDeletedOption"]</span>
+ @if (RecentlyDeletedCount > 0)
+ {
+ <span class="text-gray-400 dark:text-gray-500">@RecentlyDeletedCount</span>
+ }
+ </button>
</div>
</div>
</ClickOutsideHandler>
@@ -342,6 +353,11 @@ else
/// </summary>
private bool ShowEditFolderModalVisible { get; set; }
+ /// <summary>
+ /// Gets or sets the count of recently deleted items.
+ /// </summary>
+ private int RecentlyDeletedCount { get; set; }
+
/// <summary>
/// Gets or sets the search term.
/// </summary>
@@ -586,6 +602,15 @@ else
NavigationManager.NavigateTo("/items");
}
+ /// <summary>
+ /// Navigate to the recently deleted page.
+ /// </summary>
+ private void NavigateToRecentlyDeleted()
+ {
+ ShowFilterDropdown = false;
+ NavigationManager.NavigateTo("/items/recently-deleted");
+ }
+
/// <summary>
/// Show the create folder modal.
/// </summary>
@@ -797,6 +822,10 @@ else
// Load folders
Folders = await FolderService.GetAllWithCountsAsync();
+ // Load recently deleted count
+ var recentlyDeleted = await ItemService.GetRecentlyDeletedAsync();
+ RecentlyDeletedCount = recentlyDeleted.Count;
+
// Pass unsorted list to the view - sorting will be handled by the property
Items = itemListEntries;
IsLoading = false;
diff --git a/apps/server/AliasVault.Client/Main/Pages/Items/RecentlyDeleted.razor b/apps/server/AliasVault.Client/Main/Pages/Items/RecentlyDeleted.razor
new file mode 100644
index 000000000..b9e83d8d9
--- /dev/null
+++ b/apps/server/AliasVault.Client/Main/Pages/Items/RecentlyDeleted.razor
@@ -0,0 +1,263 @@
+@page "/items/recently-deleted"
+@inherits MainBase
+@inject ItemService ItemService
+@using Microsoft.Extensions.Localization
+@using AliasClientDb
+@using AliasClientDb.Models
+@using AliasVault.Client.Main.Components.Items
+
+<LayoutPageTitle>@Localizer["PageTitle"]</LayoutPageTitle>
+
+<PageHeader
+ BreadcrumbItems="@BreadcrumbItems"
+ Title="@Localizer["PageTitle"]"
+ Description="@Localizer["PageDescription"]">
+ <CustomActions>
+ @if (Items.Count > 0)
+ {
+ <button @onclick="ShowEmptyAllModal" class="text-sm text-red-600 dark:text-red-400 hover:text-red-700 dark:hover:text-red-300">
+ @Localizer["EmptyAll"]
+ </button>
+ }
+ </CustomActions>
+</PageHeader>
+
+@if (IsLoading)
+{
+ <LoadingIndicator />
+}
+else
+{
+ <div class="mx-4">
+ @if (Items.Count == 0)
+ {
+ <div class="p-4 mb-4 bg-white border border-gray-200 rounded-lg shadow-sm dark:border-gray-700 dark:bg-gray-800">
+ <div class="text-gray-500 dark:text-gray-400 space-y-2 mb-10">
+ <p>@Localizer["NoItems"]</p>
+ <p class="text-sm">@Localizer["NoItemsDescription"]</p>
+ </div>
+ </div>
+ }
+ else
+ {
+ <div class="p-4 mb-4 bg-white border border-gray-200 rounded-lg shadow-sm dark:border-gray-700 dark:bg-gray-800">
+ <p class="text-sm text-gray-500 dark:text-gray-400 mb-4">
+ @Localizer["Description"]
+ </p>
+
+ <ul class="space-y-2">
+ @foreach (var item in Items)
+ {
+ var daysRemaining = GetDaysRemaining(item.DeletedAt);
+ <li data-testid="recently-deleted-item" class="relative">
+ <div class="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-3">
+ <div class="flex items-start gap-3">
+ <div class="flex-1 min-w-0">
+ <div class="flex items-center gap-2">
+ <ItemIcon
+ ItemType="@(item.ItemType ?? ItemType.Login)"
+ Logo="@item.Logo?.FileData"
+ CardNumber="@ItemService.GetFieldValue(item, FieldKey.CardNumber)"
+ SizeClass="w-6 h-6" />
+ <span data-testid="recently-deleted-item-name" class="font-medium text-gray-900 dark:text-white truncate">
+ @(item.Name ?? Localizer["Untitled"])
+ </span>
+ </div>
+ <div class="text-xs text-gray-500 dark:text-gray-400 mt-1">
+ @if (daysRemaining > 0)
+ {
+ @string.Format(Localizer["DaysRemaining"], daysRemaining)
+ }
+ else
+ {
+ <span class="text-red-500">@Localizer["ExpiringSoon"]</span>
+ }
+ </div>
+ </div>
+
+ <div class="flex items-center gap-2">
+ <button data-testid="restore-button" @onclick="() => RestoreItem(item.Id)" class="px-3 py-1 text-sm bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-400 rounded hover:bg-green-200 dark:hover:bg-green-900/50">
+ @Localizer["Restore"]
+ </button>
+ <button data-testid="permanent-delete-button" @onclick="() => ShowDeleteConfirmation(item.Id)" class="px-3 py-1 text-sm bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-400 rounded hover:bg-red-200 dark:hover:bg-red-900/50">
+ @SharedLocalizer["Delete"]
+ </button>
+ </div>
+ </div>
+ </div>
+ </li>
+ }
+ </ul>
+ </div>
+ }
+ </div>
+}
+
+@* Confirm Delete Modal *@
+@if (ShowDeleteModal)
+{
+ <div class="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50">
+ <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-6 max-w-md w-full mx-4">
+ <h3 class="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+ @Localizer["ConfirmDeleteTitle"]
+ </h3>
+ <p class="text-gray-600 dark:text-gray-400 mb-6">
+ @Localizer["ConfirmDeleteMessage"]
+ </p>
+ <div class="flex justify-end gap-3">
+ <button @onclick="CloseDeleteModal" class="px-4 py-2 text-sm font-medium text-gray-700 bg-gray-100 dark:bg-gray-700 dark:text-gray-300 rounded-lg hover:bg-gray-200 dark:hover:bg-gray-600">
+ @SharedLocalizer["Cancel"]
+ </button>
+ <button data-testid="confirm-delete-button" @onclick="ConfirmDelete" class="px-4 py-2 text-sm font-medium text-white bg-red-600 rounded-lg hover:bg-red-700">
+ @Localizer["DeletePermanently"]
+ </button>
+ </div>
+ </div>
+ </div>
+}
+
+@* Confirm Empty All Modal *@
+@if (ShowEmptyAllModalVisible)
+{
+ <div class="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50">
+ <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-6 max-w-md w-full mx-4">
+ <h3 class="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+ @Localizer["ConfirmEmptyAllTitle"]
+ </h3>
+ <p class="text-gray-600 dark:text-gray-400 mb-6">
+ @string.Format(Localizer["ConfirmEmptyAllMessage"], Items.Count)
+ </p>
+ <div class="flex justify-end gap-3">
+ <button @onclick="CloseEmptyAllModal" class="px-4 py-2 text-sm font-medium text-gray-700 bg-gray-100 dark:bg-gray-700 dark:text-gray-300 rounded-lg hover:bg-gray-200 dark:hover:bg-gray-600">
+ @SharedLocalizer["Cancel"]
+ </button>
+ <button @onclick="ConfirmEmptyAll" class="px-4 py-2 text-sm font-medium text-white bg-red-600 rounded-lg hover:bg-red-700">
+ @Localizer["EmptyAll"]
+ </button>
+ </div>
+ </div>
+ </div>
+}
+
+@code {
+ private IStringLocalizer Localizer => LocalizerFactory.Create("Pages.Main.Items.RecentlyDeleted", "AliasVault.Client");
+
+ private bool IsLoading { get; set; } = true;
+ private List<Item> Items { get; set; } = new();
+ private bool ShowDeleteModal { get; set; }
+ private bool ShowEmptyAllModalVisible { get; set; }
+ private Guid? SelectedItemId { get; set; }
+
+ private const int RetentionDays = 30;
+
+ /// <inheritdoc />
+ protected override async Task OnInitializedAsync()
+ {
+ await base.OnInitializedAsync();
+ BreadcrumbItems.Add(new BreadcrumbItem { Url = "items", DisplayName = SharedLocalizer["Vault"] });
+ BreadcrumbItems.Add(new BreadcrumbItem { DisplayName = Localizer["PageTitle"] });
+ }
+
+ /// <inheritdoc />
+ protected override async Task OnAfterRenderAsync(bool firstRender)
+ {
+ await base.OnAfterRenderAsync(firstRender);
+
+ if (firstRender)
+ {
+ await LoadItemsAsync();
+ }
+ }
+
+ private async Task LoadItemsAsync()
+ {
+ IsLoading = true;
+ StateHasChanged();
+
+ Items = await ItemService.GetRecentlyDeletedAsync();
+
+ IsLoading = false;
+ StateHasChanged();
+ }
+
+ private int GetDaysRemaining(DateTime? deletedAt)
+ {
+ if (deletedAt == null)
+ {
+ return RetentionDays;
+ }
+
+ var expiryDate = deletedAt.Value.AddDays(RetentionDays);
+ var daysRemaining = (expiryDate - DateTime.UtcNow).Days;
+ return Math.Max(0, daysRemaining);
+ }
+
+ private async Task RestoreItem(Guid itemId)
+ {
+ var success = await ItemService.RestoreItemInBackgroundAsync(itemId);
+ if (success)
+ {
+ GlobalNotificationService.AddSuccessMessage(Localizer["RestoreSuccess"]);
+ NavigationManager.NavigateTo("/items");
+ }
+ else
+ {
+ GlobalNotificationService.AddErrorMessage(Localizer["RestoreFailed"], true);
+ }
+ }
+
+ private void ShowDeleteConfirmation(Guid itemId)
+ {
+ SelectedItemId = itemId;
+ ShowDeleteModal = true;
+ StateHasChanged();
+ }
+
+ private void CloseDeleteModal()
+ {
+ ShowDeleteModal = false;
+ SelectedItemId = null;
+ StateHasChanged();
+ }
+
+ private async Task ConfirmDelete()
+ {
+ if (SelectedItemId == null)
+ {
+ return;
+ }
+
+ ShowDeleteModal = false;
+
+ await ItemService.PermanentlyDeleteItemInBackgroundAsync(SelectedItemId.Value);
+ GlobalNotificationService.AddSuccessMessage(Localizer["DeleteSuccess"]);
+
+ SelectedItemId = null;
+ await LoadItemsAsync();
+ }
+
+ private void ShowEmptyAllModal()
+ {
+ ShowEmptyAllModalVisible = true;
+ StateHasChanged();
+ }
+
+ private void CloseEmptyAllModal()
+ {
+ ShowEmptyAllModalVisible = false;
+ StateHasChanged();
+ }
+
+ private async Task ConfirmEmptyAll()
+ {
+ ShowEmptyAllModalVisible = false;
+
+ foreach (var item in Items.ToList())
+ {
+ await ItemService.PermanentlyDeleteItemInBackgroundAsync(item.Id);
+ }
+
+ GlobalNotificationService.AddSuccessMessage(Localizer["EmptyAllSuccess"]);
+ await LoadItemsAsync();
+ }
+}
diff --git a/apps/server/AliasVault.Client/Main/Pages/Test/Test3.razor b/apps/server/AliasVault.Client/Main/Pages/Test/Test3.razor
deleted file mode 100644
index 163c41170..000000000
--- a/apps/server/AliasVault.Client/Main/Pages/Test/Test3.razor
+++ /dev/null
@@ -1,18 +0,0 @@
-@page "/test/cleanup-stats"
-@layout EmptyLayout
-@inherits MainBase
-
-<input type="hidden" id="soft-deleted-credential-count" value="@SoftDeletedCredentialCount" />
-
-@code {
- private int SoftDeletedCredentialCount { get; set; }
-
- /// <inheritdoc />
- protected override async Task OnInitializedAsync()
- {
- await base.OnInitializedAsync();
-
- var context = await DbService.GetDbContextAsync();
- SoftDeletedCredentialCount = await context.Items.CountAsync(i => i.IsDeleted);
- }
-}
diff --git a/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Delete.en.resx b/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Delete.en.resx
index e158b4119..ab066d0a0 100644
--- a/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Delete.en.resx
+++ b/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Delete.en.resx
@@ -32,10 +32,6 @@
<value>You can delete the item below.</value>
<comment>Page description for deleting item</comment>
</data>
- <data name="DeleteWarningMessage">
- <value>Note: removing this item is permanent and cannot be undone.</value>
- <comment>Warning message about permanent deletion</comment>
- </data>
<data name="ItemEntrySection">
<value>Item entry</value>
<comment>Section header for item details</comment>
diff --git a/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Home.en.resx b/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Home.en.resx
index 7ebf42b0f..cb9c02a7e 100644
--- a/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Home.en.resx
+++ b/apps/server/AliasVault.Client/Resources/Pages/Main/Items/Home.en.resx
@@ -58,7 +58,7 @@
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
-
+
<!-- Page Header -->
<data name="PageTitle" xml:space="preserve">
<value>Vault</value>
@@ -68,7 +68,7 @@
<value>Find all of your items below.</value>
<comment>Page description text</comment>
</data>
-
+
<!-- Settings Dropdown -->
<data name="ViewModeLabel" xml:space="preserve">
<value>View Mode</value>
@@ -98,7 +98,7 @@
<value>Alphabetical</value>
<comment>Alphabetical sort option</comment>
</data>
-
+
<!-- Empty State -->
<data name="NoItemsTitle" xml:space="preserve">
<value>No items yet</value>
@@ -132,7 +132,7 @@
<value>Import from KeePass, Bitwarden, Chrome, Firefox...</value>
<comment>Import button text</comment>
</data>
-
+
<!-- Error Messages -->
<data name="FailedToLoadItemsMessage" xml:space="preserve">
<value>Failed to load items.</value>
@@ -164,6 +164,10 @@
<value>Attachments</value>
<comment>Filter option to show only items with attachments</comment>
</data>
+ <data name="FilterRecentlyDeletedOption" xml:space="preserve">
+ <value>Recently Deleted</value>
+ <comment>Filter option to show recently deleted items</comment>
+ </data>
<!-- Filtered Empty States -->
<data name="NoPasskeysFound" xml:space="preserve">
diff --git a/apps/server/AliasVault.Client/Resources/Pages/Main/Items/RecentlyDeleted.en.resx b/apps/server/AliasVault.Client/Resources/Pages/Main/Items/RecentlyDeleted.en.resx
new file mode 100644
index 000000000..1c0101d93
--- /dev/null
+++ b/apps/server/AliasVault.Client/Resources/Pages/Main/Items/RecentlyDeleted.en.resx
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+ <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+ <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+ <xsd:element name="root" msdata:IsDataSet="true">
+ <xsd:complexType>
+ <xsd:choice maxOccurs="unbounded">
+ <xsd:element name="metadata">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" />
+ </xsd:sequence>
+ <xsd:attribute name="name" use="required" type="xsd:string" />
+ <xsd:attribute name="type" type="xsd:string" />
+ <xsd:attribute name="mimetype" type="xsd:string" />
+ <xsd:attribute ref="xml:space" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="assembly">
+ <xsd:complexType>
+ <xsd:attribute name="alias" type="xsd:string" />
+ <xsd:attribute name="name" type="xsd:string" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="data">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+ <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+ </xsd:sequence>
+ <xsd:attribute name="name" use="required" type="xsd:string" />
+ <xsd:attribute name="type" type="xsd:string" />
+ <xsd:attribute name="mimetype" type="xsd:string" />
+ <xsd:attribute ref="xml:space" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="resheader">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+ </xsd:sequence>
+ <xsd:attribute name="name" use="required" type="xsd:string" />
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:choice>
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:schema>
+ <resheader name="resmimetype">
+ <value>text/microsoft-resx</value>
+ </resheader>
+ <resheader name="version">
+ <value>2.0</value>
+ </resheader>
+ <resheader name="reader">
+ <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+ </resheader>
+ <resheader name="writer">
+ <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+ </resheader>
+
+ <!-- Page Header -->
+ <data name="PageTitle" xml:space="preserve">
+ <value>Recently Deleted</value>
+ <comment>Page title for recently deleted items</comment>
+ </data>
+ <data name="PageDescription" xml:space="preserve">
+ <value>Items that have been deleted can be restored within 30 days.</value>
+ <comment>Page description text</comment>
+ </data>
+ <data name="Description" xml:space="preserve">
+ <value>Items below will be permanently deleted after 30 days. You can restore or permanently delete them sooner.</value>
+ <comment>Description text explaining 30-day retention</comment>
+ </data>
+
+ <!-- Empty State -->
+ <data name="NoItems" xml:space="preserve">
+ <value>No recently deleted items</value>
+ <comment>Title when no deleted items exist</comment>
+ </data>
+ <data name="NoItemsDescription" xml:space="preserve">
+ <value>Items you delete will appear here for 30 days before being permanently removed.</value>
+ <comment>Description when no deleted items exist</comment>
+ </data>
+ <data name="Untitled" xml:space="preserve">
+ <value>Untitled</value>
+ <comment>Fallback name for items without a name</comment>
+ </data>
+
+ <!-- Days Remaining -->
+ <data name="DaysRemaining" xml:space="preserve">
+ <value>Permanently deleted in {0} days</value>
+ <comment>Text showing how many days until permanent deletion</comment>
+ </data>
+ <data name="ExpiringSoon" xml:space="preserve">
+ <value>Expiring soon</value>
+ <comment>Text shown when item will be deleted within 24 hours</comment>
+ </data>
+
+ <!-- Actions -->
+ <data name="Restore" xml:space="preserve">
+ <value>Restore</value>
+ <comment>Button text to restore a deleted item</comment>
+ </data>
+ <data name="EmptyAll" xml:space="preserve">
+ <value>Empty trash</value>
+ <comment>Button text to permanently delete all items</comment>
+ </data>
+
+ <!-- Confirm Delete Modal -->
+ <data name="ConfirmDeleteTitle" xml:space="preserve">
+ <value>Permanently delete item?</value>
+ <comment>Title for delete confirmation modal</comment>
+ </data>
+ <data name="ConfirmDeleteMessage" xml:space="preserve">
+ <value>This action cannot be undone. The item will be permanently removed from your vault.</value>
+ <comment>Message in delete confirmation modal</comment>
+ </data>
+ <data name="DeletePermanently" xml:space="preserve">
+ <value>Delete permanently</value>
+ <comment>Button text to confirm permanent deletion</comment>
+ </data>
+
+ <!-- Confirm Empty All Modal -->
+ <data name="ConfirmEmptyAllTitle" xml:space="preserve">
+ <value>Empty trash?</value>
+ <comment>Title for empty all confirmation modal</comment>
+ </data>
+ <data name="ConfirmEmptyAllMessage" xml:space="preserve">
+ <value>This will permanently delete {0} item(s). This action cannot be undone.</value>
+ <comment>Message in empty all confirmation modal</comment>
+ </data>
+
+ <!-- Status Messages -->
+ <data name="Restoring" xml:space="preserve">
+ <value>Restoring item...</value>
+ <comment>Loading message while restoring</comment>
+ </data>
+ <data name="RestoreSuccess" xml:space="preserve">
+ <value>Item restored successfully.</value>
+ <comment>Success message after restore</comment>
+ </data>
+ <data name="RestoreFailed" xml:space="preserve">
+ <value>Failed to restore item.</value>
+ <comment>Error message when restore fails</comment>
+ </data>
+ <data name="Deleting" xml:space="preserve">
+ <value>Deleting item...</value>
+ <comment>Loading message while deleting</comment>
+ </data>
+ <data name="DeleteSuccess" xml:space="preserve">
+ <value>Item permanently deleted.</value>
+ <comment>Success message after permanent deletion</comment>
+ </data>
+ <data name="DeleteFailed" xml:space="preserve">
+ <value>Failed to delete item.</value>
+ <comment>Error message when deletion fails</comment>
+ </data>
+ <data name="EmptyAllSuccess" xml:space="preserve">
+ <value>All items permanently deleted.</value>
+ <comment>Success message after emptying trash</comment>
+ </data>
+ <data name="EmptyAllPartialFailed" xml:space="preserve">
+ <value>Failed to delete {0} item(s).</value>
+ <comment>Error message when some deletions fail</comment>
+ </data>
+</root>
diff --git a/apps/server/AliasVault.Client/Services/Database/DbService.cs b/apps/server/AliasVault.Client/Services/Database/DbService.cs
index 9d30edf68..02d7143be 100644
--- a/apps/server/AliasVault.Client/Services/Database/DbService.cs
+++ b/apps/server/AliasVault.Client/Services/Database/DbService.cs
@@ -168,6 +168,9 @@ public sealed class DbService : IDisposable
_state.UpdateState(DbServiceState.DatabaseStatus.SavingToServer);
}
+ // Prune expired items from trash before saving.
+ await PruneExpiredTrashItemsAsync();
+
// Make sure a public/private RSA encryption key exists before saving the database.
await GetOrCreateEncryptionKeyAsync();
@@ -208,6 +211,9 @@ public sealed class DbService : IDisposable
{
try
{
+ // Prune expired items from trash before saving.
+ await PruneExpiredTrashItemsAsync();
+
// Make sure a public/private RSA encryption key exists before saving the database.
await GetOrCreateEncryptionKeyAsync();
@@ -641,6 +647,24 @@ public sealed class DbService : IDisposable
};
}
+ /// <summary>
+ /// Replace first occurrence of a string.
+ /// </summary>
+ /// <param name="text">The text to search in.</param>
+ /// <param name="search">The string to search for.</param>
+ /// <param name="replace">The replacement string.</param>
+ /// <returns>The modified string.</returns>
+ private static string ReplaceFirst(string text, string search, string replace)
+ {
+ int pos = text.IndexOf(search, StringComparison.Ordinal);
+ if (pos < 0)
+ {
+ return text;
+ }
+
+ return text[..pos] + replace + text[(pos + search.Length)..];
+ }
+
/// <summary>
/// Fetches the latest vault from server, merges with local changes using Rust WASM, and saves the merged result.
/// Called when server responds with "Outdated" status, indicating another client has uploaded a newer vault.
@@ -817,9 +841,6 @@ public sealed class DbService : IDisposable
return false;
}
- // Check if any soft-deleted records exist that are older than 7 days. If so, permanently delete them.
- await VaultCleanupSoftDeletedRecords();
-
_isSuccessfullyInitialized = true;
await _settingsService.InitializeAsync(this);
_state.UpdateState(DbServiceState.DatabaseStatus.Ready);
@@ -878,6 +899,62 @@ public sealed class DbService : IDisposable
}
}
+ /// <summary>
+ /// Prunes expired items from the trash.
+ /// Items that have been in trash (DeletedAt set) for longer than 30 days
+ /// are permanently deleted (IsDeleted = true).
+ /// </summary>
+ /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+ private async Task PruneExpiredTrashItemsAsync()
+ {
+ try
+ {
+ // Read table data for prune operation
+ var tableNames = new[] { "Items", "FieldValues", "Attachments", "TotpCodes", "Passkeys" };
+ var tables = await ReadTablesAsJsonAsync(_sqlConnection!, tableNames);
+
+ var pruneInput = new JsInterop.RustCore.PruneInput
+ {
+ Tables = tables,
+ RetentionDays = 30,
+ };
+
+ var pruneOutput = await _rustCore.PruneVaultAsync(pruneInput);
+
+ if (pruneOutput.Success && pruneOutput.Statements.Count > 0)
+ {
+ _logger.LogInformation("Pruning {StatementCount} expired items from trash.", pruneOutput.Statements.Count);
+
+ // Execute the SQL statements returned by Rust
+ foreach (var stmt in pruneOutput.Statements)
+ {
+ await using var command = _sqlConnection!.CreateCommand();
+ command.CommandText = stmt.Sql;
+
+ for (int i = 0; i < stmt.Params.Count; i++)
+ {
+ var param = stmt.Params[i];
+ command.Parameters.AddWithValue($"@p{i}", param?.ToString() ?? (object)DBNull.Value);
+ }
+
+ // Replace ? placeholders with @p0, @p1, etc.
+ var parameterizedSql = stmt.Sql;
+ for (int i = 0; i < stmt.Params.Count; i++)
+ {
+ parameterizedSql = ReplaceFirst(parameterizedSql, "?", $"@p{i}");
+ }
+
+ command.CommandText = parameterizedSql;
+ await command.ExecuteNonQueryAsync();
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ _logger.LogWarning(ex, "Failed to prune expired trash items. Continuing with save.");
+ }
+ }
+
/// <summary>
/// Get the default public/private encryption key, if it does not yet exist, create it.
/// </summary>
@@ -906,50 +983,6 @@ public sealed class DbService : IDisposable
return encryptionKey;
}
- /// <summary>
- /// Check if any soft-deleted records exist that are older than 7 days. If so, permanently delete them.
- /// </summary>
- /// <returns>Task.</returns>
- private async Task VaultCleanupSoftDeletedRecords()
- {
- var cutoffDate = DateTime.UtcNow.AddDays(-7);
- var deleteCount = 0;
-
- // Hard delete soft-deleted Items older than 7 days
- deleteCount += await _dbContext.Items
- .Where(i => i.IsDeleted && i.UpdatedAt <= cutoffDate)
- .ExecuteDeleteAsync();
-
- // Hard delete soft-deleted FieldValues older than 7 days
- deleteCount += await _dbContext.FieldValues
- .Where(fv => fv.IsDeleted && fv.UpdatedAt <= cutoffDate)
- .ExecuteDeleteAsync();
-
- // Hard delete soft-deleted Passkeys older than 7 days
- deleteCount += await _dbContext.Passkeys
- .Where(p => p.IsDeleted && p.UpdatedAt <= cutoffDate)
- .ExecuteDeleteAsync();
-
- // Hard delete soft-deleted Attachments older than 7 days
- deleteCount += await _dbContext.Attachments
- .Where(a => a.IsDeleted && a.UpdatedAt <= cutoffDate)
- .ExecuteDeleteAsync();
-
- // Hard delete soft-deleted TotpCodes older than 7 days
- deleteCount += await _dbContext.TotpCodes
- .Where(t => t.IsDeleted && t.UpdatedAt <= cutoffDate)
- .ExecuteDeleteAsync();
-
- if (deleteCount > 0)
- {
- var success = await SaveDatabaseAsync();
- if (!success)
- {
- throw new DataException("Error saving database to server after record deletion.");
- }
- }
- }
-
/// <summary>
/// Reads all specified tables from a SQLite connection as JSON data for the Rust merge.
/// </summary>
diff --git a/apps/server/AliasVault.Client/Services/ItemService.cs b/apps/server/AliasVault.Client/Services/ItemService.cs
index d979bbb01..57f301c17 100644
--- a/apps/server/AliasVault.Client/Services/ItemService.cs
+++ b/apps/server/AliasVault.Client/Services/ItemService.cs
@@ -273,6 +273,9 @@ public sealed class ItemService(HttpClient httpClient, DbService dbService, Conf
var updateDateTime = DateTime.UtcNow;
+ // Check if item type has changed
+ var typeChanged = existingItem.ItemType != item.ItemType;
+
// Update basic item info
existingItem.Name = item.Name;
existingItem.ItemType = item.ItemType;
@@ -280,6 +283,12 @@ public sealed class ItemService(HttpClient httpClient, DbService dbService, Conf
existingItem.FolderId = item.FolderId;
existingItem.UpdatedAt = updateDateTime;
+ // Clear inapplicable fields/relations when type changes
+ if (typeChanged && item.ItemType != null)
+ {
+ ClearInapplicableData(context, existingItem, item.ItemType, updateDateTime);
+ }
+
// Update field values
UpdateFieldValues(context, existingItem, item, updateDateTime);
@@ -413,6 +422,110 @@ public sealed class ItemService(HttpClient httpClient, DbService dbService, Conf
return await dbService.SaveDatabaseAsync();
}
+ /// <summary>
+ /// Soft deletes an existing item from database by moving it to trash.
+ /// Syncs to server in the background without blocking the UI.
+ /// </summary>
+ /// <param name="id">Id of item to delete.</param>
+ /// <returns>Task that completes after local mutation.</returns>
+ public async Task TrashItemInBackgroundAsync(Guid id)
+ {
+ var context = await dbService.GetDbContextAsync();
+
+ var item = await context.Items
+ .Include(x => x.Passkeys)
+ .Where(x => x.Id == id)
+ .FirstAsync();
+
+ var deleteDateTime = DateTime.UtcNow;
+
+ // Move to trash (soft delete)
+ item.DeletedAt = deleteDateTime;
+ item.UpdatedAt = deleteDateTime;
+
+ // Save locally and sync to server in background
+ await context.SaveChangesAsync();
+ dbService.SaveDatabaseInBackground();
+ }
+
+ /// <summary>
+ /// Restores an item from the trash (clears DeletedAt).
+ /// </summary>
+ /// <param name="id">Id of item to restore.</param>
+ /// <returns>Bool which indicates if restoration was successful.</returns>
+ public async Task<bool> RestoreItemAsync(Guid id)
+ {
+ var context = await dbService.GetDbContextAsync();
+
+ var item = await context.Items
+ .Where(x => x.Id == id && x.DeletedAt != null && !x.IsDeleted)
+ .FirstOrDefaultAsync();
+
+ if (item == null)
+ {
+ return false;
+ }
+
+ var restoreDateTime = DateTime.UtcNow;
+
+ // Restore from trash (clear DeletedAt)
+ item.DeletedAt = null;
+ item.UpdatedAt = restoreDateTime;
+
+ return await dbService.SaveDatabaseAsync();
+ }
+
+ /// <summary>
+ /// Restores an item from the trash (clears DeletedAt).
+ /// Syncs to server in the background without blocking the UI.
+ /// </summary>
+ /// <param name="id">Id of item to restore.</param>
+ /// <returns>True if item was found and restored locally, false if not found.</returns>
+ public async Task<bool> RestoreItemInBackgroundAsync(Guid id)
+ {
+ var context = await dbService.GetDbContextAsync();
+
+ var item = await context.Items
+ .Where(x => x.Id == id && x.DeletedAt != null && !x.IsDeleted)
+ .FirstOrDefaultAsync();
+
+ if (item == null)
+ {
+ return false;
+ }
+
+ var restoreDateTime = DateTime.UtcNow;
+
+ // Restore from trash (clear DeletedAt)
+ item.DeletedAt = null;
+ item.UpdatedAt = restoreDateTime;
+
+ // Save locally and sync to server in background
+ await context.SaveChangesAsync();
+ dbService.SaveDatabaseInBackground();
+ return true;
+ }
+
+ /// <summary>
+ /// Gets all items that are in the trash (DeletedAt is set but IsDeleted is false).
+ /// </summary>
+ /// <returns>List of trashed items.</returns>
+ public async Task<List<Item>> GetRecentlyDeletedAsync()
+ {
+ var context = await dbService.GetDbContextAsync();
+
+ var items = await context.Items
+ .Include(x => x.FieldValues.Where(fv => !fv.IsDeleted))
+ .ThenInclude(fv => fv.FieldDefinition)
+ .Include(x => x.Logo)
+ .AsSplitQuery()
+ .Where(x => !x.IsDeleted && x.DeletedAt != null)
+ .OrderByDescending(x => x.DeletedAt)
+ .ToListAsync();
+
+ return items;
+ }
+
/// <summary>
/// Permanently deletes an item (sets IsDeleted = true).
/// </summary>
@@ -463,6 +576,59 @@ public sealed class ItemService(HttpClient httpClient, DbService dbService, Conf
return await dbService.SaveDatabaseAsync();
}
+ /// <summary>
+ /// Permanently deletes an item (sets IsDeleted = true).
+ /// Syncs to server in the background without blocking the UI.
+ /// </summary>
+ /// <param name="id">Id of item to permanently delete.</param>
+ /// <returns>Task that completes after local mutation.</returns>
+ public async Task PermanentlyDeleteItemInBackgroundAsync(Guid id)
+ {
+ var context = await dbService.GetDbContextAsync();
+
+ var item = await context.Items
+ .Include(x => x.FieldValues)
+ .Include(x => x.Passkeys)
+ .Include(x => x.Attachments)
+ .Include(x => x.TotpCodes)
+ .Where(x => x.Id == id)
+ .FirstAsync();
+
+ var deleteDateTime = DateTime.UtcNow;
+
+ // Mark item and all related entities as deleted
+ item.IsDeleted = true;
+ item.UpdatedAt = deleteDateTime;
+
+ foreach (var fv in item.FieldValues)
+ {
+ fv.IsDeleted = true;
+ fv.UpdatedAt = deleteDateTime;
+ }
+
+ foreach (var passkey in item.Passkeys)
+ {
+ passkey.IsDeleted = true;
+ passkey.UpdatedAt = deleteDateTime;
+ }
+
+ foreach (var attachment in item.Attachments)
+ {
+ attachment.IsDeleted = true;
+ attachment.UpdatedAt = deleteDateTime;
+ }
+
+ foreach (var totp in item.TotpCodes)
+ {
+ totp.IsDeleted = true;
+ totp.UpdatedAt = deleteDateTime;
+ }
+
+ // Save locally and sync to server in background
+ await context.SaveChangesAsync();
+ dbService.SaveDatabaseInBackground();
+ }
+
/// <summary>
/// Hard delete all items from the database. This permanently removes all item records
/// (including soft-deleted ones) from the database for a complete vault reset.
@@ -735,6 +901,116 @@ public sealed class ItemService(HttpClient httpClient, DbService dbService, Conf
}
}
+ /// <summary>
+ /// Clears data that is not applicable to the new item type.
+ /// Called when an item's type changes (e.g., Login to Note).
+ /// </summary>
+ /// <param name="context">The database context.</param>
+ /// <param name="item">The item to clear data from.</param>
+ /// <param name="newType">The new item type.</param>
+ /// <param name="updateDateTime">The timestamp for updates.</param>
+ private static void ClearInapplicableData(AliasClientDbContext context, Item item, string newType, DateTime updateDateTime)
+ {
+ // Define field keys by category
+ var loginFieldKeys = new[]
+ {
+ FieldKey.LoginUsername,
+ FieldKey.LoginPassword,
+ FieldKey.LoginEmail,
+ FieldKey.LoginUrl,
+ };
+
+ var aliasFieldKeys = new[]
+ {
+ FieldKey.AliasFirstName,
+ FieldKey.AliasLastName,
+ FieldKey.AliasGender,
+ FieldKey.AliasBirthdate,
+ };
+
+ var cardFieldKeys = new[]
+ {
+ FieldKey.CardNumber,
+ FieldKey.CardCardholderName,
+ FieldKey.CardExpiryMonth,
+ FieldKey.CardExpiryYear,
+ FieldKey.CardCvv,
+ FieldKey.CardPin,
+ };
+
+ // Determine what to clear based on new type
+ var fieldKeysToClear = new List<string>();
+
+ switch (newType)
+ {
+ case ItemType.Note:
+ // Note only has notes.content - clear everything else
+ fieldKeysToClear.AddRange(loginFieldKeys);
+ fieldKeysToClear.AddRange(aliasFieldKeys);
+ fieldKeysToClear.AddRange(cardFieldKeys);
+
+ // Clear logo reference for Notes
+ item.LogoId = null;
+
+ // Soft-delete all TOTP codes for Notes
+ foreach (var totp in item.TotpCodes.Where(t => !t.IsDeleted))
+ {
+ totp.IsDeleted = true;
+ totp.UpdatedAt = updateDateTime;
+ }
+
+ // Soft-delete all passkeys for Notes
+ foreach (var passkey in item.Passkeys.Where(p => !p.IsDeleted))
+ {
+ passkey.IsDeleted = true;
+ passkey.UpdatedAt = updateDateTime;
+ }
+
+ break;
+
+ case ItemType.CreditCard:
+ // Credit card keeps card fields and notes - clear login/alias fields
+ fieldKeysToClear.AddRange(loginFieldKeys);
+ fieldKeysToClear.AddRange(aliasFieldKeys);
+
+ // Clear logo reference for CreditCards (uses brand detection icon)
+ item.LogoId = null;
+
+ // Soft-delete all TOTP codes for CreditCards
+ foreach (var totp in item.TotpCodes.Where(t => !t.IsDeleted))
+ {
+ totp.IsDeleted = true;
+ totp.UpdatedAt = updateDateTime;
+ }
+
+ // Soft-delete all passkeys for CreditCards
+ foreach (var passkey in item.Passkeys.Where(p => !p.IsDeleted))
+ {
+ passkey.IsDeleted = true;
+ passkey.UpdatedAt = updateDateTime;
+ }
+
+ break;
+
+ case ItemType.Login:
+ case ItemType.Alias:
+ // Login/Alias can have everything except card fields
+ fieldKeysToClear.AddRange(cardFieldKeys);
+ break;
+ }
+
+ // Soft-delete the inapplicable field values
+ foreach (var fieldKey in fieldKeysToClear)
+ {
+ var fieldValue = item.FieldValues.FirstOrDefault(fv => fv.FieldKey == fieldKey && !fv.IsDeleted);
+ if (fieldValue != null)
+ {
+ fieldValue.IsDeleted = true;
+ fieldValue.UpdatedAt = updateDateTime;
+ }
+ }
+ }
+
/// <summary>
/// Update the attachments for an item.
/// </summary>
diff --git a/apps/server/AliasVault.Client/Services/JsInterop/RustCore/PruneInput.cs b/apps/server/AliasVault.Client/Services/JsInterop/RustCore/PruneInput.cs
new file mode 100644
index 000000000..c53415092
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/JsInterop/RustCore/PruneInput.cs
@@ -0,0 +1,24 @@
+//-----------------------------------------------------------------------
+// <copyright file="PruneInput.cs" company="aliasvault">
+// Copyright (c) aliasvault. All rights reserved.
+// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace AliasVault.Client.Services.JsInterop.RustCore;
+
+/// <summary>
+/// Input structure for vault prune operation.
+/// </summary>
+public class PruneInput
+{
+ /// <summary>
+ /// Gets or sets the table data to prune.
+ /// </summary>
+ public List<TableData> Tables { get; set; } = new();
+
+ /// <summary>
+ /// Gets or sets the retention period in days (items older than this in trash will be pruned).
+ /// </summary>
+ public int RetentionDays { get; set; } = 30;
+}
diff --git a/apps/server/AliasVault.Client/Services/JsInterop/RustCore/PruneOutput.cs b/apps/server/AliasVault.Client/Services/JsInterop/RustCore/PruneOutput.cs
new file mode 100644
index 000000000..e0f72ec11
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/JsInterop/RustCore/PruneOutput.cs
@@ -0,0 +1,29 @@
+//-----------------------------------------------------------------------
+// <copyright file="PruneOutput.cs" company="aliasvault">
+// Copyright (c) aliasvault. All rights reserved.
+// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace AliasVault.Client.Services.JsInterop.RustCore;
+
+/// <summary>
+/// Output structure from vault prune operation.
+/// </summary>
+public class PruneOutput
+{
+ /// <summary>
+ /// Gets or sets a value indicating whether the prune operation was successful.
+ /// </summary>
+ public bool Success { get; set; }
+
+ /// <summary>
+ /// Gets or sets the SQL statements to execute on the local database.
+ /// </summary>
+ public List<SqlStatement> Statements { get; set; } = new();
+
+ /// <summary>
+ /// Gets or sets the error message if prune failed.
+ /// </summary>
+ public string? Error { get; set; }
+}
diff --git a/apps/server/AliasVault.Client/Services/JsInterop/RustCore/RustCoreService.cs b/apps/server/AliasVault.Client/Services/JsInterop/RustCore/RustCoreService.cs
index a9578b3f8..13664c07e 100644
--- a/apps/server/AliasVault.Client/Services/JsInterop/RustCore/RustCoreService.cs
+++ b/apps/server/AliasVault.Client/Services/JsInterop/RustCore/RustCoreService.cs
@@ -149,6 +149,44 @@ public class RustCoreService : IAsyncDisposable
}
}
+ /// <summary>
+ /// Prune expired items from trash.
+ /// Items that have been in trash (DeletedAt set) for longer than retentionDays
+ /// are permanently deleted (IsDeleted = true).
+ /// </summary>
+ /// <param name="input">The prune input containing table data and retention period.</param>
+ /// <returns>The prune output with SQL statements to execute.</returns>
+ /// <exception cref="InvalidOperationException">Thrown if prune fails or WASM module is unavailable.</exception>
+ public async Task<PruneOutput> PruneVaultAsync(PruneInput input)
+ {
+ // Wait for WASM to be available with retries, as it may still be loading.
+ if (!await WaitForAvailabilityAsync())
+ {
+ throw new InvalidOperationException("Rust WASM module is not available.");
+ }
+
+ var inputJson = JsonSerializer.Serialize(input, JsonOptions);
+ var resultJson = await jsRuntime.InvokeAsync<string>("rustCorePruneVault", inputJson);
+
+ if (string.IsNullOrEmpty(resultJson))
+ {
+ throw new InvalidOperationException("Prune operation returned empty result.");
+ }
+
+ var result = JsonSerializer.Deserialize<PruneOutput>(resultJson, JsonOptions);
+ if (result == null)
+ {
+ throw new InvalidOperationException("Failed to deserialize prune result.");
+ }
+
+ if (!result.Success && !string.IsNullOrEmpty(result.Error))
+ {
+ throw new InvalidOperationException($"Prune failed: {result.Error}");
+ }
+
+ return result;
+ }
+
/// <summary>
/// Extract domain from URL.
/// </summary>
diff --git a/apps/server/AliasVault.Client/wwwroot/css/tailwind.css b/apps/server/AliasVault.Client/wwwroot/css/tailwind.css
index cc6ad28e7..86853339d 100644
--- a/apps/server/AliasVault.Client/wwwroot/css/tailwind.css
+++ b/apps/server/AliasVault.Client/wwwroot/css/tailwind.css
@@ -924,6 +924,10 @@ video {
margin-top: 2rem;
}
+.mb-10 {
+ margin-bottom: 2.5rem;
+}
+
.block {
display: block;
}
@@ -2472,6 +2476,11 @@ video {
color: rgb(133 77 14 / var(--tw-text-opacity));
}
+.text-green-700 {
+ --tw-text-opacity: 1;
+ color: rgb(21 128 61 / var(--tw-text-opacity));
+}
+
.underline {
text-decoration-line: underline;
}
@@ -2814,6 +2823,16 @@ video {
background-color: rgb(255 224 150 / var(--tw-bg-opacity));
}
+.hover\:bg-green-200:hover {
+ --tw-bg-opacity: 1;
+ background-color: rgb(187 247 208 / var(--tw-bg-opacity));
+}
+
+.hover\:bg-red-200:hover {
+ --tw-bg-opacity: 1;
+ background-color: rgb(254 202 202 / var(--tw-bg-opacity));
+}
+
.hover\:from-primary-600:hover {
--tw-gradient-from: #d68338 var(--tw-gradient-from-position);
--tw-gradient-to: rgb(214 131 56 / 0) var(--tw-gradient-to-position);
@@ -3346,6 +3365,10 @@ video {
background-color: rgb(113 63 18 / 0.2);
}
+.dark\:bg-green-900\/30:is(.dark *) {
+ background-color: rgb(20 83 45 / 0.3);
+}
+
.dark\:bg-opacity-75:is(.dark *) {
--tw-bg-opacity: 0.75;
}
@@ -3662,6 +3685,14 @@ video {
background-color: rgb(123 74 30 / 0.2);
}
+.dark\:hover\:bg-green-900\/50:hover:is(.dark *) {
+ background-color: rgb(20 83 45 / 0.5);
+}
+
+.dark\:hover\:bg-red-900\/50:hover:is(.dark *) {
+ background-color: rgb(127 29 29 / 0.5);
+}
+
.dark\:hover\:from-primary-500:hover:is(.dark *) {
--tw-gradient-from: #f49541 var(--tw-gradient-from-position);
--tw-gradient-to: rgb(244 149 65 / 0) var(--tw-gradient-to-position);
diff --git a/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js b/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
index af68cd734..00fdecb4b 100644
--- a/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
+++ b/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
@@ -199,3 +199,34 @@ window.rustCoreExtractRootDomain = async function(domain) {
return '';
}
};
+
+/**
+ * Prune expired items from trash.
+ * Items that have been in trash (DeletedAt set) for longer than the retention period
+ * are permanently deleted (IsDeleted = true).
+ * @param {string} inputJson - JSON string containing PruneInput.
+ * @returns {Promise<string>} JSON string containing PruneOutput.
+ */
+window.rustCorePruneVault = async function(inputJson) {
+ if (!await initRustCore()) {
+ return JSON.stringify({
+ success: false,
+ error: 'Rust WASM module not available',
+ statements: [],
+ stats: {}
+ });
+ }
+
+ try {
+ const result = wasmModule.pruneVaultJson(inputJson);
+ return result;
+ } catch (error) {
+ console.error('[RustCore] Prune failed:', error);
+ return JSON.stringify({
+ success: false,
+ error: error.toString(),
+ statements: [],
+ stats: {}
+ });
+ }
+};
diff --git a/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js
index 8b76896bc..a88576afd 100644
--- a/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js
+++ b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js
@@ -400,6 +400,66 @@ export function mergeVaultsJson(input_json) {
}
}
+/**
+ * Prune expired items from trash.
+ *
+ * Items with DeletedAt older than retention_days are marked as permanently deleted (IsDeleted = true).
+ * Default retention is 30 days.
+ *
+ * Takes a JsValue (PruneInput) and returns a JsValue (PruneOutput).
+ * @param {any} input
+ * @returns {any}
+ */
+export function pruneVault(input) {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.pruneVault(retptr, addHeapObject(input));
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+ if (r2) {
+ throw takeObject(r1);
+ }
+ return takeObject(r0);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ }
+}
+
+/**
+ * Prune vault using JSON strings (alternative API).
+ *
+ * Takes a JSON string and returns a JSON string.
+ * @param {string} input_json
+ * @returns {string}
+ */
+export function pruneVaultJson(input_json) {
+ let deferred3_0;
+ let deferred3_1;
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ const len0 = WASM_VECTOR_LEN;
+ wasm.pruneVaultJson(retptr, ptr0, len0);
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+ var ptr2 = r0;
+ var len2 = r1;
+ if (r3) {
+ ptr2 = 0; len2 = 0;
+ throw takeObject(r2);
+ }
+ deferred3_0 = ptr2;
+ deferred3_1 = len2;
+ return getStringFromWasm0(ptr2, len2);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+ }
+}
+
const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
async function __wbg_load(module, imports) {
@@ -439,6 +499,10 @@ function __wbg_get_imports() {
const ret = Error(getStringFromWasm0(arg0, arg1));
return addHeapObject(ret);
};
+ imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
+ const ret = Number(getObject(arg0));
+ return ret;
+ };
imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
const ret = String(getObject(arg1));
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -537,6 +601,10 @@ function __wbg_get_imports() {
wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
}
};
+ imports.wbg.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
+ const ret = getObject(arg0).getTime();
+ return ret;
+ };
imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
const ret = getObject(arg0)[arg1 >>> 0];
return addHeapObject(ret);
@@ -599,6 +667,10 @@ function __wbg_get_imports() {
const ret = getObject(arg0).length;
return ret;
};
+ imports.wbg.__wbg_new_0_23cedd11d9b40c9d = function() {
+ const ret = new Date();
+ return addHeapObject(ret);
+ };
imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
const ret = new Object();
return addHeapObject(ret);
diff --git a/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm
index 570ce299c..7530a396c 100644
Binary files a/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm and b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm differ
diff --git a/apps/server/Tests/AliasVault.E2ETests/Tests/Client/Shard2/DbCleanupTests.cs b/apps/server/Tests/AliasVault.E2ETests/Tests/Client/Shard2/DbCleanupTests.cs
index f02668b2b..a6fd3e333 100644
--- a/apps/server/Tests/AliasVault.E2ETests/Tests/Client/Shard2/DbCleanupTests.cs
+++ b/apps/server/Tests/AliasVault.E2ETests/Tests/Client/Shard2/DbCleanupTests.cs
@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
// <copyright file="DbCleanupTests.cs" company="aliasvault">
// Copyright (c) aliasvault. All rights reserved.
// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
@@ -8,7 +8,9 @@
namespace AliasVault.E2ETests.Tests.Client.Shard2;
/// <summary>
-/// End-to-end tests for the client database persistence.
+/// End-to-end tests for the client trash bin functionality.
+/// Items are moved to trash (DeletedAt set) when deleted, and remain there for 30 days
+/// before being automatically pruned by the vault_pruner.
/// </summary>
[TestFixture]
[Category("ClientTests")]
@@ -16,12 +18,12 @@ namespace AliasVault.E2ETests.Tests.Client.Shard2;
public class DbCleanupTests : ClientPlaywrightTest
{
/// <summary>
- /// Test if the soft deleted records are cleaned up after 7 days.
+ /// Test that deleted items are moved to trash (DeletedAt is set) rather than being immediately removed.
/// </summary>
/// <returns>Async task.</returns>
[Test]
[Order(1)]
- public async Task DbCleanupSoftDeletedRecordsTest()
+ public async Task DeletedItemsAreMovedToTrashTest()
{
// Create two items. One random and one with a known name.
await CreateItemEntry();
@@ -30,19 +32,77 @@ public class DbCleanupTests : ClientPlaywrightTest
// Delete the item with the known name.
await DeleteItemEntry("ItemB");
- // Verify that the soft delete count is now 1.
- await NavigateUsingBlazorRouter("test/cleanup-stats");
+ // Navigate to recently deleted page and verify item is there.
+ await NavigateUsingBlazorRouter("items/recently-deleted");
+
+ // Wait for the page to load and check for the deleted item.
+ await Page.WaitForSelectorAsync("[data-testid='recently-deleted-item']");
+ var deletedItems = await Page.Locator("[data-testid='recently-deleted-item']").CountAsync();
+ Assert.That(deletedItems, Is.EqualTo(1), "Expected 1 item in recently deleted.");
+
+ // Verify the item name is displayed.
+ var itemName = await Page.Locator("[data-testid='recently-deleted-item-name']").TextContentAsync();
+ Assert.That(itemName, Does.Contain("ItemB"), "Expected deleted item to be ItemB.");
+ }
+
+ /// <summary>
+ /// Test that items can be restored from the trash.
+ /// </summary>
+ /// <returns>Async task.</returns>
+ [Test]
+ [Order(2)]
+ public async Task ItemsCanBeRestoredFromTrashTest()
+ {
+ // Create and delete an item.
+ await CreateItemEntry(new Dictionary<string, string> { { "service-name", "RestoreMe" } });
+ await DeleteItemEntry("RestoreMe");
+
+ // Navigate to recently deleted page.
+ await NavigateUsingBlazorRouter("items/recently-deleted");
+
+ // Wait for the page to load.
+ await Page.WaitForSelectorAsync("[data-testid='recently-deleted-item']");
+
+ // Click the restore button.
+ await Page.Locator("[data-testid='restore-button']").First.ClickAsync();
+
+ // Wait for restore to complete and navigate to items list.
+ await WaitForUrlAsync("**/items", 5000);
+
+ // Verify the item is back in the list.
+ var itemCard = await Page.Locator($"text=RestoreMe").CountAsync();
+ Assert.That(itemCard, Is.GreaterThan(0), "Expected restored item to appear in items list.");
+ }
+
+ /// <summary>
+ /// Test that items can be permanently deleted from the trash.
+ /// </summary>
+ /// <returns>Async task.</returns>
+ [Test]
+ [Order(3)]
+ public async Task ItemsCanBePermanentlyDeletedTest()
+ {
+ // Create and delete an item.
+ await CreateItemEntry(new Dictionary<string, string> { { "service-name", "DeleteForever" } });
+ await DeleteItemEntry("DeleteForever");
+
+ // Navigate to recently deleted page.
+ await NavigateUsingBlazorRouter("items/recently-deleted");
+
+ // Wait for the page to load.
+ await Page.WaitForSelectorAsync("[data-testid='recently-deleted-item']");
+
+ // Click the permanently delete button.
+ await Page.Locator("[data-testid='permanent-delete-button']").First.ClickAsync();
- // Extract value from input hidden with id soft-deleted-credential-count
- var softDeletedItemCount = await Page.EvaluateAsync<int>("document.getElementById('soft-deleted-credential-count').value");
- Assert.That(softDeletedItemCount, Is.EqualTo(1), "Soft deleted item count is not as expected.");
+ // Confirm the deletion in the modal.
+ await Page.Locator("[data-testid='confirm-delete-button']").ClickAsync();
- // Unlock the vault to trigger the cleanup.
- await RefreshPageAndUnlockVault();
+ // Wait for deletion to complete.
+ await Page.WaitForTimeoutAsync(1000);
- // Verify that the soft delete count is now 0 as cleanup should have run.
- await NavigateUsingBlazorRouter("test/cleanup-stats");
- softDeletedItemCount = await Page.EvaluateAsync<int>("document.getElementById('soft-deleted-credential-count').value");
- Assert.That(softDeletedItemCount, Is.EqualTo(1), "Soft deleted item count is not as expected. Cleanup should only run after 7 days.");
+ // Verify the item is no longer in the trash.
+ var deletedItems = await Page.Locator("[data-testid='recently-deleted-item']").CountAsync();
+ Assert.That(deletedItems, Is.EqualTo(0), "Expected no items in recently deleted after permanent deletion.");
}
}
diff --git a/core/rust/src/ffi.rs b/core/rust/src/ffi.rs
index 3ef35c036..2a757090c 100644
--- a/core/rust/src/ffi.rs
+++ b/core/rust/src/ffi.rs
@@ -7,7 +7,8 @@ use std::ffi::{c_char, CStr, CString};
use std::ptr;
use crate::credential_matcher::{filter_credentials, CredentialMatcherInput};
-use crate::merge::{merge_vaults, MergeInput, SYNCABLE_TABLE_NAMES};
+use crate::vault_merge::{merge_vaults, MergeInput, SYNCABLE_TABLE_NAMES};
+use crate::vault_pruner::{prune_vault, PruneInput};
/// Merge two vaults using LWW strategy.
///
@@ -51,6 +52,50 @@ pub unsafe extern "C" fn merge_vaults_ffi(input_json: *const c_char) -> *mut c_c
}
}
+/// Prune expired items from trash.
+///
+/// Items with DeletedAt older than retention_days are marked as permanently deleted.
+///
+/// # Safety
+///
+/// - `input_json` must be a valid null-terminated C string
+/// - The returned pointer must be freed by calling `free_string`
+///
+/// # Returns
+///
+/// A null-terminated C string containing the JSON result (PruneOutput).
+/// Returns null on error.
+#[no_mangle]
+pub unsafe extern "C" fn prune_vault_ffi(input_json: *const c_char) -> *mut c_char {
+ if input_json.is_null() {
+ return ptr::null_mut();
+ }
+
+ let c_str = match CStr::from_ptr(input_json).to_str() {
+ Ok(s) => s,
+ Err(_) => return ptr::null_mut(),
+ };
+
+ let input: PruneInput = match serde_json::from_str(c_str) {
+ Ok(i) => i,
+ Err(e) => {
+ return create_error_response(&format!("Failed to parse input: {}", e));
+ }
+ };
+
+ let output = match prune_vault(input) {
+ Ok(o) => o,
+ Err(e) => {
+ return create_error_response(&format!("Prune failed: {}", e));
+ }
+ };
+
+ match serde_json::to_string(&output) {
+ Ok(json) => string_to_c_char(json),
+ Err(e) => create_error_response(&format!("Failed to serialize output: {}", e)),
+ }
+}
+
/// Filter credentials for autofill.
///
/// # Safety
@@ -160,6 +205,9 @@ mod tests {
let result = merge_vaults_ffi(ptr::null());
assert!(result.is_null());
+ let result = prune_vault_ffi(ptr::null());
+ assert!(result.is_null());
+
let result = filter_credentials_ffi(ptr::null());
assert!(result.is_null());
}
diff --git a/core/rust/src/lib.rs b/core/rust/src/lib.rs
index ac75ef8b3..f4f37eb3c 100644
--- a/core/rust/src/lib.rs
+++ b/core/rust/src/lib.rs
@@ -1,7 +1,8 @@
//! AliasVault Core Library
//!
//! Cross-platform core functionality for AliasVault, including:
-//! - **merge**: Vault merge using Last-Write-Wins (LWW) strategy
+//! - **vault_merge**: Vault merge using Last-Write-Wins (LWW) strategy
+//! - **vault_pruner**: Prunes expired items from trash (30-day retention)
//! - **credential_matcher**: Cross-platform credential filtering for autofill
//!
//! This library accepts data as JSON and returns results as JSON.
@@ -15,20 +16,28 @@
//! let server_tables = read_all_tables_as_json(server_db);
//! let result = merge_vaults(local_tables, server_tables);
//!
+//! // Prune example (removes items in trash for > 30 days)
+//! let tables = read_all_tables_as_json(local_db);
+//! let result = prune_vault(tables, 30);
+//!
//! // Credential matching example
//! let credentials = get_credentials_json();
//! let matches = filter_credentials(credentials, "https://github.com", "GitHub");
//! ```
pub mod error;
-pub mod merge;
+pub mod vault_merge;
+pub mod vault_pruner;
pub mod credential_matcher;
pub use error::VaultError;
-pub use merge::{
+pub use vault_merge::{
merge_vaults, MergeInput, MergeOutput, MergeStats, SqlStatement, TableData,
SYNCABLE_TABLE_NAMES,
};
+pub use vault_pruner::{
+ prune_vault, PruneInput, PruneOutput, PruneStats,
+};
pub use credential_matcher::{
filter_credentials, extract_domain, extract_root_domain,
AutofillMatchingMode, CredentialMatcherInput, CredentialMatcherOutput,
diff --git a/core/rust/src/merge/mod.rs b/core/rust/src/vault_merge/mod.rs
similarity index 100%
rename from core/rust/src/merge/mod.rs
rename to core/rust/src/vault_merge/mod.rs
diff --git a/core/rust/src/merge/types.rs b/core/rust/src/vault_merge/types.rs
similarity index 100%
rename from core/rust/src/merge/types.rs
rename to core/rust/src/vault_merge/types.rs
diff --git a/core/rust/src/vault_pruner/mod.rs b/core/rust/src/vault_pruner/mod.rs
new file mode 100644
index 000000000..58c578c45
--- /dev/null
+++ b/core/rust/src/vault_pruner/mod.rs
@@ -0,0 +1,403 @@
+//! Vault pruner for automatically removing expired trash items.
+//!
+//! This module handles the automatic cleanup of items that have been in the trash
+//! (DeletedAt set) for longer than the retention period (default 30 days).
+//! It generates SQL statements to permanently delete (IsDeleted = true) these items
+//! along with their related entities.
+
+use chrono::{DateTime, Duration, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use crate::error::VaultResult;
+use crate::vault_merge::SqlStatement;
+
+/// A record is a map of column names to JSON values.
+pub type Record = HashMap<String, serde_json::Value>;
+
+/// Data for a single table.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TableData {
+ /// Table name
+ pub name: String,
+ /// All records in this table
+ pub records: Vec<Record>,
+}
+
+/// Input for the prune operation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PruneInput {
+ /// Tables from the local database (at minimum, Items table is required)
+ pub tables: Vec<TableData>,
+ /// Retention period in days (default: 30)
+ #[serde(default = "default_retention_days")]
+ pub retention_days: u32,
+}
+
+fn default_retention_days() -> u32 {
+ 30
+}
+
+/// Statistics about what was pruned.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
+pub struct PruneStats {
+ /// Number of items permanently deleted
+ pub items_pruned: u32,
+ /// Number of field values permanently deleted
+ pub field_values_pruned: u32,
+ /// Number of attachments permanently deleted
+ pub attachments_pruned: u32,
+ /// Number of TOTP codes permanently deleted
+ pub totp_codes_pruned: u32,
+ /// Number of passkeys permanently deleted
+ pub passkeys_pruned: u32,
+}
+
+/// Output of the prune operation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PruneOutput {
+ /// Whether the prune was successful
+ pub success: bool,
+ /// SQL statements to execute on the local database (in order)
+ pub statements: Vec<SqlStatement>,
+ /// Statistics about what was pruned
+ pub stats: PruneStats,
+}
+
+/// Main entry point: prune expired items from trash.
+///
+/// This function finds all Items with DeletedAt set that are older than
+/// retention_days and generates SQL statements to mark them and their
+/// related entities as permanently deleted (IsDeleted = true).
+///
+/// # Arguments
+/// * `input` - PruneInput containing table data and retention period
+///
+/// # Returns
+/// PruneOutput with SQL statements to execute on local database
+pub fn prune_vault(input: PruneInput) -> VaultResult<PruneOutput> {
+ let mut stats = PruneStats::default();
+ let mut statements: Vec<SqlStatement> = Vec::new();
+
+ // Calculate cutoff date
+ let cutoff_date = Utc::now() - Duration::days(input.retention_days as i64);
+
+ // Find Items table
+ let items_table = input.tables.iter().find(|t| t.name == "Items");
+ if items_table.is_none() {
+ return Ok(PruneOutput {
+ success: true,
+ statements: vec![],
+ stats,
+ });
+ }
+
+ let items = &items_table.unwrap().records;
+
+ // Find items that are in trash (DeletedAt set) and older than retention period
+ let mut expired_item_ids: Vec<String> = Vec::new();
+ let now = Utc::now();
+
+ for item in items {
+ // Skip if already permanently deleted
+ if let Some(is_deleted) = item.get("IsDeleted") {
+ if is_deleted.as_i64() == Some(1) || is_deleted.as_bool() == Some(true) {
+ continue;
+ }
+ }
+
+ // Check if item is in trash (DeletedAt is set and not null)
+ if let Some(deleted_at) = item.get("DeletedAt") {
+ if deleted_at.is_null() {
+ continue;
+ }
+
+ if let Some(deleted_at_str) = deleted_at.as_str() {
+ if let Some(deleted_date) = parse_datetime(deleted_at_str) {
+ if deleted_date < cutoff_date {
+ if let Some(id) = item.get("Id").and_then(|v| v.as_str()) {
+ expired_item_ids.push(id.to_string());
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // If no expired items, return early
+ if expired_item_ids.is_empty() {
+ return Ok(PruneOutput {
+ success: true,
+ statements: vec![],
+ stats,
+ });
+ }
+
+ // Generate SQL statements to permanently delete the expired items and related entities
+ let now_str = now.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+
+ for item_id in &expired_item_ids {
+ // Mark item as permanently deleted
+ statements.push(SqlStatement {
+ sql: "UPDATE Items SET IsDeleted = 1, UpdatedAt = ? WHERE Id = ?".to_string(),
+ params: vec![
+ serde_json::json!(now_str),
+ serde_json::json!(item_id),
+ ],
+ });
+ stats.items_pruned += 1;
+
+ // Mark related FieldValues as deleted
+ if let Some(field_values_table) = input.tables.iter().find(|t| t.name == "FieldValues") {
+ let related_count = count_related_records(&field_values_table.records, "ItemId", item_id);
+ if related_count > 0 {
+ statements.push(SqlStatement {
+ sql: "UPDATE FieldValues SET IsDeleted = 1, UpdatedAt = ? WHERE ItemId = ? AND IsDeleted = 0".to_string(),
+ params: vec![
+ serde_json::json!(now_str),
+ serde_json::json!(item_id),
+ ],
+ });
+ stats.field_values_pruned += related_count;
+ }
+ }
+
+ // Mark related Attachments as deleted
+ if let Some(attachments_table) = input.tables.iter().find(|t| t.name == "Attachments") {
+ let related_count = count_related_records(&attachments_table.records, "ItemId", item_id);
+ if related_count > 0 {
+ statements.push(SqlStatement {
+ sql: "UPDATE Attachments SET IsDeleted = 1, UpdatedAt = ? WHERE ItemId = ? AND IsDeleted = 0".to_string(),
+ params: vec![
+ serde_json::json!(now_str),
+ serde_json::json!(item_id),
+ ],
+ });
+ stats.attachments_pruned += related_count;
+ }
+ }
+
+ // Mark related TotpCodes as deleted
+ if let Some(totp_table) = input.tables.iter().find(|t| t.name == "TotpCodes") {
+ let related_count = count_related_records(&totp_table.records, "ItemId", item_id);
+ if related_count > 0 {
+ statements.push(SqlStatement {
+ sql: "UPDATE TotpCodes SET IsDeleted = 1, UpdatedAt = ? WHERE ItemId = ? AND IsDeleted = 0".to_string(),
+ params: vec![
+ serde_json::json!(now_str),
+ serde_json::json!(item_id),
+ ],
+ });
+ stats.totp_codes_pruned += related_count;
+ }
+ }
+
+ // Mark related Passkeys as deleted
+ if let Some(passkeys_table) = input.tables.iter().find(|t| t.name == "Passkeys") {
+ let related_count = count_related_records(&passkeys_table.records, "ItemId", item_id);
+ if related_count > 0 {
+ statements.push(SqlStatement {
+ sql: "UPDATE Passkeys SET IsDeleted = 1, UpdatedAt = ? WHERE ItemId = ? AND IsDeleted = 0".to_string(),
+ params: vec![
+ serde_json::json!(now_str),
+ serde_json::json!(item_id),
+ ],
+ });
+ stats.passkeys_pruned += related_count;
+ }
+ }
+ }
+
+ Ok(PruneOutput {
+ success: true,
+ statements,
+ stats,
+ })
+}
+
+/// Prune vault using JSON strings.
+/// Convenience function for FFI.
+pub fn prune_vault_json(input_json: &str) -> VaultResult<String> {
+ let input: PruneInput = serde_json::from_str(input_json)?;
+ let output = prune_vault(input)?;
+ let output_json = serde_json::to_string(&output)?;
+ Ok(output_json)
+}
+
+/// Parse a datetime string in various formats.
+/// Handles both RFC3339 format (2025-12-11T06:50:10.674Z) and
+/// SQLite format (2025-12-11 06:50:10.674).
+fn parse_datetime(s: &str) -> Option<DateTime<Utc>> {
+ // Try RFC3339 first
+ DateTime::parse_from_rfc3339(s)
+ .map(|dt| dt.with_timezone(&Utc))
+ .ok()
+ .or_else(|| {
+ // Try SQLite format: "YYYY-MM-DD HH:MM:SS.mmm"
+ chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f")
+ .ok()
+ .map(|naive| naive.and_utc())
+ })
+}
+
+/// Count related records that match a foreign key value and are not already deleted.
+fn count_related_records(records: &[Record], fk_column: &str, fk_value: &str) -> u32 {
+ records.iter().filter(|r| {
+ // Check if FK matches
+ let fk_matches = r.get(fk_column)
+ .and_then(|v| v.as_str())
+ .map(|v| v == fk_value)
+ .unwrap_or(false);
+
+ // Check if not already deleted
+ let not_deleted = match r.get("IsDeleted") {
+ Some(v) => v.as_i64() != Some(1) && v.as_bool() != Some(true),
+ None => true,
+ };
+
+ fk_matches && not_deleted
+ }).count() as u32
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn make_item_record(id: &str, deleted_at: Option<&str>, is_deleted: bool) -> Record {
+ let mut record = HashMap::new();
+ record.insert("Id".to_string(), serde_json::json!(id));
+ record.insert("UpdatedAt".to_string(), serde_json::json!("2024-01-01T00:00:00Z"));
+ record.insert("IsDeleted".to_string(), serde_json::json!(if is_deleted { 1 } else { 0 }));
+ if let Some(dt) = deleted_at {
+ record.insert("DeletedAt".to_string(), serde_json::json!(dt));
+ } else {
+ record.insert("DeletedAt".to_string(), serde_json::Value::Null);
+ }
+ record
+ }
+
+ fn make_field_value_record(id: &str, item_id: &str, is_deleted: bool) -> Record {
+ let mut record = HashMap::new();
+ record.insert("Id".to_string(), serde_json::json!(id));
+ record.insert("ItemId".to_string(), serde_json::json!(item_id));
+ record.insert("UpdatedAt".to_string(), serde_json::json!("2024-01-01T00:00:00Z"));
+ record.insert("IsDeleted".to_string(), serde_json::json!(if is_deleted { 1 } else { 0 }));
+ record
+ }
+
+ #[test]
+ fn test_prune_expired_items() {
+ // Create an item deleted 60 days ago
+ let old_date = (Utc::now() - Duration::days(60)).format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+
+ let input = PruneInput {
+ tables: vec![
+ TableData {
+ name: "Items".to_string(),
+ records: vec![make_item_record("item-1", Some(&old_date), false)],
+ },
+ TableData {
+ name: "FieldValues".to_string(),
+ records: vec![make_field_value_record("fv-1", "item-1", false)],
+ },
+ ],
+ retention_days: 30,
+ };
+
+ let output = prune_vault(input).unwrap();
+
+ assert!(output.success);
+ assert_eq!(output.stats.items_pruned, 1);
+ assert_eq!(output.stats.field_values_pruned, 1);
+ assert!(output.statements.len() >= 2); // At least item + field value updates
+ }
+
+ #[test]
+ fn test_no_prune_recent_items() {
+ // Create an item deleted 10 days ago (within retention)
+ let recent_date = (Utc::now() - Duration::days(10)).format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+
+ let input = PruneInput {
+ tables: vec![
+ TableData {
+ name: "Items".to_string(),
+ records: vec![make_item_record("item-1", Some(&recent_date), false)],
+ },
+ ],
+ retention_days: 30,
+ };
+
+ let output = prune_vault(input).unwrap();
+
+ assert!(output.success);
+ assert_eq!(output.stats.items_pruned, 0);
+ assert!(output.statements.is_empty());
+ }
+
+ #[test]
+ fn test_no_prune_active_items() {
+ // Create an item that's not in trash (DeletedAt is null)
+ let input = PruneInput {
+ tables: vec![
+ TableData {
+ name: "Items".to_string(),
+ records: vec![make_item_record("item-1", None, false)],
+ },
+ ],
+ retention_days: 30,
+ };
+
+ let output = prune_vault(input).unwrap();
+
+ assert!(output.success);
+ assert_eq!(output.stats.items_pruned, 0);
+ assert!(output.statements.is_empty());
+ }
+
+ #[test]
+ fn test_no_prune_already_deleted() {
+ // Create an item that's already permanently deleted
+ let old_date = (Utc::now() - Duration::days(60)).format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+
+ let input = PruneInput {
+ tables: vec![
+ TableData {
+ name: "Items".to_string(),
+ records: vec![make_item_record("item-1", Some(&old_date), true)],
+ },
+ ],
+ retention_days: 30,
+ };
+
+ let output = prune_vault(input).unwrap();
+
+ assert!(output.success);
+ assert_eq!(output.stats.items_pruned, 0);
+ assert!(output.statements.is_empty());
+ }
+
+ #[test]
+ fn test_prune_json_api() {
+ let old_date = (Utc::now() - Duration::days(60)).format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+
+ let input_json = format!(r#"{{
+ "tables": [{{
+ "name": "Items",
+ "records": [{{
+ "Id": "item-1",
+ "UpdatedAt": "2024-01-01T00:00:00Z",
+ "IsDeleted": 0,
+ "DeletedAt": "{}"
+ }}]
+ }}],
+ "retention_days": 30
+ }}"#, old_date);
+
+ let output_json = prune_vault_json(&input_json).unwrap();
+ let output: PruneOutput = serde_json::from_str(&output_json).unwrap();
+
+ assert!(output.success);
+ assert_eq!(output.stats.items_pruned, 1);
+ }
+}
diff --git a/core/rust/src/wasm.rs b/core/rust/src/wasm.rs
index 586e0f56c..27be05e04 100644
--- a/core/rust/src/wasm.rs
+++ b/core/rust/src/wasm.rs
@@ -5,7 +5,8 @@ use wasm_bindgen::prelude::*;
use crate::credential_matcher::{
filter_credentials, CredentialMatcherInput, CredentialMatcherOutput,
};
-use crate::merge::{merge_vaults, MergeInput, MergeOutput};
+use crate::vault_merge::{merge_vaults, MergeInput, MergeOutput};
+use crate::vault_pruner::{prune_vault, PruneInput, PruneOutput};
#[wasm_bindgen]
extern "C" {
@@ -19,10 +20,14 @@ pub fn init() {
console_error_panic_hook::set_once();
}
+// ═══════════════════════════════════════════════════════════════════════════════
+// Vault Merge WASM Bindings
+// ═══════════════════════════════════════════════════════════════════════════════
+
/// Get the list of table names that need to be synced.
#[wasm_bindgen(js_name = getSyncableTableNames)]
pub fn get_syncable_table_names() -> Vec<String> {
- crate::merge::SYNCABLE_TABLE_NAMES
+ crate::vault_merge::SYNCABLE_TABLE_NAMES
.iter()
.map(|s| s.to_string())
.collect()
@@ -48,10 +53,41 @@ pub fn merge_vaults_js(input: JsValue) -> Result<JsValue, JsValue> {
/// Takes a JSON string and returns a JSON string.
#[wasm_bindgen(js_name = mergeVaultsJson)]
pub fn merge_vaults_json_js(input_json: &str) -> Result<String, JsValue> {
- crate::merge::merge_vaults_json(input_json)
+ crate::vault_merge::merge_vaults_json(input_json)
.map_err(|e| JsValue::from_str(&format!("Merge failed: {}", e)))
}
+// ═══════════════════════════════════════════════════════════════════════════════
+// Vault Pruner WASM Bindings
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Prune expired items from trash.
+///
+/// Items with DeletedAt older than retention_days are marked as permanently deleted (IsDeleted = true).
+/// Default retention is 30 days.
+///
+/// Takes a JsValue (PruneInput) and returns a JsValue (PruneOutput).
+#[wasm_bindgen(js_name = pruneVault)]
+pub fn prune_vault_js(input: JsValue) -> Result<JsValue, JsValue> {
+ let input: PruneInput = serde_wasm_bindgen::from_value(input)
+ .map_err(|e| JsValue::from_str(&format!("Failed to parse input: {}", e)))?;
+
+ let output: PruneOutput = prune_vault(input)
+ .map_err(|e| JsValue::from_str(&format!("Prune failed: {}", e)))?;
+
+ serde_wasm_bindgen::to_value(&output)
+ .map_err(|e| JsValue::from_str(&format!("Failed to serialize output: {}", e)))
+}
+
+/// Prune vault using JSON strings (alternative API).
+///
+/// Takes a JSON string and returns a JSON string.
+#[wasm_bindgen(js_name = pruneVaultJson)]
+pub fn prune_vault_json_js(input_json: &str) -> Result<String, JsValue> {
+ crate::vault_pruner::prune_vault_json(input_json)
+ .map_err(|e| JsValue::from_str(&format!("Prune failed: {}", e)))
+}
+
// ═══════════════════════════════════════════════════════════════════════════════
// Credential Matcher WASM Bindings
// ═══════════════════════════════════════════════════════════════════════════════