mirror of
https://github.com/SableClient/Sable.git
synced 2026-11-20 09:01:17 -08:00
626 lines
19 KiB
TypeScript
626 lines
19 KiB
TypeScript
import type {
|
|
CryptoCallbacks,
|
|
MatrixClient,
|
|
MSC3575SlidingSyncRequest,
|
|
MSC3575SlidingSyncResponse,
|
|
} from '$types/matrix-sdk';
|
|
import {
|
|
ClientEvent,
|
|
createClient,
|
|
IndexedDBStore,
|
|
IndexedDBCryptoStore,
|
|
SyncState,
|
|
} from '$types/matrix-sdk';
|
|
|
|
import { clearNavToActivePathStore } from '$state/navToActivePath';
|
|
import type { Session, Sessions, SessionStoreName } from '$state/sessions';
|
|
import { getSessionStoreName, MATRIX_SESSIONS_KEY } from '$state/sessions';
|
|
import { getLocalStorageItem } from '$state/utils/atomWithLocalStorage';
|
|
import { createLogger } from '$utils/debug';
|
|
import { createDebugLogger } from '$utils/debugLogger';
|
|
import * as Sentry from '@sentry/react';
|
|
import { pushSessionToSW } from '../sw-session';
|
|
import { cryptoCallbacks } from './secretStorageKeys';
|
|
import type { SlidingSyncDiagnostics } from './slidingSync';
|
|
import { SlidingSyncManager } from './slidingSync';
|
|
import { PresenceSyncManager } from './presenceSync';
|
|
|
|
const log = createLogger('initMatrix');
|
|
const debugLog = createDebugLogger('initMatrix');
|
|
const slidingSyncByClient = new WeakMap<MatrixClient, SlidingSyncManager>();
|
|
const presenceSyncByClient = new WeakMap<MatrixClient, PresenceSyncManager>();
|
|
const presenceStartCleanupByClient = new WeakMap<MatrixClient, () => void>();
|
|
const SLIDING_SYNC_POLL_TIMEOUT_MS = 20000;
|
|
|
|
const isInitialSyncReady = (state: string | null): boolean =>
|
|
state === SyncState.Prepared || state === SyncState.Syncing || state === SyncState.Catchup;
|
|
|
|
const startPresenceAfterInitialSync = (
|
|
mx: MatrixClient,
|
|
manager: PresenceSyncManager
|
|
): (() => void) => {
|
|
let started = false;
|
|
let startTimer: ReturnType<typeof globalThis.setTimeout> | undefined;
|
|
|
|
const start = () => {
|
|
if (started) return;
|
|
started = true;
|
|
presenceStartCleanupByClient.delete(mx);
|
|
mx.removeListener(ClientEvent.Sync, onSync);
|
|
manager.start();
|
|
};
|
|
|
|
const scheduleStart = () => {
|
|
if (startTimer !== undefined) return;
|
|
startTimer = globalThis.setTimeout(() => {
|
|
startTimer = undefined;
|
|
start();
|
|
}, 0);
|
|
};
|
|
|
|
const onSync = (state: SyncState) => {
|
|
if (isInitialSyncReady(state)) scheduleStart();
|
|
};
|
|
|
|
if (isInitialSyncReady(mx.getSyncState())) scheduleStart();
|
|
else mx.on(ClientEvent.Sync, onSync);
|
|
|
|
const cleanup = () => {
|
|
if (startTimer !== undefined) globalThis.clearTimeout(startTimer);
|
|
mx.removeListener(ClientEvent.Sync, onSync);
|
|
presenceStartCleanupByClient.delete(mx);
|
|
};
|
|
presenceStartCleanupByClient.set(mx, cleanup);
|
|
return cleanup;
|
|
};
|
|
|
|
type StartupPhase = 'sync_store' | 'rust_crypto' | 'client_init' | 'client_start';
|
|
|
|
const measureStartupPhase = async <T>(
|
|
phase: StartupPhase,
|
|
task: () => Promise<T>,
|
|
attributes?: Record<string, string>
|
|
): Promise<T> => {
|
|
const startTime = performance.now();
|
|
try {
|
|
const result = await task();
|
|
Sentry.metrics.distribution('sable.startup.phase_ms', performance.now() - startTime, {
|
|
attributes: { phase, outcome: 'success', ...attributes },
|
|
});
|
|
return result;
|
|
} catch (error) {
|
|
Sentry.metrics.distribution('sable.startup.phase_ms', performance.now() - startTime, {
|
|
attributes: { phase, outcome: 'error', ...attributes },
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
type FetchRoomEventResult = Awaited<ReturnType<MatrixClient['fetchRoomEvent']>>;
|
|
type MatrixClientWithWritableFetchRoomEvent = MatrixClient & {
|
|
fetchRoomEvent: (roomId: string, eventId: string) => Promise<FetchRoomEventResult>;
|
|
};
|
|
|
|
const fetchRoomEventStartupCleanupByClient = new WeakMap<MatrixClient, () => void>();
|
|
|
|
const slidingSyncConnIdCleanupByClient = new WeakMap<MatrixClient, () => void>();
|
|
|
|
type SlidingSyncMethod = (
|
|
reqBody: MSC3575SlidingSyncRequest,
|
|
baseUrl?: string,
|
|
abortSignal?: AbortSignal
|
|
) => Promise<MSC3575SlidingSyncResponse>;
|
|
|
|
type MatrixClientWithWritableSlidingSync = MatrixClient & {
|
|
slidingSync: SlidingSyncMethod;
|
|
};
|
|
|
|
type SlidingSyncRequestWithConnId = MSC3575SlidingSyncRequest & { conn_id?: string };
|
|
|
|
const SLIDING_SYNC_CONN_ID = 'sable-main';
|
|
|
|
function installSlidingSyncConnId(mx: MatrixClient): void {
|
|
slidingSyncConnIdCleanupByClient.get(mx)?.();
|
|
|
|
const mxWritable = mx as MatrixClientWithWritableSlidingSync;
|
|
const original = mx.slidingSync.bind(mx) as SlidingSyncMethod;
|
|
mxWritable.slidingSync = (reqBody, baseUrl, abortSignal) => {
|
|
const req = reqBody as SlidingSyncRequestWithConnId;
|
|
if (req.conn_id === undefined) {
|
|
req.conn_id = SLIDING_SYNC_CONN_ID;
|
|
}
|
|
|
|
return original(reqBody, baseUrl, abortSignal);
|
|
};
|
|
|
|
slidingSyncConnIdCleanupByClient.set(mx, () => {
|
|
slidingSyncConnIdCleanupByClient.delete(mx);
|
|
mxWritable.slidingSync = original;
|
|
});
|
|
}
|
|
|
|
function installStartupFetchRoomEventPatch(
|
|
mx: MatrixClient,
|
|
slidingSyncManager: SlidingSyncManager
|
|
): void {
|
|
fetchRoomEventStartupCleanupByClient.get(mx)?.();
|
|
|
|
const mxWritable = mx as MatrixClientWithWritableFetchRoomEvent;
|
|
const origFetchRoomEvent = mx.fetchRoomEvent.bind(mx);
|
|
|
|
const restore = () => {
|
|
fetchRoomEventStartupCleanupByClient.delete(mx);
|
|
mxWritable.fetchRoomEvent = origFetchRoomEvent;
|
|
};
|
|
|
|
mxWritable.fetchRoomEvent = (roomId: string, eventId: string) => {
|
|
if (slidingSyncManager.isRoomActive(roomId)) {
|
|
return origFetchRoomEvent(roomId, eventId);
|
|
}
|
|
const cachedEvent = mx.getRoom(roomId)?.findEventById(eventId);
|
|
const payload: FetchRoomEventResult = cachedEvent?.event ?? {
|
|
event_id: eventId,
|
|
room_id: roomId,
|
|
};
|
|
return Promise.resolve(payload);
|
|
};
|
|
|
|
fetchRoomEventStartupCleanupByClient.set(mx, restore);
|
|
}
|
|
|
|
const deleteDatabase = (name: string): Promise<void> =>
|
|
new Promise((resolve) => {
|
|
const req = window.indexedDB.deleteDatabase(name);
|
|
req.addEventListener('success', () => resolve());
|
|
req.addEventListener('error', () => resolve()); // resolve anyway — we tried
|
|
req.addEventListener('blocked', () => resolve());
|
|
});
|
|
|
|
const deleteSyncStoreGroup = async (syncStoreName: string): Promise<void> => {
|
|
await Promise.all([
|
|
deleteDatabase(syncStoreName),
|
|
deleteDatabase(syncStoreName.replace(/^sync/, 'crypto')),
|
|
deleteDatabase(`${syncStoreName}::matrix-sdk-crypto`),
|
|
]);
|
|
};
|
|
|
|
const deleteSessionStores = async (storeName: SessionStoreName): Promise<void> => {
|
|
await Promise.all([
|
|
deleteDatabase(storeName.sync),
|
|
deleteDatabase(storeName.crypto),
|
|
deleteDatabase(`${storeName.rustCryptoPrefix}::matrix-sdk-crypto`),
|
|
]);
|
|
};
|
|
|
|
/**
|
|
* Reads the account stored in an IndexedDB sync store without opening a full MatrixClient.
|
|
* Returns undefined if the database doesn't exist or has no account record.
|
|
*/
|
|
const readStoredAccount = (dbName: string): Promise<string | undefined> =>
|
|
new Promise((resolve) => {
|
|
let settled = false;
|
|
const finish = (value: string | undefined) => {
|
|
if (settled) return;
|
|
settled = true;
|
|
resolve(value);
|
|
};
|
|
const req = window.indexedDB.open(dbName);
|
|
req.addEventListener('error', () => finish(undefined));
|
|
req.addEventListener('success', () => {
|
|
const db = req.result;
|
|
try {
|
|
if (!db.objectStoreNames.contains('account')) {
|
|
db.close();
|
|
finish(undefined);
|
|
} else {
|
|
const tx = db.transaction('account', 'readonly');
|
|
const store = tx.objectStore('account');
|
|
const getReq = store.get('account');
|
|
getReq.addEventListener('success', () => {
|
|
db.close();
|
|
const record = getReq.result;
|
|
if (!record?.account_data) {
|
|
finish(undefined);
|
|
} else {
|
|
try {
|
|
const data = JSON.parse(record.account_data);
|
|
finish(data?.user_id ?? undefined);
|
|
} catch {
|
|
finish(undefined);
|
|
}
|
|
}
|
|
});
|
|
getReq.addEventListener('error', () => {
|
|
db.close();
|
|
finish(undefined);
|
|
});
|
|
}
|
|
} catch {
|
|
try {
|
|
db.close();
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
finish(undefined);
|
|
}
|
|
});
|
|
});
|
|
|
|
const isMismatch = (err: unknown): boolean => {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
return (
|
|
msg.includes("doesn't match") ||
|
|
msg.includes('does not match') ||
|
|
msg.includes('account in the store') ||
|
|
msg.includes('account in the constructor')
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Pre-flight check: scans every IndexedDB database and deletes any that
|
|
* belong to a userId not present in the stored sessions list, or whose
|
|
* sync-store data contradicts the expected session userId.
|
|
* Call this once on startup before initClient.
|
|
*/
|
|
export const clearMismatchedStores = async (): Promise<void> => {
|
|
const sessions = getLocalStorageItem<Sessions>(MATRIX_SESSIONS_KEY, []);
|
|
const knownUserIds = new Set(sessions.map((s) => s.userId));
|
|
const knownStoreNames = new Set(
|
|
sessions.flatMap((s) => {
|
|
const sn = getSessionStoreName(s);
|
|
return [sn.sync, sn.crypto, `${sn.rustCryptoPrefix}::matrix-sdk-crypto`];
|
|
})
|
|
);
|
|
|
|
let allDbs: IDBDatabaseInfo[] = [];
|
|
try {
|
|
allDbs = await window.indexedDB.databases();
|
|
} catch {
|
|
// databases() not supported in all browsers
|
|
}
|
|
|
|
await Promise.all(
|
|
allDbs.map(async ({ name }) => {
|
|
if (!name) return;
|
|
|
|
const containsKnownUser = Array.from(knownUserIds).some((uid) => name.includes(uid));
|
|
const looksLikeUserDb = name.includes('@');
|
|
if (looksLikeUserDb && !containsKnownUser && !knownStoreNames.has(name)) {
|
|
log.warn(`clearMismatchedStores: "${name}" has unknown user — deleting`);
|
|
await deleteDatabase(name);
|
|
return;
|
|
}
|
|
|
|
if (!name.startsWith('sync')) return;
|
|
|
|
const storedUserId = await readStoredAccount(name);
|
|
if (!storedUserId) return;
|
|
|
|
if (!knownUserIds.has(storedUserId)) {
|
|
log.warn(`clearMismatchedStores: "${name}" has unknown user ${storedUserId} — deleting`);
|
|
await deleteSyncStoreGroup(name);
|
|
return;
|
|
}
|
|
|
|
const expectedStore = `sync${storedUserId}`;
|
|
if (name !== expectedStore && !knownStoreNames.has(name)) {
|
|
log.warn(`clearMismatchedStores: "${name}" is misplaced for ${storedUserId} — deleting`);
|
|
await deleteSyncStoreGroup(name);
|
|
}
|
|
})
|
|
);
|
|
|
|
await Promise.all(
|
|
sessions.map(async (session) => {
|
|
const sn = getSessionStoreName(session);
|
|
const storedUserId = await readStoredAccount(sn.sync);
|
|
if (storedUserId && storedUserId !== session.userId) {
|
|
log.warn(
|
|
`clearMismatchedStores: "${sn.sync}" has ${storedUserId} but session is ${session.userId} — deleting`
|
|
);
|
|
await deleteSessionStores(sn);
|
|
}
|
|
})
|
|
);
|
|
};
|
|
|
|
type BuiltClient = {
|
|
mx: MatrixClient;
|
|
indexedDBStore: IndexedDBStore;
|
|
};
|
|
|
|
const buildClient = (session: Session): BuiltClient => {
|
|
const storeName = getSessionStoreName(session);
|
|
|
|
const indexedDBStore = new IndexedDBStore({
|
|
indexedDB: global.indexedDB,
|
|
localStorage: global.localStorage,
|
|
dbName: storeName.sync,
|
|
});
|
|
|
|
const legacyCryptoStore = new IndexedDBCryptoStore(global.indexedDB, storeName.crypto);
|
|
|
|
const mx = createClient({
|
|
baseUrl: session.baseUrl,
|
|
accessToken: session.accessToken,
|
|
userId: session.userId,
|
|
store: indexedDBStore,
|
|
cryptoStore: legacyCryptoStore,
|
|
deviceId: session.deviceId,
|
|
timelineSupport: true,
|
|
cryptoCallbacks: cryptoCallbacks as unknown as CryptoCallbacks,
|
|
verificationMethods: ['m.sas.v1'],
|
|
});
|
|
|
|
return { mx, indexedDBStore };
|
|
};
|
|
|
|
type ClientInitializationResult =
|
|
| { ok: true; mx: MatrixClient }
|
|
| { ok: false; error: unknown; phase: 'sync_store' | 'rust_crypto' };
|
|
|
|
const initializeClient = async (
|
|
session: Session,
|
|
cryptoDatabasePrefix: string
|
|
): Promise<ClientInitializationResult> => {
|
|
let builtClient: BuiltClient;
|
|
try {
|
|
builtClient = buildClient(session);
|
|
} catch (error) {
|
|
return { ok: false, error, phase: 'sync_store' };
|
|
}
|
|
const { mx, indexedDBStore } = builtClient;
|
|
|
|
void mx.getVersions().catch(() => undefined);
|
|
|
|
const syncStorePromise = measureStartupPhase('sync_store', () => indexedDBStore.startup());
|
|
const cryptoPromise = measureStartupPhase('rust_crypto', () =>
|
|
mx.initRustCrypto({ cryptoDatabasePrefix })
|
|
);
|
|
const [syncStoreResult, cryptoResult] = await Promise.allSettled([
|
|
syncStorePromise,
|
|
cryptoPromise,
|
|
]);
|
|
|
|
if (syncStoreResult.status === 'rejected') {
|
|
mx.stopClient();
|
|
return { ok: false, error: syncStoreResult.reason, phase: 'sync_store' };
|
|
}
|
|
if (cryptoResult.status === 'rejected') {
|
|
mx.stopClient();
|
|
return { ok: false, error: cryptoResult.reason, phase: 'rust_crypto' };
|
|
}
|
|
|
|
return { ok: true, mx };
|
|
};
|
|
|
|
export const initClient = async (session: Session): Promise<MatrixClient> => {
|
|
const storeName = getSessionStoreName(session);
|
|
debugLog.info('sync', 'Initializing Matrix client', {
|
|
userId: session.userId,
|
|
baseUrl: session.baseUrl,
|
|
});
|
|
|
|
const wipeAllStores = async () => {
|
|
log.warn('initClient: wiping all stores for', session.userId);
|
|
debugLog.warn('sync', 'Wiping all stores due to mismatch', {
|
|
userId: session.userId,
|
|
});
|
|
Sentry.addBreadcrumb({
|
|
category: 'crypto',
|
|
message: 'Crypto store mismatch — wiping local stores and retrying',
|
|
level: 'warning',
|
|
});
|
|
Sentry.metrics.count('sable.crypto.store_wipe', 1);
|
|
await deleteSessionStores(storeName);
|
|
try {
|
|
const allDbs = await window.indexedDB.databases();
|
|
await Promise.all(
|
|
allDbs.map(async ({ name }) => {
|
|
if (name && name.includes(session.userId)) {
|
|
log.warn('initClient: also wiping db', name);
|
|
await deleteDatabase(name);
|
|
}
|
|
})
|
|
);
|
|
} catch {
|
|
// databases() not available in all browsers
|
|
}
|
|
};
|
|
|
|
const initStartTime = performance.now();
|
|
let initOutcome = 'success';
|
|
try {
|
|
let result = await initializeClient(session, storeName.rustCryptoPrefix);
|
|
if (!result.ok) {
|
|
if (!isMismatch(result.error)) {
|
|
debugLog.error('sync', 'Failed to initialize client', {
|
|
phase: result.phase,
|
|
error: result.error,
|
|
});
|
|
throw result.error;
|
|
}
|
|
|
|
log.warn(`initClient: mismatch during ${result.phase} — wiping and retrying:`, result.error);
|
|
debugLog.warn('sync', 'Client initialization mismatch - wiping stores and retrying', {
|
|
phase: result.phase,
|
|
error: result.error,
|
|
});
|
|
await wipeAllStores();
|
|
result = await initializeClient(session, storeName.rustCryptoPrefix);
|
|
if (!result.ok) {
|
|
debugLog.error('sync', 'Failed to initialize client after store reset', {
|
|
phase: result.phase,
|
|
error: result.error,
|
|
});
|
|
throw result.error;
|
|
}
|
|
}
|
|
|
|
result.mx.setMaxListeners(50);
|
|
return result.mx;
|
|
} catch (error) {
|
|
initOutcome = 'error';
|
|
throw error;
|
|
} finally {
|
|
Sentry.metrics.distribution('sable.startup.phase_ms', performance.now() - initStartTime, {
|
|
attributes: { phase: 'client_init', outcome: initOutcome },
|
|
});
|
|
}
|
|
};
|
|
|
|
export type StartClientConfig = {
|
|
baseUrl?: string;
|
|
sessionSlidingSyncOptIn?: boolean;
|
|
pollTimeoutMs?: number;
|
|
timelineLimit?: number;
|
|
};
|
|
|
|
export type ClientSyncDiagnostics = {
|
|
transport: 'sliding' | 'classic';
|
|
syncState: string | null;
|
|
sliding?: SlidingSyncDiagnostics;
|
|
};
|
|
|
|
const disposeSlidingSync = (mx: MatrixClient): void => {
|
|
const manager = slidingSyncByClient.get(mx);
|
|
if (!manager) return;
|
|
manager.dispose();
|
|
slidingSyncByClient.delete(mx);
|
|
};
|
|
|
|
const disposePresenceSync = (mx: MatrixClient): void => {
|
|
presenceStartCleanupByClient.get(mx)?.();
|
|
const manager = presenceSyncByClient.get(mx);
|
|
if (!manager) return;
|
|
manager.dispose();
|
|
presenceSyncByClient.delete(mx);
|
|
};
|
|
|
|
export const getSlidingSyncManager = (mx: MatrixClient): SlidingSyncManager | undefined =>
|
|
slidingSyncByClient.get(mx);
|
|
|
|
export const getPresenceSyncManager = (mx: MatrixClient): PresenceSyncManager | undefined =>
|
|
presenceSyncByClient.get(mx);
|
|
|
|
export const startClient = async (mx: MatrixClient, config?: StartClientConfig): Promise<void> => {
|
|
disposeSlidingSync(mx);
|
|
disposePresenceSync(mx);
|
|
|
|
const baseUrl = config?.baseUrl ?? mx.baseUrl;
|
|
const useSliding = config?.sessionSlidingSyncOptIn === true;
|
|
|
|
debugLog.info('sync', 'Starting Matrix client', { userId: mx.getUserId() });
|
|
|
|
const presenceManager = new PresenceSyncManager(mx);
|
|
presenceSyncByClient.set(mx, presenceManager);
|
|
startPresenceAfterInitialSync(mx, presenceManager);
|
|
|
|
let manager: SlidingSyncManager | undefined;
|
|
|
|
if (useSliding) {
|
|
manager = new SlidingSyncManager(mx, baseUrl, {
|
|
pollTimeoutMs: config?.pollTimeoutMs ?? SLIDING_SYNC_POLL_TIMEOUT_MS,
|
|
timelineLimit: config?.timelineLimit,
|
|
});
|
|
|
|
installStartupFetchRoomEventPatch(mx, manager);
|
|
installSlidingSyncConnId(mx);
|
|
|
|
manager.attach();
|
|
slidingSyncByClient.set(mx, manager);
|
|
}
|
|
|
|
try {
|
|
await measureStartupPhase(
|
|
'client_start',
|
|
() =>
|
|
mx.startClient({
|
|
lazyLoadMembers: true,
|
|
slidingSync: manager?.slidingSync,
|
|
threadSupport: true,
|
|
}),
|
|
{ transport: useSliding ? 'sliding' : 'classic' }
|
|
);
|
|
} catch (err) {
|
|
debugLog.error('network', 'Failed to start client with sliding sync', {
|
|
error: err instanceof Error ? err.message : String(err),
|
|
userId: mx.getUserId(),
|
|
baseUrl: useSliding ? baseUrl : undefined,
|
|
stack: err instanceof Error ? err.stack : undefined,
|
|
});
|
|
disposeSlidingSync(mx);
|
|
disposePresenceSync(mx);
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
export const stopClient = (mx: MatrixClient): void => {
|
|
log.log('stopClient', mx.getUserId());
|
|
debugLog.info('sync', 'Stopping client', { userId: mx.getUserId() });
|
|
slidingSyncConnIdCleanupByClient.get(mx)?.();
|
|
disposeSlidingSync(mx);
|
|
disposePresenceSync(mx);
|
|
mx.stopClient();
|
|
};
|
|
|
|
export const clearCacheAndReload = async (mx: MatrixClient) => {
|
|
log.log('clearCacheAndReload', mx.getUserId());
|
|
stopClient(mx);
|
|
clearNavToActivePathStore(mx.getSafeUserId());
|
|
await mx.store.deleteAllData();
|
|
window.location.reload();
|
|
};
|
|
|
|
export const getClientSyncDiagnostics = (mx: MatrixClient): ClientSyncDiagnostics => {
|
|
const slidingManager = slidingSyncByClient.get(mx);
|
|
return {
|
|
transport: slidingManager ? 'sliding' : 'classic',
|
|
syncState: mx.getSyncState(),
|
|
sliding: slidingManager?.getDiagnostics(),
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Logs out a Matrix client and cleans up its SDK stores + IndexedDB databases.
|
|
* Does NOT touch the Jotai sessions atom — callers must do that themselves
|
|
* so the correct Jotai Provider store is used.
|
|
*/
|
|
export const logoutClient = async (mx: MatrixClient, session?: Session) => {
|
|
log.log('logoutClient', {
|
|
userId: mx.getUserId(),
|
|
sessionUserId: session?.userId,
|
|
});
|
|
debugLog.info('general', 'Logging out client', { userId: mx.getUserId() });
|
|
pushSessionToSW();
|
|
stopClient(mx);
|
|
try {
|
|
await mx.logout();
|
|
debugLog.info('general', 'Logout successful', { userId: mx.getUserId() });
|
|
} catch {
|
|
// ignore
|
|
}
|
|
|
|
if (session) {
|
|
const storeName: SessionStoreName = getSessionStoreName(session);
|
|
await mx.clearStores({ cryptoDatabasePrefix: storeName.rustCryptoPrefix });
|
|
await deleteDatabase(storeName.sync);
|
|
await deleteDatabase(storeName.crypto);
|
|
await deleteDatabase(`${storeName.rustCryptoPrefix}::matrix-sdk-crypto`);
|
|
} else {
|
|
await mx.clearStores();
|
|
window.localStorage.clear();
|
|
}
|
|
};
|
|
|
|
export const clearLoginData = async () => {
|
|
debugLog.info('general', 'Clearing all login data and reloading');
|
|
const dbs = await window.indexedDB.databases();
|
|
dbs.forEach((idbInfo) => {
|
|
const { name } = idbInfo;
|
|
if (name) window.indexedDB.deleteDatabase(name);
|
|
});
|
|
window.localStorage.clear();
|
|
window.location.reload();
|
|
};
|