Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Get data bucket definitions from Rust layer (#2159)
Leendert de Borst82661dc003a1
diff --git a/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts b/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.tsindex 6ef9e091b..a5316eaea 100644--- a/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts+++ b/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts@@ -10,7 +10,7 @@ import type { VaultResponse, VaultPostResponse } from '@/utils/dist/core/models/import { EncryptionUtility } from '@/utils/EncryptionUtility';import { LocalPreferencesService } from '@/utils/LocalPreferencesService';import { RecentlySelectedItemService } from '@/utils/RecentlySelectedItemService';-import { filterItems, AutofillMatchingMode, extractRootDomain, isUrlAlreadyLinked, generatePassword, vaultCodecExtractBucket } from '@/utils/RustCore';+import { filterItems, AutofillMatchingMode, extractRootDomain, isUrlAlreadyLinked, generatePassword, vaultCodecExtractBucket, vaultCodecBucketLayout } from '@/utils/RustCore';import { ServiceDetectionUtility } from '@/utils/serviceDetection/ServiceDetectionUtility';import { SqliteClient } from '@/utils/SqliteClient';import { getItemWithFallback } from '@/utils/StorageUtility';@@ -746,11 +746,10 @@ async function clearDirtyScopes(): Promise<void> {}/**- * Push only the data buckets named by the dirty scopes — no manifest upload. Used when every pending local+ * Push only the data buckets named by the dirty scopes, no manifest upload. Used when every pending local* mutation since the last sync is bucket-scoped (e.g. a settings toggle): the server's vault content manifest* is still current, so re-uploading it would be pure waste.*- * Extension point for future bucket categories: map each category name to its extraction + push logic below.* Unknown categories fall back to a full vault upload, which always covers everything.* @param sqliteClient - the in-memory SQLite client to read bucket data from* @param scopes - the pending dirty scopes (bucket category names, deduplicated here)@@ -761,20 +760,26 @@ async function uploadDirtyBucketsOnly(sqliteClient: SqliteClient, scopes: VaultMthrow new Error(formatErrorWithCode(await t('common.errors.vaultIsLocked'), AppErrorCode.VAULT_LOCKED));}+ /*+ * Which tables make up each bucket category is owned by the Rust layer.+ */+ const layout = await vaultCodecBucketLayout();+for (const category of new Set(scopes)) {- if (category === 'Settings') {- const settingsRows = VaultCodec.readSettingsRows(sqliteClient);- const bucket = await vaultCodecExtractBucket('Settings', { Settings: settingsRows });- const result = await vaultV2SyncService.pushDataBucketOnly(bucket, encryptionKey);- if (result.status !== 'ok') {- // Conflict persisted even after the rebase-retry — let the caller run a full re-sync (status 2).- return { status: 2, newRevisionNumber: (await storage.getItem('local:serverRevision')) as number | null ?? 0 };- }- devLog(`[V2Push] Bucket-only push for "Settings" done (bucket revision ${result.revision}); manifest untouched.`);- } else {- devWarn(`[V2Push] Unknown bucket scope "${category}" — falling back to full vault upload.`);+ const spec = layout.find(entry => entry.category === category);+ if (!spec) {+ devWarn(`[V2Push] Unknown bucket scope "${category}", falling back to full vault upload.`);return (await uploadNewVaultToServer(sqliteClient)).response;}++ const tables = VaultCodec.readNamedTables(sqliteClient, spec.tables);+ const bucket = await vaultCodecExtractBucket(category, tables);+ const result = await vaultV2SyncService.pushDataBucketOnly(bucket, encryptionKey);+ if (result.status !== 'ok') {+ // Conflict persisted even after the rebase-retry, let the caller run a full re-sync (status 2).+ return { status: 2, newRevisionNumber: (await storage.getItem('local:serverRevision')) as number | null ?? 0 };+ }+ devLog(`[V2Push] Bucket-only push for "${category}" done (bucket revision ${result.revision}); manifest untouched.`);}// Manifest unchanged, so the content revision stays where it was.diff --git a/apps/browser-extension/src/utils/RustCore.ts b/apps/browser-extension/src/utils/RustCore.tsindex 3696b2b0d..5a335dd0f 100644--- a/apps/browser-extension/src/utils/RustCore.ts+++ b/apps/browser-extension/src/utils/RustCore.ts@@ -224,6 +224,9 @@ export type CodecCanonicalizeInput = {/** Materialized tables the platform inserts into a fresh SQLite DB. */export type CodecMaterialized = { tables: CodecTableData[]; migrationId: string };+/** One entry in the bucket layout: a category and the tables it owns. */+export type CodecBucketLayoutEntry = { category: string; tables: string[] };+/** Structural validation outcome. */export type CodecValidation = { ok: boolean; failedRules: string[]; message: string };@@ -251,6 +254,14 @@ export async function vaultCodecExtractBucket(category: string, tables: Record<sreturn core.vaultCodecExtractBucket({ category, tables }) as CodecDataBucket;}+/**+ * The bucket layout: every category and the tables it owns.+ */+export async function vaultCodecBucketLayout(): Promise<CodecBucketLayoutEntry[]> {+ await initRustCore();+ return core.vaultCodecBucketLayout() as CodecBucketLayoutEntry[];+}+/*** Generate a fresh 32-byte per-user salt (lowercase hex).*/diff --git a/core/rust/src/ffi.rs b/core/rust/src/ffi.rsindex 522f1716f..6233fe245 100644--- a/core/rust/src/ffi.rs+++ b/core/rust/src/ffi.rs@@ -271,6 +271,18 @@ pub unsafe extern "C" fn vault_codec_validate_data_bucket_ffi(input_json: *constcodec_json_ffi(input_json, "input_json", crate::vault_codec::validate_data_bucket_json)}+/// The bucket layout: `[{ category, tables: [<name>] }]` JSON.+///+/// # Safety+/// Free the result with `free_string`.+#[no_mangle]+pub extern "C" fn vault_codec_bucket_layout_ffi() -> *mut c_char {+ match crate::vault_codec::bucket_layout_json() {+ Ok(json) => string_to_c_char(json),+ Err(e) => create_error_response(&format!("vault_codec error: {}", e)),+ }+}+/// Generate a fresh per-user salt (lowercase hex).////// # Safetydiff --git a/core/rust/src/uniffi_api.rs b/core/rust/src/uniffi_api.rsindex faf6a8e76..69cae50f2 100644--- a/core/rust/src/uniffi_api.rs+++ b/core/rust/src/uniffi_api.rs@@ -172,6 +172,12 @@ pub fn vault_codec_extract_bucket(input_json: String) -> Result<String, VaultErrcrate::vault_codec::extract_bucket_json(&input_json)}+/// The bucket layout: `[{ category, tables: [<name>] }]` JSON. Source of truth for bucket-only sync.+#[uniffi::export]+pub fn vault_codec_bucket_layout() -> Result<String, VaultError> {+ crate::vault_codec::bucket_layout_json()+}+/// Generate a fresh 32-byte per-user salt (lowercase hex).#[uniffi::export]pub fn vault_codec_generate_user_salt() -> String {diff --git a/core/rust/src/vault_codec/manifest.rs b/core/rust/src/vault_codec/manifest.rsindex f99a1699b..ed3ebc7f6 100644--- a/core/rust/src/vault_codec/manifest.rs+++ b/core/rust/src/vault_codec/manifest.rs@@ -54,6 +54,14 @@ impl DataBucket {}}+/// One entry in the bucket layout: a category and the tables it owns.+#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct BucketLayoutEntry {+ pub category: String,+ pub tables: Vec<String>,+}+/// A decoded blob entry. `bytes_base64` is the plaintext blob, base64-encoded for transport#[derive(Debug, Clone, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]diff --git a/core/rust/src/vault_codec/mod.rs b/core/rust/src/vault_codec/mod.rsindex edb248361..6e69f7b54 100644--- a/core/rust/src/vault_codec/mod.rs+++ b/core/rust/src/vault_codec/mod.rs@@ -24,12 +24,12 @@ use crate::error::{VaultError, VaultResult};pub use hash::{canonical_json, content_hash};pub use manifest::{- BlobEntry, CanonicalizeInput, CanonicalizedVault, DataBucket, Manifest, MaterializeInput,- MaterializedTables, CodecRecord, CodecTableData,+ BlobEntry, BucketLayoutEntry, CanonicalizeInput, CanonicalizedVault, DataBucket, Manifest,+ MaterializeInput, MaterializedTables, CodecRecord, CodecTableData,};pub use types::{- bucket_categories, bucket_category_for, BLOB_COLUMNS, BUCKET_TABLES, SCHEMA_VERSION,- SKIP_TABLES,+ bucket_categories, bucket_category_for, tables_for_category, BLOB_COLUMNS, BUCKET_TABLES,+ SCHEMA_VERSION, SKIP_TABLES,};pub use validate::ValidationResult;@@ -52,6 +52,17 @@ pub fn extract_bucket(category: String, tables: std::collections::HashMap<Stringcanonicalize::extract_bucket(category, tables)}+/// The bucket layout: every category and the tables it owns, in declaration order.+pub fn bucket_layout() -> Vec<BucketLayoutEntry> {+ bucket_categories()+ .into_iter()+ .map(|category| BucketLayoutEntry {+ category: category.to_string(),+ tables: tables_for_category(category).into_iter().map(str::to_string).collect(),+ })+ .collect()+}+/// Generate a fresh 32-byte per-user salt as a lowercase hex string.pub fn generate_user_salt() -> String {use rand::RngCore;@@ -160,6 +171,11 @@ pub fn extract_bucket_json(input_json: &str) -> VaultResult<String> {Ok(serde_json::to_string(&extract_bucket(input.category, input.tables))?)}+/// JSON-string sibling of [`bucket_layout`]. Output: `[{ "category": <str>, "tables": [<str>] }]`.+pub fn bucket_layout_json() -> VaultResult<String> {+ Ok(serde_json::to_string(&bucket_layout())?)+}+/// JSON-string sibling of [`validate_manifest`].pub fn validate_manifest_json(manifest_json: &str) -> VaultResult<String> {let m: Manifest = serde_json::from_str(manifest_json)?;diff --git a/core/rust/src/vault_codec/tests.rs b/core/rust/src/vault_codec/tests.rsindex 3a69fe190..b416e880a 100644--- a/core/rust/src/vault_codec/tests.rs+++ b/core/rust/src/vault_codec/tests.rs@@ -44,9 +44,25 @@ fn canonicalize_from_sqlite_splits_settings_into_data_bucket() {assert_eq!(bucket_rows(&out, "Settings", "Settings").len(), 1);}+#[test]+fn bucket_layout_matches_bucket_tables_source_of_truth() {+ // The layout platforms consume must be derived purely from BUCKET_TABLES, one entry per distinct+ // category, each listing exactly that category's tables.+ let layout = bucket_layout();+ assert_eq!(layout.len(), bucket_categories().len());+ for entry in &layout {+ assert_eq!(entry.tables, tables_for_category(&entry.category));+ for table in &entry.tables {+ assert_eq!(bucket_category_for(table), Some(entry.category.as_str()));+ }+ }+ assert_eq!(layout.iter().map(|e| e.category.as_str()).collect::<Vec<_>>(), vec!["Settings"]);+ assert_eq!(bucket_layout_json().unwrap(), serde_json::to_string(&layout).unwrap());+}+#[test]fn canonicalize_from_sqlite_skips_internal_tables() {- // Gotcha #4: skip-tables must never enter the manifest.+ // Skip-tables must never enter the manifest.let input = basic_input(vec![CodecTableData { name: "Items".to_string(), records: vec![] },CodecTableData { name: "__EFMigrationsHistory".to_string(), records: vec![row(&[("MigrationId", json!("x"))])] },diff --git a/core/rust/src/vault_codec/types.rs b/core/rust/src/vault_codec/types.rsindex 66aaaad9a..873f5bb4d 100644--- a/core/rust/src/vault_codec/types.rs+++ b/core/rust/src/vault_codec/types.rs@@ -42,6 +42,11 @@ pub fn bucket_categories() -> Vec<&'static str> {out}+/// The tables that make up a bucket category, in declaration order. Empty if the category is unknown.+pub fn tables_for_category(category: &str) -> Vec<&'static str> {+ BUCKET_TABLES.iter().filter(|(_, c)| *c == category).map(|(t, _)| *t).collect()+}+/// Manifest / metadata schema version. This is the manifest *wire structure* version and is its own/// axis, independent of the data-model `version` string (which tracks EF migrations)./// It starts at 1 for the first manifest generation; bump only on a breaking structural changediff --git a/core/rust/src/wasm.rs b/core/rust/src/wasm.rsindex 6ddc3bc30..6b392c59c 100644--- a/core/rust/src/wasm.rs+++ b/core/rust/src/wasm.rs@@ -159,6 +159,12 @@ pub fn vault_codec_extract_bucket_js(input: JsValue) -> Result<JsValue, JsValue>codec_to_js(&vault_codec::extract_bucket(input.category, input.tables))}+/// The bucket layout: `[{ category, tables: [<name>] }]`. Source of truth for platform bucket-only sync.+#[wasm_bindgen(js_name = vaultCodecBucketLayout)]+pub fn vault_codec_bucket_layout_js() -> Result<JsValue, JsValue> {+ codec_to_js(&vault_codec::bucket_layout())+}+/// Generate a fresh 32-byte per-user salt (lowercase hex).#[wasm_bindgen(js_name = vaultCodecGenerateUserSalt)]pub fn vault_codec_generate_user_salt_js() -> String {