mattermost-mobile-upstream/app/actions/local/session/index.ts
Carlos Garcia a5ff8a0d95
Mm 68767 zero persistence (#9803)
* implements auto cache cleanup when zero persistence mode is enabled (0 value)

* uses memory flag with sqlite instead of loki when running in zero persistence mode

* renames ephemeral mode manager and improves readability

* zero persistence refactors and restore values during transitions

* fixes ephemeral mode tests

* use initializeClient instead of just initialize to wait for doReconnect to finish

that way teams loading is awaited while WS reconnects during ZPM transitions

* adds inital sync as a mount hook to prevent undesired load error states

during app cold start in ZPM mode, we need a way to load team and channels
without showing loading error during the transition. The nre is initial sync
hook allows for it

* reset started sync subject on wipe

* removes extra log lines

* resets tracked server during ephemeral mode transitions

* improvements to apply persistence mode changes when something fails

* address coderabbit PR suggestions

* add batching time logging

* throws ephemeral mode change error as is

* make deleteServerDatabaseFiles private

* inline derive persistence flag function

* return current user id when refetching current user

* support zero persistence mode server for push notifications

* adds support for zero persistence mode when sharing to mattermost

* adds clarifying comment

* catch and log error deleting files

* reorder translations to correct position

* adds some new tests to improve coverage

* ios push notification native fix

* logout when fetchMe fails with 401 status code during reconnection

* properly surface errors

* return proper false value when checking for zero persistence flag

* change comments and properly await on some operations

* prevent not set persistence mode to report as an error

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* include servers with no persistence flag set in share list

* disable button for accessibility

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* improves when to store and remove signing key from global area

* review push notification reception running in zero persistence mode

* add server to ephemeral mode manager right after login

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
2026-07-16 13:55:45 +02:00

203 lines
7.4 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 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);
// 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 {};
};