1 Commits
Author SHA1 Message Date
litruv 9b657e3ab4 Cache profile fields and assets behind one shared store.
Trigger cinny-mobile / dispatch (push) Successful in 1s
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.
2026-10-06 07:42:47 +11:00
8 changed files with 282 additions and 285 deletions
+17 -46
View File
@@ -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<string, { bannerMxc: string | undefined; timestamp: number }>();
const CACHE_TTL_MS = 5 * 60 * 1000;
registerBannerCacheClear((userId: string) => {
userBannerCache.delete(userId);
});
async function fetchBannerBlobUrl(
mx: ReturnType<typeof useMatrixClient>,
bannerMxc: string,
useAuthentication: boolean
): Promise<string | undefined> {
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<string | undefined>();
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]);
+28 -76
View File
@@ -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<string, { data: CollectibleProfileFields; timestamp: number }>();
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<typeof useMatrixClient>,
mxc: string,
useAuthentication: boolean
): Promise<string | undefined> {
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<string, string | undefined>;
} {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [collectibles, setCollectibles] = useState<CollectibleProfileFields>({});
const [assetUrls, setAssetUrls] = useState<Record<string, string | undefined>>({});
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<CollectibleProfileFields>(() => {
const cached = getCachedProfileFields(userId);
return cached ? extractCollectiblesFromProfile(cached) : {};
});
const [assetUrls, setAssetUrls] = useState<Record<string, string | undefined>>({});
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 };
}
+27 -59
View File
@@ -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<K, V> {
private cache = new Map<K, V>();
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<string, { preference: ColorPreference | undefined; timestamp: number }>(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<ColorPreference | undefined>(cachedPreference);
const [preference, setPreference] = useState<ColorPreference | undefined>(() => {
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<string, unknown>) => {
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]);
+37 -9
View File
@@ -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<string, unknown>) => {
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]);
+73
View File
@@ -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<string, string>();
const inflightAssets = new Map<string, Promise<string | undefined>>();
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<string | undefined> {
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();
}
+91
View File
@@ -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<string, unknown>;
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<string, ProfileCacheEntry>();
const inflightRequests = new Map<string, Promise<ProfileFields>>();
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<ProfileFields> {
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);
}
}
+8 -73
View File
@@ -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<string, unknown>)
};
}
async function loadCollectiblesFromProfile(mx: MatrixClient, userId: string): Promise<CollectibleProfileFields> {
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<string, unknown>;
return extractCollectiblesFromProfile(profile);
} catch {
return {};
}
}
export async function loadUserCollectibles(mx: MatrixClient, userId: string): Promise<CollectibleProfileFields> {
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<string>
}
export async function loadBannerUrl(mx: MatrixClient, userId: string): Promise<string | undefined> {
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<string, unknown>;
return extractBannerUrlFromProfile(profile);
} catch {
return undefined;
}
return extractBannerUrlFromProfile(await getProfileFields(mx, userId));
}
export async function saveBannerUrl(mx: MatrixClient, bannerMxc: string): Promise<void> {
@@ -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<void> {
@@ -215,17 +184,7 @@ export async function deleteBannerUrl(mx: MatrixClient): Promise<void> {
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<string> {
@@ -239,21 +198,7 @@ export async function loadColorPreference(
mx: MatrixClient,
userId: string
): Promise<ColorPreference | undefined> {
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<string, unknown>;
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<void> {
@@ -293,5 +228,5 @@ export async function deleteColorPreference(mx: MatrixClient): Promise<void> {
const key = await getColorPreferenceProfileKey(mx);
await mx.deleteExtendedProfileProperty(key);
const userId = mx.getUserId();
if (userId) clearPreferenceCache(userId);
if (userId) clearProfileCache(userId);
}
+1 -22
View File
@@ -239,28 +239,7 @@ export const initClient = async (session: Session): Promise<MatrixClient> => {
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);