Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Use Locker WASM for authenticated Legacy operations

Manav Rathi419aeb2a0247
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 232237abb2..4177327c2c 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -2644,7 +2644,6 @@ dependencies = [
name = "ente-legacy-wasm"
version = "0.0.0"
dependencies = [
- "ente-core",
"ente-legacy",
"ente-wasm-lib",
"serde",
@@ -2936,6 +2935,7 @@ dependencies = [
"ente-collections",
"ente-contacts",
"ente-core",
+ "ente-legacy",
"ente-locker",
"js-sys",
"log",
diff --git a/rust/bindings/wasm/legacy/Cargo.toml b/rust/bindings/wasm/legacy/Cargo.toml
index 9102d61fa8..ab608ecbd2 100644
--- a/rust/bindings/wasm/legacy/Cargo.toml
+++ b/rust/bindings/wasm/legacy/Cargo.toml
@@ -6,9 +6,8 @@ edition.workspace = true
crate-type = ["cdylib"]
[dependencies]
-ente-core.workspace = true
ente-legacy.workspace = true
-ente-wasm-lib = { workspace = true, features = ["session"] }
+ente-wasm-lib.workspace = true
serde.workspace = true
serde-wasm-bindgen.workspace = true
thiserror.workspace = true
diff --git a/rust/bindings/wasm/legacy/src/lib.rs b/rust/bindings/wasm/legacy/src/lib.rs
index ae43b0ef3d..228638577d 100644
--- a/rust/bindings/wasm/legacy/src/lib.rs
+++ b/rust/bindings/wasm/legacy/src/lib.rs
@@ -1,13 +1,9 @@
mod types;
-use ente_core::b64;
use ente_legacy::LegacyKitRecoveryClient;
-use ente_wasm_lib::session::Session;
use serde_wasm_bindgen as swb;
use tsify::Tsify;
-use types::{
- LegacyContactState, LegacyInfo, LegacyKitRecoverySession, LegacyKitShare, OpenKitRecoveryInput,
-};
+use types::{LegacyKitRecoverySession, LegacyKitShare, OpenKitRecoveryInput};
use wasm_bindgen::prelude::*;
#[derive(Debug, thiserror::Error)]
@@ -16,8 +12,6 @@ pub enum Error {
Legacy(#[from] ente_legacy::Error),
#[error(transparent)]
Serde(#[from] swb::Error),
- #[error(transparent)]
- Decode(#[from] b64::DecodeError),
}
impl Error {
@@ -28,10 +22,6 @@ impl Error {
Some("duplicate_legacy_kit_share")
}
Self::Legacy(ente_legacy::Error::LegacyKitInactive) => Some("legacy_kit_inactive"),
- Self::Legacy(ente_legacy::Error::ContactNotOnEnte) => Some("contact_not_on_ente"),
- Self::Legacy(ente_legacy::Error::ActiveRecoverySession) => {
- Some("active_recovery_session")
- }
_ => None,
}
}
@@ -43,110 +33,6 @@ impl From<Error> for JsValue {
}
}
-#[wasm_bindgen(js_name = legacyGetInfo)]
-pub async fn legacy_get_info(session: &Session) -> Result<<LegacyInfo as Tsify>::JsType, Error> {
- LegacyInfo::from(ente_legacy::info(session.inner()).await?)
- .into_js()
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyPublicKey)]
-pub async fn legacy_public_key(session: &Session, email: String) -> Result<Option<String>, Error> {
- ente_legacy::public_key(session.inner(), &email)
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyVerificationID)]
-pub fn legacy_verification_id(public_key_b64: String) -> Result<String, Error> {
- ente_legacy::verification_id(&public_key_b64).map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyAddContact)]
-pub async fn legacy_add_contact(
- session: &Session,
- email: String,
- recovery_notice_in_days: Option<i32>,
-) -> Result<(), Error> {
- ente_legacy::add_contact(session.inner(), &email, recovery_notice_in_days)
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyUpdateContact)]
-pub async fn legacy_update_contact(
- session: &Session,
- user_id: i64,
- emergency_contact_id: i64,
- state: <LegacyContactState as Tsify>::JsType,
-) -> Result<(), Error> {
- let state = LegacyContactState::from_js(state)?;
- ente_legacy::update_contact(session.inner(), user_id, emergency_contact_id, state.into())
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyUpdateRecoveryNotice)]
-pub async fn legacy_update_recovery_notice(
- session: &Session,
- emergency_contact_id: i64,
- recovery_notice_in_days: i32,
-) -> Result<(), Error> {
- ente_legacy::update_recovery_notice(
- session.inner(),
- emergency_contact_id,
- recovery_notice_in_days,
- )
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyStartRecovery)]
-pub async fn legacy_start_recovery(
- session: &Session,
- user_id: i64,
- emergency_contact_id: i64,
-) -> Result<(), Error> {
- ente_legacy::start_recovery(session.inner(), user_id, emergency_contact_id)
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyStopRecovery)]
-pub async fn legacy_stop_recovery(
- session: &Session,
- recovery_id: String,
- user_id: i64,
- emergency_contact_id: i64,
-) -> Result<(), Error> {
- ente_legacy::stop_recovery(session.inner(), &recovery_id, user_id, emergency_contact_id)
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyRejectRecovery)]
-pub async fn legacy_reject_recovery(
- session: &Session,
- recovery_id: String,
- user_id: i64,
- emergency_contact_id: i64,
-) -> Result<(), Error> {
- ente_legacy::reject_recovery(session.inner(), &recovery_id, user_id, emergency_contact_id)
- .await
- .map_err(Into::into)
-}
-
-#[wasm_bindgen(js_name = legacyChangePassword)]
-pub async fn legacy_change_password(
- session: &Session,
- recovery_id: String,
- new_password: String,
-) -> Result<(), Error> {
- ente_legacy::change_password(session.inner(), &recovery_id, &new_password)
- .await
- .map_err(Into::into)
-}
-
#[wasm_bindgen(js_name = parseLegacyKitShare)]
pub fn parse_legacy_kit_share(input: &str) -> Result<<LegacyKitShare as Tsify>::JsType, Error> {
LegacyKitShare::from(ente_legacy::LegacyKitShare::parse(input)?)
diff --git a/rust/bindings/wasm/legacy/src/types.rs b/rust/bindings/wasm/legacy/src/types.rs
index ca6c091ed4..a85b1b9a91 100644
--- a/rust/bindings/wasm/legacy/src/types.rs
+++ b/rust/bindings/wasm/legacy/src/types.rs
@@ -1,151 +1,6 @@
use serde::{Deserialize, Serialize};
use tsify::Tsify;
-#[derive(Serialize, Tsify)]
-#[serde(rename_all = "camelCase")]
-pub struct LegacyInfo {
- contacts: Vec<LegacyContactRecord>,
- recover_sessions: Vec<LegacyRecoverySession>,
- others_emergency_contact: Vec<LegacyContactRecord>,
- others_recovery_session: Vec<LegacyRecoverySession>,
-}
-
-impl From<ente_legacy::LegacyInfo> for LegacyInfo {
- fn from(value: ente_legacy::LegacyInfo) -> Self {
- Self {
- contacts: value.contacts.into_iter().map(Into::into).collect(),
- recover_sessions: value.recover_sessions.into_iter().map(Into::into).collect(),
- others_emergency_contact: value
- .others_emergency_contact
- .into_iter()
- .map(Into::into)
- .collect(),
- others_recovery_session: value
- .others_recovery_session
- .into_iter()
- .map(Into::into)
- .collect(),
- }
- }
-}
-
-#[derive(Serialize, Tsify)]
-#[serde(rename_all = "camelCase")]
-struct LegacyContactRecord {
- user: LegacyUser,
- emergency_contact: LegacyUser,
- state: LegacyContactState,
- recovery_notice_in_days: i32,
-}
-
-impl From<ente_legacy::LegacyContactRecord> for LegacyContactRecord {
- fn from(value: ente_legacy::LegacyContactRecord) -> Self {
- Self {
- user: value.user.into(),
- emergency_contact: value.emergency_contact.into(),
- state: value.state.into(),
- recovery_notice_in_days: value.recovery_notice_in_days,
- }
- }
-}
-
-#[derive(Serialize, Deserialize, Tsify)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum LegacyContactState {
- Invited,
- Revoked,
- Accepted,
- ContactLeft,
- ContactDenied,
-}
-
-impl From<ente_legacy::LegacyContactState> for LegacyContactState {
- fn from(value: ente_legacy::LegacyContactState) -> Self {
- match value {
- ente_legacy::LegacyContactState::Invited => Self::Invited,
- ente_legacy::LegacyContactState::Revoked => Self::Revoked,
- ente_legacy::LegacyContactState::Accepted => Self::Accepted,
- ente_legacy::LegacyContactState::ContactLeft => Self::ContactLeft,
- ente_legacy::LegacyContactState::ContactDenied => Self::ContactDenied,
- }
- }
-}
-
-impl From<LegacyContactState> for ente_legacy::LegacyContactState {
- fn from(value: LegacyContactState) -> Self {
- match value {
- LegacyContactState::Invited => Self::Invited,
- LegacyContactState::Revoked => Self::Revoked,
- LegacyContactState::Accepted => Self::Accepted,
- LegacyContactState::ContactLeft => Self::ContactLeft,
- LegacyContactState::ContactDenied => Self::ContactDenied,
- }
- }
-}
-
-#[derive(Serialize, Tsify)]
-#[serde(rename_all = "camelCase")]
-struct LegacyRecoverySession {
- id: String,
- user: LegacyUser,
- emergency_contact: LegacyUser,
- status: LegacyRecoveryStatus,
- wait_till: i64,
- created_at: i64,
-}
-
-impl From<ente_legacy::LegacyRecoverySession> for LegacyRecoverySession {
- fn from(value: ente_legacy::LegacyRecoverySession) -> Self {
- Self {
- id: value.id,
- user: value.user.into(),
- emergency_contact: value.emergency_contact.into(),
- status: value.status.into(),
- wait_till: value.wait_till,
- created_at: value.created_at,
- }
- }
-}
-
-#[derive(Serialize, Tsify)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-enum LegacyRecoveryStatus {
- Initiated,
- Waiting,
- Rejected,
- Recovered,
- Stopped,
- Ready,
-}
-
-impl From<ente_legacy::LegacyRecoveryStatus> for LegacyRecoveryStatus {
- fn from(value: ente_legacy::LegacyRecoveryStatus) -> Self {
- match value {
- ente_legacy::LegacyRecoveryStatus::Initiated => Self::Initiated,
- ente_legacy::LegacyRecoveryStatus::Waiting => Self::Waiting,
- ente_legacy::LegacyRecoveryStatus::Rejected => Self::Rejected,
- ente_legacy::LegacyRecoveryStatus::Recovered => Self::Recovered,
- ente_legacy::LegacyRecoveryStatus::Stopped => Self::Stopped,
- ente_legacy::LegacyRecoveryStatus::Ready => Self::Ready,
- }
- }
-}
-
-#[derive(Serialize, Tsify)]
-struct LegacyUser {
- id: i64,
- email: String,
-}
-
-impl From<ente_legacy::LegacyUser> for LegacyUser {
- fn from(value: ente_legacy::LegacyUser) -> Self {
- Self {
- id: value.id,
- email: value.email,
- }
- }
-}
-
#[derive(Deserialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct OpenKitRecoveryInput {
diff --git a/rust/bindings/wasm/lib/Cargo.toml b/rust/bindings/wasm/lib/Cargo.toml
index b58bfbb3da..b8d07e5b86 100644
--- a/rust/bindings/wasm/lib/Cargo.toml
+++ b/rust/bindings/wasm/lib/Cargo.toml
@@ -14,6 +14,7 @@ crypto = ["dep:serde", "dep:serde-wasm-bindgen", "dep:tsify"]
crypto-blob = ["crypto"]
crypto-file = ["crypto-blob", "dep:md-5"]
crypto-seal = ["crypto"]
+legacy = ["session", "dep:ente-legacy", "dep:wasm-bindgen-futures"]
locker = ["session", "dep:ente-locker"]
prelogin = ["accounts", "crypto"]
session = [
@@ -28,6 +29,7 @@ ente-accounts = { workspace = true, optional = true }
ente-collections = { workspace = true, optional = true }
ente-contacts = { workspace = true, optional = true }
ente-core.workspace = true
+ente-legacy = { workspace = true, optional = true }
ente-locker = { workspace = true, optional = true }
js-sys.workspace = true
log.workspace = true
diff --git a/rust/bindings/wasm/lib/src/legacy.rs b/rust/bindings/wasm/lib/src/legacy.rs
new file mode 100644
index 0000000000..59b0551040
--- /dev/null
+++ b/rust/bindings/wasm/lib/src/legacy.rs
@@ -0,0 +1,281 @@
+use serde::{Deserialize, Serialize};
+use serde_wasm_bindgen as swb;
+use tsify::Tsify;
+use wasm_bindgen::prelude::*;
+
+use crate::session::Session;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error(transparent)]
+ Legacy(#[from] ente_legacy::Error),
+ #[error(transparent)]
+ Serde(#[from] swb::Error),
+}
+
+impl Error {
+ fn name(&self) -> Option<&'static str> {
+ match self {
+ Self::Legacy(ente_legacy::Error::ContactNotOnEnte) => Some("contact_not_on_ente"),
+ Self::Legacy(ente_legacy::Error::ActiveRecoverySession) => {
+ Some("active_recovery_session")
+ }
+ _ => None,
+ }
+ }
+}
+
+impl From<Error> for JsValue {
+ fn from(error: Error) -> Self {
+ crate::js_error(&error, error.name())
+ }
+}
+
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct LegacyInfo {
+ contacts: Vec<LegacyContactRecord>,
+ recover_sessions: Vec<LegacyRecoverySession>,
+ others_emergency_contact: Vec<LegacyContactRecord>,
+ others_recovery_session: Vec<LegacyRecoverySession>,
+}
+
+impl From<ente_legacy::LegacyInfo> for LegacyInfo {
+ fn from(value: ente_legacy::LegacyInfo) -> Self {
+ Self {
+ contacts: value.contacts.into_iter().map(Into::into).collect(),
+ recover_sessions: value.recover_sessions.into_iter().map(Into::into).collect(),
+ others_emergency_contact: value
+ .others_emergency_contact
+ .into_iter()
+ .map(Into::into)
+ .collect(),
+ others_recovery_session: value
+ .others_recovery_session
+ .into_iter()
+ .map(Into::into)
+ .collect(),
+ }
+ }
+}
+
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+struct LegacyContactRecord {
+ user: LegacyUser,
+ emergency_contact: LegacyUser,
+ state: LegacyContactState,
+ recovery_notice_in_days: i32,
+}
+
+impl From<ente_legacy::LegacyContactRecord> for LegacyContactRecord {
+ fn from(value: ente_legacy::LegacyContactRecord) -> Self {
+ Self {
+ user: value.user.into(),
+ emergency_contact: value.emergency_contact.into(),
+ state: value.state.into(),
+ recovery_notice_in_days: value.recovery_notice_in_days,
+ }
+ }
+}
+
+#[derive(Serialize, Deserialize, Tsify)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum LegacyContactState {
+ Invited,
+ Revoked,
+ Accepted,
+ ContactLeft,
+ ContactDenied,
+}
+
+impl From<ente_legacy::LegacyContactState> for LegacyContactState {
+ fn from(value: ente_legacy::LegacyContactState) -> Self {
+ match value {
+ ente_legacy::LegacyContactState::Invited => Self::Invited,
+ ente_legacy::LegacyContactState::Revoked => Self::Revoked,
+ ente_legacy::LegacyContactState::Accepted => Self::Accepted,
+ ente_legacy::LegacyContactState::ContactLeft => Self::ContactLeft,
+ ente_legacy::LegacyContactState::ContactDenied => Self::ContactDenied,
+ }
+ }
+}
+
+impl From<LegacyContactState> for ente_legacy::LegacyContactState {
+ fn from(value: LegacyContactState) -> Self {
+ match value {
+ LegacyContactState::Invited => Self::Invited,
+ LegacyContactState::Revoked => Self::Revoked,
+ LegacyContactState::Accepted => Self::Accepted,
+ LegacyContactState::ContactLeft => Self::ContactLeft,
+ LegacyContactState::ContactDenied => Self::ContactDenied,
+ }
+ }
+}
+
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+struct LegacyRecoverySession {
+ id: String,
+ user: LegacyUser,
+ emergency_contact: LegacyUser,
+ status: LegacyRecoveryStatus,
+ wait_till: i64,
+ created_at: i64,
+}
+
+impl From<ente_legacy::LegacyRecoverySession> for LegacyRecoverySession {
+ fn from(value: ente_legacy::LegacyRecoverySession) -> Self {
+ Self {
+ id: value.id,
+ user: value.user.into(),
+ emergency_contact: value.emergency_contact.into(),
+ status: value.status.into(),
+ wait_till: value.wait_till,
+ created_at: value.created_at,
+ }
+ }
+}
+
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+enum LegacyRecoveryStatus {
+ Initiated,
+ Waiting,
+ Rejected,
+ Recovered,
+ Stopped,
+ Ready,
+}
+
+impl From<ente_legacy::LegacyRecoveryStatus> for LegacyRecoveryStatus {
+ fn from(value: ente_legacy::LegacyRecoveryStatus) -> Self {
+ match value {
+ ente_legacy::LegacyRecoveryStatus::Initiated => Self::Initiated,
+ ente_legacy::LegacyRecoveryStatus::Waiting => Self::Waiting,
+ ente_legacy::LegacyRecoveryStatus::Rejected => Self::Rejected,
+ ente_legacy::LegacyRecoveryStatus::Recovered => Self::Recovered,
+ ente_legacy::LegacyRecoveryStatus::Stopped => Self::Stopped,
+ ente_legacy::LegacyRecoveryStatus::Ready => Self::Ready,
+ }
+ }
+}
+
+#[derive(Serialize, Tsify)]
+struct LegacyUser {
+ id: i64,
+ email: String,
+}
+
+impl From<ente_legacy::LegacyUser> for LegacyUser {
+ fn from(value: ente_legacy::LegacyUser) -> Self {
+ Self {
+ id: value.id,
+ email: value.email,
+ }
+ }
+}
+
+#[wasm_bindgen(js_name = legacyGetInfo)]
+pub async fn legacy_get_info(session: &Session) -> Result<<LegacyInfo as Tsify>::JsType, Error> {
+ LegacyInfo::from(ente_legacy::info(session.inner()).await?)
+ .into_js()
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyPublicKey)]
+pub async fn legacy_public_key(session: &Session, email: String) -> Result<Option<String>, Error> {
+ ente_legacy::public_key(session.inner(), &email)
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyVerificationID)]
+pub fn legacy_verification_id(public_key_b64: String) -> Result<String, Error> {
+ ente_legacy::verification_id(&public_key_b64).map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyAddContact)]
+pub async fn legacy_add_contact(
+ session: &Session,
+ email: String,
+ recovery_notice_in_days: Option<i32>,
+) -> Result<(), Error> {
+ ente_legacy::add_contact(session.inner(), &email, recovery_notice_in_days)
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyUpdateContact)]
+pub async fn legacy_update_contact(
+ session: &Session,
+ user_id: i64,
+ emergency_contact_id: i64,
+ state: <LegacyContactState as Tsify>::JsType,
+) -> Result<(), Error> {
+ let state = LegacyContactState::from_js(state)?;
+ ente_legacy::update_contact(session.inner(), user_id, emergency_contact_id, state.into())
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyUpdateRecoveryNotice)]
+pub async fn legacy_update_recovery_notice(
+ session: &Session,
+ emergency_contact_id: i64,
+ recovery_notice_in_days: i32,
+) -> Result<(), Error> {
+ ente_legacy::update_recovery_notice(
+ session.inner(),
+ emergency_contact_id,
+ recovery_notice_in_days,
+ )
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyStartRecovery)]
+pub async fn legacy_start_recovery(
+ session: &Session,
+ user_id: i64,
+ emergency_contact_id: i64,
+) -> Result<(), Error> {
+ ente_legacy::start_recovery(session.inner(), user_id, emergency_contact_id)
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyStopRecovery)]
+pub async fn legacy_stop_recovery(
+ session: &Session,
+ recovery_id: String,
+ user_id: i64,
+ emergency_contact_id: i64,
+) -> Result<(), Error> {
+ ente_legacy::stop_recovery(session.inner(), &recovery_id, user_id, emergency_contact_id)
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyRejectRecovery)]
+pub async fn legacy_reject_recovery(
+ session: &Session,
+ recovery_id: String,
+ user_id: i64,
+ emergency_contact_id: i64,
+) -> Result<(), Error> {
+ ente_legacy::reject_recovery(session.inner(), &recovery_id, user_id, emergency_contact_id)
+ .await
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = legacyChangePassword)]
+pub async fn legacy_change_password(
+ session: &Session,
+ recovery_id: String,
+ new_password: String,
+) -> Result<(), Error> {
+ ente_legacy::change_password(session.inner(), &recovery_id, &new_password)
+ .await
+ .map_err(Into::into)
+}
diff --git a/rust/bindings/wasm/lib/src/lib.rs b/rust/bindings/wasm/lib/src/lib.rs
index da0f5af1f4..d4bd490f6a 100644
--- a/rust/bindings/wasm/lib/src/lib.rs
+++ b/rust/bindings/wasm/lib/src/lib.rs
@@ -6,6 +6,8 @@ pub mod collections;
pub mod contacts;
#[cfg(feature = "crypto")]
pub mod crypto;
+#[cfg(feature = "legacy")]
+pub mod legacy;
#[cfg(feature = "locker")]
pub mod locker;
mod logging;
diff --git a/rust/bindings/wasm/locker/Cargo.toml b/rust/bindings/wasm/locker/Cargo.toml
index 087d0867ff..ea3ab2f3bd 100644
--- a/rust/bindings/wasm/locker/Cargo.toml
+++ b/rust/bindings/wasm/locker/Cargo.toml
@@ -6,7 +6,7 @@ edition.workspace = true
crate-type = ["cdylib"]
[dependencies]
-ente-wasm-lib = { workspace = true, features = ["collections", "contacts", "crypto-file", "crypto-seal", "locker"] }
+ente-wasm-lib = { workspace = true, features = ["collections", "contacts", "crypto-file", "crypto-seal", "legacy", "locker"] }
[lints]
workspace = true
diff --git a/web/apps/locker/package.json b/web/apps/locker/package.json
index 5cd4816853..14b14deb44 100644
--- a/web/apps/locker/package.json
+++ b/web/apps/locker/package.json
@@ -12,7 +12,6 @@
"ente-accounts": "*",
"ente-base": "*",
"ente-contacts": "*",
- "ente-legacy-wasm": "*",
"ente-locker-wasm": "*"
},
"devDependencies": {
diff --git a/web/apps/locker/src/components/sidebar/LockerLegacyDrawer.tsx b/web/apps/locker/src/components/sidebar/LockerLegacyDrawer.tsx
index 094eb03361..e2550f3d98 100644
--- a/web/apps/locker/src/components/sidebar/LockerLegacyDrawer.tsx
+++ b/web/apps/locker/src/components/sidebar/LockerLegacyDrawer.tsx
@@ -1,10 +1,11 @@
-import { authenticatedLegacySession } from "@/services/authenticated-session";
+import { authenticatedSession } from "@/services/authenticated-session";
import { UserAdd01Icon } from "@hugeicons/core-free-icons";
import { CircularProgress } from "@mui/material";
import {
LegacyDrawerContent,
type LegacySuggestedUser,
} from "ente-contacts/legacy";
+import { createLegacyService } from "ente-locker-wasm/legacy";
import { t } from "i18next";
import React from "react";
import { LockerSidebarCardButton } from "./LockerSidebarCardButton";
@@ -13,6 +14,8 @@ import {
type LockerNestedSidebarDrawerVisibilityProps,
} from "./LockerSidebarShell";
+const legacyService = createLegacyService(authenticatedSession);
+
export const LockerLegacyDrawer: React.FC<
LockerNestedSidebarDrawerVisibilityProps & {
suggestedUsers: LegacySuggestedUser[];
@@ -26,7 +29,7 @@ export const LockerLegacyDrawer: React.FC<
intro={t("legacy_intro")}
open={open}
suggestedUsers={suggestedUsers}
- getSession={authenticatedLegacySession}
+ service={legacyService}
renderAddContactButton={({ onClick, disabled, loading }) => (
<LockerSidebarCardButton
icon={UserAdd01Icon}
diff --git a/web/apps/locker/src/services/authenticated-session.ts b/web/apps/locker/src/services/authenticated-session.ts
index 801d6c7994..17e8275c85 100644
--- a/web/apps/locker/src/services/authenticated-session.ts
+++ b/web/apps/locker/src/services/authenticated-session.ts
@@ -1,23 +1,14 @@
import { createAuthenticatedSessionCache } from "ente-accounts/services/authenticated-session";
-import { openSession as openLegacySession } from "ente-legacy-wasm/authenticated";
import { openSession } from "ente-locker-wasm";
import { masterKeyFromSession } from "./account-keys";
-const lockerSessions = createAuthenticatedSessionCache(
+const sessions = createAuthenticatedSessionCache(
openSession,
masterKeyFromSession,
);
-const legacySessions = createAuthenticatedSessionCache(
- openLegacySession,
- masterKeyFromSession,
-);
-export const openAuthenticatedSession = lockerSessions.open;
+export const openAuthenticatedSession = sessions.open;
export const ensureAuthenticatedSession = () =>
- lockerSessions.current() ?? lockerSessions.ensure();
-export const authenticatedLegacySession = legacySessions.ensure;
-
-export const clearAuthenticatedSession = () => {
- lockerSessions.clear();
- legacySessions.clear();
-};
+ sessions.current() ?? sessions.ensure();
+export const authenticatedSession = sessions.ensure;
+export const clearAuthenticatedSession = sessions.clear;
diff --git a/web/apps/locker/tests/authenticated-session.test.ts b/web/apps/locker/tests/authenticated-session.test.ts
index c530233d8e..bdd64c2bfb 100644
--- a/web/apps/locker/tests/authenticated-session.test.ts
+++ b/web/apps/locker/tests/authenticated-session.test.ts
@@ -10,7 +10,6 @@ const {
encryptBoxWithRecoveryKey,
generateKey,
openLocker,
- openLegacy,
} = vi.hoisted(() => ({
apiOrigin: vi.fn<() => Promise<string>>(),
savedAuthToken: vi.fn<() => Promise<string>>(),
@@ -27,8 +26,6 @@ const {
vi.fn<typeof import("ente-locker-wasm").encryptBoxWithRecoveryKey>(),
generateKey: vi.fn<typeof import("ente-locker-wasm").generateKey>(),
openLocker: vi.fn<typeof import("ente-locker-wasm").openSession>(),
- openLegacy:
- vi.fn<typeof import("ente-legacy-wasm/authenticated").openSession>(),
}));
vi.mock("ente-base/app", () => ({
@@ -48,7 +45,6 @@ vi.mock("ente-locker-wasm", () => ({
generateKey,
openSession: openLocker,
}));
-vi.mock("ente-legacy-wasm/authenticated", () => ({ openSession: openLegacy }));
let sessions: typeof import("../src/services/authenticated-session");
@@ -62,39 +58,25 @@ beforeEach(async () => {
sessions = await import("../src/services/authenticated-session");
});
-test("opens each artifact only when needed, reuses sessions, and clears both at logout", async () => {
+test("Legacy reuses the Locker session and refreshes its token", async () => {
const locker = mockSession();
- const legacy = mockSession();
openLocker.mockResolvedValue(locker);
- openLegacy.mockResolvedValue(legacy);
- expect(openLocker).not.toHaveBeenCalled();
- expect(openLegacy).not.toHaveBeenCalled();
expect(await sessions.openAuthenticatedSession(1, "token", "key")).toBe(
locker,
);
expect(await sessions.ensureAuthenticatedSession()).toBe(locker);
expect(masterKeyFromSession).not.toHaveBeenCalled();
- expect(openLocker).toHaveBeenCalledTimes(1);
- expect(openLegacy).not.toHaveBeenCalled();
-
- const first = sessions.authenticatedLegacySession();
- const second = sessions.authenticatedLegacySession();
- expect(await first).toBe(legacy);
- expect(await second).toBe(legacy);
+ expect(await sessions.authenticatedSession()).toBe(locker);
savedAuthToken.mockResolvedValue("rotated-token");
- expect(await sessions.authenticatedLegacySession()).toBe(legacy);
- expect(legacy.updateAuthToken).toHaveBeenLastCalledWith("rotated-token");
- expect(openLegacy).toHaveBeenCalledTimes(1);
+ expect(await sessions.authenticatedSession()).toBe(locker);
+ expect(locker.updateAuthToken).toHaveBeenLastCalledWith("rotated-token");
+ expect(openLocker).toHaveBeenCalledOnce();
sessions.clearAuthenticatedSession();
expect(locker.free).not.toHaveBeenCalled();
- expect(legacy.free).not.toHaveBeenCalled();
- await sessions.openAuthenticatedSession(1, "rotated-token", "key");
+ await sessions.authenticatedSession();
expect(openLocker).toHaveBeenCalledTimes(2);
- expect(openLegacy).toHaveBeenCalledTimes(1);
- await sessions.authenticatedLegacySession();
- expect(openLegacy).toHaveBeenCalledTimes(2);
});
test("retries a failed Locker session", async () => {
@@ -110,15 +92,15 @@ test("retries a failed Locker session", async () => {
expect(openLocker).toHaveBeenCalledTimes(2);
});
-test("logout during credential lookup cannot reopen a Legacy session", async () => {
+test("logout during credential lookup cannot reopen a session", async () => {
const key = Promise.withResolvers<string>();
masterKeyFromSession.mockReturnValue(key.promise);
- const opening = sessions.authenticatedLegacySession();
+ const opening = sessions.authenticatedSession();
sessions.clearAuthenticatedSession();
key.resolve("key");
await expect(opening).rejects.toThrow("Authenticated session was cleared");
- expect(openLegacy).not.toHaveBeenCalled();
+ expect(openLocker).not.toHaveBeenCalled();
});
test("logout during WASM initialization frees the unused handle and permits a new session", async () => {
@@ -126,42 +108,42 @@ test("logout during WASM initialization frees the unused handle and permits a ne
const started = Promise.withResolvers<undefined>();
const previous = mockSession();
const next = mockSession();
- openLegacy
+ openLocker
.mockImplementationOnce(() => {
started.resolve(undefined);
return ready.promise;
})
.mockResolvedValueOnce(next);
- const opening = sessions.authenticatedLegacySession();
+ const opening = sessions.authenticatedSession();
await started.promise;
sessions.clearAuthenticatedSession();
- expect(await sessions.authenticatedLegacySession()).toBe(next);
+ expect(await sessions.authenticatedSession()).toBe(next);
ready.resolve(previous);
await expect(opening).rejects.toThrow("Authenticated session was cleared");
expect(previous.free).toHaveBeenCalledOnce();
- expect(await sessions.authenticatedLegacySession()).toBe(next);
+ expect(await sessions.authenticatedSession()).toBe(next);
expect(next.free).not.toHaveBeenCalled();
- expect(openLegacy).toHaveBeenCalledTimes(2);
+ expect(openLocker).toHaveBeenCalledTimes(2);
});
-test("failed opens can be retried and account changes replace the cached Legacy session", async () => {
+test("failed opens can be retried and account changes replace the cached session", async () => {
const previous = mockSession();
const next = mockSession();
- openLegacy
+ openLocker
.mockRejectedValueOnce(new Error("Download failed"))
.mockResolvedValueOnce(previous)
.mockResolvedValueOnce(next);
- await expect(sessions.authenticatedLegacySession()).rejects.toThrow(
+ await expect(sessions.authenticatedSession()).rejects.toThrow(
"Download failed",
);
- expect(await sessions.authenticatedLegacySession()).toBe(previous);
+ expect(await sessions.authenticatedSession()).toBe(previous);
user.id = 2;
savedAuthToken.mockResolvedValue("other-token");
masterKeyFromSession.mockResolvedValue("other-key");
- expect(await sessions.authenticatedLegacySession()).toBe(next);
- expect(openLegacy).toHaveBeenLastCalledWith({
+ expect(await sessions.authenticatedSession()).toBe(next);
+ expect(openLocker).toHaveBeenLastCalledWith({
baseUrl: "http://localhost:8080",
authToken: "other-token",
userID: 2,
diff --git a/web/apps/locker/tests/logout.test.ts b/web/apps/locker/tests/logout.test.ts
index 318e3d9158..f1d155d119 100644
--- a/web/apps/locker/tests/logout.test.ts
+++ b/web/apps/locker/tests/logout.test.ts
@@ -45,7 +45,6 @@ vi.mock("ente-accounts/services/logout", () => ({
logoutClearStateAgain: vi.fn(),
}));
vi.mock("ente-locker-wasm", () => ({ openSession }));
-vi.mock("ente-legacy-wasm/authenticated", () => ({ openSession }));
vi.mock("../src/services/locker-db", () => ({ clearLockerDB: vi.fn() }));
afterEach(() => vi.unstubAllGlobals());
diff --git a/web/package-lock.json b/web/package-lock.json
index dea040228b..ce0602fe66 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -232,7 +232,6 @@
"ente-accounts": "*",
"ente-base": "*",
"ente-contacts": "*",
- "ente-legacy-wasm": "*",
"ente-locker-wasm": "*"
},
"devDependencies": {
@@ -11247,7 +11246,6 @@
"@mui/material": "9.3.1",
"ente-accounts": "*",
"ente-base": "*",
- "ente-legacy-wasm": "*",
"ente-utils": "*",
"react": "19.2.7",
"zod": "4.4.3"
diff --git a/web/package.json b/web/package.json
index 46051635e8..3a0f9309ea 100644
--- a/web/package.json
+++ b/web/package.json
@@ -20,7 +20,7 @@
"build:ensu-wasm": "npm run build --workspace ente-ensu-wasm",
"build:legacy": "npm run build:legacy-wasm && npm exec --workspace legacy -- next build --webpack",
"build:legacy-wasm": "npm run build --workspace ente-legacy-wasm",
- "build:locker": "npm run build:prelogin-wasm && npm run build:legacy-wasm && npm run build:locker-wasm && npm exec --workspace locker -- next build --webpack",
+ "build:locker": "npm run build:prelogin-wasm && npm run build:locker-wasm && npm exec --workspace locker -- next build --webpack",
"build:locker-wasm": "npm run build --workspace ente-locker-wasm",
"build:memories": "npm run build:prelogin-wasm && npm exec --workspace memories -- next build --webpack && npm run build:post --workspace memories",
"build:paste": "npm run build:paste-wasm && npm exec --workspace paste -- next build --webpack && npm run build:post --workspace paste",
@@ -42,7 +42,7 @@
"dev:embed": "npm run build:prelogin-wasm && npm exec --workspace embed -- next dev --webpack -p 3006",
"dev:ensu": "npm run build:ensu-wasm && npm exec --workspace ensu -- next dev --webpack -p 3007",
"dev:legacy": "npm run build:legacy-wasm && npm exec --workspace legacy -- next dev --webpack -p 3011",
- "dev:locker": "npm run build:prelogin-wasm && npm run build:legacy-wasm && npm run build:locker-wasm && npm exec --workspace locker -- next dev --webpack -p 3009",
+ "dev:locker": "npm run build:prelogin-wasm && npm run build:locker-wasm && npm exec --workspace locker -- next dev --webpack -p 3009",
"dev:memories": "npm run build:prelogin-wasm && npm exec --workspace memories -- next dev --webpack -p 3010",
"dev:paste": "npm run build:paste-wasm && npm exec --workspace paste -- next dev --webpack -p 3008",
"dev:payments": "npm run dev --workspace payments",
diff --git a/web/packages/contacts/legacy/components/LegacyAddContactContent.tsx b/web/packages/contacts/legacy/components/LegacyAddContactContent.tsx
index cd4d4a68e3..6194c86b15 100644
--- a/web/packages/contacts/legacy/components/LegacyAddContactContent.tsx
+++ b/web/packages/contacts/legacy/components/LegacyAddContactContent.tsx
@@ -10,13 +10,8 @@ import {
import { ensureLocalUser } from "ente-accounts/services/user";
import { useBaseContext } from "ente-base/context";
import { isNamedError } from "ente-base/error";
-import { publicKey, type Session } from "ente-legacy-wasm/authenticated";
import React, { useMemo, useState } from "react";
-import {
- legacyAddContact,
- legacyVerificationID,
- type LegacySuggestedUser,
-} from "..";
+import type { LegacyService, LegacySuggestedUser } from "..";
import { contactsDisplaySnapshot } from "../..";
import { resolveContactDisplayFromSnapshot } from "../../resolver";
import { ActionButton } from "./ActionButton";
@@ -26,7 +21,7 @@ import { LegacyRecoveryDayPicker } from "./LegacyRecoveryDayPicker";
const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
interface LegacyAddContactContentProps {
- getSession: () => Promise<Session>;
+ service: LegacyService;
existingEmails: string[];
onAdded: () => Promise<void>;
suggestedUsers: LegacySuggestedUser[];
@@ -41,7 +36,7 @@ const nonEnteDialogAttributes = (email: string) => ({
export const LegacyAddContactContent: React.FC<
LegacyAddContactContentProps
> = ({
- getSession,
+ service,
existingEmails,
onAdded,
suggestedUsers,
@@ -109,10 +104,8 @@ export const LegacyAddContactContent: React.FC<
return;
}
try {
- const verificationID = await legacyVerificationID(
- await getSession(),
- normalizedEmail,
- );
+ const verificationID =
+ await service.verificationID(normalizedEmail);
if (!verificationID) {
showMiniDialog({
title: "Verification ID unavailable",
@@ -166,10 +159,7 @@ export const LegacyAddContactContent: React.FC<
void (async () => {
try {
- const key = await publicKey(
- await getSession(),
- normalizedEmail,
- );
+ const key = await service.publicKey(normalizedEmail);
if (!key) {
showMiniDialog(nonEnteDialogAttributes(normalizedEmail));
return;
@@ -200,8 +190,7 @@ export const LegacyAddContactContent: React.FC<
text: "Add trusted contact",
action: async () => {
try {
- await legacyAddContact(
- await getSession(),
+ await service.addContact(
normalizedEmail,
selectedRecoveryDays,
);
diff --git a/web/packages/contacts/legacy/components/LegacyDrawerContent.tsx b/web/packages/contacts/legacy/components/LegacyDrawerContent.tsx
index fbb2a9a1de..35165d9d84 100644
--- a/web/packages/contacts/legacy/components/LegacyDrawerContent.tsx
+++ b/web/packages/contacts/legacy/components/LegacyDrawerContent.tsx
@@ -5,23 +5,14 @@ import { Box, CircularProgress, Stack, Typography } from "@mui/material";
import { useBaseContext } from "ente-base/context";
import { isNamedError } from "ente-base/error";
import log from "ente-base/log";
-import {
- getInfo,
- rejectRecovery,
- startRecovery,
- stopRecovery,
- updateContact,
- updateRecoveryNotice,
- type Session,
-} from "ente-legacy-wasm/authenticated";
import { t } from "i18next";
import React, { useCallback, useEffect, useMemo, useState } from "react";
-import {
- legacyChangePassword,
- type LegacyContactRecord,
- type LegacyInfo,
- type LegacyRecoverySession,
- type LegacySuggestedUser,
+import type {
+ LegacyContactRecord,
+ LegacyInfo,
+ LegacyRecoverySession,
+ LegacyService,
+ LegacySuggestedUser,
} from "..";
import { mergeLegacySuggestedUsers } from "../suggestions";
import { ActionButton } from "./ActionButton";
@@ -163,7 +154,7 @@ interface LegacyDrawerContentProps {
loading: boolean;
}) => React.ReactNode;
open: boolean;
- getSession: () => Promise<Session>;
+ service: LegacyService;
suggestedUsers?: LegacySuggestedUser[];
}
@@ -178,7 +169,7 @@ interface ConfirmActionDialogInput {
export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
intro,
open,
- getSession,
+ service,
suggestedUsers = [],
renderAddContactButton,
}) => {
@@ -194,7 +185,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
async (reportErrors: boolean) => {
setIsLoading(true);
try {
- setInfo(await getInfo(await getSession()));
+ setInfo(await service.getInfo());
return true;
} catch (error) {
if (reportErrors) {
@@ -210,7 +201,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
setIsLoading(false);
}
},
- [getSession, onGenericError],
+ [service, onGenericError],
);
const refresh = useCallback(async () => {
@@ -345,8 +336,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
}
setIsSubmitting(true);
try {
- await updateRecoveryNotice(
- await getSession(),
+ await service.updateRecoveryNotice(
selectedOwnerContact.emergencyContact.id,
selectedOwnerDays,
);
@@ -366,7 +356,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
setIsSubmitting(false);
}
}, [
- getSession,
+ service,
onGenericError,
refreshAfterMutation,
selectedOwnerContact,
@@ -396,8 +386,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
continueText: "Start recovery",
continueColor: "accent",
action: async () => {
- await startRecovery(
- await getSession(),
+ await service.startRecovery(
selectedTrustedContact.user.id,
selectedTrustedContact.emergencyContact.id,
);
@@ -423,8 +412,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
message: `Are you sure you want to cancel recovery of ${selectedTrustedContact.user.email}'s account?`,
continueText: "Cancel recovery",
action: async () => {
- await stopRecovery(
- await getSession(),
+ await service.stopRecovery(
selectedTrustedRecovery.id,
selectedTrustedRecovery.user.id,
selectedTrustedRecovery.emergencyContact.id,
@@ -438,8 +426,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
message: `If you remove yourself as a trusted contact, you'll lose access to ${selectedTrustedContact.user.email}'s account after their inactivity period.`,
continueText: "Remove contact",
action: async () => {
- await updateContact(
- await getSession(),
+ await service.updateContact(
selectedTrustedContact.user.id,
selectedTrustedContact.emergencyContact.id,
"CONTACT_LEFT",
@@ -462,8 +449,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
onSubmit={async (password) => {
setIsSubmitting(true);
try {
- await legacyChangePassword(
- await getSession(),
+ await service.changePassword(
resetPasswordPage.session.id,
password,
);
@@ -756,7 +742,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
onClose={() => setActiveSheet(undefined)}
>
<LegacyAddContactContent
- getSession={getSession}
+ service={service}
variant="sheet"
suggestedUsers={addScreenSuggestedUsers}
existingEmails={existingEmails}
@@ -818,8 +804,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
? "Revoke invite"
: "Remove contact",
action: async () => {
- await updateContact(
- await getSession(),
+ await service.updateContact(
selectedOwnerContact.user.id,
selectedOwnerContact
.emergencyContact.id,
@@ -858,8 +843,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
onClick={() =>
void runAction(
async () =>
- updateContact(
- await getSession(),
+ service.updateContact(
selectedTrustedInvite.user.id,
selectedTrustedInvite
.emergencyContact.id,
@@ -876,8 +860,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
onClick={() =>
void runAction(
async () =>
- updateContact(
- await getSession(),
+ service.updateContact(
selectedTrustedInvite.user.id,
selectedTrustedInvite
.emergencyContact.id,
@@ -916,8 +899,7 @@ export const LegacyDrawerContent: React.FC<LegacyDrawerContentProps> = ({
),
continueText: "Reject recovery",
action: async () => {
- await rejectRecovery(
- await getSession(),
+ await service.rejectRecovery(
selectedRecoveryAttempt.id,
selectedRecoveryAttempt.user.id,
selectedRecoveryAttempt.emergencyContact
diff --git a/web/packages/contacts/legacy/index.ts b/web/packages/contacts/legacy/index.ts
index 9a3cb90086..9e75ffa9ff 100644
--- a/web/packages/contacts/legacy/index.ts
+++ b/web/packages/contacts/legacy/index.ts
@@ -1,13 +1,9 @@
export { LegacyDrawerContent } from "./components/LegacyDrawerContent";
-export {
- legacyAddContact,
- legacyChangePassword,
- legacyVerificationID,
-} from "./service";
export { mergeLegacySuggestedUsers } from "./suggestions";
export type {
LegacyContactRecord,
LegacyInfo,
LegacyRecoverySession,
+ LegacyService,
LegacySuggestedUser,
} from "./types";
diff --git a/web/packages/contacts/legacy/service.ts b/web/packages/contacts/legacy/service.ts
deleted file mode 100644
index 99a4e93ae8..0000000000
--- a/web/packages/contacts/legacy/service.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import {
- publicKey,
- verificationID,
- type Session,
-} from "ente-legacy-wasm/authenticated";
-
-export {
- addContact as legacyAddContact,
- changePassword as legacyChangePassword,
-} from "ente-legacy-wasm/authenticated";
-
-export const legacyVerificationID = async (session: Session, email: string) => {
- const key = await publicKey(session, email);
- return key ? verificationID(key) : undefined;
-};
diff --git a/web/packages/contacts/legacy/types.ts b/web/packages/contacts/legacy/types.ts
index b208bb77ae..638d88e606 100644
--- a/web/packages/contacts/legacy/types.ts
+++ b/web/packages/contacts/legacy/types.ts
@@ -1,10 +1,71 @@
-export type {
- LegacyContactRecord,
- LegacyInfo,
- LegacyRecoverySession,
-} from "ente-legacy-wasm/authenticated";
+export interface LegacyUser {
+ id: number;
+ email: string;
+}
+
+export interface LegacyContactRecord {
+ user: LegacyUser;
+ emergencyContact: LegacyUser;
+ state:
+ | "INVITED"
+ | "REVOKED"
+ | "ACCEPTED"
+ | "CONTACT_LEFT"
+ | "CONTACT_DENIED";
+ recoveryNoticeInDays: number;
+}
+
+export interface LegacyRecoverySession {
+ id: string;
+ user: LegacyUser;
+ emergencyContact: LegacyUser;
+ status:
+ | "INITIATED"
+ | "WAITING"
+ | "REJECTED"
+ | "RECOVERED"
+ | "STOPPED"
+ | "READY";
+ waitTill: number;
+ createdAt: number;
+}
+
+export interface LegacyInfo {
+ contacts: LegacyContactRecord[];
+ recoverSessions: LegacyRecoverySession[];
+ othersEmergencyContact: LegacyContactRecord[];
+ othersRecoverySession: LegacyRecoverySession[];
+}
export interface LegacySuggestedUser {
id?: number;
email: string;
}
+
+export interface LegacyService {
+ getInfo(): Promise<LegacyInfo>;
+ publicKey(email: string): Promise<string | undefined>;
+ verificationID(email: string): Promise<string | undefined>;
+ addContact(email: string, recoveryNoticeInDays?: number): Promise<void>;
+ updateContact(
+ userID: number,
+ emergencyContactID: number,
+ state: LegacyContactRecord["state"],
+ ): Promise<void>;
+ updateRecoveryNotice(
+ emergencyContactID: number,
+ recoveryNoticeInDays: number,
+ ): Promise<void>;
+ startRecovery(userID: number, emergencyContactID: number): Promise<void>;
+ stopRecovery(
+ recoveryID: string,
+ userID: number,
+ emergencyContactID: number,
+ ): Promise<void>;
+ rejectRecovery(
+ recoveryID: string,
+ userID: number,
+ emergencyContactID: number,
+ ): Promise<void>;
+ changePassword(recoveryID: string, newPassword: string): Promise<void>;
+}
diff --git a/web/packages/contacts/package.json b/web/packages/contacts/package.json
index 2fa932bcf9..3d6ad412f5 100644
--- a/web/packages/contacts/package.json
+++ b/web/packages/contacts/package.json
@@ -12,7 +12,6 @@
"@mui/material": "9.3.1",
"ente-accounts": "*",
"ente-base": "*",
- "ente-legacy-wasm": "*",
"ente-utils": "*",
"react": "19.2.7",
"zod": "4.4.3"
diff --git a/web/packages/wasm/legacy/authenticated.ts b/web/packages/wasm/legacy/authenticated.ts
deleted file mode 100644
index 0c538ef4b7..0000000000
--- a/web/packages/wasm/legacy/authenticated.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import type {
- LegacyContactState,
- OpenSessionInput,
- Session,
-} from "./pkg/ente_legacy_wasm";
-
-export type {
- LegacyContactRecord,
- LegacyInfo,
- LegacyRecoverySession,
- OpenSessionInput,
- Session,
-} from "./pkg/ente_legacy_wasm";
-
-const wasm = () => import("./pkg/ente_legacy_wasm");
-
-export const openSession = async (input: OpenSessionInput): Promise<Session> =>
- (await wasm()).openSession(input);
-
-export const getInfo = async (session: Session) =>
- (await wasm()).legacyGetInfo(session);
-
-export const publicKey = async (session: Session, email: string) =>
- (await wasm()).legacyPublicKey(session, email);
-
-export const verificationID = async (publicKeyB64: string) =>
- (await wasm()).legacyVerificationID(publicKeyB64);
-
-export const addContact = async (
- session: Session,
- email: string,
- recoveryNoticeInDays?: number,
-) => (await wasm()).legacyAddContact(session, email, recoveryNoticeInDays);
-
-export const updateContact = async (
- session: Session,
- userID: number,
- emergencyContactID: number,
- state: LegacyContactState,
-) =>
- (await wasm()).legacyUpdateContact(
- session,
- BigInt(userID),
- BigInt(emergencyContactID),
- state,
- );
-
-export const updateRecoveryNotice = async (
- session: Session,
- emergencyContactID: number,
- recoveryNoticeInDays: number,
-) =>
- (await wasm()).legacyUpdateRecoveryNotice(
- session,
- BigInt(emergencyContactID),
- recoveryNoticeInDays,
- );
-
-export const startRecovery = async (
- session: Session,
- userID: number,
- emergencyContactID: number,
-) =>
- (await wasm()).legacyStartRecovery(
- session,
- BigInt(userID),
- BigInt(emergencyContactID),
- );
-
-export const stopRecovery = async (
- session: Session,
- recoveryID: string,
- userID: number,
- emergencyContactID: number,
-) =>
- (await wasm()).legacyStopRecovery(
- session,
- recoveryID,
- BigInt(userID),
- BigInt(emergencyContactID),
- );
-
-export const rejectRecovery = async (
- session: Session,
- recoveryID: string,
- userID: number,
- emergencyContactID: number,
-) =>
- (await wasm()).legacyRejectRecovery(
- session,
- recoveryID,
- BigInt(userID),
- BigInt(emergencyContactID),
- );
-
-export const changePassword = async (
- session: Session,
- recoveryID: string,
- newPassword: string,
-) => (await wasm()).legacyChangePassword(session, recoveryID, newPassword);
diff --git a/web/packages/wasm/legacy/package.json b/web/packages/wasm/legacy/package.json
index cc496cacf4..14e9dac984 100644
--- a/web/packages/wasm/legacy/package.json
+++ b/web/packages/wasm/legacy/package.json
@@ -6,10 +6,6 @@
".": {
"types": "./index.ts",
"import": "./index.ts"
- },
- "./authenticated": {
- "types": "./authenticated.ts",
- "import": "./authenticated.ts"
}
},
"module": "./index.ts",
diff --git a/web/packages/wasm/locker/legacy.ts b/web/packages/wasm/locker/legacy.ts
new file mode 100644
index 0000000000..716e59370e
--- /dev/null
+++ b/web/packages/wasm/locker/legacy.ts
@@ -0,0 +1,83 @@
+import type { LegacyContactState, Session } from "./pkg/ente_locker_wasm";
+
+const wasm = () => import("./pkg/ente_locker_wasm");
+
+export const createLegacyService = (getSession: () => Promise<Session>) => ({
+ getInfo: async () => (await wasm()).legacyGetInfo(await getSession()),
+
+ publicKey: async (email: string) =>
+ (await wasm()).legacyPublicKey(await getSession(), email),
+
+ verificationID: async (email: string) => {
+ const api = await wasm();
+ const key = await api.legacyPublicKey(await getSession(), email);
+ return key ? api.legacyVerificationID(key) : undefined;
+ },
+
+ addContact: async (email: string, recoveryNoticeInDays?: number) =>
+ (await wasm()).legacyAddContact(
+ await getSession(),
+ email,
+ recoveryNoticeInDays,
+ ),
+
+ updateContact: async (
+ userID: number,
+ emergencyContactID: number,
+ state: LegacyContactState,
+ ) =>
+ (await wasm()).legacyUpdateContact(
+ await getSession(),
+ BigInt(userID),
+ BigInt(emergencyContactID),
+ state,
+ ),
+
+ updateRecoveryNotice: async (
+ emergencyContactID: number,
+ recoveryNoticeInDays: number,
+ ) =>
+ (await wasm()).legacyUpdateRecoveryNotice(
+ await getSession(),
+ BigInt(emergencyContactID),
+ recoveryNoticeInDays,
+ ),
+
+ startRecovery: async (userID: number, emergencyContactID: number) =>
+ (await wasm()).legacyStartRecovery(
+ await getSession(),
+ BigInt(userID),
+ BigInt(emergencyContactID),
+ ),
+
+ stopRecovery: async (
+ recoveryID: string,
+ userID: number,
+ emergencyContactID: number,
+ ) =>
+ (await wasm()).legacyStopRecovery(
+ await getSession(),
+ recoveryID,
+ BigInt(userID),
+ BigInt(emergencyContactID),
+ ),
+
+ rejectRecovery: async (
+ recoveryID: string,
+ userID: number,
+ emergencyContactID: number,
+ ) =>
+ (await wasm()).legacyRejectRecovery(
+ await getSession(),
+ recoveryID,
+ BigInt(userID),
+ BigInt(emergencyContactID),
+ ),
+
+ changePassword: async (recoveryID: string, newPassword: string) =>
+ (await wasm()).legacyChangePassword(
+ await getSession(),
+ recoveryID,
+ newPassword,
+ ),
+});
diff --git a/web/packages/wasm/locker/package.json b/web/packages/wasm/locker/package.json
index 536be3644a..de91038078 100644
--- a/web/packages/wasm/locker/package.json
+++ b/web/packages/wasm/locker/package.json
@@ -6,6 +6,10 @@
".": {
"types": "./index.ts",
"import": "./index.ts"
+ },
+ "./legacy": {
+ "types": "./legacy.ts",
+ "import": "./legacy.ts"
}
},
"module": "./index.ts",
diff --git a/web/packages/wasm/tests/bindings.test.ts b/web/packages/wasm/tests/bindings.test.ts
index e267dc4e13..95ceae23e6 100644
--- a/web/packages/wasm/tests/bindings.test.ts
+++ b/web/packages/wasm/tests/bindings.test.ts
@@ -1,6 +1,6 @@
import * as cast from "ente-cast-wasm";
-import * as legacy from "ente-legacy-wasm/authenticated";
import * as locker from "ente-locker-wasm";
+import { createLegacyService } from "ente-locker-wasm/legacy";
import * as photos from "ente-photos-wasm";
import {
boxSealOpenBytes,
@@ -193,7 +193,7 @@ test("Locker file-link payload survives cloning and unlocks its file key", async
).toBe(fileKey);
});
-describe("Legacy", () => {
+describe("Locker Legacy", () => {
test("returns plain information and sends typed updates through a reused session", async () => {
const user = { id: 42, email: "[email protected]" };
const emergencyContact = { id: 43, email: "[email protected]" };
@@ -236,33 +236,34 @@ describe("Legacy", () => {
}
});
const masterKey = await generateKey();
- const session = await legacy.openSession({
+ const session = await locker.openSession({
baseUrl: "http://localhost",
authToken: "token",
masterKeyB64: masterKey,
...(await sessionKeyAttributes(masterKey)),
});
try {
- expect(await legacy.getInfo(session)).toStrictEqual(info);
+ const legacy = createLegacyService(async () => session);
+ expect(await legacy.getInfo()).toStrictEqual(info);
session.updateAuthToken("rotated-token");
- await legacy.updateContact(session, 42, 43, "CONTACT_LEFT");
+ await legacy.updateContact(42, 43, "CONTACT_LEFT");
expect(updateBody).toStrictEqual({
userID: 42,
emergencyContactID: 43,
state: "CONTACT_LEFT",
});
await expect(
- legacy.updateRecoveryNotice(session, 43, 30),
+ legacy.updateRecoveryNotice(43, 30),
).rejects.toMatchObject({ name: "active_recovery_session" });
recoveryErrorBody = {
code: "BAD_REQUEST",
message: "Cannot update during an active recovery session",
};
await expect(
- legacy.updateRecoveryNotice(session, 43, 30),
+ legacy.updateRecoveryNotice(43, 30),
).rejects.not.toMatchObject({ name: "active_recovery_session" });
recovery.createdAt = Number.MAX_SAFE_INTEGER + 1;
- await expect(legacy.getInfo(session)).rejects.toBeInstanceOf(Error);
+ await expect(legacy.getInfo()).rejects.toBeInstanceOf(Error);
} finally {
session.free();
}
@@ -295,14 +296,15 @@ describe("Legacy", () => {
throw new Error(`Unexpected request: ${request.url}`);
}
});
- const session = await legacy.openSession({
+ const session = await locker.openSession({
baseUrl: "http://localhost",
authToken: "token",
masterKeyB64: masterKey,
...(await sessionKeyAttributes(masterKey, recoveryKey)),
});
try {
- await legacy.addContact(session, "[email protected]", 30);
+ const legacy = createLegacyService(async () => session);
+ await legacy.addContact("[email protected]", 30);
expect(sharedRecoveryKey).toStrictEqual(
new Uint8Array(Buffer.from(recoveryKey, "base64")),
);