Skip to content

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.ts
index 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: VaultM
throw 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.ts
index 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<s
return 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.rs
index 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: *const
codec_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).
///
/// # Safety
diff --git a/core/rust/src/uniffi_api.rs b/core/rust/src/uniffi_api.rs
index 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, VaultErr
crate::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.rs
index 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.rs
index 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<String
canonicalize::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.rs
index 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.rs
index 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 change
diff --git a/core/rust/src/wasm.rs b/core/rust/src/wasm.rs
index 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 {