mattermost-mobile-upstream/app/actions/local/session/index.ts
Guillermo Vayá 6b0618d043 feat(drafts): Phase 4.4 — wire DraftSyncManager lifecycle teardown
Connect the manager to the app lifecycle so late HTTP completions can never
touch a destroyed database.

- app/init/app.ts: initialize DraftSyncManager for every server after pending
  ephemeral wipes finish and before WebSocket startup.
- actions/local/session/index.ts: invalidate(serverUrl) at the start of
  terminateSession, before client invalidation and database destruction
  (un-flushed outbox intent is intentionally discarded on logout).
- managers/ephemeral_mode_manager: invalidate before wipeServerArtifacts and
  re-initialize after the server is re-added post-wipe.

Checks: npm run tsc clean; eslint --quiet clean; 87 Jest tests pass across the
session, ephemeral, and manager suites (no regressions).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-08-04 12:52:58 +02:00

209 lines
7.8 KiB
TypeScript

// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
import NetInfo from '@react-native-community/netinfo';
import {Platform} from 'react-native';
import {removePushDisabledInServerAcknowledged, removePushSigningKey} from '@actions/app/global';
import {clearConversationCacheForServer} from '@agents/actions/remote/conversation';
import streamingStore from '@agents/store/streaming_store';
import {SYSTEM_IDENTIFIERS} from '@constants/database';
import DatabaseManager from '@database/manager';
import {resetMomentLocale} from '@i18n';
import {getAllServerCredentials, removeServerCredentials} from '@init/credentials';
import PushNotifications from '@init/push_notifications';
import DraftSyncManager from '@managers/draft_sync_manager';
import NetworkManager from '@managers/network_manager';
import WebsocketManager from '@managers/websocket_manager';
import {getDeviceToken} from '@queries/app/global';
import {getExpiredSession} from '@queries/servers/system';
import {getCurrentUser} from '@queries/servers/user';
import EphemeralStore from '@store/ephemeral_store';
import {deleteFileCache, deleteFileCacheByDir} from '@utils/file';
import {logError, logWarning} from '@utils/log';
import {clearCookiesForServer, getCSRFFromCookie, urlSafeBase64Encode} from '@utils/security';
const resetLocale = async () => {
if (Object.keys(DatabaseManager.serverDatabases).length) {
const serverDatabase = await DatabaseManager.getActiveServerDatabase();
const user = await getCurrentUser(serverDatabase!);
resetMomentLocale(user?.locale);
} else {
resetMomentLocale();
}
};
export async function findSession(serverUrl: string, sessions: Session[]) {
try {
const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
const expiredSession = await getExpiredSession(database);
const deviceToken = await getDeviceToken();
// First try and find the session by the given identifier
let session = sessions.find((s) => s.id === expiredSession?.id);
if (session) {
return session;
}
// Next try and find the session by deviceId
if (deviceToken) {
session = sessions.find((s) => s.device_id === deviceToken);
if (session) {
return session;
}
}
// Next try and find the session by the CSRF token
const csrfToken = await getCSRFFromCookie(serverUrl);
if (csrfToken) {
session = sessions.find((s) => s.props?.csrf === csrfToken);
if (session) {
return session;
}
}
// Next try and find the session based on the OS
// if multiple sessions exists with the same os type this can be inaccurate
session = sessions.find((s) => s.props?.os.toLowerCase() === Platform.OS);
if (session) {
return session;
}
} catch (e) {
logError('findSession', e);
}
// At this point we did not find the session
return undefined;
}
export const cancelAllSessionNotifications = async () => {
const serverCredentials = await getAllServerCredentials();
for (const {serverUrl} of serverCredentials) {
cancelSessionNotification(serverUrl);
}
};
export const cancelSessionNotification = async (serverUrl: string) => {
try {
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
const expiredSession = await getExpiredSession(database);
const rechable = (await NetInfo.fetch()).isInternetReachable;
if (expiredSession?.notificationId && rechable) {
PushNotifications.cancelScheduleNotification(parseInt(expiredSession.notificationId, 10));
operator.handleSystem({
systems: [{
id: SYSTEM_IDENTIFIERS.SESSION_EXPIRATION,
value: '',
}],
prepareRecordsOnly: false,
});
}
return {};
} catch (e) {
logError('cancelSessionNotification', e);
return {error: e};
}
};
export const terminateSession = async (serverUrl: string, removeServer: boolean) => {
const errors: Array<{operation: string; error: unknown}> = [];
// Helper to safely execute operations and optionally track errors
const safeExecute = async (operation: string, fn: () => Promise<unknown>, critical = true) => {
try {
const result = await fn();
// Check if function returned {error}
if (result && typeof result === 'object' && 'error' in result && critical) {
errors.push({operation, error: result.error});
}
} catch (error) {
if (critical) {
errors.push({operation, error});
} else {
// Log but don't track as failure
logWarning(`terminateSession: ${operation} failed (non-critical)`, error);
}
}
};
// Cancel session notification (critical)
await safeExecute('cancelSessionNotification', async () => {
await cancelSessionNotification(serverUrl);
}, false);
// Remove server credentials (critical)
await safeExecute('removeServerCredentials', async () => {
await removeServerCredentials(serverUrl);
});
// Remove push notifications (synchronous, no error handling needed)
PushNotifications.removeServerNotifications(serverUrl);
// Stop draft sync before invalidating the client and destroying the database so a late
// HTTP completion cannot touch a destroyed database (invalidate is synchronous). Un-flushed
// outbox intent is intentionally discarded on logout/session termination.
DraftSyncManager.invalidate(serverUrl);
// Invalidate clients (websocket waits for close event before destroying)
await safeExecute('invalidateNetworkClient', async () => {
NetworkManager.invalidateClient(serverUrl);
});
await safeExecute('invalidateWebsocketClient', async () => {
await WebsocketManager.invalidateClient(serverUrl);
});
EphemeralStore.clearManagedCategoryPropertyIds(serverUrl);
// Drop ephemeral agents caches for this server only; other connected
// servers must keep their cached conversations and in-flight streams.
clearConversationCacheForServer(serverUrl);
streamingStore.removeServer(serverUrl);
// Remove push disabled acknowledgment (non-critical)
if (removeServer) {
await safeExecute('removePushDisabledInServerAcknowledged', async () => {
const result = await removePushDisabledInServerAcknowledged(urlSafeBase64Encode(serverUrl));
if (result && typeof result === 'object' && 'error' in result) {
throw result.error;
}
}, false);
await safeExecute('removePushSigningKey', async () => {
const result = await removePushSigningKey(serverUrl);
if (result && typeof result === 'object' && 'error' in result) {
throw result.error;
}
}, false);
}
// Database operations (critical)
await safeExecute('databaseOperation', async () => {
if (removeServer) {
await DatabaseManager.destroyServerDatabase(serverUrl);
} else {
await DatabaseManager.deleteServerDatabase(serverUrl);
}
});
// Reset locale (non-critical)
await safeExecute('resetLocale', async () => {
await resetLocale();
}, false);
// Clear cookies (synchronous)
clearCookiesForServer(serverUrl);
// Delete file caches (synchronous, no error handling needed)
deleteFileCache(serverUrl);
deleteFileCacheByDir('mmPasteInput');
deleteFileCacheByDir('thumbnails');
if (errors.length > 0) {
return {error: errors};
}
return {};
};