From 9b657e3ab4a5182c6cabde28383c3f8960c15cb2 Mon Sep 17 00:00:00 2001 From: litruv Date: Tue, 6 Oct 2026 07:42:47 +1100 Subject: [PATCH] Cache profile fields and assets behind one shared store. Colour, banner, collectibles, and profile each read the same extended profile endpoint through separate caches with mismatched TTLs, so a single profile view fired three round trips. They now read through one cache with a shared TTL and in-flight dedupe, and profile media is kept as blob URLs instead of being re-downloaded per mount. useUserProfile now prefers the SDK's sync-cached user and only fetches when both the SDK and the cache are cold. --- src/app/hooks/useUserBanner.ts | 63 +++++----------- src/app/hooks/useUserCollectibles.ts | 104 ++++++++------------------- src/app/hooks/useUserColor.ts | 86 +++++++--------------- src/app/hooks/useUserProfile.ts | 46 +++++++++--- src/app/utils/profileAssetCache.ts | 73 +++++++++++++++++++ src/app/utils/profileCache.ts | 91 +++++++++++++++++++++++ src/app/utils/profileFields.ts | 81 +++------------------ src/client/initMatrix.ts | 23 +----- 8 files changed, 282 insertions(+), 285 deletions(-) create mode 100644 src/app/utils/profileAssetCache.ts create mode 100644 src/app/utils/profileCache.ts diff --git a/src/app/hooks/useUserBanner.ts b/src/app/hooks/useUserBanner.ts index 143676c5..05f5a784 100644 --- a/src/app/hooks/useUserBanner.ts +++ b/src/app/hooks/useUserBanner.ts @@ -1,14 +1,13 @@ import { useCallback, useEffect, useState } from 'react'; import { useMatrixClient } from './useMatrixClient'; import { useMediaAuthentication } from './useMediaAuthentication'; -import { mxcUrlToHttp } from '../utils/matrix'; -import { getCurrentAccessToken } from '../utils/auth'; import { + extractBannerUrlFromProfile, deleteBannerUrl, - loadBannerUrl, - registerBannerCacheClear, saveBannerUrl, } from '../utils/profileFields'; +import { getProfileFields, registerProfileCacheListener } from '../utils/profileCache'; +import { getProfileAssetUrl } from '../utils/profileAssetCache'; /** * Hook to manage the user's profile banner (MSC4427 via MSC4133). @@ -34,7 +33,7 @@ export function useUserBanner(): [ const load = async () => { setLoading(true); try { - const bannerMxc = await loadBannerUrl(mx, userId); + const bannerMxc = extractBannerUrlFromProfile(await getProfileFields(mx, userId)); if (!cancelled) setBanner(bannerMxc); } catch { if (!cancelled) setBanner(undefined); @@ -65,40 +64,15 @@ export function useUserBanner(): [ return [banner, updateBanner, loading]; } -const userBannerCache = new Map(); -const CACHE_TTL_MS = 5 * 60 * 1000; - -registerBannerCacheClear((userId: string) => { - userBannerCache.delete(userId); -}); - -async function fetchBannerBlobUrl( - mx: ReturnType, - bannerMxc: string, - useAuthentication: boolean -): Promise { - const bannerHttpUrl = mxcUrlToHttp(mx, bannerMxc, useAuthentication); - if (!bannerHttpUrl) return undefined; - - const accessToken = getCurrentAccessToken(); - const headers: HeadersInit = {}; - if (useAuthentication && accessToken) { - headers.Authorization = `Bearer ${accessToken}`; - } - - const response = await fetch(bannerHttpUrl, { headers }); - if (!response.ok) return undefined; - - const blob = await response.blob(); - return URL.createObjectURL(blob); -} - /** * Hook to get another user's profile banner as a blob URL. + * Profile fields come from the shared profile cache, and the media itself is + * cached so reopening the same profile does not re-download the banner. */ export function useOtherUserBanner(userId: string): string | undefined { const mx = useMatrixClient(); const useAuthentication = useMediaAuthentication(); + const [bannerBlobUrl, setBannerBlobUrl] = useState(); useEffect(() => { @@ -107,34 +81,31 @@ export function useOtherUserBanner(userId: string): string | undefined { return undefined; } - let blobUrl: string | undefined; let cancelled = false; const load = async () => { - const cached = userBannerCache.get(userId); - let bannerMxc: string | undefined; - - if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) { - bannerMxc = cached.bannerMxc; - } else { - bannerMxc = await loadBannerUrl(mx, userId); - userBannerCache.set(userId, { bannerMxc, timestamp: Date.now() }); - } + const fields = await getProfileFields(mx, userId); + if (cancelled) return; + const bannerMxc = extractBannerUrlFromProfile(fields); if (!bannerMxc) { - if (!cancelled) setBannerBlobUrl(undefined); + setBannerBlobUrl(undefined); return; } - blobUrl = await fetchBannerBlobUrl(mx, bannerMxc, useAuthentication); + const blobUrl = await getProfileAssetUrl(mx, bannerMxc, useAuthentication); if (!cancelled) setBannerBlobUrl(blobUrl); }; + const unsubscribe = registerProfileCacheListener((changedUserId) => { + if (changedUserId === userId) load(); + }); + load(); return () => { cancelled = true; - if (blobUrl) URL.revokeObjectURL(blobUrl); + unsubscribe(); }; }, [mx, useAuthentication, userId]); diff --git a/src/app/hooks/useUserCollectibles.ts b/src/app/hooks/useUserCollectibles.ts index 2ccd4099..94deda05 100644 --- a/src/app/hooks/useUserCollectibles.ts +++ b/src/app/hooks/useUserCollectibles.ts @@ -1,16 +1,16 @@ import { useCallback, useEffect, useState } from 'react'; import { useMatrixClient } from './useMatrixClient'; import { useMediaAuthentication } from './useMediaAuthentication'; -import { mxcUrlToHttp } from '../utils/matrix'; -import { getCurrentAccessToken } from '../utils/auth'; import { CollectibleProfileFields, StoredCollectible, - loadUserCollectibles, + extractCollectiblesFromProfile, saveAvatarDecoration, saveNameplate, saveProfileEffect, } from '../utils/profileFields'; +import { clearProfileCache, getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache'; +import { getProfileAssetUrl } from '../utils/profileAssetCache'; import { CollectibleKind } from '../utils/discordCollectibles'; export function useUserCollectibles(): [ @@ -34,7 +34,7 @@ export function useUserCollectibles(): [ const load = async () => { setLoading(true); try { - const data = await loadUserCollectibles(mx, userId); + const data = extractCollectiblesFromProfile(await getProfileFields(mx, userId)); if (!cancelled) setCollectibles(data); } catch { if (!cancelled) setCollectibles({}); @@ -52,19 +52,14 @@ export function useUserCollectibles(): [ async (kind: CollectibleKind, collectible: StoredCollectible | undefined) => { if (kind === 'profile_effect') { await saveProfileEffect(mx, collectible); - clearUserCollectiblesCache(mx.getUserId()); - setCollectibles((prev) => ({ ...prev, profile_effect: collectible })); - return; - } - if (kind === 'nameplate') { + } else if (kind === 'nameplate') { await saveNameplate(mx, collectible); - clearUserCollectiblesCache(mx.getUserId()); - setCollectibles((prev) => ({ ...prev, nameplate: collectible })); - return; + } else { + await saveAvatarDecoration(mx, collectible); } - await saveAvatarDecoration(mx, collectible); - clearUserCollectiblesCache(mx.getUserId()); - setCollectibles((prev) => ({ ...prev, avatar_decoration: collectible })); + + clearProfileCache(mx.getUserId()); + setCollectibles((prev) => ({ ...prev, [kind]: collectible })); }, [mx] ); @@ -72,55 +67,21 @@ export function useUserCollectibles(): [ return [collectibles, updateCollectible, loading]; } -const collectibleCache = new Map(); -const collectibleCacheListeners = new Set<(userId: string) => void>(); -const CACHE_TTL_MS = 5 * 60 * 1000; - -export function clearUserCollectiblesCache(userId?: string): void { - if (!userId) return; - collectibleCache.delete(userId); - collectibleCacheListeners.forEach((listener) => listener(userId)); -} - -async function fetchMxcBlobUrl( - mx: ReturnType, - mxc: string, - useAuthentication: boolean -): Promise { - const httpUrl = mxcUrlToHttp(mx, mxc, useAuthentication); - if (!httpUrl) return undefined; - - const accessToken = getCurrentAccessToken(); - const headers: HeadersInit = {}; - if (useAuthentication && accessToken) { - headers.Authorization = `Bearer ${accessToken}`; - } - - const response = await fetch(httpUrl, { headers }); - if (!response.ok) return undefined; - - const blob = await response.blob(); - return URL.createObjectURL(blob); -} - +/** + * Shared profile fields for another user, served from the profile cache so a + * timeline of many messages by the same author resolves one request per user. + */ export function useOtherUserCollectibles(userId: string): CollectibleProfileFields & { assetUrls: Record; } { const mx = useMatrixClient(); const useAuthentication = useMediaAuthentication(); - const [collectibles, setCollectibles] = useState({}); - const [assetUrls, setAssetUrls] = useState>({}); - const [cacheVersion, setCacheVersion] = useState(0); - useEffect(() => { - const handleCacheClear = (clearedUserId: string) => { - if (clearedUserId === userId) { - setCacheVersion((version) => version + 1); - } - }; - collectibleCacheListeners.add(handleCacheClear); - return () => collectibleCacheListeners.delete(handleCacheClear); - }, [userId]); + const [collectibles, setCollectibles] = useState(() => { + const cached = getCachedProfileFields(userId); + return cached ? extractCollectiblesFromProfile(cached) : {}; + }); + const [assetUrls, setAssetUrls] = useState>({}); useEffect(() => { if (!userId) { @@ -130,19 +91,9 @@ export function useOtherUserCollectibles(userId: string): CollectibleProfileFiel } let cancelled = false; - const blobUrls: string[] = []; const load = async () => { - const cached = collectibleCache.get(userId); - let data: CollectibleProfileFields; - - if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) { - data = cached.data; - } else { - data = await loadUserCollectibles(mx, userId); - collectibleCache.set(userId, { data, timestamp: Date.now() }); - } - + const data = extractCollectiblesFromProfile(await getProfileFields(mx, userId)); if (cancelled) return; setCollectibles(data); @@ -156,24 +107,25 @@ export function useOtherUserCollectibles(userId: string): CollectibleProfileFiel for (const [kind, collectible] of entries) { if (!collectible) continue; for (const [role, mxc] of Object.entries(collectible.assets)) { - const blobUrl = await fetchMxcBlobUrl(mx, mxc, useAuthentication); - if (blobUrl) { - blobUrls.push(blobUrl); - urls[`${kind}:${role}`] = blobUrl; - } + const blobUrl = await getProfileAssetUrl(mx, mxc, useAuthentication); + if (blobUrl) urls[`${kind}:${role}`] = blobUrl; } } if (!cancelled) setAssetUrls(urls); }; + const unsubscribe = registerProfileCacheListener((changedUserId) => { + if (changedUserId === userId) load(); + }); + load(); return () => { cancelled = true; - blobUrls.forEach((url) => URL.revokeObjectURL(url)); + unsubscribe(); }; - }, [cacheVersion, mx, useAuthentication, userId]); + }, [mx, useAuthentication, userId]); return { ...collectibles, assetUrls }; } diff --git a/src/app/hooks/useUserColor.ts b/src/app/hooks/useUserColor.ts index 96ba5f53..8a6c72d7 100644 --- a/src/app/hooks/useUserColor.ts +++ b/src/app/hooks/useUserColor.ts @@ -5,13 +5,13 @@ import { ThemeKind, useTheme } from './useTheme'; import { ColorPreference, deleteColorPreference, + extractColorPreferenceFromProfile, extractMemberColorPreference, hasColorPreference, - loadColorPreference, - registerPreferenceCacheClear, resolveColorForTheme, saveColorPreference, } from '../utils/profileFields'; +import { getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache'; /** * Hook to manage the user's MSC4522 color preference on their global profile. @@ -37,7 +37,7 @@ export function useUserColorPreference(): [ const load = async () => { setLoading(true); try { - const loaded = await loadColorPreference(mx, userId); + const loaded = extractColorPreferenceFromProfile(await getProfileFields(mx, userId)); if (!cancelled) setPreference(loaded); } catch (e) { console.error('Failed to load color preference:', e); @@ -69,80 +69,48 @@ export function useUserColorPreference(): [ return [preference, updatePreference, loading]; } -class LRUCache { - private cache = new Map(); - - constructor(private maxSize: number) {} - - get(key: K): V | undefined { - const value = this.cache.get(key); - if (value !== undefined) { - this.cache.delete(key); - this.cache.set(key, value); - } - return value; - } - - set(key: K, value: V): void { - if (this.cache.has(key)) { - this.cache.delete(key); - } else if (this.cache.size >= this.maxSize) { - const firstKey = this.cache.keys().next().value; - if (firstKey !== undefined) this.cache.delete(firstKey); - } - this.cache.set(key, value); - } - - delete(key: K): void { - this.cache.delete(key); - } -} - -const preferenceCache = new LRUCache(200); -const CACHE_TTL_MS = 30 * 60 * 1000; - -registerPreferenceCacheClear((userId: string) => { - preferenceCache.delete(userId); -}); - /** * Hook to get another user's MSC4522 color preference from their global profile. + * Reads through the shared profile cache so the same request is not repeated for + * every message, reply, or profile view by the same user. */ export function useOtherUserColorPreference(userId: string): ColorPreference | undefined { const mx = useMatrixClient(); - const cachedEntry = preferenceCache.get(userId); - const cachedPreference = - cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL_MS ? cachedEntry.preference : undefined; - const [preference, setPreference] = useState(cachedPreference); + const [preference, setPreference] = useState(() => { + const cached = getCachedProfileFields(userId); + return cached ? extractColorPreferenceFromProfile(cached) : undefined; + }); useEffect(() => { if (!userId) { setPreference(undefined); - return; - } - - const cached = preferenceCache.get(userId); - if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) { - setPreference(cached.preference); - return; + return undefined; } let cancelled = false; - const load = async () => { - try { - const loaded = await loadColorPreference(mx, userId); - preferenceCache.set(userId, { preference: loaded, timestamp: Date.now() }); - if (!cancelled) setPreference(loaded); - } catch { - if (!cancelled) setPreference(undefined); - } + const apply = (fields: Record) => { + if (cancelled) return; + setPreference(extractColorPreferenceFromProfile(fields)); }; - load(); + const unsubscribe = registerProfileCacheListener((changedUserId) => { + if (changedUserId === userId) { + const fields = getCachedProfileFields(userId); + if (fields) apply(fields); + } + }); + + getProfileFields(mx, userId) + .then(apply) + .catch(() => { + if (!cancelled) setPreference(undefined); + }); + return () => { cancelled = true; + unsubscribe(); }; }, [mx, userId]); diff --git a/src/app/hooks/useUserProfile.ts b/src/app/hooks/useUserProfile.ts index c7cb7487..1eef1dee 100644 --- a/src/app/hooks/useUserProfile.ts +++ b/src/app/hooks/useUserProfile.ts @@ -1,11 +1,13 @@ import { useEffect, useState } from 'react'; import { UserEvent, UserEventHandlerMap } from 'matrix-js-sdk'; import { useMatrixClient } from './useMatrixClient'; +import { getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache'; export type UserProfile = { avatarUrl?: string; displayName?: string; }; + export const useUserProfile = (userId: string): UserProfile => { const mx = useMatrixClient(); @@ -18,8 +20,33 @@ export const useUserProfile = (userId: string): UserProfile => { }); useEffect(() => { + if (!userId) return undefined; + const user = mx.getUser(userId); - const onAvatarChange: UserEventHandlerMap[UserEvent.AvatarUrl] = (event, myUser) => { + let disposed = false; + + const applyFields = (fields: Record) => { + const avatarUrl = typeof fields.avatar_url === 'string' ? fields.avatar_url : undefined; + const displayName = typeof fields.displayname === 'string' ? fields.displayname : undefined; + if (!avatarUrl && !displayName) return; + setProfile((cp) => ({ + avatarUrl: avatarUrl ?? cp.avatarUrl, + displayName: displayName ?? cp.displayName, + })); + }; + + // The SDK already holds profile data from sync, so only hit the network when + // both the SDK and the shared profile cache are cold. + const cached = getCachedProfileFields(userId); + if (cached) { + applyFields(cached); + } else if (!user?.displayName && !user?.avatarUrl) { + getProfileFields(mx, userId).then((fields) => { + if (!disposed) applyFields(fields); + }); + } + + const onProfileChange: UserEventHandlerMap[UserEvent.AvatarUrl] = (event, myUser) => { setProfile((cp) => ({ ...cp, avatarUrl: myUser.avatarUrl, @@ -32,17 +59,18 @@ export const useUserProfile = (userId: string): UserProfile => { })); }; - mx.getProfileInfo(userId).then((info) => - setProfile({ - avatarUrl: info.avatar_url, - displayName: info.displayname, - }) - ); + const unsubscribeCache = registerProfileCacheListener((changedUserId) => { + if (changedUserId !== userId) return; + const fields = getCachedProfileFields(userId); + if (fields) applyFields(fields); + }); - user?.on(UserEvent.AvatarUrl, onAvatarChange); + user?.on(UserEvent.AvatarUrl, onProfileChange); user?.on(UserEvent.DisplayName, onDisplayNameChange); return () => { - user?.removeListener(UserEvent.AvatarUrl, onAvatarChange); + disposed = true; + unsubscribeCache(); + user?.removeListener(UserEvent.AvatarUrl, onProfileChange); user?.removeListener(UserEvent.DisplayName, onDisplayNameChange); }; }, [mx, userId]); diff --git a/src/app/utils/profileAssetCache.ts b/src/app/utils/profileAssetCache.ts new file mode 100644 index 00000000..8506b893 --- /dev/null +++ b/src/app/utils/profileAssetCache.ts @@ -0,0 +1,73 @@ +import { MatrixClient } from 'matrix-js-sdk'; +import { mxcUrlToHttp } from './matrix'; +import { getCurrentAccessToken } from './auth'; + +/** + * Blob URLs for profile assets (banner, nameplate, avatar decoration). + * + * Kept in one cache so reopening the same profile does not re-download the + * same media on every mount. Entries are revoked only when evicted. + */ +const MAX_ASSET_CACHE_ENTRIES = 200; + +const assetCache = new Map(); +const inflightAssets = new Map>(); + +function evictOldest(): void { + const firstKey = assetCache.keys().next().value; + if (firstKey === undefined) return; + const url = assetCache.get(firstKey); + assetCache.delete(firstKey); + if (url) URL.revokeObjectURL(url); +} + +export async function getProfileAssetUrl( + mx: MatrixClient, + mxcUrl: string, + useAuthentication: boolean +): Promise { + if (!mxcUrl) return undefined; + + const cached = assetCache.get(mxcUrl); + if (cached) return cached; + + const pending = inflightAssets.get(mxcUrl); + if (pending) return pending; + + const request = (async () => { + const httpUrl = mxcUrlToHttp(mx, mxcUrl, useAuthentication); + if (!httpUrl) return undefined; + + const headers: HeadersInit = {}; + if (useAuthentication) { + const accessToken = getCurrentAccessToken(); + if (accessToken) headers.Authorization = `Bearer ${accessToken}`; + } + + try { + const response = await fetch(httpUrl, { headers }); + if (!response.ok) return undefined; + + const blob = await response.blob(); + const blobUrl = URL.createObjectURL(blob); + if (assetCache.size >= MAX_ASSET_CACHE_ENTRIES) evictOldest(); + assetCache.set(mxcUrl, blobUrl); + return blobUrl; + } catch { + return undefined; + } + })(); + + inflightAssets.set(mxcUrl, request); + try { + return await request; + } finally { + if (inflightAssets.get(mxcUrl) === request) inflightAssets.delete(mxcUrl); + } +} + +export function clearProfileAssetCache(): void { + assetCache.forEach((url) => URL.revokeObjectURL(url)); + assetCache.clear(); + inflightAssets.clear(); +} diff --git a/src/app/utils/profileCache.ts b/src/app/utils/profileCache.ts new file mode 100644 index 00000000..70190afd --- /dev/null +++ b/src/app/utils/profileCache.ts @@ -0,0 +1,91 @@ +import { MatrixClient } from 'matrix-js-sdk'; + +/** + * Single shared cache for a user's profile fields. + * + * Colour, banner and collectibles all come from the same profile endpoint, so they + * must read through one cache instead of each keeping their own - otherwise opening + * a profile view fires the same request three times. + */ +export type ProfileFields = Record; + +export const PROFILE_CACHE_TTL_MS = 5 * 60 * 1000; +const MAX_PROFILE_CACHE_ENTRIES = 500; + +type ProfileCacheEntry = { fields: ProfileFields; timestamp: number }; + +const profileCache = new Map(); +const inflightRequests = new Map>(); +const cacheListeners = new Set<(userId: string) => void>(); + +export function registerProfileCacheListener(fn: (userId: string) => void): () => void { + cacheListeners.add(fn); + return () => cacheListeners.delete(fn); +} + +export function clearProfileCache(userId?: string): void { + if (!userId) return; + profileCache.delete(userId); + inflightRequests.delete(userId); + cacheListeners.forEach((listener) => listener(userId)); +} + +function setProfileCache(userId: string, fields: ProfileFields): void { + if (profileCache.size >= MAX_PROFILE_CACHE_ENTRIES) { + const firstKey = profileCache.keys().next().value; + if (firstKey !== undefined) profileCache.delete(firstKey); + } + profileCache.set(userId, { fields, timestamp: Date.now() }); +} + +/** Cached profile fields, or undefined when the entry is missing or expired. */ +export function getCachedProfileFields(userId: string): ProfileFields | undefined { + if (!userId) return undefined; + const entry = profileCache.get(userId); + if (!entry || Date.now() - entry.timestamp >= PROFILE_CACHE_TTL_MS) return undefined; + return entry.fields; +} + +/** + * Profile fields for a user, served from the shared cache when possible. + * Concurrent callers for the same user share one request. + */ +export async function getProfileFields(mx: MatrixClient, userId: string): Promise { + if (!userId) return {}; + + const cached = getCachedProfileFields(userId); + if (cached) return cached; + + const pending = inflightRequests.get(userId); + if (pending) return pending; + + const request = (async () => { + let fields: ProfileFields = {}; + + try { + if (await mx.doesServerSupportExtendedProfiles()) { + fields = await mx.getExtendedProfile(userId); + } + } catch { + // Server may not support MSC4133, or the user has no extended fields. + } + + if (Object.keys(fields).length === 0) { + try { + fields = (await mx.getProfileInfo(userId)) as ProfileFields; + } catch { + fields = {}; + } + } + + setProfileCache(userId, fields); + return fields; + })(); + + inflightRequests.set(userId, request); + try { + return await request; + } finally { + if (inflightRequests.get(userId) === request) inflightRequests.delete(userId); + } +} diff --git a/src/app/utils/profileFields.ts b/src/app/utils/profileFields.ts index 72391122..93908f11 100644 --- a/src/app/utils/profileFields.ts +++ b/src/app/utils/profileFields.ts @@ -1,5 +1,6 @@ import { MatrixClient, Room } from 'matrix-js-sdk'; import { ThemeKind } from '../hooks/useTheme'; +import { clearProfileCache, getProfileFields } from './profileCache'; /** MSC4522 stable profile field for username colors */ export const PROFILE_KEY_COLOR_PREFERENCE_STABLE = 'm.color_preference'; @@ -120,26 +121,8 @@ export function extractCollectiblesFromProfile(profile: Record) }; } -async function loadCollectiblesFromProfile(mx: MatrixClient, userId: string): Promise { - if (await mx.doesServerSupportExtendedProfiles()) { - try { - const profile = await mx.getExtendedProfile(userId); - return extractCollectiblesFromProfile(profile); - } catch { - // fall through - } - } - - try { - const profile = (await mx.getProfileInfo(userId)) as Record; - return extractCollectiblesFromProfile(profile); - } catch { - return {}; - } -} - export async function loadUserCollectibles(mx: MatrixClient, userId: string): Promise { - return loadCollectiblesFromProfile(mx, userId); + return extractCollectiblesFromProfile(await getProfileFields(mx, userId)); } export async function saveCollectible( @@ -179,21 +162,7 @@ export async function getBannerUrlProfileKey(mx: MatrixClient): Promise } export async function loadBannerUrl(mx: MatrixClient, userId: string): Promise { - if (await mx.doesServerSupportExtendedProfiles()) { - try { - const profile = await mx.getExtendedProfile(userId); - return extractBannerUrlFromProfile(profile); - } catch { - // fall through - } - } - - try { - const profile = (await mx.getProfileInfo(userId)) as Record; - return extractBannerUrlFromProfile(profile); - } catch { - return undefined; - } + return extractBannerUrlFromProfile(await getProfileFields(mx, userId)); } export async function saveBannerUrl(mx: MatrixClient, bannerMxc: string): Promise { @@ -204,7 +173,7 @@ export async function saveBannerUrl(mx: MatrixClient, bannerMxc: string): Promis const key = await getBannerUrlProfileKey(mx); await mx.setExtendedProfileProperty(key, bannerMxc); const userId = mx.getUserId(); - if (userId) clearBannerCache(userId); + if (userId) clearProfileCache(userId); } export async function deleteBannerUrl(mx: MatrixClient): Promise { @@ -215,17 +184,7 @@ export async function deleteBannerUrl(mx: MatrixClient): Promise { const key = await getBannerUrlProfileKey(mx); await mx.deleteExtendedProfileProperty(key); const userId = mx.getUserId(); - if (userId) clearBannerCache(userId); -} - -let bannerCacheClearImpl: (userId: string) => void = () => {}; - -export function registerBannerCacheClear(fn: (userId: string) => void): void { - bannerCacheClearImpl = fn; -} - -function clearBannerCache(userId: string): void { - bannerCacheClearImpl(userId); + if (userId) clearProfileCache(userId); } export async function getColorPreferenceProfileKey(mx: MatrixClient): Promise { @@ -239,21 +198,7 @@ export async function loadColorPreference( mx: MatrixClient, userId: string ): Promise { - if (await mx.doesServerSupportExtendedProfiles()) { - try { - const profile = await mx.getExtendedProfile(userId); - return extractColorPreferenceFromProfile(profile); - } catch { - // fall through to standard profile endpoint - } - } - - try { - const profile = (await mx.getProfileInfo(userId)) as Record; - return extractColorPreferenceFromProfile(profile); - } catch { - return undefined; - } + return extractColorPreferenceFromProfile(await getProfileFields(mx, userId)); } export function extractMemberColorPreference(room: Room | undefined, userId: string): ColorPreference | undefined { @@ -272,17 +217,7 @@ export async function saveColorPreference(mx: MatrixClient, preference: ColorPre const key = await getColorPreferenceProfileKey(mx); await mx.setExtendedProfileProperty(key, preference); const userId = mx.getUserId(); - if (userId) clearPreferenceCache(userId); -} - -let preferenceCacheClearImpl: (userId: string) => void = () => {}; - -export function registerPreferenceCacheClear(fn: (userId: string) => void): void { - preferenceCacheClearImpl = fn; -} - -function clearPreferenceCache(userId: string): void { - preferenceCacheClearImpl(userId); + if (userId) clearProfileCache(userId); } export async function deleteColorPreference(mx: MatrixClient): Promise { @@ -293,5 +228,5 @@ export async function deleteColorPreference(mx: MatrixClient): Promise { const key = await getColorPreferenceProfileKey(mx); await mx.deleteExtendedProfileProperty(key); const userId = mx.getUserId(); - if (userId) clearPreferenceCache(userId); + if (userId) clearProfileCache(userId); } diff --git a/src/client/initMatrix.ts b/src/client/initMatrix.ts index 5491bdcd..1bc8ce9f 100644 --- a/src/client/initMatrix.ts +++ b/src/client/initMatrix.ts @@ -239,28 +239,7 @@ export const initClient = async (session: Session): Promise => { await mx.initRustCrypto({ storagePrefix: `${session.userId}@${session.deviceId}`, }); - - // List databases after init to verify isolation - try { - const dbsAfterInit = await getAllIndexedDBNames(); - console.log('[initMatrix] 📦 Databases after initialization:', dbsAfterInit); - - // Check if a shared crypto database was created despite storagePrefix - const hasSharedCrypto = dbsAfterInit.includes('matrix-js-sdk::matrix-sdk-crypto'); - if (hasSharedCrypto) { - console.warn('[initMatrix] ⚠️ WARNING: Shared crypto database still exists after init!'); - console.warn('[initMatrix] The storagePrefix option may not be working correctly.'); - } - - // List account-specific databases - const accountDbs = dbsAfterInit.filter(db => - db.includes(session.userId) || db.includes(session.deviceId) - ); - console.log('[initMatrix] 📁 Account-specific databases:', accountDbs); - } catch (e) { - console.log('[initMatrix] Could not list databases after init:', e); - } - + console.log('[initMatrix] ✅ Client initialized successfully!'); mx.setMaxListeners(50);