fix: missing avatars for bridged users in timeline with sliding sync

This commit is contained in:
Erwan Leboucher committed 2026-07-18 10:45:23 +02:00
1 parent b2a02d57ca
commit 1e1b2fca30
6 files changed
+180 -14

No files matched your search

@@ -0,0 +1,5 @@
---
default: patch
---
Fix missing profile pictures for bridged users in the timeline when using sliding sync.
@@ -1,6 +1,6 @@
import { Box, Button, color, config, Menu, MenuItem, Scroll, Text, toRem } from 'folds';
import type { CSSProperties, SyntheticEvent } from 'react';
import { useCallback, useEffect, useMemo, useState } from 'react';
import { useCallback, useMemo, useState } from 'react';
import { useNavigate } from 'react-router-dom';
import { useAtomValue } from 'jotai';
import type { Opts as LinkifyOpts } from 'linkifyjs';
@@ -59,7 +59,7 @@ import { PowerChip } from './PowerChip';
import { IgnoredUserAlert, MutualRoomsChip, OptionsChip, ServerChip, ShareChip } from './UserChips';
import { UserHero, UserHeroName } from './UserHero';
import { KnownMembership } from '$types/matrix-sdk';
import { hydrateRoomMember } from '$client/roomMemberHydration';
import { useRoomMemberHydration } from '$hooks/useRoomMemberHydration';
import * as css from './styles.css';
import * as prefix from '$unstable/prefixes';
@@ -445,17 +445,7 @@ export function UserRoomProfile({ userId, initialProfile }: Readonly<UserRoomPro
? fetchedProfile
: (initialProfile as UserProfile) || fetchedProfile;
const [, refreshMemberProfile] = useState(0);
useEffect(() => {
if (room.getMember(userId)) return undefined;
let disposed = false;
void hydrateRoomMember(mx, room.roomId, userId).then(() => {
if (!disposed) refreshMemberProfile((version) => version + 1);
});
return () => {
disposed = true;
};
}, [mx, room, userId]);
useRoomMemberHydration(room, userId);
const avatarMxc = getMemberAvatarMxc(room, userId) ?? extendedProfile.avatarUrl;
const avatarUrl = (avatarMxc && mxcUrlToHttp(mx, avatarMxc, useAuthentication)) ?? undefined;
@@ -47,6 +47,7 @@ import { useSableCosmetics } from '$hooks/useSableCosmetics';
import { SwipeableMessageWrapper } from '$components/SwipeableMessageWrapper';
import { mobileOrTablet } from '$utils/user-agent';
import { useUserProfile } from '$hooks/useUserProfile';
import { useRoomMemberHydration } from '$hooks/useRoomMemberHydration';
import { useSetting } from '$state/hooks/settings';
import { useBlobCache } from '$hooks/useBlobCache';
import { filterPronounsByLanguage, getParsedPronouns } from '$utils/pronouns';
@@ -459,6 +460,7 @@ function MessageInternal(
// Avatars
// Prefer the room-scoped member avatar (m.room.member) over the global profile
// avatar so per-room avatar overrides are respected in the timeline.
useRoomMemberHydration(room, senderId);
const memberAvatarMxc = getMemberAvatarMxc(room, senderId);
const avatarUrl = useMemo(() => {
const mxc = pmp?.avatar_url || memberAvatarMxc || profile.avatarUrl;
+27
View File
@@ -0,0 +1,27 @@
import { useEffect, useState } from 'react';
import type { Room } from '$types/matrix-sdk';
import { hydrateRoomMember } from '$client/roomMemberHydration';
import { useMatrixClient } from './useMatrixClient';
/**
* Under sliding sync, m.room.member events only arrive for senders in the
* lazy-loaded sync window. Fetch the member on demand and bump local state so
* the caller re-reads room member state (avatar, display name) once hydrated.
*/
export const useRoomMemberHydration = (room: Room, userId: string): number => {
const mx = useMatrixClient();
const [version, setVersion] = useState(0);
useEffect(() => {
if (!userId.startsWith('@') || room.getMember(userId)) return undefined;
let disposed = false;
void hydrateRoomMember(mx, room.roomId, userId).then(() => {
if (!disposed && room.getMember(userId)) setVersion((v) => v + 1);
});
return () => {
disposed = true;
};
}, [mx, room, userId]);
return version;
};
+129
View File
@@ -0,0 +1,129 @@
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import type { MatrixClient, Room, RoomMember } from '$types/matrix-sdk';
import { EventType } from '$types/matrix-sdk';
import { hydrateRoomMember, hydrateRoomMembers } from './roomMemberHydration';
const ROOM_ID = '!room:server';
const USER_ID = '@ghost:server';
type FakeSetup = {
mx: MatrixClient;
room: Room;
getStateEvent: ReturnType<typeof vi.fn>;
setStateEvents: ReturnType<typeof vi.fn>;
getMember: ReturnType<typeof vi.fn>;
};
const makeFakes = (): FakeSetup => {
const getMember = vi.fn<() => RoomMember | null>(() => null);
const setStateEvents = vi.fn<() => void>();
const room = {
roomId: ROOM_ID,
getMember,
currentState: { setStateEvents },
} as unknown as Room;
const getStateEvent = vi.fn<() => Promise<object>>(() =>
Promise.resolve({ membership: 'join', avatar_url: 'mxc://server/abc' })
);
const mx = {
getRoom: () => room,
getStateEvent,
} as unknown as MatrixClient;
return { mx, room, getStateEvent, setStateEvents, getMember };
};
describe('hydrateRoomMember', () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.useRealTimers();
});
it('fetches and injects a missing member', async () => {
const { mx, getStateEvent, setStateEvents } = makeFakes();
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
expect(getStateEvent).toHaveBeenCalledWith(ROOM_ID, EventType.RoomMember, USER_ID);
expect(setStateEvents).toHaveBeenCalledTimes(1);
const [events] = setStateEvents.mock.calls[0] as [Array<{ getType: () => string }>];
expect(events[0]?.getType()).toBe(EventType.RoomMember);
});
it('does nothing when the member already exists', async () => {
const { mx, getStateEvent, getMember } = makeFakes();
getMember.mockReturnValue({} as RoomMember);
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
expect(getStateEvent).not.toHaveBeenCalled();
});
it('skips injection when the member appears while the fetch is in flight', async () => {
const { mx, getMember, setStateEvents } = makeFakes();
const promise = hydrateRoomMember(mx, ROOM_ID, USER_ID);
getMember.mockReturnValue({} as RoomMember);
await promise;
expect(setStateEvents).not.toHaveBeenCalled();
});
it('dedups concurrent requests for the same member', async () => {
const { mx, getStateEvent } = makeFakes();
await Promise.all([
hydrateRoomMember(mx, ROOM_ID, USER_ID),
hydrateRoomMember(mx, ROOM_ID, USER_ID),
]);
expect(getStateEvent).toHaveBeenCalledTimes(1);
});
it('negative-caches failed fetches and retries after the TTL', async () => {
const { mx, getStateEvent } = makeFakes();
getStateEvent.mockRejectedValueOnce(new Error('404'));
await expect(hydrateRoomMember(mx, ROOM_ID, USER_ID)).resolves.toBeUndefined();
expect(getStateEvent).toHaveBeenCalledTimes(1);
// Within the TTL the failure is cached — no refetch.
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
expect(getStateEvent).toHaveBeenCalledTimes(1);
// After the TTL the fetch is retried.
vi.advanceTimersByTime(5 * 60_000 + 1);
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
expect(getStateEvent).toHaveBeenCalledTimes(2);
});
it('clears the failure entry on a later success', async () => {
const { mx, getStateEvent, setStateEvents, getMember } = makeFakes();
getStateEvent.mockRejectedValueOnce(new Error('404'));
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
vi.advanceTimersByTime(5 * 60_000 + 1);
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
expect(setStateEvents).toHaveBeenCalledTimes(1);
// The stale failure no longer blocks further hydration attempts.
getMember.mockReturnValue(null);
await hydrateRoomMember(mx, ROOM_ID, USER_ID);
expect(getStateEvent).toHaveBeenCalledTimes(3);
});
});
describe('hydrateRoomMembers', () => {
it('dedups user ids and filters non-user ids', async () => {
const { mx, getStateEvent } = makeFakes();
await hydrateRoomMembers(mx, ROOM_ID, [USER_ID, USER_ID, 'not-a-user', '@other:server']);
expect(getStateEvent).toHaveBeenCalledTimes(2);
expect(getStateEvent).toHaveBeenCalledWith(ROOM_ID, EventType.RoomMember, USER_ID);
expect(getStateEvent).toHaveBeenCalledWith(ROOM_ID, EventType.RoomMember, '@other:server');
});
});
+14 -1
View File
@@ -3,6 +3,11 @@ import { EventType, MatrixEvent } from '$types/matrix-sdk';
const inFlight = new WeakMap<MatrixClient, Map<string, Promise<void>>>();
// Members whose state event could not be fetched (e.g. defunct bridge ghosts)
// are skipped for a while so virtualized-timeline remounts don't refetch them.
const FAILURE_TTL_MS = 5 * 60_000;
const failedAt = new WeakMap<MatrixClient, Map<string, number>>();
export const hydrateRoomMember = (
mx: MatrixClient,
roomId: string,
@@ -12,6 +17,9 @@ export const hydrateRoomMember = (
if (!room || room.getMember(userId)) return Promise.resolve();
const key = `${roomId}\u0000${userId}`;
const failedTs = failedAt.get(mx)?.get(key);
if (failedTs !== undefined && Date.now() - failedTs < FAILURE_TTL_MS) return Promise.resolve();
const pending = inFlight.get(mx) ?? new Map<string, Promise<void>>();
inFlight.set(mx, pending);
const existing = pending.get(key);
@@ -20,6 +28,7 @@ export const hydrateRoomMember = (
const request = mx
.getStateEvent(roomId, EventType.RoomMember, userId)
.then((content) => {
failedAt.get(mx)?.delete(key);
const currentRoom = mx.getRoom(roomId);
if (!currentRoom || currentRoom.getMember(userId)) return;
currentRoom.currentState.setStateEvents([
@@ -32,7 +41,11 @@ export const hydrateRoomMember = (
}),
]);
})
.catch(() => undefined)
.catch(() => {
const failures = failedAt.get(mx) ?? new Map<string, number>();
failedAt.set(mx, failures);
failures.set(key, Date.now());
})
.finally(() => pending.delete(key));
pending.set(key, request);