feat: migrate certificate

Author: peterpeterparker

src/console/src/lib.rs

@@ -17,6 +17,7 @@ mod rates;
 mod segments;
 mod store;
 mod types;
+mod upgrade;
 
 use crate::types::interface::AuthenticationArgs;
 use crate::types::interface::AuthenticationResult;

src/console/src/memory/lifecycle.rs

@@ -4,6 +4,7 @@ use crate::fees::init_factory_fees;
 use crate::memory::manager::{get_memory_upgrades, init_stable_state, STATE};
 use crate::rates::init::init_factory_rates;
 use crate::types::state::{HeapState, ReleasesMetadata, State};
+use crate::upgrade::types::upgrade::UpgradeState;
 use ciborium::{from_reader, into_writer};
 use ic_cdk_macros::{init, post_upgrade, pre_upgrade};
 use junobuild_shared::ic::api::caller;
@@ -50,9 +51,12 @@ fn post_upgrade() {
     let memory = get_memory_upgrades();
     let state_bytes = read_post_upgrade(&memory);
 
-    let state: State = from_reader(&*state_bytes)
+    // TODO: remove once stable memory introduced on mainnet
+    let upgrade_state: UpgradeState = from_reader(&*state_bytes)
         .expect("Failed to decode the state of the console in post_upgrade hook.");
 
+    let state: State = upgrade_state.into();
+
     STATE.with(|s| *s.borrow_mut() = state);
 
     defer_init_certified_assets();

src/console/src/upgrade/impls.rs

@@ -0,0 +1,56 @@
+use crate::types::state::{HeapState, State};
+use crate::upgrade::types::upgrade::{
+    UpgradeAuthenticationHeapState, UpgradeHeapState, UpgradeOpenIdProvider, UpgradeState,
+};
+use junobuild_auth::openid::types::provider::OpenIdProvider;
+use junobuild_auth::state::types::state::{AuthenticationHeapState, OpenIdState};
+
+impl From<UpgradeState> for State {
+    fn from(upgrade: UpgradeState) -> Self {
+        State {
+            stable: upgrade.stable,
+            heap: upgrade.heap.into(),
+        }
+    }
+}
+
+impl From<UpgradeHeapState> for HeapState {
+    fn from(upgrade: UpgradeHeapState) -> Self {
+        HeapState {
+            authentication: upgrade.authentication.map(|auth| auth.into()),
+            controllers: upgrade.controllers,
+            mission_controls: upgrade.mission_controls,
+            payments: upgrade.payments,
+            invitation_codes: upgrade.invitation_codes,
+            factory_fees: upgrade.factory_fees,
+            factory_rates: upgrade.factory_rates,
+            storage: upgrade.storage,
+            releases_metadata: upgrade.releases_metadata,
+        }
+    }
+}
+
+impl From<UpgradeAuthenticationHeapState> for AuthenticationHeapState {
+    fn from(upgrade: UpgradeAuthenticationHeapState) -> Self {
+        AuthenticationHeapState {
+            config: upgrade.config,
+            salt: upgrade.salt,
+            openid: upgrade.openid.map(|openid_state| OpenIdState {
+                certificates: openid_state
+                    .certificates
+                    .into_iter()
+                    .map(|(provider, cert)| (provider.into(), cert))
+                    .collect(),
+            }),
+        }
+    }
+}
+
+impl From<UpgradeOpenIdProvider> for OpenIdProvider {
+    fn from(old: UpgradeOpenIdProvider) -> Self {
+        match old {
+            UpgradeOpenIdProvider::Google => OpenIdProvider::Google,
+            UpgradeOpenIdProvider::GitHub => OpenIdProvider::GitHubAuth,
+        }
+    }
+}

src/console/src/upgrade/mod.rs

@@ -0,0 +1,2 @@
+mod impls;
+pub mod types;

src/console/src/upgrade/types.rs

@@ -0,0 +1,58 @@
+pub mod upgrade {
+    use crate::memory::manager::init_stable_state;
+    use crate::types::state::{
+        Accounts, FactoryFees, FactoryRates, IcpPayments, InvitationCodes, ReleasesMetadata,
+        StableState,
+    };
+    use candid::{CandidType, Deserialize};
+    use junobuild_auth::state::types::config::AuthenticationConfig;
+    use junobuild_auth::state::types::state::{OpenIdCachedCertificate, Salt};
+    use junobuild_shared::types::state::Controllers;
+    use junobuild_storage::types::state::StorageHeapState;
+    use serde::Serialize;
+    use std::collections::HashMap;
+
+    #[derive(Serialize, Deserialize)]
+    pub struct UpgradeState {
+        // Direct stable state: State that is uses stable memory directly as its store. No need for pre/post upgrade hooks.
+        #[serde(skip, default = "init_stable_state")]
+        pub stable: StableState,
+
+        pub heap: UpgradeHeapState,
+    }
+
+    #[derive(Default, CandidType, Serialize, Deserialize, Clone)]
+    pub struct UpgradeHeapState {
+        #[deprecated(note = "Deprecated. Use stable memory instead.")]
+        pub mission_controls: Accounts,
+        #[deprecated(note = "Deprecated. Use stable memory instead.")]
+        pub payments: IcpPayments,
+        pub invitation_codes: InvitationCodes,
+        pub controllers: Controllers,
+        pub factory_fees: Option<FactoryFees>,
+        pub factory_rates: Option<FactoryRates>,
+        pub storage: StorageHeapState,
+        pub authentication: Option<UpgradeAuthenticationHeapState>,
+        pub releases_metadata: ReleasesMetadata,
+    }
+
+    #[derive(Default, CandidType, Serialize, Deserialize, Clone)]
+    pub struct UpgradeAuthenticationHeapState {
+        pub config: AuthenticationConfig,
+        pub salt: Option<Salt>,
+        pub openid: Option<UpgradeOpenIdState>,
+    }
+
+    #[derive(Default, CandidType, Serialize, Deserialize, Clone)]
+    pub struct UpgradeOpenIdState {
+        pub certificates: HashMap<UpgradeOpenIdProvider, OpenIdCachedCertificate>,
+    }
+
+    #[derive(
+        CandidType, Serialize, Deserialize, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug,
+    )]
+    pub enum UpgradeOpenIdProvider {
+        Google,
+        GitHub,
+    }
+}

src/tests/specs/console/upgrade/console.upgrade-v0-4-0.openid-provider.spec.ts

@@ -163,6 +163,6 @@ describe('Console > Upgrade > OpenIdProvider > v0.3.3 -> v0.4.0', () => {
 	});
 
 	it('should migrate OpenIdState.certificates to OpenIdProvider.GitHubAuth', async () => {
-		await expect(upgradeCurrent()).not.toThrowError();
+		await expect(upgradeCurrent()).resolves.not.toThrowError();
 	});
 });