Skip to content

armgit / ente

Public Imported from GitHub
0

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

Cache Space identity for faster feed loads

Anand Baburajan4de88589b7bf
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 9d5faf80ca..5babd07c03 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -7,7 +7,7 @@ use ente_space::{
AccountSpaceCtx, CreatedSpace, DecryptedMessage, DecryptedPost, DecryptedSpaceProfile,
MessageConversationActivity, MessageResponse, OpenAccountSpaceCtxInput, PostPhotoAssetOptions,
PostResponse, ProfileAvatarResponse, ProfileCoverResponse, SpaceActorResponse,
- SpaceError as CoreSpaceError,
+ SpaceError as CoreSpaceError, SpaceKeyResponse,
};
use serde::{Deserialize, Serialize};
use serde_wasm_bindgen as swb;
@@ -84,6 +84,8 @@ struct OpenAccountSpaceCtxJsInput {
base_url: String,
space_session_token: Option<String>,
space_root_key_b64: String,
+ #[serde(default)]
+ owned_spaces: Option<Vec<SpaceKeyResponse>>,
user_agent: Option<String>,
client_package: Option<String>,
client_version: Option<String>,
@@ -502,6 +504,7 @@ pub async fn space_open_account_ctx(
base_url: input.base_url.clone(),
space_session_token: input.space_session_token,
space_root_key,
+ initial_owned_spaces: input.owned_spaces,
user_agent: input.user_agent.clone(),
client_package: input.client_package.clone(),
client_version: input.client_version.clone(),
diff --git a/rust/space/src/client/mod.rs b/rust/space/src/client/mod.rs
index 48bde52ada..2f37741571 100644
--- a/rust/space/src/client/mod.rs
+++ b/rust/space/src/client/mod.rs
@@ -122,7 +122,7 @@ impl AccountSpaceCtx {
api,
space_root_key,
space_identity_cache: Mutex::new(BTreeMap::new()),
- owned_spaces_cache: Mutex::new(None),
+ owned_spaces_cache: Mutex::new(input.initial_owned_spaces),
friend_shares_cache: Mutex::new(BTreeMap::new()),
})
}
@@ -147,6 +147,10 @@ impl AccountSpaceCtx {
if let Some(value) = cache_lock(&self.owned_spaces_cache, "owned spaces")?.clone() {
return Ok(value);
}
+ self.refresh_owned_spaces().await
+ }
+
+ async fn refresh_owned_spaces(&self) -> Result<Vec<SpaceKeyResponse>> {
let spaces: Vec<SpaceKeyResponse> = self
.api
.get("/account/space")
@@ -482,11 +486,14 @@ impl AccountSpaceCtx {
space_id: &str,
version: Option<i32>,
) -> Result<Option<Vec<u8>>> {
- let access = match self.resolve_space_access(space_id).await? {
+ let mut access = match self.resolve_space_access(space_id).await? {
Some(value) => value,
None => return Ok(None),
};
let target_version = version.unwrap_or(access.key_version);
+ access = self
+ .refresh_owned_access_for_version(space_id, target_version, access)
+ .await?;
if target_version == access.key_version {
return Ok(Some(access.space_key));
}
@@ -507,11 +514,14 @@ impl AccountSpaceCtx {
}
None => self.resolve_space_access(space_id).await?,
};
- let access = match access {
+ let mut access = match access {
Some(value) => value,
None => return Ok(None),
};
let target_version = version.unwrap_or(access.key_version);
+ access = self
+ .refresh_owned_access_for_version(space_id, target_version, access)
+ .await?;
if target_version == access.key_version {
return Ok(Some(access.space_key));
}
@@ -521,6 +531,29 @@ impl AccountSpaceCtx {
Ok(history.get(&target_version).cloned())
}
+ async fn refresh_owned_access_for_version(
+ &self,
+ space_id: &str,
+ target_version: i32,
+ access: ResolvedSpaceAccess,
+ ) -> Result<ResolvedSpaceAccess> {
+ if target_version <= access.key_version {
+ return Ok(access);
+ }
+ let is_owned = cache_lock(&self.owned_spaces_cache, "owned spaces")?
+ .as_ref()
+ .is_some_and(|spaces| spaces.iter().any(|space| space.space_id == space_id));
+ if !is_owned {
+ return Ok(access);
+ }
+ self.refresh_owned_spaces().await?;
+ self.resolve_owned_space_access(space_id)
+ .await?
+ .ok_or_else(|| {
+ SpaceError::InvalidInput(format!("space {space_id} is not owned by the account"))
+ })
+ }
+
pub(crate) async fn list_owned_spaces_cached(&self) -> Result<Vec<SpaceKeyResponse>> {
if let Some(value) = cache_lock(&self.owned_spaces_cache, "owned spaces")?.clone() {
return Ok(value);
diff --git a/rust/space/src/client/test_support.rs b/rust/space/src/client/test_support.rs
index f1143e29f1..2602fa0f8c 100644
--- a/rust/space/src/client/test_support.rs
+++ b/rust/space/src/client/test_support.rs
@@ -34,6 +34,7 @@ pub(crate) fn test_account_ctx_with_space_root_key(
base_url: base_url.to_owned(),
space_session_token: Some("space-session-token".to_owned()),
space_root_key,
+ initial_owned_spaces: None,
user_agent: None,
client_package: None,
client_version: None,
diff --git a/rust/space/src/client/tests.rs b/rust/space/src/client/tests.rs
index dd81d43d1d..e91fdb41c5 100644
--- a/rust/space/src/client/tests.rs
+++ b/rust/space/src/client/tests.rs
@@ -775,6 +775,102 @@ async fn create_space_updates_loaded_owned_space_cache() {
update_profile.assert_async().await;
}
+#[tokio::test]
+async fn list_owned_spaces_uses_initial_cache() {
+ let server = Server::new_async().await;
+ let expected = SpaceKeyResponse {
+ space_id: "space_owner_main".to_owned(),
+ space_slug: "owner-main".to_owned(),
+ root_wrapped_space_key: "wrapped-key".to_owned(),
+ public_key: "public-key".to_owned(),
+ encrypted_secret_key: "encrypted-secret-key".to_owned(),
+ encrypted_profile: "encrypted-profile".to_owned(),
+ key_version: 3,
+ };
+ let ctx = AccountSpaceCtx::open(OpenAccountSpaceCtxInput {
+ base_url: server.url(),
+ space_session_token: Some("space-session-token".to_owned()),
+ space_root_key: generate_key(),
+ initial_owned_spaces: Some(vec![expected.clone()]),
+ user_agent: None,
+ client_package: None,
+ client_version: None,
+ })
+ .expect("account space ctx should open");
+
+ let spaces = ctx
+ .list_owned_spaces()
+ .await
+ .expect("seeded space list should load");
+
+ assert_eq!(spaces.len(), 1);
+ assert_eq!(spaces[0].space_id, expected.space_id);
+ assert_eq!(
+ spaces[0].root_wrapped_space_key,
+ expected.root_wrapped_space_key
+ );
+}
+
+#[tokio::test]
+async fn newer_key_version_refreshes_initial_owned_cache() {
+ let mut server = Server::new_async().await;
+ let space_root_key = generate_key();
+ let old_space_key = generate_key();
+ let current_space_key = generate_key();
+ let list_spaces = server
+ .mock("GET", "/account/space")
+ .match_header("x-space-session-token", "space-session-token")
+ .with_status(200)
+ .with_body(owned_space_response(
+ &space_root_key,
+ &current_space_key,
+ "space_owner_main",
+ "owner-main",
+ 3,
+ ))
+ .expect(1)
+ .create_async()
+ .await;
+ let cached = SpaceKeyResponse {
+ space_id: "space_owner_main".to_owned(),
+ space_slug: "owner-main".to_owned(),
+ root_wrapped_space_key: encode_b64(
+ &encrypt_secretbox_payload(&space_root_key, &old_space_key)
+ .expect("old space key wrap"),
+ ),
+ public_key: String::new(),
+ encrypted_secret_key: String::new(),
+ encrypted_profile: String::new(),
+ key_version: 2,
+ };
+ let ctx = AccountSpaceCtx::open(OpenAccountSpaceCtxInput {
+ base_url: server.url(),
+ space_session_token: Some("space-session-token".to_owned()),
+ space_root_key,
+ initial_owned_spaces: Some(vec![cached]),
+ user_agent: None,
+ client_package: None,
+ client_version: None,
+ })
+ .expect("account space ctx should open");
+
+ let resolved = ctx
+ .resolve_space_key_for_version("space_owner_main", Some(3))
+ .await
+ .expect("current space key should resolve")
+ .expect("current space key should exist");
+
+ assert_eq!(resolved, current_space_key);
+ assert_eq!(
+ ctx.list_owned_spaces()
+ .await
+ .expect("refreshed owned spaces")[0]
+ .key_version,
+ 3
+ );
+ list_spaces.assert_async().await;
+}
+
#[tokio::test]
async fn list_owned_spaces_reuses_loaded_cache() {
let mut server = Server::new_async().await;
diff --git a/rust/space/src/models.rs b/rust/space/src/models.rs
index f18414e418..8aee7ac0e4 100644
--- a/rust/space/src/models.rs
+++ b/rust/space/src/models.rs
@@ -3,6 +3,7 @@ use zeroize::Zeroize;
use crate::transport::{
PostObjectPayload, ProfileAvatarResponse, ProfileCoverResponse, SpaceActorResponse,
+ SpaceKeyResponse,
};
#[derive(Clone)]
@@ -10,6 +11,7 @@ pub struct OpenAccountSpaceCtxInput {
pub base_url: String,
pub space_session_token: Option<String>,
pub space_root_key: Vec<u8>,
+ pub initial_owned_spaces: Option<Vec<SpaceKeyResponse>>,
pub user_agent: Option<String>,
pub client_package: Option<String>,
pub client_version: Option<String>,
diff --git a/rust/space/tests/support/space.rs b/rust/space/tests/support/space.rs
index 541fcafcec..d930428d30 100644
--- a/rust/space/tests/support/space.rs
+++ b/rust/space/tests/support/space.rs
@@ -42,6 +42,7 @@ pub async fn open_ctx(endpoint: &str, account: &TestAccount) -> AccountSpaceCtx
base_url: endpoint.to_string(),
space_session_token: Some(session.session_token),
space_root_key,
+ initial_owned_spaces: None,
user_agent: Some(USER_AGENT.to_string()),
client_package: Some(CLIENT_PACKAGE.to_string()),
client_version: Some(USER_AGENT.to_string()),
diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsx
index bc3c029260..822efb858a 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -20,6 +20,7 @@ import {
consumeSentSpaceInviteFriend,
spaceInviteURL,
} from "services/spaceInvite";
+import { loadExistingSpaceId } from "services/spaceProfile";
import { useSpaceAppState } from "state/spaceAppState";
import {
confirmLocalFeedPost,
@@ -54,13 +55,13 @@ const Page: React.FC = () => {
const [isFeedLoading, setIsFeedLoading] = useState(true);
const [isFeedLoadingMore, setIsFeedLoadingMore] = useState(false);
const [isFriendsLoading, setIsFriendsLoading] = useState(true);
+ const [spaceId, setSpaceId] = useState<string>();
const [showInviteFriendsToast, setShowInviteFriendsToast] = useState(false);
const inviteFriendsToastTimerRef = React.useRef<number | undefined>(
undefined,
);
const isInitialFeedLoading =
- profileLoadStatus == "ready" &&
- Boolean(profile?.spaceId) &&
+ Boolean(spaceId || profile?.spaceId) &&
isFeedLoading &&
feedItems.length == 0 &&
localFeedPosts.length == 0;
@@ -100,22 +101,9 @@ const Page: React.FC = () => {
}, [router.isReady]);
useEffect(() => {
- if (profileLoadStatus != "ready") return;
-
- const spaceId = profile?.spaceId;
- if (!spaceId) {
- setFeedItems([]);
- setHasFeedLoadMoreError(false);
- setFeedNextCursor(undefined);
- setHasUnreadMessages(false);
- setIsFeedLoading(false);
- setIsFeedLoadingMore(false);
- setIsFriendsLoading(false);
- setSkipNextHomeFeedSkeleton(false);
- return;
- }
-
let cancelled = false;
+ let loadedSpaceId: string | undefined;
+ setSpaceId(undefined);
setFeedItems([]);
setHasFeedLoadMoreError(false);
setFeedNextCursor(undefined);
@@ -123,9 +111,18 @@ const Page: React.FC = () => {
setIsFeedLoading(true);
setIsFeedLoadingMore(false);
setIsFriendsLoading(true);
- void loadCurrentFeedPage(spaceId)
+ void loadExistingSpaceId()
+ .then((nextSpaceId) => {
+ if (cancelled) return undefined;
+
+ loadedSpaceId = nextSpaceId;
+ setSpaceId(nextSpaceId);
+ return nextSpaceId
+ ? loadCurrentFeedPage(nextSpaceId)
+ : undefined;
+ })
.then((feed) => {
- if (cancelled) return;
+ if (cancelled || !feed) return;
setFeedItems(feed.items);
setFeedNextCursor(feed.nextCursor);
@@ -134,45 +131,46 @@ const Page: React.FC = () => {
console.error("Failed to load space feed", error),
)
.finally(() => {
- if (!cancelled) {
- setIsFeedLoading(false);
- setSkipNextHomeFeedSkeleton(false);
- }
- });
+ if (cancelled) return;
- void loadCurrentUnreadStatus(spaceId)
- .then((unreadStatus) => {
- if (!cancelled) {
- setHasUnreadMessages(unreadStatus.messagesUnread);
+ setIsFeedLoading(false);
+ setSkipNextHomeFeedSkeleton(false);
+ if (!loadedSpaceId) {
+ setHasUnreadMessages(false);
+ setIsFriendsLoading(false);
+ return;
}
- })
- .catch((error: unknown) =>
- console.error("Failed to load space unread status", error),
- );
- void loadCurrentSpaceFriends(spaceId)
- .then((nextFriends) => {
- if (!cancelled) setFriends(nextFriends);
- })
- .catch((error: unknown) =>
- console.error("Failed to load space friends", error),
- )
- .finally(() => {
- if (!cancelled) setIsFriendsLoading(false);
+ void loadCurrentUnreadStatus(loadedSpaceId)
+ .then((unreadStatus) => {
+ if (!cancelled) {
+ setHasUnreadMessages(unreadStatus.messagesUnread);
+ }
+ })
+ .catch((error: unknown) =>
+ console.error(
+ "Failed to load space unread status",
+ error,
+ ),
+ );
+ void loadCurrentSpaceFriends(loadedSpaceId)
+ .then((nextFriends) => {
+ if (!cancelled) setFriends(nextFriends);
+ })
+ .catch((error: unknown) =>
+ console.error("Failed to load space friends", error),
+ )
+ .finally(() => {
+ if (!cancelled) setIsFriendsLoading(false);
+ });
});
return () => {
cancelled = true;
};
- }, [
- profile?.spaceId,
- profileLoadStatus,
- setFriends,
- setSkipNextHomeFeedSkeleton,
- ]);
+ }, [setFriends, setSkipNextHomeFeedSkeleton]);
const loadMoreFeedItems = React.useCallback(async () => {
- const spaceId = profile?.spaceId;
if (!spaceId || !feedNextCursor || isFeedLoadingMore) return;
setHasFeedLoadMoreError(false);
@@ -197,11 +195,10 @@ const Page: React.FC = () => {
} finally {
setIsFeedLoadingMore(false);
}
- }, [feedNextCursor, isFeedLoadingMore, profile?.spaceId]);
+ }, [feedNextCursor, isFeedLoadingMore, spaceId]);
const setFeedPostLiked = React.useCallback(
async (postId: number, liked: boolean) => {
- const spaceId = profile?.spaceId;
if (!spaceId) throw new Error("Missing space.");
await setCurrentPostLiked(spaceId, postId, liked);
@@ -213,7 +210,7 @@ const Page: React.FC = () => {
),
);
},
- [profile?.spaceId],
+ [spaceId],
);
if (
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index bf869627f7..1d2c59ebcb 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -11,6 +11,7 @@ import {
import {
ensureCurrentSpaceContext,
loadExistingSpaceProfile,
+ persistCurrentOwnedSpaces,
releaseCurrentSpaceContext,
} from "services/spaceProfile";
import {
@@ -953,16 +954,13 @@ export const loadCurrentFeedPage = async (
): Promise<SpacePostPage> => {
const ctx = await ensureCurrentSpaceContext();
try {
- return await postPageFromAccountPage(
- ctx,
- (await ctx.listFeed(
- spaceId,
- cursor ?? null,
- currentFeedPageSize,
- )) as SpacePostPageResponse,
- false,
+ const page = (await ctx.listFeed(
spaceId,
- );
+ cursor ?? null,
+ currentFeedPageSize,
+ )) as SpacePostPageResponse;
+ await persistCurrentOwnedSpaces(ctx);
+ return await postPageFromAccountPage(ctx, page, false, spaceId);
} finally {
releaseCurrentSpaceContext(ctx);
}
diff --git a/web/apps/space/src/services/spacePersistentSession.ts b/web/apps/space/src/services/spacePersistentSession.ts
index d6f7c4168d..e34cee8095 100644
--- a/web/apps/space/src/services/spacePersistentSession.ts
+++ b/web/apps/space/src/services/spacePersistentSession.ts
@@ -29,10 +29,23 @@ import { z } from "zod";
const spaceBrowserSessionStorageKey = "spaceBrowserSession";
const spaceSessionTokenHeader = "X-Space-Session-Token";
+const OwnedSpace = z.object({
+ spaceId: z.string(),
+ spaceSlug: z.string(),
+ rootWrappedSpaceKey: z.string(),
+ publicKey: z.string().default(""),
+ encryptedSecretKey: z.string().default(""),
+ encryptedProfile: z.string().default(""),
+ keyVersion: z.number(),
+});
+const OwnedSpaces = OwnedSpace.array();
+export type OwnedSpace = z.infer<typeof OwnedSpace>;
+
const PersistedSpaceBrowserSession = z.object({
encryptedSpaceRootKey: z.string(),
email: z.string(),
nonce: z.string(),
+ ownedSpaces: OwnedSpaces.optional(),
sessionToken: z.string(),
userId: z.number(),
});
@@ -130,6 +143,23 @@ export const logoutRevokedSpaceSession = async () => {
export const savedSpaceSessionToken = () =>
savedPersistedSession()?.sessionToken;
+export const savedSpaceOwnedSpaces = () => savedPersistedSession()?.ownedSpaces;
+
+export const saveSpaceOwnedSpaces = (
+ sessionToken: string,
+ ownedSpaces: OwnedSpace[],
+) => {
+ const persisted = savedPersistedSession();
+ if (persisted?.sessionToken != sessionToken) return;
+ localStorage.setItem(
+ spaceBrowserSessionStorageKey,
+ JSON.stringify({
+ ...persisted,
+ ownedSpaces: ownedSpaces.length ? ownedSpaces : undefined,
+ }),
+ );
+};
+
const forgetBootstrapToken = async () => {
const user = savedPartialLocalUser();
if (user?.id && user.email) {
diff --git a/web/apps/space/src/services/spaceProfile.ts b/web/apps/space/src/services/spaceProfile.ts
index f0dfbbe9c9..cb29bfa37f 100644
--- a/web/apps/space/src/services/spaceProfile.ts
+++ b/web/apps/space/src/services/spaceProfile.ts
@@ -13,7 +13,10 @@ import {
} from "services/spaceMediaCache";
import {
restoreSpaceBrowserSessionIfNeeded,
+ savedSpaceOwnedSpaces,
savedSpaceSessionToken,
+ saveSpaceOwnedSpaces,
+ type OwnedSpace,
} from "services/spacePersistentSession";
import {
parseSpaceProfilePayload,
@@ -34,11 +37,6 @@ interface SpaceAvatar {
type SpaceCover = SpaceAvatar;
-interface OwnedSpace {
- spaceId: string;
- spaceSlug: string;
-}
-
interface CreatedSpace {
spaceId: string;
spaceSlug: string;
@@ -139,6 +137,7 @@ const currentSpaceContextConfig = async () => {
baseUrl,
clientPackage: clientPackageName,
clientVersion: isDesktop ? desktopAppVersion : undefined,
+ ownedSpaces: savedSpaceOwnedSpaces(),
spaceRootKeyB64,
spaceSessionToken,
},
@@ -152,6 +151,10 @@ let currentSpaceContext:
let pendingCurrentSpaceContext:
| { cacheKey: string; promise: Promise<SpaceAccountCtxHandle> }
| undefined;
+let currentOwnedSpace: { cacheKey: string; space: OwnedSpace } | undefined;
+let pendingCurrentOwnedSpace:
+ | { cacheKey: string; promise: Promise<OwnedSpace | undefined> }
+ | undefined;
let currentSpaceProfile:
| { cacheKey: string; profile: SetupProfile | null }
| undefined;
@@ -163,6 +166,9 @@ let currentSpaceContextGeneration = 0;
const cloneSetupProfile = (profile: SetupProfile | null) =>
profile ? { ...profile } : null;
+const cloneOwnedSpace = (space: OwnedSpace | undefined) =>
+ space ? { ...space } : undefined;
+
export const openCurrentSpaceContext = async () => {
const config = await currentSpaceContextConfig();
if (!config) return undefined;
@@ -175,6 +181,8 @@ export const clearCurrentSpaceContext = () => {
currentSpaceContextGeneration += 1;
currentSpaceContext = undefined;
pendingCurrentSpaceContext = undefined;
+ currentOwnedSpace = undefined;
+ pendingCurrentOwnedSpace = undefined;
currentSpaceProfile = undefined;
pendingCurrentSpaceProfile = undefined;
cached?.ctx.free();
@@ -227,6 +235,22 @@ export const releaseCurrentSpaceContext = (_ctx: SpaceAccountCtxHandle) => {
// Shared context is freed by clearCurrentSpaceContext on logout/session change.
};
+const loadAndPersistOwnedSpaces = async (
+ ctx: SpaceAccountCtxHandle,
+ sessionToken: string,
+) => {
+ const spaces = (await ctx.listOwnedSpaces()) as OwnedSpace[];
+ saveSpaceOwnedSpaces(sessionToken, spaces);
+ return spaces;
+};
+
+export const persistCurrentOwnedSpaces = async (ctx: SpaceAccountCtxHandle) => {
+ const sessionToken = savedSpaceSessionToken();
+ if (sessionToken) {
+ await loadAndPersistOwnedSpaces(ctx, sessionToken);
+ }
+};
+
const avatarURLForRemoteAvatar = async (
ctx: SpaceAccountCtxHandle,
spaceId: string,
@@ -298,6 +322,44 @@ const profileFromDecryptedSpaceProfile = (
};
};
+const loadExistingOwnedSpace = async () => {
+ const config = await currentSpaceContextConfig();
+ if (!config) return undefined;
+
+ if (pendingCurrentOwnedSpace?.cacheKey == config.cacheKey) {
+ return cloneOwnedSpace(await pendingCurrentOwnedSpace.promise);
+ }
+ if (currentOwnedSpace?.cacheKey == config.cacheKey) {
+ return cloneOwnedSpace(currentOwnedSpace.space);
+ }
+
+ const promise = (async () => {
+ const ctx = await ensureCurrentSpaceContext();
+ const spaces = await loadAndPersistOwnedSpaces(
+ ctx,
+ config.input.spaceSessionToken,
+ );
+ return defaultOwnedSpace(spaces);
+ })();
+ const pendingSpace = { cacheKey: config.cacheKey, promise };
+ pendingCurrentOwnedSpace = pendingSpace;
+
+ try {
+ const space = await promise;
+ if (space && pendingCurrentOwnedSpace == pendingSpace) {
+ currentOwnedSpace = { cacheKey: config.cacheKey, space };
+ }
+ return cloneOwnedSpace(space);
+ } finally {
+ if (pendingCurrentOwnedSpace == pendingSpace) {
+ pendingCurrentOwnedSpace = undefined;
+ }
+ }
+};
+
+export const loadExistingSpaceId = async () =>
+ (await loadExistingOwnedSpace())?.spaceId;
+
export const loadExistingSpaceProfile = async (options?: {
force?: boolean;
}) => {
@@ -312,15 +374,17 @@ export const loadExistingSpaceProfile = async (options?: {
}
const promise = (async () => {
- const ctx = await ensureCurrentSpaceContext();
- const spaces = (await ctx.listOwnedSpaces()) as OwnedSpace[];
- const space = defaultOwnedSpace(spaces);
+ const space = await loadExistingOwnedSpace();
if (!space) return null;
+ // Give the home feed, which shares this lookup, the first request slot.
+ await new Promise<void>((resolve) => setTimeout(resolve, 0));
+ const ctx = await ensureCurrentSpaceContext();
const spaceProfile = (await ctx.getSpaceProfile(
space.spaceId,
space.spaceId,
)) as DecryptedSpaceProfile;
+ await persistCurrentOwnedSpaces(ctx);
return profileFromDecryptedSpaceProfile(spaceProfile);
})();
@@ -407,6 +471,8 @@ export const saveSpaceProfile = async (
const ctx = await ensureCurrentSpaceContext();
try {
const spaces = (await ctx.listOwnedSpaces()) as OwnedSpace[];
+ const sessionToken = savedSpaceSessionToken();
+ if (sessionToken) saveSpaceOwnedSpaces(sessionToken, spaces);
const existingSpace =
(profile.spaceId &&
spaces.find((space) => space.spaceId == profile.spaceId)) ||
@@ -441,6 +507,10 @@ export const saveSpaceProfile = async (
)) as CreatedSpace;
spaceId = created.spaceId;
spaceSlug = created.spaceSlug;
+ const createdSpaces = (await ctx.listOwnedSpaces()) as OwnedSpace[];
+ if (sessionToken) {
+ saveSpaceOwnedSpaces(sessionToken, createdSpaces);
+ }
}
let avatarUrl = profile.avatarUrl ?? null;