Skip to content

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

Add Rust Core WASM scaffolding to AliasVault.Client (#1404)

Leendert de Borst75377d795e06
diff --git a/apps/server/AliasVault.Client/Program.cs b/apps/server/AliasVault.Client/Program.cs
index df2d9920d..4d656f631 100644
--- a/apps/server/AliasVault.Client/Program.cs
+++ b/apps/server/AliasVault.Client/Program.cs
@@ -10,6 +10,7 @@ using AliasVault.Client;
using AliasVault.Client.Main.Services;
using AliasVault.Client.Providers;
using AliasVault.Client.Services;
+using AliasVault.Client.Services.Native;
using AliasVault.RazorComponents.Services;
using AliasVault.Shared.Core;
using Blazor.WebAssembly.DynamicCulture.Loader;
@@ -99,6 +100,7 @@ builder.Services.AddScoped<ClipboardCopyService>();
builder.Services.AddScoped<ConfirmModalService>();
builder.Services.AddScoped<QuickCreateStateService>();
builder.Services.AddScoped<LanguageService>();
+builder.Services.AddScoped<RustCore>();
builder.Services.AddAuthorizationCore();
builder.Services.AddBlazoredLocalStorage();
diff --git a/apps/server/AliasVault.Client/Services/Database/DbMergeUtility.cs b/apps/server/AliasVault.Client/Services/Database/DbMergeUtility.cs
deleted file mode 100644
index f9834d875..000000000
--- a/apps/server/AliasVault.Client/Services/Database/DbMergeUtility.cs
+++ /dev/null
@@ -1,162 +0,0 @@
-//-----------------------------------------------------------------------
-// <copyright file="DbMergeUtility.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.Database;
-
-using System.Globalization;
-using Microsoft.Data.Sqlite;
-
-/// <summary>
-/// Class with helper methods to merge two or more vaults.
-/// </summary>
-public static class DbMergeUtility
-{
- /// <summary>
- /// Retrieves the names of all tables in the SQLite database.
- /// </summary>
- /// <param name="connection">The SQLite connection to use.</param>
- /// <returns>A list of table names.</returns>
- /// <returns>List of table names.</returns>
- public static async Task<List<string>> GetTableNames(SqliteConnection connection)
- {
- var tables = new List<string>();
- await using var command = connection.CreateCommand();
- command.CommandText = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';";
- await using var reader = await command.ExecuteReaderAsync();
- while (await reader.ReadAsync())
- {
- tables.Add(reader.GetString(0));
- }
-
- return tables;
- }
-
- /// <summary>
- /// Merges data from a source table into a base table.
- /// </summary>
- /// <param name="baseConnection">The connection to the base database.</param>
- /// <param name="sourceConnection">The connection to the source database.</param>
- /// <param name="tableName">The name of the table to merge.</param>
- /// <param name="logger">ILogger instance.</param>
- /// <returns>Task.</returns>
- public static async Task MergeTable(SqliteConnection baseConnection, SqliteConnection sourceConnection, string tableName, ILogger<DbService> logger)
- {
- await using var baseCommand = baseConnection.CreateCommand();
- await using var sourceCommand = sourceConnection.CreateCommand();
-
- baseCommand.CommandText = $"PRAGMA table_info({tableName})";
- var columns = new List<string>();
-
- // Get column names from the base table.
- await using (var reader = await baseCommand.ExecuteReaderAsync())
- {
- while (await reader.ReadAsync())
- {
- string columnName = reader.GetString(1);
- columns.Add(columnName);
- }
- }
-
- // Check if the table has Id, UpdatedAt and IsDeleted columns which are required in order to merge.
- // If columns are missing, skip the table.
- if (!columns.Contains("Id") || !columns.Contains("UpdatedAt") || !columns.Contains("IsDeleted"))
- {
- return;
- }
-
- // Get all records from the source table.
- sourceCommand.CommandText = $"SELECT * FROM {tableName}";
- await using var sourceReader = await sourceCommand.ExecuteReaderAsync();
-
- logger.LogDebug("Got records for {tableName}.", tableName);
- while (await sourceReader.ReadAsync())
- {
- var id = sourceReader.GetValue(0);
- var updatedAt = sourceReader.GetDateTime(columns.IndexOf("UpdatedAt"));
-
- // Check if the record exists in the base table.
- baseCommand.CommandText = $"SELECT UpdatedAt FROM {tableName} WHERE Id = @Id";
- baseCommand.Parameters.Clear();
- baseCommand.Parameters.AddWithValue("@Id", id);
-
- logger.LogDebug("Checking if record exists in {tableName}.", tableName);
-
- var existingRecord = await baseCommand.ExecuteScalarAsync();
- if (existingRecord != null)
- {
- logger.LogDebug("Record exists in {tableName}.", tableName);
-
- // Record exists, compare UpdatedAt if it exists.
- logger.LogDebug("Comparing UpdatedAt in {tableName}.", tableName);
- logger.LogDebug("UpdatedAt: {existingRecord}", existingRecord);
- var baseUpdatedAt = DateTime.Parse((string)existingRecord, CultureInfo.InvariantCulture);
- if (updatedAt > baseUpdatedAt)
- {
- // Source record is newer, update the base record.
- await UpdateRecord(baseConnection, tableName, sourceReader, columns);
- }
- else
- {
- // Base record is newer, skip.
- logger.LogDebug("Base record is newer, skipping {tableName}.", tableName);
- }
- }
- else
- {
- // Record doesn't exist in base, add it.
- await InsertRecord(baseConnection, tableName, sourceReader, columns);
- }
- }
-
- logger.LogDebug("Finished merging {tableName}.", tableName);
- }
-
- /// <summary>
- /// Inserts a new record into the specified table with data from the source reader.
- /// </summary>
- /// <param name="connection">The SQLite connection to use.</param>
- /// <param name="tableName">The name of the table to insert into.</param>
- /// <param name="sourceReader">The data reader containing the source record.</param>
- /// <param name="columns">The list of column names in the table.</param>
- /// <returns>Task.</returns>
- private static async Task InsertRecord(SqliteConnection connection, string tableName, SqliteDataReader sourceReader, List<string> columns)
- {
- await using var command = connection.CreateCommand();
- var columnNames = string.Join(", ", columns);
- var parameterNames = string.Join(", ", columns.Select(c => $"@{c}"));
- command.CommandText = $"INSERT INTO {tableName} ({columnNames}) VALUES ({parameterNames})";
-
- for (int i = 0; i < columns.Count; i++)
- {
- command.Parameters.AddWithValue($"@{columns[i]}", sourceReader.GetValue(i));
- }
-
- await command.ExecuteNonQueryAsync();
- }
-
- /// <summary>
- /// Updates a record in the specified table with data from the source reader.
- /// </summary>
- /// <param name="connection">The SQLite connection to use.</param>
- /// <param name="tableName">The name of the table to update.</param>
- /// <param name="sourceReader">The data reader containing the source record.</param>
- /// <param name="columns">The list of column names in the table.</param>
- /// <returns>Task.</returns>
- private static async Task UpdateRecord(SqliteConnection connection, string tableName, SqliteDataReader sourceReader, List<string> columns)
- {
- await using var command = connection.CreateCommand();
- var updateColumns = string.Join(", ", columns.Select(c => $"{c} = @{c}"));
- command.CommandText = $"UPDATE {tableName} SET {updateColumns} WHERE Id = @Id";
-
- for (int i = 0; i < columns.Count; i++)
- {
- command.Parameters.AddWithValue($"@{columns[i]}", sourceReader.GetValue(i));
- }
-
- await command.ExecuteNonQueryAsync();
- }
-}
diff --git a/apps/server/AliasVault.Client/Services/Database/DbService.cs b/apps/server/AliasVault.Client/Services/Database/DbService.cs
index c73126180..0d0c06f6e 100644
--- a/apps/server/AliasVault.Client/Services/Database/DbService.cs
+++ b/apps/server/AliasVault.Client/Services/Database/DbService.cs
@@ -9,11 +9,13 @@ namespace AliasVault.Client.Services.Database;
using System.Data;
using System.Net.Http.Json;
+using System.Text.Json;
using AliasClientDb;
using AliasClientDb.Models;
using AliasVault.Client.Services;
using AliasVault.Client.Services.Auth;
using AliasVault.Client.Services.JsInterop.Models;
+using AliasVault.Client.Services.Native;
using AliasVault.Client.Utilities;
using AliasVault.Shared.Models.Enums;
using AliasVault.Shared.Models.WebApi.Vault;
@@ -30,6 +32,7 @@ public sealed class DbService : IDisposable
private const string _UNKNOWN_VERSION = "Unknown";
private readonly AuthService _authService;
private readonly JsInteropService _jsInteropService;
+ private readonly RustCore _rustCore;
private readonly HttpClient _httpClient;
private readonly DbServiceState _state = new();
private readonly Config _config;
@@ -48,14 +51,16 @@ public sealed class DbService : IDisposable
/// </summary>
/// <param name="authService">AuthService.</param>
/// <param name="jsInteropService">JsInteropService.</param>
+ /// <param name="rustCore">RustCore service for WASM interop.</param>
/// <param name="httpClient">HttpClient.</param>
/// <param name="config">Config instance.</param>
/// <param name="globalNotificationService">Global notification service.</param>
/// <param name="logger">ILogger instance.</param>
- public DbService(AuthService authService, JsInteropService jsInteropService, HttpClient httpClient, Config config, GlobalNotificationService globalNotificationService, ILogger<DbService> logger)
+ public DbService(AuthService authService, JsInteropService jsInteropService, RustCore rustCore, HttpClient httpClient, Config config, GlobalNotificationService globalNotificationService, ILogger<DbService> logger)
{
_authService = authService;
_jsInteropService = jsInteropService;
+ _rustCore = rustCore;
_httpClient = httpClient;
_config = config;
_globalNotificationService = globalNotificationService;
@@ -113,7 +118,7 @@ public sealed class DbService : IDisposable
}
/// <summary>
- /// Merges two or more databases into one.
+ /// Merges two or more databases into one using the Rust WASM merge logic.
/// </summary>
/// <returns>Bool which indicates if merging was successful.</returns>
public async Task<bool> MergeDatabasesAsync()
@@ -128,51 +133,61 @@ public sealed class DbService : IDisposable
return false;
}
- var sqlConnections = new List<SqliteConnection>();
- _logger.LogInformation("Merging databases...");
+ _logger.LogInformation("Merging databases using Rust WASM...");
- // Decrypt and instantiate each vault as a separate in-memory SQLite database.
+ // Get the list of syncable table names from Rust core.
+ var tableNames = await _rustCore.GetSyncableTableNamesAsync();
+
+ // Read local tables as JSON.
+ var localTables = await ReadTablesAsJsonAsync(_sqlConnection!, tableNames);
+ _logger.LogDebug("Read {Count} local tables.", localTables.Count);
+
+ // Process each vault to merge.
foreach (var vault in vaultsToMerge.Vaults)
{
// Store username of the loaded vault in memory to send to server as sanity check when updating the vault later.
_authService.StoreUsername(vault.Username);
var decryptedBase64String = await _jsInteropService.SymmetricDecrypt(vault.Blob, _authService.GetEncryptionKeyAsBase64Async());
-
_logger.LogInformation("Decrypted vault {VaultUpdatedAt}.", vault.UpdatedAt);
- var connection = new SqliteConnection("Data Source=:memory:");
- await connection.OpenAsync();
- await ImportDbContextFromBase64Async(decryptedBase64String, connection);
- sqlConnections.Add(connection);
- }
- // Get all table names from the current base database.
- var tables = await DbMergeUtility.GetTableNames(_sqlConnection!);
+ // Create a temporary in-memory SQLite database for the server vault.
+ await using var serverConnection = new SqliteConnection("Data Source=:memory:");
+ await serverConnection.OpenAsync();
+ await ImportDbContextFromBase64Async(decryptedBase64String, serverConnection);
- // Disable foreign key checks on the base connection.
- await using (var command = _sqlConnection!.CreateCommand())
- {
- command.CommandText = "PRAGMA foreign_keys = OFF;";
- await command.ExecuteNonQueryAsync();
- }
+ // Read server tables as JSON.
+ var serverTables = await ReadTablesAsJsonAsync(serverConnection, tableNames);
+ _logger.LogDebug("Read {Count} server tables.", serverTables.Count);
- // Merge every remote database into the current database.
- foreach (var connection in sqlConnections)
- {
- foreach (var table in tables)
+ // Create the merge input.
+ var mergeInput = new MergeInput
{
- _logger.LogInformation("Merging table {Table}.", table);
- await DbMergeUtility.MergeTable(_sqlConnection, connection, table, _logger);
- }
+ LocalTables = localTables,
+ ServerTables = serverTables,
+ };
+
+ // Call Rust WASM merge.
+ var mergeOutput = await _rustCore.MergeVaultsAsync(mergeInput);
+
+ _logger.LogInformation(
+ "Merge completed: {TablesProcessed} tables, {FromLocal} kept local, {FromServer} from server, {Inserted} inserted, {Conflicts} conflicts.",
+ mergeOutput.Stats.TablesProcessed,
+ mergeOutput.Stats.RecordsFromLocal,
+ mergeOutput.Stats.RecordsFromServer,
+ mergeOutput.Stats.RecordsInserted,
+ mergeOutput.Stats.Conflicts);
+
+ // Execute the SQL statements returned by the merge.
+ await ExecuteMergeSqlStatementsAsync(mergeOutput.Statements);
+
+ // Update local tables for the next merge iteration (if there are multiple vaults).
+ localTables = await ReadTablesAsJsonAsync(_sqlConnection!, tableNames);
}
- // Re-enable foreign key checks and verify integrity.
- await using (var command = _sqlConnection.CreateCommand())
+ // Verify foreign key integrity after merge.
+ await using (var command = _sqlConnection!.CreateCommand())
{
- command.CommandText = "PRAGMA foreign_keys = ON;";
- await command.ExecuteNonQueryAsync();
-
- // Verify foreign key integrity.
command.CommandText = "PRAGMA foreign_key_check;";
await using var reader = await command.ExecuteReaderAsync();
if (await reader.ReadAsync())
@@ -186,13 +201,6 @@ public sealed class DbService : IDisposable
// Update the db context with the new merged database.
_dbContext = new AliasClientDbContext(_sqlConnection, log => _logger.LogDebug("{Message}", log));
- // Clean up other connections.
- foreach (var connection in sqlConnections)
- {
- await connection.CloseAsync();
- await connection.DisposeAsync();
- }
-
// Update the current vault revision number to the highest revision number in the merged database(s).
// This is important so the server knows that the local client has successfully merged the databases
// and should overwrite the existing database on the server with the new merged database.
@@ -671,6 +679,25 @@ public sealed class DbService : IDisposable
File.Delete(tempFileName);
}
+ /// <summary>
+ /// Converts a JsonElement to its appropriate .NET value for SQLite parameters.
+ /// </summary>
+ /// <param name="element">The JsonElement to convert.</param>
+ /// <returns>The converted value.</returns>
+ private static object? ConvertJsonElementToValue(JsonElement element)
+ {
+ return element.ValueKind switch
+ {
+ JsonValueKind.String => element.GetString(),
+ JsonValueKind.Number => element.TryGetInt64(out var longVal) ? longVal : element.GetDouble(),
+ JsonValueKind.True => 1L, // SQLite stores booleans as integers
+ JsonValueKind.False => 0L,
+ JsonValueKind.Null => null,
+ JsonValueKind.Undefined => null,
+ _ => element.ToString(),
+ };
+ }
+
/// <summary>
/// Checks if there are any pending migrations.
/// </summary>
@@ -894,6 +921,136 @@ public sealed class DbService : IDisposable
}
}
+ /// <summary>
+ /// Reads all specified tables from a SQLite connection as JSON data for the Rust merge.
+ /// </summary>
+ /// <param name="connection">The SQLite connection to read from.</param>
+ /// <param name="tableNames">The names of tables to read.</param>
+ /// <returns>List of TableData objects containing the table records.</returns>
+ private async Task<List<TableData>> ReadTablesAsJsonAsync(SqliteConnection connection, string[] tableNames)
+ {
+ var tables = new List<TableData>();
+
+ foreach (var tableName in tableNames)
+ {
+ var tableData = new TableData { Name = tableName };
+
+ // Check if table exists in the database.
+ await using var checkCommand = connection.CreateCommand();
+ checkCommand.CommandText = "SELECT name FROM sqlite_master WHERE type='table' AND name=@tableName";
+ checkCommand.Parameters.AddWithValue("@tableName", tableName);
+ var exists = await checkCommand.ExecuteScalarAsync();
+
+ if (exists == null)
+ {
+ // Table doesn't exist, add empty table data.
+ tables.Add(tableData);
+ continue;
+ }
+
+ // Get column names for the table.
+ await using var columnsCommand = connection.CreateCommand();
+ columnsCommand.CommandText = $"PRAGMA table_info({tableName})";
+ var columns = new List<string>();
+ await using (var columnsReader = await columnsCommand.ExecuteReaderAsync())
+ {
+ while (await columnsReader.ReadAsync())
+ {
+ columns.Add(columnsReader.GetString(1));
+ }
+ }
+
+ // Read all records from the table.
+ await using var selectCommand = connection.CreateCommand();
+ selectCommand.CommandText = $"SELECT * FROM {tableName}";
+ await using var reader = await selectCommand.ExecuteReaderAsync();
+
+ while (await reader.ReadAsync())
+ {
+ var record = new Dictionary<string, object?>();
+ for (var i = 0; i < columns.Count; i++)
+ {
+ var value = reader.GetValue(i);
+
+ // Convert DBNull to null for proper JSON serialization.
+ record[columns[i]] = value == DBNull.Value ? null : value;
+ }
+
+ tableData.Records.Add(record);
+ }
+
+ tables.Add(tableData);
+ }
+
+ return tables;
+ }
+
+ /// <summary>
+ /// Executes the SQL statements returned by the Rust merge operation.
+ /// </summary>
+ /// <param name="statements">The SQL statements to execute.</param>
+ /// <returns>Task.</returns>
+ private async Task ExecuteMergeSqlStatementsAsync(List<SqlStatement> statements)
+ {
+ if (statements.Count == 0)
+ {
+ _logger.LogDebug("No SQL statements to execute from merge.");
+ return;
+ }
+
+ _logger.LogDebug("Executing {Count} SQL statements from merge.", statements.Count);
+
+ // Disable foreign key checks during merge execution.
+ await using (var pragmaCommand = _sqlConnection!.CreateCommand())
+ {
+ pragmaCommand.CommandText = "PRAGMA foreign_keys = OFF;";
+ await pragmaCommand.ExecuteNonQueryAsync();
+ }
+
+ try
+ {
+ foreach (var statement in statements)
+ {
+ await using var command = _sqlConnection!.CreateCommand();
+ command.CommandText = statement.Sql;
+
+ // Add parameters in order (SQLite uses positional parameters with ?).
+ for (var i = 0; i < statement.Params.Count; i++)
+ {
+ var value = statement.Params[i];
+
+ // Handle JsonElement values from deserialization.
+ if (value is JsonElement jsonElement)
+ {
+ value = ConvertJsonElementToValue(jsonElement);
+ }
+
+ command.Parameters.AddWithValue($"@p{i}", value ?? DBNull.Value);
+ }
+
+ // Replace ? placeholders with named parameters.
+ var paramIndex = 0;
+ var sql = statement.Sql;
+ while (sql.Contains('?'))
+ {
+ var pos = sql.IndexOf('?');
+ sql = sql[..pos] + $"@p{paramIndex}" + sql[(pos + 1)..];
+ paramIndex++;
+ }
+
+ command.CommandText = sql;
+ await command.ExecuteNonQueryAsync();
+ }
+ }
+ finally
+ {
+ // Re-enable foreign key checks.
+ await using var pragmaCommand = _sqlConnection!.CreateCommand();
+ pragmaCommand.CommandText = "PRAGMA foreign_keys = ON;";
+ await pragmaCommand.ExecuteNonQueryAsync();
+ }
+ }
+
/// <summary>
/// Disposes the service.
/// </summary>
diff --git a/apps/server/AliasVault.Client/Services/Native/MergeInput.cs b/apps/server/AliasVault.Client/Services/Native/MergeInput.cs
new file mode 100644
index 000000000..df1d97457
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/MergeInput.cs
@@ -0,0 +1,28 @@
+//-----------------------------------------------------------------------
+// <copyright file="MergeInput.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.Native;
+
+using System.Text.Json.Serialization;
+
+/// <summary>
+/// Input for the vault merge operation.
+/// </summary>
+public class MergeInput
+{
+ /// <summary>
+ /// Gets or sets tables from the local database.
+ /// </summary>
+ [JsonPropertyName("local_tables")]
+ public List<TableData> LocalTables { get; set; } = [];
+
+ /// <summary>
+ /// Gets or sets tables from the server database.
+ /// </summary>
+ [JsonPropertyName("server_tables")]
+ public List<TableData> ServerTables { get; set; } = [];
+}
diff --git a/apps/server/AliasVault.Client/Services/Native/MergeOutput.cs b/apps/server/AliasVault.Client/Services/Native/MergeOutput.cs
new file mode 100644
index 000000000..55ee305e6
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/MergeOutput.cs
@@ -0,0 +1,40 @@
+//-----------------------------------------------------------------------
+// <copyright file="MergeOutput.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.Native;
+
+using System.Text.Json.Serialization;
+
+/// <summary>
+/// Output of the merge operation.
+/// </summary>
+public class MergeOutput
+{
+ /// <summary>
+ /// Gets or sets a value indicating whether the merge was successful.
+ /// </summary>
+ [JsonPropertyName("success")]
+ public bool Success { get; set; }
+
+ /// <summary>
+ /// Gets or sets SQL statements to execute on the local database (in order).
+ /// </summary>
+ [JsonPropertyName("statements")]
+ public List<SqlStatement> Statements { get; set; } = [];
+
+ /// <summary>
+ /// Gets or sets overall statistics.
+ /// </summary>
+ [JsonPropertyName("stats")]
+ public MergeStats Stats { get; set; } = new();
+
+ /// <summary>
+ /// Gets or sets error message if success is false.
+ /// </summary>
+ [JsonPropertyName("error")]
+ public string? Error { get; set; }
+}
diff --git a/apps/server/AliasVault.Client/Services/Native/MergeStats.cs b/apps/server/AliasVault.Client/Services/Native/MergeStats.cs
new file mode 100644
index 000000000..be0868778
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/MergeStats.cs
@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+// <copyright file="MergeStats.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.Native;
+
+using System.Text.Json.Serialization;
+
+/// <summary>
+/// Statistics about what was merged.
+/// </summary>
+public class MergeStats
+{
+ /// <summary>
+ /// Gets or sets the number of tables processed.
+ /// </summary>
+ [JsonPropertyName("tables_processed")]
+ public int TablesProcessed { get; set; }
+
+ /// <summary>
+ /// Gets or sets records where local version was kept.
+ /// </summary>
+ [JsonPropertyName("records_from_local")]
+ public int RecordsFromLocal { get; set; }
+
+ /// <summary>
+ /// Gets or sets records where server version was used (updates).
+ /// </summary>
+ [JsonPropertyName("records_from_server")]
+ public int RecordsFromServer { get; set; }
+
+ /// <summary>
+ /// Gets or sets records that only existed locally (created offline).
+ /// </summary>
+ [JsonPropertyName("records_created_locally")]
+ public int RecordsCreatedLocally { get; set; }
+
+ /// <summary>
+ /// Gets or sets number of conflicts resolved (both had the record).
+ /// </summary>
+ [JsonPropertyName("conflicts")]
+ public int Conflicts { get; set; }
+
+ /// <summary>
+ /// Gets or sets records inserted from server (server-only records).
+ /// </summary>
+ [JsonPropertyName("records_inserted")]
+ public int RecordsInserted { get; set; }
+}
diff --git a/apps/server/AliasVault.Client/Services/Native/RustCore.cs b/apps/server/AliasVault.Client/Services/Native/RustCore.cs
new file mode 100644
index 000000000..81c39af41
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/RustCore.cs
@@ -0,0 +1,166 @@
+//-----------------------------------------------------------------------
+// <copyright file="RustCore.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.Native;
+
+using System.Text.Json;
+using Microsoft.JSInterop;
+
+/// <summary>
+/// JavaScript interop wrapper for the Rust WASM core library.
+/// Provides vault merge and credential matching functionality via WASM.
+/// </summary>
+public class RustCore : IAsyncDisposable
+{
+ private static readonly JsonSerializerOptions JsonOptions = new()
+ {
+ PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+ WriteIndented = false,
+ };
+
+ private readonly IJSRuntime jsRuntime;
+ private bool? isAvailable;
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="RustCore"/> class.
+ /// </summary>
+ /// <param name="jsRuntime">The JS runtime for interop.</param>
+ public RustCore(IJSRuntime jsRuntime)
+ {
+ this.jsRuntime = jsRuntime;
+ }
+
+ /// <summary>
+ /// Check if the Rust WASM module is available.
+ /// </summary>
+ /// <returns>True if the WASM module is loaded and available.</returns>
+ public async Task<bool> IsAvailableAsync()
+ {
+ if (isAvailable.HasValue)
+ {
+ return isAvailable.Value;
+ }
+
+ try
+ {
+ isAvailable = await jsRuntime.InvokeAsync<bool>("rustCoreIsAvailable");
+ return isAvailable.Value;
+ }
+ catch
+ {
+ isAvailable = false;
+ return false;
+ }
+ }
+
+ /// <summary>
+ /// Merge two vaults using Last-Write-Wins (LWW) strategy.
+ /// </summary>
+ /// <param name="input">The merge input containing local and server tables.</param>
+ /// <returns>The merge output with SQL statements to execute.</returns>
+ /// <exception cref="InvalidOperationException">Thrown if merge fails or WASM module is unavailable.</exception>
+ public async Task<MergeOutput> MergeVaultsAsync(MergeInput input)
+ {
+ if (!await IsAvailableAsync())
+ {
+ throw new InvalidOperationException("Rust WASM module is not available.");
+ }
+
+ var inputJson = JsonSerializer.Serialize(input, JsonOptions);
+ var resultJson = await jsRuntime.InvokeAsync<string>("rustCoreMergeVaults", inputJson);
+
+ if (string.IsNullOrEmpty(resultJson))
+ {
+ throw new InvalidOperationException("Merge operation returned empty result.");
+ }
+
+ var result = JsonSerializer.Deserialize<MergeOutput>(resultJson, JsonOptions);
+ if (result == null)
+ {
+ throw new InvalidOperationException("Failed to deserialize merge result.");
+ }
+
+ if (!result.Success && !string.IsNullOrEmpty(result.Error))
+ {
+ throw new InvalidOperationException($"Merge failed: {result.Error}");
+ }
+
+ return result;
+ }
+
+ /// <summary>
+ /// Get the list of table names that need to be synced.
+ /// </summary>
+ /// <returns>Array of table names.</returns>
+ public async Task<string[]> GetSyncableTableNamesAsync()
+ {
+ if (!await IsAvailableAsync())
+ {
+ return SyncableTables.Names;
+ }
+
+ try
+ {
+ var result = await jsRuntime.InvokeAsync<string[]>("rustCoreGetSyncableTableNames");
+ return result ?? SyncableTables.Names;
+ }
+ catch
+ {
+ return SyncableTables.Names;
+ }
+ }
+
+ /// <summary>
+ /// Extract domain from URL.
+ /// </summary>
+ /// <param name="url">The URL to extract domain from.</param>
+ /// <returns>The extracted domain.</returns>
+ public async Task<string> ExtractDomainAsync(string url)
+ {
+ if (!await IsAvailableAsync())
+ {
+ return string.Empty;
+ }
+
+ try
+ {
+ return await jsRuntime.InvokeAsync<string>("rustCoreExtractDomain", url);
+ }
+ catch
+ {
+ return string.Empty;
+ }
+ }
+
+ /// <summary>
+ /// Extract root domain from a domain string.
+ /// </summary>
+ /// <param name="domain">The domain to extract root from.</param>
+ /// <returns>The root domain.</returns>
+ public async Task<string> ExtractRootDomainAsync(string domain)
+ {
+ if (!await IsAvailableAsync())
+ {
+ return string.Empty;
+ }
+
+ try
+ {
+ return await jsRuntime.InvokeAsync<string>("rustCoreExtractRootDomain", domain);
+ }
+ catch
+ {
+ return string.Empty;
+ }
+ }
+
+ /// <inheritdoc/>
+ public ValueTask DisposeAsync()
+ {
+ return ValueTask.CompletedTask;
+ }
+}
diff --git a/apps/server/AliasVault.Client/Services/Native/SqlStatement.cs b/apps/server/AliasVault.Client/Services/Native/SqlStatement.cs
new file mode 100644
index 000000000..38f90301f
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/SqlStatement.cs
@@ -0,0 +1,28 @@
+//-----------------------------------------------------------------------
+// <copyright file="SqlStatement.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.Native;
+
+using System.Text.Json.Serialization;
+
+/// <summary>
+/// A SQL statement with its parameter values, generated by the merge operation.
+/// </summary>
+public class SqlStatement
+{
+ /// <summary>
+ /// Gets or sets the SQL query with ? placeholders.
+ /// </summary>
+ [JsonPropertyName("sql")]
+ public string Sql { get; set; } = string.Empty;
+
+ /// <summary>
+ /// Gets or sets parameter values in order.
+ /// </summary>
+ [JsonPropertyName("params")]
+ public List<object?> Params { get; set; } = [];
+}
diff --git a/apps/server/AliasVault.Client/Services/Native/SyncableTables.cs b/apps/server/AliasVault.Client/Services/Native/SyncableTables.cs
new file mode 100644
index 000000000..768e64b8b
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/SyncableTables.cs
@@ -0,0 +1,32 @@
+//-----------------------------------------------------------------------
+// <copyright file="SyncableTables.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.Native;
+
+/// <summary>
+/// List of syncable table names that need to be read for merge operations.
+/// </summary>
+public static class SyncableTables
+{
+ /// <summary>
+ /// Table names that need LWW merge.
+ /// </summary>
+ public static readonly string[] Names =
+ [
+ "Items",
+ "FieldValues",
+ "Folders",
+ "Tags",
+ "ItemTags",
+ "Attachments",
+ "TotpCodes",
+ "Passkeys",
+ "FieldDefinitions",
+ "FieldHistories",
+ "Logos",
+ ];
+}
diff --git a/apps/server/AliasVault.Client/Services/Native/TableData.cs b/apps/server/AliasVault.Client/Services/Native/TableData.cs
new file mode 100644
index 000000000..ff1519163
--- /dev/null
+++ b/apps/server/AliasVault.Client/Services/Native/TableData.cs
@@ -0,0 +1,28 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableData.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.Native;
+
+using System.Text.Json.Serialization;
+
+/// <summary>
+/// Data for a single database table, used in vault merge operations.
+/// </summary>
+public class TableData
+{
+ /// <summary>
+ /// Gets or sets the table name.
+ /// </summary>
+ [JsonPropertyName("name")]
+ public string Name { get; set; } = string.Empty;
+
+ /// <summary>
+ /// Gets or sets all records in this table as dictionaries.
+ /// </summary>
+ [JsonPropertyName("records")]
+ public List<Dictionary<string, object?>> Records { get; set; } = [];
+}
diff --git a/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js b/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
new file mode 100644
index 000000000..0a08547b8
--- /dev/null
+++ b/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
@@ -0,0 +1,175 @@
+// Rust Core WASM Interop for Blazor
+// This module provides JavaScript functions that Blazor can call via JSInterop
+// to access the Rust WASM merge and credential matching functionality.
+
+let wasmModule = null;
+let isInitialized = false;
+let initPromise = null;
+
+/**
+ * Initialize the Rust WASM module.
+ * @returns {Promise<boolean>} True if initialization succeeded.
+ */
+async function initRustCore() {
+ if (isInitialized) {
+ return true;
+ }
+
+ if (initPromise) {
+ return initPromise;
+ }
+
+ initPromise = (async () => {
+ try {
+ // Fetch the WASM binary first
+ const wasmResponse = await fetch('/wasm/aliasvault_core_bg.wasm');
+ if (!wasmResponse.ok) {
+ throw new Error(`Failed to fetch WASM: ${wasmResponse.status}`);
+ }
+ const wasmBytes = await wasmResponse.arrayBuffer();
+
+ // Dynamically import the ES module
+ const module = await import('/wasm/aliasvault_core.js');
+
+ // Initialize the WASM module with the binary bytes
+ await module.default(wasmBytes);
+
+ // Call init to set up panic hook
+ if (typeof module.init === 'function') {
+ module.init();
+ }
+
+ wasmModule = module;
+ isInitialized = true;
+ console.log('[RustCore] WASM module initialized successfully');
+ return true;
+ } catch (error) {
+ console.error('[RustCore] Failed to initialize WASM module:', error);
+ isInitialized = false;
+ initPromise = null; // Allow retry on failure
+ return false;
+ }
+ })();
+
+ return initPromise;
+}
+
+/**
+ * Check if the Rust WASM module is available.
+ * @returns {Promise<boolean>} True if available.
+ */
+window.rustCoreIsAvailable = async function() {
+ return await initRustCore();
+};
+
+/**
+ * Merge two vaults using LWW strategy.
+ * @param {string} inputJson - JSON string containing MergeInput.
+ * @returns {Promise<string>} JSON string containing MergeOutput.
+ */
+window.rustCoreMergeVaults = async function(inputJson) {
+ if (!await initRustCore()) {
+ return JSON.stringify({
+ success: false,
+ error: 'Rust WASM module not available',
+ statements: [],
+ stats: {}
+ });
+ }
+
+ try {
+ const result = wasmModule.mergeVaultsJson(inputJson);
+ return result;
+ } catch (error) {
+ console.error('[RustCore] Merge failed:', error);
+ return JSON.stringify({
+ success: false,
+ error: error.toString(),
+ statements: [],
+ stats: {}
+ });
+ }
+};
+
+/**
+ * Filter credentials for autofill.
+ * @param {string} inputJson - JSON string containing CredentialMatcherInput.
+ * @returns {Promise<string>} JSON string containing CredentialMatcherOutput.
+ */
+window.rustCoreFilterCredentials = async function(inputJson) {
+ if (!await initRustCore()) {
+ return JSON.stringify({
+ matches: [],
+ error: 'Rust WASM module not available'
+ });
+ }
+
+ try {
+ const result = wasmModule.filterCredentialsJson(inputJson);
+ return result;
+ } catch (error) {
+ console.error('[RustCore] Filter credentials failed:', error);
+ return JSON.stringify({
+ matches: [],
+ error: error.toString()
+ });
+ }
+};
+
+/**
+ * Get the list of syncable table names.
+ * @returns {Promise<string[]>} Array of table names.
+ */
+window.rustCoreGetSyncableTableNames = async function() {
+ if (!await initRustCore()) {
+ // Return default list if WASM not available
+ return [
+ 'Items', 'FieldValues', 'Folders', 'Tags', 'ItemTags',
+ 'Attachments', 'TotpCodes', 'Passkeys', 'FieldDefinitions',
+ 'FieldHistories', 'Logos'
+ ];
+ }
+
+ try {
+ return wasmModule.getSyncableTableNames();
+ } catch (error) {
+ console.error('[RustCore] Get syncable table names failed:', error);
+ return [];
+ }
+};
+
+/**
+ * Extract domain from URL.
+ * @param {string} url - The URL to extract domain from.
+ * @returns {Promise<string>} The extracted domain.
+ */
+window.rustCoreExtractDomain = async function(url) {
+ if (!await initRustCore()) {
+ return '';
+ }
+
+ try {
+ return wasmModule.extractDomain(url);
+ } catch (error) {
+ console.error('[RustCore] Extract domain failed:', error);
+ return '';
+ }
+};
+
+/**
+ * Extract root domain from a domain string.
+ * @param {string} domain - The domain to extract root from.
+ * @returns {Promise<string>} The root domain.
+ */
+window.rustCoreExtractRootDomain = async function(domain) {
+ if (!await initRustCore()) {
+ return '';
+ }
+
+ try {
+ return wasmModule.extractRootDomain(domain);
+ } catch (error) {
+ console.error('[RustCore] Extract root domain failed:', error);
+ return '';
+ }
+};
diff --git a/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js
new file mode 100644
index 000000000..8b76896bc
--- /dev/null
+++ b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core.js
@@ -0,0 +1,743 @@
+let wasm;
+
+function addHeapObject(obj) {
+ if (heap_next === heap.length) heap.push(heap.length + 1);
+ const idx = heap_next;
+ heap_next = heap[idx];
+
+ heap[idx] = obj;
+ return idx;
+}
+
+function debugString(val) {
+ // primitive types
+ const type = typeof val;
+ if (type == 'number' || type == 'boolean' || val == null) {
+ return `${val}`;
+ }
+ if (type == 'string') {
+ return `"${val}"`;
+ }
+ if (type == 'symbol') {
+ const description = val.description;
+ if (description == null) {
+ return 'Symbol';
+ } else {
+ return `Symbol(${description})`;
+ }
+ }
+ if (type == 'function') {
+ const name = val.name;
+ if (typeof name == 'string' && name.length > 0) {
+ return `Function(${name})`;
+ } else {
+ return 'Function';
+ }
+ }
+ // objects
+ if (Array.isArray(val)) {
+ const length = val.length;
+ let debug = '[';
+ if (length > 0) {
+ debug += debugString(val[0]);
+ }
+ for(let i = 1; i < length; i++) {
+ debug += ', ' + debugString(val[i]);
+ }
+ debug += ']';
+ return debug;
+ }
+ // Test for built-in
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+ let className;
+ if (builtInMatches && builtInMatches.length > 1) {
+ className = builtInMatches[1];
+ } else {
+ // Failed to match the standard '[object ClassName]'
+ return toString.call(val);
+ }
+ if (className == 'Object') {
+ // we're a user defined class or Object
+ // JSON.stringify avoids problems with cycles, and is generally much
+ // easier than looping through ownProperties of `val`.
+ try {
+ return 'Object(' + JSON.stringify(val) + ')';
+ } catch (_) {
+ return 'Object';
+ }
+ }
+ // errors
+ if (val instanceof Error) {
+ return `${val.name}: ${val.message}\n${val.stack}`;
+ }
+ // TODO we could test for more things here, like `Set`s and `Map`s.
+ return className;
+}
+
+function dropObject(idx) {
+ if (idx < 132) return;
+ heap[idx] = heap_next;
+ heap_next = idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ const mem = getDataViewMemory0();
+ const result = [];
+ for (let i = ptr; i < ptr + 4 * len; i += 4) {
+ result.push(takeObject(mem.getUint32(i, true)));
+ }
+ return result;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+ }
+ return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+ }
+ return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+ try {
+ return f.apply(this, args);
+ } catch (e) {
+ wasm.__wbindgen_export3(addHeapObject(e));
+ }
+}
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+ return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+ if (realloc === undefined) {
+ const buf = cachedTextEncoder.encode(arg);
+ const ptr = malloc(buf.length, 1) >>> 0;
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+ WASM_VECTOR_LEN = buf.length;
+ return ptr;
+ }
+
+ let len = arg.length;
+ let ptr = malloc(len, 1) >>> 0;
+
+ const mem = getUint8ArrayMemory0();
+
+ let offset = 0;
+
+ for (; offset < len; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+ if (offset !== len) {
+ if (offset !== 0) {
+ arg = arg.slice(offset);
+ }
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+ const ret = cachedTextEncoder.encodeInto(arg, view);
+
+ offset += ret.written;
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
+ }
+
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+}
+
+function takeObject(idx) {
+ const ret = getObject(idx);
+ dropObject(idx);
+ return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+ numBytesDecoded += len;
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+ cachedTextDecoder.decode();
+ numBytesDecoded = len;
+ }
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+ cachedTextEncoder.encodeInto = function (arg, view) {
+ const buf = cachedTextEncoder.encode(arg);
+ view.set(buf);
+ return {
+ read: arg.length,
+ written: buf.length
+ };
+ }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+/**
+ * Extract domain from URL.
+ *
+ * Handles both full URLs and partial domains, returning normalized domain
+ * without protocol, www prefix, path, query, or fragment.
+ * @param {string} url
+ * @returns {string}
+ */
+export function extractDomain(url) {
+ let deferred2_0;
+ let deferred2_1;
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ const ptr0 = passStringToWasm0(url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ const len0 = WASM_VECTOR_LEN;
+ wasm.extractDomain(retptr, ptr0, len0);
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+ deferred2_0 = r0;
+ deferred2_1 = r1;
+ return getStringFromWasm0(r0, r1);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+ }
+}
+
+/**
+ * Extract root domain from a domain string.
+ *
+ * E.g., "sub.example.com" -> "example.com"
+ * E.g., "sub.example.co.uk" -> "example.co.uk"
+ * @param {string} domain
+ * @returns {string}
+ */
+export function extractRootDomain(domain) {
+ let deferred2_0;
+ let deferred2_1;
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ const ptr0 = passStringToWasm0(domain, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ const len0 = WASM_VECTOR_LEN;
+ wasm.extractRootDomain(retptr, ptr0, len0);
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+ deferred2_0 = r0;
+ deferred2_1 = r1;
+ return getStringFromWasm0(r0, r1);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+ }
+}
+
+/**
+ * Filter credentials for autofill.
+ *
+ * Takes a JsValue (CredentialMatcherInput) and returns a JsValue (CredentialMatcherOutput).
+ * @param {any} input
+ * @returns {any}
+ */
+export function filterCredentials(input) {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.filterCredentials(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);
+ }
+}
+
+/**
+ * Filter credentials using JSON strings (alternative API).
+ *
+ * Takes a JSON string and returns a JSON string.
+ * @param {string} input_json
+ * @returns {string}
+ */
+export function filterCredentialsJson(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.filterCredentialsJson(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);
+ }
+}
+
+/**
+ * Get the list of table names that need to be synced.
+ * @returns {string[]}
+ */
+export function getSyncableTableNames() {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.getSyncableTableNames(retptr);
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+ wasm.__wbindgen_export4(r0, r1 * 4, 4);
+ return v1;
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ }
+}
+
+/**
+ * Initialize panic hook for better error messages.
+ */
+export function init() {
+ wasm.init();
+}
+
+/**
+ * Merge vaults using LWW strategy.
+ *
+ * Takes a JsValue (MergeInput) and returns a JsValue (MergeOutput).
+ * @param {any} input
+ * @returns {any}
+ */
+export function mergeVaults(input) {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.mergeVaults(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);
+ }
+}
+
+/**
+ * Merge vaults using JSON strings (alternative API).
+ *
+ * Takes a JSON string and returns a JSON string.
+ * @param {string} input_json
+ * @returns {string}
+ */
+export function mergeVaultsJson(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.mergeVaultsJson(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) {
+ if (typeof Response === 'function' && module instanceof Response) {
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
+ try {
+ return await WebAssembly.instantiateStreaming(module, imports);
+ } catch (e) {
+ const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+ if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ const bytes = await module.arrayBuffer();
+ return await WebAssembly.instantiate(bytes, imports);
+ } else {
+ const instance = await WebAssembly.instantiate(module, imports);
+
+ if (instance instanceof WebAssembly.Instance) {
+ return { instance, module };
+ } else {
+ return instance;
+ }
+ }
+}
+
+function __wbg_get_imports() {
+ const imports = {};
+ imports.wbg = {};
+ imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+ const ret = Error(getStringFromWasm0(arg0, arg1));
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+ const ret = String(getObject(arg1));
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
+ const v = getObject(arg1);
+ const ret = typeof(v) === 'bigint' ? v : undefined;
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+ };
+ imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+ const v = getObject(arg0);
+ const ret = typeof(v) === 'boolean' ? v : undefined;
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+ };
+ imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+ const ret = debugString(getObject(arg1));
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
+ const ret = getObject(arg0) in getObject(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
+ const ret = typeof(getObject(arg0)) === 'bigint';
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+ const ret = typeof(getObject(arg0)) === 'function';
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+ const val = getObject(arg0);
+ const ret = typeof(val) === 'object' && val !== null;
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
+ const ret = typeof(getObject(arg0)) === 'string';
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+ const ret = getObject(arg0) === undefined;
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
+ const ret = getObject(arg0) === getObject(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+ const ret = getObject(arg0) == getObject(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+ const obj = getObject(arg1);
+ const ret = typeof(obj) === 'number' ? obj : undefined;
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+ };
+ imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+ const obj = getObject(arg1);
+ const ret = typeof(obj) === 'string' ? obj : undefined;
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+ throw new Error(getStringFromWasm0(arg0, arg1));
+ };
+ imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+ const ret = getObject(arg0).call(getObject(arg1));
+ return addHeapObject(ret);
+ }, arguments) };
+ imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+ const ret = getObject(arg0).done;
+ return ret;
+ };
+ imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
+ const ret = Object.entries(getObject(arg0));
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+ let deferred0_0;
+ let deferred0_1;
+ try {
+ deferred0_0 = arg0;
+ deferred0_1 = arg1;
+ console.error(getStringFromWasm0(arg0, arg1));
+ } finally {
+ wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+ }
+ };
+ imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+ const ret = getObject(arg0)[arg1 >>> 0];
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
+ return addHeapObject(ret);
+ }, arguments) };
+ imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
+ const ret = getObject(arg0)[getObject(arg1)];
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+ let result;
+ try {
+ result = getObject(arg0) instanceof ArrayBuffer;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_Map_084be8da74364158 = function(arg0) {
+ let result;
+ try {
+ result = getObject(arg0) instanceof Map;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+ let result;
+ try {
+ result = getObject(arg0) instanceof Uint8Array;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+ const ret = Array.isArray(getObject(arg0));
+ return ret;
+ };
+ imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
+ const ret = Number.isSafeInteger(getObject(arg0));
+ return ret;
+ };
+ imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+ const ret = Symbol.iterator;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+ const ret = getObject(arg0).length;
+ return ret;
+ };
+ imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+ const ret = getObject(arg0).length;
+ return ret;
+ };
+ imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+ const ret = new Object();
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+ const ret = new Array();
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+ const ret = new Uint8Array(getObject(arg0));
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+ const ret = new Error();
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_new_b546ae120718850e = function() {
+ const ret = new Map();
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+ const ret = getObject(arg0).next;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
+ const ret = getObject(arg0).next();
+ return addHeapObject(ret);
+ }, arguments) };
+ imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+ };
+ imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+ };
+ imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+ };
+ imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+ const ret = getObject(arg1).stack;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+ const ret = getObject(arg0).value;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(String) -> Externref`.
+ const ret = getStringFromWasm0(arg0, arg1);
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+ // Cast intrinsic for `U64 -> Externref`.
+ const ret = BigInt.asUintN(64, arg0);
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+ // Cast intrinsic for `I64 -> Externref`.
+ const ret = arg0;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+ // Cast intrinsic for `F64 -> Externref`.
+ const ret = arg0;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+ const ret = getObject(arg0);
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+ takeObject(arg0);
+ };
+
+ return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+ wasm = instance.exports;
+ __wbg_init.__wbindgen_wasm_module = module;
+ cachedDataViewMemory0 = null;
+ cachedUint8ArrayMemory0 = null;
+
+
+ wasm.__wbindgen_start();
+ return wasm;
+}
+
+function initSync(module) {
+ if (wasm !== undefined) return wasm;
+
+
+ if (typeof module !== 'undefined') {
+ if (Object.getPrototypeOf(module) === Object.prototype) {
+ ({module} = module)
+ } else {
+ console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+ }
+ }
+
+ const imports = __wbg_get_imports();
+ if (!(module instanceof WebAssembly.Module)) {
+ module = new WebAssembly.Module(module);
+ }
+ const instance = new WebAssembly.Instance(module, imports);
+ return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+ if (wasm !== undefined) return wasm;
+
+
+ if (typeof module_or_path !== 'undefined') {
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+ ({module_or_path} = module_or_path)
+ } else {
+ console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+ }
+ }
+
+ if (typeof module_or_path === 'undefined') {
+ module_or_path = new URL('aliasvault_core_bg.wasm', import.meta.url);
+ }
+ const imports = __wbg_get_imports();
+
+ if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+ module_or_path = fetch(module_or_path);
+ }
+
+ const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;
diff --git a/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm
new file mode 100644
index 000000000..d86832e86
Binary files /dev/null and b/apps/server/AliasVault.Client/wwwroot/wasm/aliasvault_core_bg.wasm differ
diff --git a/apps/server/Databases/AliasClientDb/Models/SystemFieldRegistry.cs b/apps/server/Databases/AliasClientDb/Models/SystemFieldRegistry.cs
new file mode 100644
index 000000000..e165bf19f
--- /dev/null
+++ b/apps/server/Databases/AliasClientDb/Models/SystemFieldRegistry.cs
@@ -0,0 +1,289 @@
+// <auto-generated />
+// This file is auto-generated from core/models/src/vault/SystemFieldRegistry.ts
+// Do not edit this file directly. Run 'npm run generate:models' to regenerate.
+
+#nullable enable
+
+namespace AliasClientDb.Models;
+
+/// <summary>
+/// Field categories for grouping in UI.
+/// </summary>
+public enum FieldCategory
+{
+ /// <summary>Primary fields.</summary>
+ Primary,
+ /// <summary>Login fields.</summary>
+ Login,
+ /// <summary>Alias fields.</summary>
+ Alias,
+ /// <summary>Card fields.</summary>
+ Card,
+ /// <summary>Custom fields.</summary>
+ Custom,
+ /// <summary>Notes fields.</summary>
+ Notes,
+ /// <summary>Metadata fields.</summary>
+ Metadata
+}
+
+/// <summary>
+/// Per-item-type configuration for a system field.
+/// </summary>
+/// <param name="ShowByDefault">Whether this field is shown by default in create mode (vs. hidden behind an "add" button)</param>
+public record ItemTypeFieldConfig(bool ShowByDefault);
+
+/// <summary>
+/// System field definition with metadata.
+/// </summary>
+/// <param name="FieldKey">Unique system field key (e.g., 'login.username')</param>
+/// <param name="FieldType">Field type for rendering/validation</param>
+/// <param name="IsHidden">Whether field is hidden/masked by default</param>
+/// <param name="IsMultiValue">Whether field supports multiple values</param>
+/// <param name="ApplicableToTypes">ApplicableToTypes</param>
+/// <param name="EnableHistory">Whether to track field value history</param>
+/// <param name="Category">Category for grouping in UI. 'Primary' fields are shown in the name block.</param>
+/// <param name="DefaultDisplayOrder">Default display order within category (lower = first)</param>
+public record SystemFieldDefinition(
+ string FieldKey,
+ string FieldType,
+ bool IsHidden,
+ bool IsMultiValue,
+ IReadOnlyDictionary<string, ItemTypeFieldConfig> ApplicableToTypes,
+ bool EnableHistory,
+ FieldCategory Category,
+ int DefaultDisplayOrder);
+
+/// <summary>
+/// Registry of all system-defined fields.
+/// These fields are immutable and their metadata is defined in code.
+/// </summary>
+public static class SystemFieldRegistry
+{
+ /// <summary>
+ /// All system field definitions indexed by field key.
+ /// </summary>
+ public static readonly IReadOnlyDictionary<string, SystemFieldDefinition> Fields =
+ new Dictionary<string, SystemFieldDefinition>
+ {
+ [FieldKey.LoginUsername] = new SystemFieldDefinition(
+ FieldKey: "login.username",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Login"] = new ItemTypeFieldConfig(true), ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: true,
+ Category: FieldCategory.Login,
+ DefaultDisplayOrder: 10),
+ [FieldKey.LoginPassword] = new SystemFieldDefinition(
+ FieldKey: "login.password",
+ FieldType: "Password",
+ IsHidden: true,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Login"] = new ItemTypeFieldConfig(true), ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: true,
+ Category: FieldCategory.Login,
+ DefaultDisplayOrder: 20),
+ [FieldKey.LoginEmail] = new SystemFieldDefinition(
+ FieldKey: "login.email",
+ FieldType: "Email",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Login"] = new ItemTypeFieldConfig(false), ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: true,
+ Category: FieldCategory.Login,
+ DefaultDisplayOrder: 15),
+ [FieldKey.LoginUrl] = new SystemFieldDefinition(
+ FieldKey: "login.url",
+ FieldType: "URL",
+ IsHidden: false,
+ IsMultiValue: true,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Login"] = new ItemTypeFieldConfig(true), ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Primary,
+ DefaultDisplayOrder: 5),
+ [FieldKey.AliasFirstName] = new SystemFieldDefinition(
+ FieldKey: "alias.first_name",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Alias,
+ DefaultDisplayOrder: 20),
+ [FieldKey.AliasLastName] = new SystemFieldDefinition(
+ FieldKey: "alias.last_name",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Alias,
+ DefaultDisplayOrder: 30),
+ [FieldKey.AliasGender] = new SystemFieldDefinition(
+ FieldKey: "alias.gender",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Alias,
+ DefaultDisplayOrder: 50),
+ [FieldKey.AliasBirthdate] = new SystemFieldDefinition(
+ FieldKey: "alias.birthdate",
+ FieldType: "Date",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Alias"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Alias,
+ DefaultDisplayOrder: 60),
+ [FieldKey.CardCardholderName] = new SystemFieldDefinition(
+ FieldKey: "card.cardholder_name",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["CreditCard"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Card,
+ DefaultDisplayOrder: 10),
+ [FieldKey.CardNumber] = new SystemFieldDefinition(
+ FieldKey: "card.number",
+ FieldType: "Hidden",
+ IsHidden: true,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["CreditCard"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Card,
+ DefaultDisplayOrder: 20),
+ [FieldKey.CardExpiryMonth] = new SystemFieldDefinition(
+ FieldKey: "card.expiry_month",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["CreditCard"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Card,
+ DefaultDisplayOrder: 30),
+ [FieldKey.CardExpiryYear] = new SystemFieldDefinition(
+ FieldKey: "card.expiry_year",
+ FieldType: "Text",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["CreditCard"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Card,
+ DefaultDisplayOrder: 40),
+ [FieldKey.CardCvv] = new SystemFieldDefinition(
+ FieldKey: "card.cvv",
+ FieldType: "Hidden",
+ IsHidden: true,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["CreditCard"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Card,
+ DefaultDisplayOrder: 50),
+ [FieldKey.CardPin] = new SystemFieldDefinition(
+ FieldKey: "card.pin",
+ FieldType: "Hidden",
+ IsHidden: true,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["CreditCard"] = new ItemTypeFieldConfig(false) },
+ EnableHistory: false,
+ Category: FieldCategory.Card,
+ DefaultDisplayOrder: 60),
+ [FieldKey.NotesContent] = new SystemFieldDefinition(
+ FieldKey: "notes.content",
+ FieldType: "TextArea",
+ IsHidden: false,
+ IsMultiValue: false,
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ["Login"] = new ItemTypeFieldConfig(false), ["Alias"] = new ItemTypeFieldConfig(false), ["CreditCard"] = new ItemTypeFieldConfig(false), ["Note"] = new ItemTypeFieldConfig(true) },
+ EnableHistory: false,
+ Category: FieldCategory.Notes,
+ DefaultDisplayOrder: 100)
+ };
+
+ /// <summary>
+ /// Get system field definition by key.
+ /// </summary>
+ /// <param name="fieldKey">The field key to look up.</param>
+ /// <returns>The field definition, or null if not found.</returns>
+ public static SystemFieldDefinition? GetSystemField(string fieldKey)
+ {
+ return Fields.TryGetValue(fieldKey, out var field) ? field : null;
+ }
+
+ /// <summary>
+ /// Check if a field key represents a system field.
+ /// </summary>
+ /// <param name="fieldKey">The field key to check.</param>
+ /// <returns>True if the field key is a system field.</returns>
+ public static bool IsSystemField(string fieldKey)
+ {
+ return Fields.ContainsKey(fieldKey);
+ }
+
+ /// <summary>
+ /// Check if a field applies to a specific item type.
+ /// </summary>
+ /// <param name="field">The field definition.</param>
+ /// <param name="itemType">The item type to check.</param>
+ /// <returns>True if the field applies to the item type.</returns>
+ public static bool FieldAppliesToType(SystemFieldDefinition field, string itemType)
+ {
+ return field.ApplicableToTypes.ContainsKey(itemType);
+ }
+
+ /// <summary>
+ /// Get all system fields applicable to a specific item type.
+ /// Results are sorted by DefaultDisplayOrder.
+ /// </summary>
+ /// <param name="itemType">The item type.</param>
+ /// <returns>Fields applicable to the item type.</returns>
+ public static IEnumerable<SystemFieldDefinition> GetFieldsForItemType(string itemType)
+ {
+ return Fields.Values
+ .Where(f => f.ApplicableToTypes.ContainsKey(itemType))
+ .OrderBy(f => f.DefaultDisplayOrder);
+ }
+
+ /// <summary>
+ /// Get system fields that should be shown by default for a specific item type.
+ /// Results are sorted by DefaultDisplayOrder.
+ /// </summary>
+ /// <param name="itemType">The item type.</param>
+ /// <returns>Fields shown by default for the item type.</returns>
+ public static IEnumerable<SystemFieldDefinition> GetDefaultFieldsForItemType(string itemType)
+ {
+ return Fields.Values
+ .Where(f => f.ApplicableToTypes.TryGetValue(itemType, out var config) && config.ShowByDefault)
+ .OrderBy(f => f.DefaultDisplayOrder);
+ }
+
+ /// <summary>
+ /// Get system fields that are NOT shown by default for a specific item type.
+ /// These are the fields that can be added via an "add field" button.
+ /// Results are sorted by DefaultDisplayOrder.
+ /// </summary>
+ /// <param name="itemType">The item type.</param>
+ /// <returns>Optional fields for the item type.</returns>
+ public static IEnumerable<SystemFieldDefinition> GetOptionalFieldsForItemType(string itemType)
+ {
+ return Fields.Values
+ .Where(f => f.ApplicableToTypes.TryGetValue(itemType, out var config) && !config.ShowByDefault)
+ .OrderBy(f => f.DefaultDisplayOrder);
+ }
+
+ /// <summary>
+ /// Check if a field key matches a known system field prefix.
+ /// </summary>
+ /// <param name="fieldKey">The field key to check.</param>
+ /// <returns>True if the field key has a system field prefix.</returns>
+ public static bool IsSystemFieldPrefix(string fieldKey)
+ {
+ return fieldKey.StartsWith("login.") ||
+ fieldKey.StartsWith("alias.") ||
+ fieldKey.StartsWith("card.") ||
+ fieldKey.StartsWith("notes.");
+ }
+}
diff --git a/core/models/scripts/generate-field-keys.cjs b/core/models/scripts/generate-field-keys.cjs
index 2039e0306..09ea1c65a 100755
--- a/core/models/scripts/generate-field-keys.cjs
+++ b/core/models/scripts/generate-field-keys.cjs
@@ -1,6 +1,7 @@
#!/usr/bin/env node
/**
- * Generates FieldKey constants for C#, Swift, and Kotlin from TypeScript source.
+ * Generates FieldKey constants and SystemFieldRegistry for C#, Swift, and Kotlin from TypeScript source.
+ * All type definitions are dynamically extracted from the TypeScript source files.
*/
const fs = require('fs');
@@ -9,7 +10,9 @@ const path = require('path');
// Paths
const REPO_ROOT = path.join(__dirname, '../../..');
const TS_SOURCE = path.join(REPO_ROOT, 'core/models/src/vault/FieldKey.ts');
+const TS_REGISTRY_SOURCE = path.join(REPO_ROOT, 'core/models/src/vault/SystemFieldRegistry.ts');
const CS_OUTPUT = path.join(REPO_ROOT, 'apps/server/Databases/AliasClientDb/Models/FieldKey.cs');
+const CS_REGISTRY_OUTPUT = path.join(REPO_ROOT, 'apps/server/Databases/AliasClientDb/Models/SystemFieldRegistry.cs');
const SWIFT_OUTPUT = path.join(REPO_ROOT, 'apps/mobile-app/ios/VaultModels/FieldKey.swift');
const KOTLIN_OUTPUT = path.join(REPO_ROOT, 'apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/models/FieldKey.kt');
@@ -50,7 +53,140 @@ function parseTypeScriptFieldKeys(tsContent) {
}
/**
- * Generate C# static class
+ * Parse FieldCategories from TypeScript source
+ * Returns an array of category names in order
+ */
+function parseFieldCategories(tsContent) {
+ const categories = [];
+
+ // Find the FieldCategories constant
+ const match = tsContent.match(/export const FieldCategories\s*=\s*\{([^}]+)\}/s);
+ if (!match) {
+ console.warn('Warning: Could not find FieldCategories in source');
+ return categories;
+ }
+
+ const body = match[1];
+ // Match each category: Primary: 'Primary',
+ const categoryRegex = /(\w+):\s*'(\w+)'/g;
+ let categoryMatch;
+
+ while ((categoryMatch = categoryRegex.exec(body)) !== null) {
+ categories.push(categoryMatch[1]);
+ }
+
+ return categories;
+}
+
+/**
+ * Parse ItemTypeFieldConfig type from TypeScript source
+ * Returns an array of property definitions
+ */
+function parseItemTypeFieldConfig(tsContent) {
+ const properties = [];
+
+ // Find the ItemTypeFieldConfig type
+ const match = tsContent.match(/export type ItemTypeFieldConfig\s*=\s*\{([^}]+)\}/s);
+ if (!match) {
+ console.warn('Warning: Could not find ItemTypeFieldConfig in source');
+ return properties;
+ }
+
+ const body = match[1];
+ // Match properties with comments
+ const lines = body.split('\n');
+ let currentComment = '';
+
+ for (const line of lines) {
+ const trimmed = line.trim();
+
+ // Capture comments
+ const commentMatch = trimmed.match(/\/\*\*\s*(.+)\s*\*\//);
+ if (commentMatch) {
+ currentComment = commentMatch[1].trim();
+ }
+
+ // Match property: PropertyName: type;
+ const propMatch = trimmed.match(/^(\w+):\s*(\w+);?$/);
+ if (propMatch) {
+ properties.push({
+ name: propMatch[1],
+ type: propMatch[2],
+ comment: currentComment
+ });
+ currentComment = '';
+ }
+ }
+
+ return properties;
+}
+
+/**
+ * Parse SystemFieldDefinition type from TypeScript source
+ * Returns an array of property definitions
+ */
+function parseSystemFieldDefinition(tsContent) {
+ const properties = [];
+
+ // Find the SystemFieldDefinition type
+ const match = tsContent.match(/export type SystemFieldDefinition\s*=\s*\{([\s\S]*?)\n\};/);
+ if (!match) {
+ console.warn('Warning: Could not find SystemFieldDefinition in source');
+ return properties;
+ }
+
+ const body = match[1];
+ const lines = body.split('\n');
+ let currentComment = '';
+
+ for (const line of lines) {
+ const trimmed = line.trim();
+
+ // Capture single-line comments
+ const singleCommentMatch = trimmed.match(/\/\*\*\s*(.+)\s*\*\//);
+ if (singleCommentMatch) {
+ currentComment = singleCommentMatch[1].trim();
+ continue;
+ }
+
+ // Match property definition
+ const propMatch = trimmed.match(/^(\w+):\s*(.+);?$/);
+ if (propMatch && !trimmed.startsWith('/*') && !trimmed.startsWith('*')) {
+ let propType = propMatch[2].replace(/;$/, '').trim();
+
+ // Simplify complex types for C# mapping
+ let csharpType = mapTypeToCSharp(propType);
+
+ properties.push({
+ name: propMatch[1],
+ tsType: propType,
+ csharpType: csharpType,
+ comment: currentComment
+ });
+ currentComment = '';
+ }
+ }
+
+ return properties;
+}
+
+/**
+ * Map TypeScript type to C# type
+ */
+function mapTypeToCSharp(tsType) {
+ if (tsType === 'string') return 'string';
+ if (tsType === 'boolean') return 'bool';
+ if (tsType === 'number') return 'int';
+ if (tsType === 'FieldType') return 'string'; // FieldType is a string union
+ if (tsType === 'FieldCategory') return 'FieldCategory';
+ if (tsType.includes('Partial<Record<ItemType, ItemTypeFieldConfig>>')) {
+ return 'IReadOnlyDictionary<string, ItemTypeFieldConfig>';
+ }
+ return 'string'; // Default fallback
+}
+
+/**
+ * Generate C# static class for FieldKey
*/
function generateCSharp(fieldKeys) {
const header = `// <auto-generated />
@@ -148,6 +284,322 @@ object FieldKey {`;
return header + '\n' + fields + footer;
}
+/**
+ * Parse the TypeScript SystemFieldRegistry.ts file and extract field definitions
+ */
+function parseSystemFieldRegistry(tsContent) {
+ const fields = {};
+
+ // Find the start of SystemFieldRegistry definition
+ const registryStart = tsContent.indexOf('export const SystemFieldRegistry');
+ if (registryStart === -1) {
+ return fields;
+ }
+
+ // Extract just the registry content
+ const registryContent = tsContent.slice(registryStart);
+
+ // Match each field definition block using a state machine approach
+ // Look for patterns like: 'login.username': {
+ const fieldStartRegex = /'([a-z]+\.[a-z_]+)':\s*\{/g;
+ let match;
+
+ while ((match = fieldStartRegex.exec(registryContent)) !== null) {
+ const fieldKey = match[1];
+ const startIdx = match.index + match[0].length;
+
+ // Find matching closing brace by counting braces
+ let braceCount = 1;
+ let endIdx = startIdx;
+ while (braceCount > 0 && endIdx < registryContent.length) {
+ if (registryContent[endIdx] === '{') braceCount++;
+ if (registryContent[endIdx] === '}') braceCount--;
+ endIdx++;
+ }
+
+ const fieldBody = registryContent.slice(startIdx, endIdx - 1);
+
+ // Skip if this doesn't look like a SystemFieldDefinition (needs FieldKey property)
+ if (!fieldBody.includes('FieldKey:')) {
+ continue;
+ }
+
+ const field = {
+ FieldKey: fieldKey,
+ FieldType: extractStringValue(fieldBody, 'FieldType'),
+ IsHidden: extractBoolValue(fieldBody, 'IsHidden'),
+ IsMultiValue: extractBoolValue(fieldBody, 'IsMultiValue'),
+ EnableHistory: extractBoolValue(fieldBody, 'EnableHistory'),
+ Category: extractEnumValue(fieldBody, 'Category', 'FieldCategories'),
+ DefaultDisplayOrder: extractNumberValue(fieldBody, 'DefaultDisplayOrder'),
+ ApplicableToTypes: extractApplicableToTypes(fieldBody)
+ };
+
+ fields[fieldKey] = field;
+ }
+
+ return fields;
+}
+
+/**
+ * Extract a string value from a field body
+ */
+function extractStringValue(body, propName) {
+ const match = body.match(new RegExp(`${propName}:\\s*'([^']+)'`));
+ return match ? match[1] : '';
+}
+
+/**
+ * Extract a boolean value from a field body
+ */
+function extractBoolValue(body, propName) {
+ const match = body.match(new RegExp(`${propName}:\\s*(true|false)`));
+ return match ? match[1] === 'true' : false;
+}
+
+/**
+ * Extract a number value from a field body
+ */
+function extractNumberValue(body, propName) {
+ const match = body.match(new RegExp(`${propName}:\\s*(\\d+)`));
+ return match ? parseInt(match[1], 10) : 0;
+}
+
+/**
+ * Extract an enum value from a field body (e.g., FieldCategories.Login -> Login)
+ */
+function extractEnumValue(body, propName, enumName) {
+ const match = body.match(new RegExp(`${propName}:\\s*${enumName}\\.(\\w+)`));
+ return match ? match[1] : '';
+}
+
+/**
+ * Extract ApplicableToTypes object from field body
+ */
+function extractApplicableToTypes(body) {
+ const applicableToTypes = {};
+
+ // Find the start of ApplicableToTypes
+ const startMatch = body.match(/ApplicableToTypes:\s*\{/);
+ if (!startMatch) {
+ return applicableToTypes;
+ }
+
+ const startIdx = startMatch.index + startMatch[0].length;
+
+ // Find matching closing brace by counting braces
+ let braceCount = 1;
+ let endIdx = startIdx;
+ while (braceCount > 0 && endIdx < body.length) {
+ if (body[endIdx] === '{') braceCount++;
+ if (body[endIdx] === '}') braceCount--;
+ endIdx++;
+ }
+
+ const typesBody = body.slice(startIdx, endIdx - 1);
+
+ // Match each item type configuration: ItemType: { ShowByDefault: bool }
+ const itemTypeRegex = /(\w+):\s*\{\s*ShowByDefault:\s*(true|false)\s*\}/g;
+ let typeMatch;
+
+ while ((typeMatch = itemTypeRegex.exec(typesBody)) !== null) {
+ const itemType = typeMatch[1];
+ const showByDefault = typeMatch[2] === 'true';
+ applicableToTypes[itemType] = { ShowByDefault: showByDefault };
+ }
+
+ return applicableToTypes;
+}
+
+/**
+ * Generate C# SystemFieldRegistry with full metadata
+ * All types are dynamically generated from the parsed TypeScript
+ */
+function generateCSharpSystemFieldRegistry(fields, categories, itemTypeFieldConfigProps, systemFieldDefProps) {
+ // Generate FieldCategory enum dynamically
+ const categoryEnum = categories.map((cat, index) => {
+ return ` /// <summary>${cat} fields.</summary>
+ ${cat}${index < categories.length - 1 ? ',' : ''}`;
+ }).join('\n');
+
+ // Generate ItemTypeFieldConfig record dynamically
+ const itemTypeFieldConfigParams = itemTypeFieldConfigProps
+ .map(p => `${mapTypeToCSharp(p.type)} ${p.name}`)
+ .join(', ');
+
+ // Generate SystemFieldDefinition record dynamically
+ const systemFieldDefParams = systemFieldDefProps
+ .map(p => `${p.csharpType} ${p.name}`)
+ .join(',\n ');
+
+ const systemFieldDefXmlParams = systemFieldDefProps
+ .map(p => `/// <param name="${p.name}">${p.comment || p.name}</param>`)
+ .join('\n');
+
+ const header = `// <auto-generated />
+// This file is auto-generated from core/models/src/vault/SystemFieldRegistry.ts
+// Do not edit this file directly. Run 'npm run generate:models' to regenerate.
+
+#nullable enable
+
+namespace AliasClientDb.Models;
+
+/// <summary>
+/// Field categories for grouping in UI.
+/// </summary>
+public enum FieldCategory
+{
+${categoryEnum}
+}
+
+/// <summary>
+/// Per-item-type configuration for a system field.
+/// </summary>
+${itemTypeFieldConfigProps.map(p => `/// <param name="${p.name}">${p.comment || p.name}</param>`).join('\n')}
+public record ItemTypeFieldConfig(${itemTypeFieldConfigParams});
+
+/// <summary>
+/// System field definition with metadata.
+/// </summary>
+${systemFieldDefXmlParams}
+public record SystemFieldDefinition(
+ ${systemFieldDefParams});
+
+/// <summary>
+/// Registry of all system-defined fields.
+/// These fields are immutable and their metadata is defined in code.
+/// </summary>
+public static class SystemFieldRegistry
+{
+ /// <summary>
+ /// All system field definitions indexed by field key.
+ /// </summary>
+ public static readonly IReadOnlyDictionary<string, SystemFieldDefinition> Fields =
+ new Dictionary<string, SystemFieldDefinition>
+ {
+`;
+
+ const fieldEntries = Object.entries(fields)
+ .map(([key, field]) => {
+ const applicableTypes = Object.entries(field.ApplicableToTypes)
+ .map(([type, config]) => `["${type}"] = new ItemTypeFieldConfig(${config.ShowByDefault})`)
+ .join(', ');
+
+ return ` [FieldKey.${fieldKeyToPropertyName(key)}] = new SystemFieldDefinition(
+ FieldKey: "${field.FieldKey}",
+ FieldType: "${field.FieldType}",
+ IsHidden: ${field.IsHidden.toString().toLowerCase()},
+ IsMultiValue: ${field.IsMultiValue.toString().toLowerCase()},
+ ApplicableToTypes: new Dictionary<string, ItemTypeFieldConfig> { ${applicableTypes} },
+ EnableHistory: ${field.EnableHistory.toString().toLowerCase()},
+ Category: FieldCategory.${field.Category},
+ DefaultDisplayOrder: ${field.DefaultDisplayOrder})`;
+ })
+ .join(',\n');
+
+ // Extract unique prefixes from field keys for IsSystemFieldPrefix
+ const prefixes = [...new Set(Object.keys(fields).map(k => k.split('.')[0]))];
+ const prefixChecks = prefixes.map(p => `fieldKey.StartsWith("${p}.")`).join(' ||\n ');
+
+ const methods = `
+ };
+
+ /// <summary>
+ /// Get system field definition by key.
+ /// </summary>
+ /// <param name="fieldKey">The field key to look up.</param>
+ /// <returns>The field definition, or null if not found.</returns>
+ public static SystemFieldDefinition? GetSystemField(string fieldKey)
+ {
+ return Fields.TryGetValue(fieldKey, out var field) ? field : null;
+ }
+
+ /// <summary>
+ /// Check if a field key represents a system field.
+ /// </summary>
+ /// <param name="fieldKey">The field key to check.</param>
+ /// <returns>True if the field key is a system field.</returns>
+ public static bool IsSystemField(string fieldKey)
+ {
+ return Fields.ContainsKey(fieldKey);
+ }
+
+ /// <summary>
+ /// Check if a field applies to a specific item type.
+ /// </summary>
+ /// <param name="field">The field definition.</param>
+ /// <param name="itemType">The item type to check.</param>
+ /// <returns>True if the field applies to the item type.</returns>
+ public static bool FieldAppliesToType(SystemFieldDefinition field, string itemType)
+ {
+ return field.ApplicableToTypes.ContainsKey(itemType);
+ }
+
+ /// <summary>
+ /// Get all system fields applicable to a specific item type.
+ /// Results are sorted by DefaultDisplayOrder.
+ /// </summary>
+ /// <param name="itemType">The item type.</param>
+ /// <returns>Fields applicable to the item type.</returns>
+ public static IEnumerable<SystemFieldDefinition> GetFieldsForItemType(string itemType)
+ {
+ return Fields.Values
+ .Where(f => f.ApplicableToTypes.ContainsKey(itemType))
+ .OrderBy(f => f.DefaultDisplayOrder);
+ }
+
+ /// <summary>
+ /// Get system fields that should be shown by default for a specific item type.
+ /// Results are sorted by DefaultDisplayOrder.
+ /// </summary>
+ /// <param name="itemType">The item type.</param>
+ /// <returns>Fields shown by default for the item type.</returns>
+ public static IEnumerable<SystemFieldDefinition> GetDefaultFieldsForItemType(string itemType)
+ {
+ return Fields.Values
+ .Where(f => f.ApplicableToTypes.TryGetValue(itemType, out var config) && config.ShowByDefault)
+ .OrderBy(f => f.DefaultDisplayOrder);
+ }
+
+ /// <summary>
+ /// Get system fields that are NOT shown by default for a specific item type.
+ /// These are the fields that can be added via an "add field" button.
+ /// Results are sorted by DefaultDisplayOrder.
+ /// </summary>
+ /// <param name="itemType">The item type.</param>
+ /// <returns>Optional fields for the item type.</returns>
+ public static IEnumerable<SystemFieldDefinition> GetOptionalFieldsForItemType(string itemType)
+ {
+ return Fields.Values
+ .Where(f => f.ApplicableToTypes.TryGetValue(itemType, out var config) && !config.ShowByDefault)
+ .OrderBy(f => f.DefaultDisplayOrder);
+ }
+
+ /// <summary>
+ /// Check if a field key matches a known system field prefix.
+ /// </summary>
+ /// <param name="fieldKey">The field key to check.</param>
+ /// <returns>True if the field key has a system field prefix.</returns>
+ public static bool IsSystemFieldPrefix(string fieldKey)
+ {
+ return ${prefixChecks};
+ }
+}
+`;
+
+ return header + fieldEntries + methods;
+}
+
+/**
+ * Convert field key to C# property name (e.g., 'login.username' -> 'LoginUsername')
+ */
+function fieldKeyToPropertyName(fieldKey) {
+ return fieldKey
+ .split('.')
+ .map(part => part.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(''))
+ .join('');
+}
+
/**
* Ensure directory exists
*/
@@ -162,8 +614,7 @@ function ensureDir(filePath) {
* Main execution
*/
function main() {
-
- // Read TypeScript source
+ // Read TypeScript FieldKey source
if (!fs.existsSync(TS_SOURCE)) {
throw new Error(`Source file not found: ${TS_SOURCE}`);
}
@@ -175,20 +626,59 @@ function main() {
throw new Error('No field keys found in source file');
}
- // Generate C#
+ // Read TypeScript SystemFieldRegistry source
+ if (!fs.existsSync(TS_REGISTRY_SOURCE)) {
+ throw new Error(`Source file not found: ${TS_REGISTRY_SOURCE}`);
+ }
+
+ const tsRegistryContent = fs.readFileSync(TS_REGISTRY_SOURCE, 'utf8');
+
+ // Parse types dynamically from TypeScript
+ const categories = parseFieldCategories(tsRegistryContent);
+ const itemTypeFieldConfigProps = parseItemTypeFieldConfig(tsRegistryContent);
+ const systemFieldDefProps = parseSystemFieldDefinition(tsRegistryContent);
+ const systemFields = parseSystemFieldRegistry(tsRegistryContent);
+
+ if (Object.keys(systemFields).length === 0) {
+ throw new Error('No system fields found in registry source file');
+ }
+
+ console.log(`Parsed ${Object.keys(fieldKeys).length} field keys`);
+ console.log(`Parsed ${categories.length} field categories: ${categories.join(', ')}`);
+ console.log(`Parsed ${itemTypeFieldConfigProps.length} ItemTypeFieldConfig properties`);
+ console.log(`Parsed ${systemFieldDefProps.length} SystemFieldDefinition properties`);
+ console.log(`Parsed ${Object.keys(systemFields).length} system field definitions`);
+
+ // Generate C# FieldKey
ensureDir(CS_OUTPUT);
const csContent = generateCSharp(fieldKeys);
fs.writeFileSync(CS_OUTPUT, csContent, 'utf8');
+ console.log(`Generated: ${CS_OUTPUT}`);
+
+ // Generate C# SystemFieldRegistry
+ ensureDir(CS_REGISTRY_OUTPUT);
+ const csRegistryContent = generateCSharpSystemFieldRegistry(
+ systemFields,
+ categories,
+ itemTypeFieldConfigProps,
+ systemFieldDefProps
+ );
+ fs.writeFileSync(CS_REGISTRY_OUTPUT, csRegistryContent, 'utf8');
+ console.log(`Generated: ${CS_REGISTRY_OUTPUT}`);
// Generate Swift
ensureDir(SWIFT_OUTPUT);
const swiftContent = generateSwift(fieldKeys);
fs.writeFileSync(SWIFT_OUTPUT, swiftContent, 'utf8');
+ console.log(`Generated: ${SWIFT_OUTPUT}`);
// Generate Kotlin
ensureDir(KOTLIN_OUTPUT);
const kotlinContent = generateKotlin(fieldKeys);
fs.writeFileSync(KOTLIN_OUTPUT, kotlinContent, 'utf8');
+ console.log(`Generated: ${KOTLIN_OUTPUT}`);
+
+ console.log('\nCode generation complete!');
}
main();
diff --git a/core/rust/Cargo.toml b/core/rust/Cargo.toml
index 4039d3369..751a4e285 100644
--- a/core/rust/Cargo.toml
+++ b/core/rust/Cargo.toml
@@ -20,6 +20,8 @@ default = []
uniffi = ["dep:uniffi"]
# Feature for WASM builds (browser extension)
wasm = ["dep:wasm-bindgen", "dep:serde-wasm-bindgen", "dep:console_error_panic_hook"]
+# Feature for C FFI exports (.NET P/Invoke)
+ffi = []
[dependencies]
# Serialization - core dependency for JSON handling
diff --git a/core/rust/build.sh b/core/rust/build.sh
index bb7de702d..f552cca85 100755
--- a/core/rust/build.sh
+++ b/core/rust/build.sh
@@ -17,9 +17,11 @@ cd "$SCRIPT_DIR"
# Output directories
DIST_DIR="$SCRIPT_DIR/dist"
WASM_DIR="$DIST_DIR/wasm"
+DOTNET_DIR="$DIST_DIR/dotnet"
# Target directories in consumer apps
BROWSER_EXT_DIST="$SCRIPT_DIR/../../apps/browser-extension/src/utils/dist/core/rust"
+BLAZOR_CLIENT_DIST="$SCRIPT_DIR/../../apps/server/AliasVault.Client/wwwroot/wasm"
echo -e "${BLUE}========================================${NC}"
echo -e "${BLUE} AliasVault Rust Core Build Script${NC}"
@@ -47,6 +49,7 @@ echo -e " Rust version: ${GREEN}$RUST_VERSION${NC}"
# Build mode selection
BUILD_ALL=false
BUILD_BROWSER=false
+BUILD_DOTNET=false
FAST_MODE=false
# Parse arguments
@@ -56,6 +59,15 @@ while [[ $# -gt 0 ]]; do
BUILD_BROWSER=true
shift
;;
+ --dotnet)
+ BUILD_DOTNET=true
+ shift
+ ;;
+ --all)
+ BUILD_BROWSER=true
+ BUILD_DOTNET=true
+ shift
+ ;;
--fast|--dev)
FAST_MODE=true
echo -e "${YELLOW}Fast/dev mode enabled${NC}"
@@ -65,7 +77,9 @@ while [[ $# -gt 0 ]]; do
echo "Usage: $0 [options]"
echo ""
echo "Target options:"
- echo " --browser Build WASM for browser extension"
+ echo " --browser Build WASM for browser extension and Blazor WASM client"
+ echo " --dotnet Build native library for .NET server-side use (macOS/Linux/Windows)"
+ echo " --all Build all targets"
echo ""
echo "Speed options:"
echo " --fast, --dev Faster builds (for development)"
@@ -73,9 +87,6 @@ while [[ $# -gt 0 ]]; do
echo "Other options:"
echo " --help Show this help message"
echo ""
- echo "Examples:"
- echo " ./build.sh --browser # Build WASM for browser extension"
- echo " ./build.sh --browser --fast # Fast dev build"
exit 0
;;
*)
@@ -86,11 +97,12 @@ while [[ $# -gt 0 ]]; do
done
# If no targets specified, show help
-if ! $BUILD_BROWSER; then
+if ! $BUILD_BROWSER && ! $BUILD_DOTNET; then
echo "No target specified. Use --help for usage."
echo ""
echo "Quick start:"
echo " ./build.sh --browser # Build for browser extension"
+ echo " ./build.sh --dotnet # Build for .NET"
exit 0
fi
@@ -163,7 +175,97 @@ README_EOF
echo -e "${GREEN}Distributed to: $BROWSER_EXT_DIST${NC}"
ls -lh "$BROWSER_EXT_DIST/"
+
+ # Also distribute to Blazor client
+ echo ""
+ echo -e "${BLUE}Distributing to Blazor client...${NC}"
+ rm -rf "$BLAZOR_CLIENT_DIST"
+ mkdir -p "$BLAZOR_CLIENT_DIST"
+ cp "$WASM_DIR"/aliasvault_core_bg.wasm "$BLAZOR_CLIENT_DIST/"
+ cp "$WASM_DIR"/aliasvault_core.js "$BLAZOR_CLIENT_DIST/"
+
+ echo -e "${GREEN}Distributed to: $BLAZOR_CLIENT_DIST${NC}"
+ ls -lh "$BLAZOR_CLIENT_DIST/"
+ fi
+}
+
+# ============================================
+# .NET Build (Native Library with FFI)
+# ============================================
+build_dotnet() {
+ echo ""
+ echo -e "${BLUE}Building native library for .NET...${NC}"
+
+ local start_time=$(date +%s)
+
+ # Detect current platform
+ local os_name
+ local arch_name
+ local lib_name
+ local target_dir
+
+ case "$(uname -s)" in
+ Darwin)
+ os_name="macos"
+ lib_name="libaliasvault_core.dylib"
+ ;;
+ Linux)
+ os_name="linux"
+ lib_name="libaliasvault_core.so"
+ ;;
+ MINGW*|MSYS*|CYGWIN*)
+ os_name="windows"
+ lib_name="aliasvault_core.dll"
+ ;;
+ *)
+ echo -e "${RED}Unsupported OS: $(uname -s)${NC}"
+ exit 1
+ ;;
+ esac
+
+ case "$(uname -m)" in
+ x86_64|amd64)
+ arch_name="x64"
+ ;;
+ arm64|aarch64)
+ arch_name="arm64"
+ ;;
+ *)
+ arch_name="$(uname -m)"
+ ;;
+ esac
+
+ target_dir="$DOTNET_DIR/${os_name}-${arch_name}"
+ mkdir -p "$target_dir"
+
+ echo -e " Platform: ${YELLOW}${os_name}-${arch_name}${NC}"
+
+ # Build with cargo
+ echo -e " Running cargo build..."
+ if $FAST_MODE; then
+ cargo build --features ffi
+ local cargo_target="target/debug"
+ else
+ cargo build --release --features ffi
+ local cargo_target="target/release"
+ fi
+
+ # Copy the library
+ if [ -f "$cargo_target/$lib_name" ]; then
+ cp "$cargo_target/$lib_name" "$target_dir/"
+ local lib_size
+ lib_size=$(ls -lh "$target_dir/$lib_name" | awk '{print $5}')
+ echo -e "${GREEN}Native library built! ${NC}"
+ echo -e " Output: ${YELLOW}$target_dir/$lib_name${NC}"
+ echo -e " Size: ${YELLOW}$lib_size${NC}"
+ else
+ echo -e "${RED}Build failed: $lib_name not found${NC}"
+ exit 1
fi
+
+ local end_time=$(date +%s)
+ local duration=$((end_time - start_time))
+ echo -e "${GREEN}.NET build complete! (${duration}s)${NC}"
}
# ============================================
@@ -176,6 +278,13 @@ if $BUILD_BROWSER; then
distribute_browser
fi
+if $BUILD_DOTNET; then
+ build_dotnet
+ # Note: dotnet native libs are built to dist/dotnet/ but not distributed
+ # Blazor WASM uses the WASM module via JS interop instead
+ echo -e "${YELLOW}Note: Native library built to dist/dotnet/ (for server-side .NET use)${NC}"
+fi
+
TOTAL_END=$(date +%s)
TOTAL_DURATION=$((TOTAL_END - TOTAL_START))
diff --git a/core/rust/src/ffi.rs b/core/rust/src/ffi.rs
new file mode 100644
index 000000000..3ef35c036
--- /dev/null
+++ b/core/rust/src/ffi.rs
@@ -0,0 +1,181 @@
+//! C FFI exports for .NET P/Invoke.
+//!
+//! These functions provide a C-compatible interface for calling Rust functions from C#.
+//! All functions use JSON strings for input/output to simplify marshalling.
+
+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};
+
+/// Merge two vaults using LWW strategy.
+///
+/// # 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 (MergeOutput).
+/// Returns null on error.
+#[no_mangle]
+pub unsafe extern "C" fn merge_vaults_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: MergeInput = 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 merge_vaults(input) {
+ Ok(o) => o,
+ Err(e) => {
+ return create_error_response(&format!("Merge 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
+///
+/// - `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 (CredentialMatcherOutput).
+/// Returns null on error.
+#[no_mangle]
+pub unsafe extern "C" fn filter_credentials_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: CredentialMatcherInput = match serde_json::from_str(c_str) {
+ Ok(i) => i,
+ Err(e) => {
+ return create_error_response(&format!("Failed to parse input: {}", e));
+ }
+ };
+
+ let output = filter_credentials(input);
+
+ match serde_json::to_string(&output) {
+ Ok(json) => string_to_c_char(json),
+ Err(e) => create_error_response(&format!("Failed to serialize output: {}", e)),
+ }
+}
+
+/// Get the list of syncable table names as a JSON array.
+///
+/// # Safety
+///
+/// - The returned pointer must be freed by calling `free_string`
+///
+/// # Returns
+///
+/// A null-terminated C string containing a JSON array of table names.
+#[no_mangle]
+pub extern "C" fn get_syncable_table_names_ffi() -> *mut c_char {
+ let names: Vec<&str> = SYNCABLE_TABLE_NAMES.iter().map(|s| *s).collect();
+ match serde_json::to_string(&names) {
+ Ok(json) => string_to_c_char(json),
+ Err(_) => ptr::null_mut(),
+ }
+}
+
+/// Free a string that was allocated by Rust.
+///
+/// # Safety
+///
+/// - `s` must be a pointer that was returned by one of the FFI functions
+/// - This function must only be called once per pointer
+/// - After calling this function, the pointer is invalid
+#[no_mangle]
+pub unsafe extern "C" fn free_string(s: *mut c_char) {
+ if !s.is_null() {
+ drop(CString::from_raw(s));
+ }
+}
+
+/// Convert a Rust string to a C string pointer.
+fn string_to_c_char(s: String) -> *mut c_char {
+ match CString::new(s) {
+ Ok(c_string) => c_string.into_raw(),
+ Err(_) => ptr::null_mut(),
+ }
+}
+
+/// Create an error response JSON string.
+fn create_error_response(message: &str) -> *mut c_char {
+ let error_json = format!(r#"{{"success":false,"error":"{}"}}"#, message.replace('"', r#"\""#));
+ string_to_c_char(error_json)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::ffi::CString;
+
+ #[test]
+ fn test_get_syncable_table_names() {
+ let result = get_syncable_table_names_ffi();
+ assert!(!result.is_null());
+
+ unsafe {
+ let c_str = CStr::from_ptr(result);
+ let json = c_str.to_str().unwrap();
+ let names: Vec<String> = serde_json::from_str(json).unwrap();
+ assert!(names.contains(&"Items".to_string()));
+ assert!(names.contains(&"FieldValues".to_string()));
+ free_string(result);
+ }
+ }
+
+ #[test]
+ fn test_null_input() {
+ unsafe {
+ let result = merge_vaults_ffi(ptr::null());
+ assert!(result.is_null());
+
+ let result = filter_credentials_ffi(ptr::null());
+ assert!(result.is_null());
+ }
+ }
+
+ #[test]
+ fn test_invalid_json_input() {
+ let invalid_json = CString::new("not valid json").unwrap();
+ unsafe {
+ let result = merge_vaults_ffi(invalid_json.as_ptr());
+ assert!(!result.is_null());
+
+ let c_str = CStr::from_ptr(result);
+ let json = c_str.to_str().unwrap();
+ assert!(json.contains("error"));
+ free_string(result);
+ }
+ }
+}
diff --git a/core/rust/src/lib.rs b/core/rust/src/lib.rs
index 76d4764d0..ac75ef8b3 100644
--- a/core/rust/src/lib.rs
+++ b/core/rust/src/lib.rs
@@ -41,6 +41,10 @@ pub mod wasm;
#[cfg(feature = "wasm")]
pub use wasm::*;
+// C FFI exports for .NET P/Invoke
+#[cfg(feature = "ffi")]
+pub mod ffi;
+
// UniFFI scaffolding
#[cfg(feature = "uniffi")]
uniffi::setup_scaffolding!();
diff --git a/core/rust/src/merge/mod.rs b/core/rust/src/merge/mod.rs
index 9f63077a8..7d10c48f4 100644
--- a/core/rust/src/merge/mod.rs
+++ b/core/rust/src/merge/mod.rs
@@ -231,29 +231,10 @@ fn merge_table_by_composite_key(
) -> Vec<SqlStatement> {
let mut statements: Vec<SqlStatement> = Vec::new();
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- log(&format!(
- "[merge_composite] Processing {} - local={} records, server={} records, key_cols={:?}",
- table_name,
- local_records.len(),
- server_records.len(),
- key_columns
- ));
- }
-
// Create map of server records by composite key
let mut server_map: HashMap<String, &Record> = HashMap::new();
for record in server_records {
let key = get_composite_key(record, key_columns);
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- let value = record.get("Value").and_then(|v| v.as_str()).unwrap_or("(no value)");
- let updated = record.get("UpdatedAt").and_then(|v| v.as_str()).unwrap_or("(no ts)");
- log(&format!("[merge_composite] SERVER record: key={}, value={}, updated={}", key, value, updated));
- }
// Keep the one with latest UpdatedAt if duplicate keys
if let Some(existing) = server_map.get(&key) {
if get_updated_at(record) > get_updated_at(existing) {
@@ -273,14 +254,6 @@ fn merge_table_by_composite_key(
None => continue,
};
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- let value = local_record.get("Value").and_then(|v| v.as_str()).unwrap_or("(no value)");
- let updated = local_record.get("UpdatedAt").and_then(|v| v.as_str()).unwrap_or("(no ts)");
- log(&format!("[merge_composite] LOCAL record: key={}, value={}, updated={}", composite_key, value, updated));
- }
-
if let Some(server_record) = server_map.get(&composite_key) {
// Record exists in both - compare UpdatedAt
let local_ts = get_updated_at(local_record);
@@ -292,44 +265,24 @@ fn merge_table_by_composite_key(
stats.conflicts += 1;
stats.records_from_server += 1;
if let Some(stmt) = generate_update_sql(table_name, server_record, &local_id) {
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- log(&format!("[merge_composite] SERVER WINS: key={}", composite_key));
- }
statements.push(stmt);
}
}
_ => {
// Local wins - no action needed
stats.records_from_local += 1;
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- log(&format!("[merge_composite] LOCAL WINS: key={}", composite_key));
- }
}
}
server_map.remove(&composite_key);
} else {
// Only in local - no action needed
stats.records_created_locally += 1;
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- log(&format!("[merge_composite] LOCAL ONLY: key={}", composite_key));
- }
}
}
// Server-only records (by composite key) - generate INSERTs
for (_key, server_record) in &server_map {
stats.records_inserted += 1;
- #[cfg(feature = "wasm")]
- {
- use crate::wasm::log;
- log(&format!("[merge_composite] SERVER ONLY (INSERT): key={}", _key));
- }
if let Some(stmt) = generate_insert_sql(table_name, server_record) {
statements.push(stmt);
}