mirror of
https://github.com/mattermost/mattermost-mobile.git
synced 2026-11-17 17:08:16 +00:00
* app fixes surfaced by detox RF migration Carve the app-side bug fixes from the migrate_RF_to_detox branch into their own PR. Includes: - NavigationStore.waitUntilScreenIsTop helper + matching switchToChannel / notification.test wiring (Screens.CHANNEL_LIST -> Screens.HOME) - Detox source build + null-guard patch for Android FabricUIManagerIdlingResources (android/settings.gradle, android/app/build.gradle, gradle.properties) - iOS Podfile: Alamofire 5.10 duplicate-allHeaders patch + stdlib embed for extensions - iOS Server screen: defer push-proxy verification alert past Navigation.push to fix iOS 26 race - Android NetworkClient: null-guard host extraction to prevent NPE on bad cert reports - ephemeral_store: track recently-unsaved saved posts with 2-min TTL - post_draft: filter undefined channel observable to prevent archived-banner flicker - queries/servers/thread: is_following nullish-coalesce to false - datetime: NaN guard for invalid scheduled-message timestamp (MM-T5720) - navigation: dismissBottomSheet handles GENERIC_BOTTOM_SHEET fallback - bottom_sheet: accessibilityViewIsModal for VoiceOver - calls websocket_client: extend interface for optional sendBinary - edit_profile: wrap Save Pressable in View to constrain Detox tap bounds (MM-T4989_2/MM-T3250) - invite/summary: fix retry testID hardcoded to use the dynamic type - channel_bookmark/bookmark_link: URL resolution timeout + setBookmarkLinkUrl - categories_list/load_channel_error: missing return statement for error UI - iOS MattermostShare: TestID-friendly testIDs on Swift share-extension views - patches/react-native-network-client: Android host null-guard patch - scripts/build.sh: copy compass-icons.ttf manually when --ignore-scripts is used - types/modules: WebSocketClientInterface sendBinary extension Matched detox specs that exercise these bugs land in the rf-split/detox-tests PR. * address CodeRabbit review on PR #9789 - post_list/index.ts, thread_options/index.ts: track serverUrl in withObservables dependency keys - post/body/index.tsx: restore React.memo(Body) to avoid per-item re-render regression - thread.tsx, edit_profile.tsx: add pressed feedback via style callback; move inline typography to stylesheet - bookmark_link.tsx: include queueFetch in useDidUpdate deps - ephemeral_store.ts: complete and delete per-post recently-unsaved subjects on expiry/clear to bound growth Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * test: fix stale mocks and add coverage for recently-unsaved saved posts Update thread/preference tests for the new NavigationStore and prepareDestroyPermanently call paths, and add unit tests for the EphemeralStore recently-unsaved saved-post logic plus the websocket filterStaleSavedPostPreferences path. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * test: tighten recently-unsaved saved post assertions Address CodeRabbit nitpicks on #9789: - preference.test.ts: assert addRecentlyUnsavedSavedPost is called once with (serverUrl, postId) so the echoed websocket re-save is filtered. - ephemeral_store.test.ts: assert the observed Set size (2 after two adds, 1 after clearing one) so we catch stray/missing entries. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * docs: explain pinned posts descending sort order The asc->desc change to queryPinnedPostsInChannel surfaced during the detox RF migration was correct but undocumented. selectOrderedPosts (reached via observePinnedPostsInChannel) iterates the posts array from the end backwards expecting oldest->newest, so it requires descending (newest-first) input, matching queryPostsInChannel. Add a comment so the sort order isn't questioned in review. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * test: cover thread/config/bottom-sheet edge cases flagged in review Add unit tests for coverage gaps identified by CodeRabbit on #9789: - createThreadFromNewPost: reply where the thread is missing but the root post exists (back-fills + auto-follows), and where neither exists (only records the participant, no crash) - processReceivedThreads: thread entry with no post/participants is skipped without crashing - markThreadAsUnread: unread_replies/unread_mentions from the API response are persisted to the local thread - getConfigBooleanValue: 'true' -> true, non-'true' -> false, missing key honors the default - dismissBottomSheet: falls back to GENERIC_BOTTOM_SHEET when only the generic variant is in the stack Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * refactor(thread_options): use withServerUrl HOC Replace the hand-rolled `ThreadOptionsWithServerUrl` wrapper (which called `useServerUrl()` inside a function component and re-created the element via `React.createElement`) with the existing `withServerUrl` HOC from `@context/server`. Composition chain becomes: withDatabase(withServerUrl(enhanced(ThreadOptions))) Addresses larkox's review on app/screens/thread_options/index.ts:41: "This is not needed. You should be able to use `withServerUrl` function." Also tightens the Props type — `serverUrl` is now required (the HOC guarantees it), not optional. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * chore(deps): bump react-native-network-client to 1.10.2; drop workarounds 1.10.2 upstreams both fixes that were being carried locally: - iOS: apply_patches.rb is now idempotent (mattermost/react-native-network-client#167), so its bundled Alamofire diff can no longer double-apply. Removes the need for the Podfile post_install workaround that stripped the duplicate `let allHeaders` (Swift 6 / Xcode 26 "invalid redeclaration"). Workaround deleted. - Android: the cert-error host null-fallback in NetworkClient.kt is now upstream (and improved — prefers HttpUrl host, then URI, then baseUrlString; references #9789). The patch-package patch (@mattermost+react-native-network-client+1.10.0.patch) is therefore obsolete and deleted. It was also a silent no-op here anyway — named 1.10.0 while 1.10.1 was installed, so patch-package skipped it. Addresses @enahum's review on #9789: the fix belongs in network-client, not patched downstream — and it now is. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * chore(ios): update Podfile.lock for rnnc 1.10.2 Run `pod install` to sync Podfile.lock with the dependency bump in the previous commit: - react-native-network-client 1.10.1 → 1.10.2 - its pod checksum recomputed - PODFILE CHECKSUM recomputed (the Podfile changed — Alamofire duplicate-allHeaders workaround removed) The previous commit bumped package.json + ran npm install but did not regenerate Podfile.lock, so the iOS lockfile-consistency check would have failed (caught in review by @enahum). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * refactor(thread): use shared NavigationButton for header back Addresses @larkox's review on #9789: the thread route hand-rolled its header back button with a raw Pressable + CompassIcon + local StyleSheet, which is inconsistent with the rest of the app. Switch to the shared NavigationButton component — the same pattern used by app/screens/code/index.tsx, custom_status_clear_after, channel_bookmark, and the getModalHeaderOptions/getLoginModalHeaderOptions helpers (navigation.setOptions → NavigationButton with iconName/iconSize/color/ onPress/testID). Behavior is unchanged (still navigation.goBack() via handleBack) and the testID 'thread.navigation.back.button' is preserved for Detox. Net effect in the app: Android now gets the standard header ripple, a larger hitSlop touch target, and the arrow aligns like other NavigationButton headers. Removes the local styles, Pressable, StyleSheet, and CompassIcon imports. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
324 lines
13 KiB
TypeScript
324 lines
13 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
import {DeviceEventEmitter} from 'react-native';
|
|
|
|
import {ActionType, Events, Navigation, Screens} from '@constants';
|
|
import DatabaseManager from '@database/manager';
|
|
import {getChannelById} from '@queries/servers/channel';
|
|
import {getPostById} from '@queries/servers/post';
|
|
import {getCurrentTeamId, getCurrentUserId, prepareCommonSystemValues, type PrepareCommonSystemValuesArgs, setCurrentTeamAndChannelId} from '@queries/servers/system';
|
|
import {addChannelToTeamHistory, addTeamToTeamHistory} from '@queries/servers/team';
|
|
import {getThreadById, prepareThreadsFromReceivedPosts, queryThreadsInTeam} from '@queries/servers/thread';
|
|
import {getCurrentUser} from '@queries/servers/user';
|
|
import {navigateToScreen, dismissToStackRoot, navigateToRoot} from '@screens/navigation';
|
|
import EphemeralStore from '@store/ephemeral_store';
|
|
import {NavigationStore} from '@store/navigation_store';
|
|
import {isTablet} from '@utils/helpers';
|
|
import {logError} from '@utils/log';
|
|
|
|
import type Model from '@nozbe/watermelondb/Model';
|
|
|
|
export const switchToGlobalThreads = async (serverUrl: string, teamId?: string, prepareRecordsOnly = false) => {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const models: Model[] = [];
|
|
|
|
let teamIdToUse = teamId;
|
|
if (!teamId) {
|
|
teamIdToUse = await getCurrentTeamId(database);
|
|
}
|
|
|
|
if (!teamIdToUse) {
|
|
throw new Error('no team to switch to');
|
|
}
|
|
|
|
await setCurrentTeamAndChannelId(operator, teamIdToUse, '');
|
|
const history = await addChannelToTeamHistory(operator, teamIdToUse, Screens.GLOBAL_THREADS, true);
|
|
models.push(...history);
|
|
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords(models, 'switchToGlobalThreads');
|
|
}
|
|
|
|
const isTabletDevice = isTablet();
|
|
if (isTabletDevice) {
|
|
DeviceEventEmitter.emit(Navigation.NAVIGATION_HOME, Screens.GLOBAL_THREADS);
|
|
} else {
|
|
await NavigationStore.waitUntilScreenHasLoaded(Screens.HOME);
|
|
navigateToScreen(Screens.GLOBAL_THREADS);
|
|
}
|
|
|
|
return {models};
|
|
} catch (error) {
|
|
logError('Failed switchToGlobalThreads', error);
|
|
return {error};
|
|
}
|
|
};
|
|
|
|
export const switchToThread = async (serverUrl: string, rootId: string, isFromNotification = false) => {
|
|
DeviceEventEmitter.emit(Events.BLUR_AND_DISMISS_KEYBOARD);
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const user = await getCurrentUser(database);
|
|
if (!user) {
|
|
throw new Error('User not found');
|
|
}
|
|
|
|
const post = await getPostById(database, rootId);
|
|
if (!post) {
|
|
throw new Error('Post not found');
|
|
}
|
|
const channel = await getChannelById(database, post.channelId);
|
|
if (!channel) {
|
|
throw new Error('Channel not found');
|
|
}
|
|
|
|
const currentTeamId = await getCurrentTeamId(database);
|
|
const isTabletDevice = isTablet();
|
|
const teamId = channel.teamId || currentTeamId;
|
|
const currentThreadId = EphemeralStore.getCurrentThreadId();
|
|
|
|
EphemeralStore.setCurrentThreadId(rootId);
|
|
if (isFromNotification) {
|
|
if (currentThreadId && currentThreadId === rootId && NavigationStore.getScreensInStack().includes(Screens.THREAD)) {
|
|
await dismissToStackRoot();
|
|
return {};
|
|
}
|
|
|
|
await navigateToRoot();
|
|
await NavigationStore.waitUntilScreenIsTop(Screens.HOME);
|
|
if (currentTeamId !== teamId && isTabletDevice) {
|
|
DeviceEventEmitter.emit(Navigation.NAVIGATION_HOME, Screens.GLOBAL_THREADS);
|
|
}
|
|
}
|
|
|
|
if (currentTeamId !== teamId) {
|
|
const modelPromises: Array<Promise<Model[]>> = [];
|
|
modelPromises.push(addTeamToTeamHistory(operator, teamId, true));
|
|
const commonValues: PrepareCommonSystemValuesArgs = {
|
|
currentChannelId: channel.id,
|
|
currentTeamId: teamId,
|
|
};
|
|
modelPromises.push(prepareCommonSystemValues(operator, commonValues));
|
|
const models = (await Promise.all(modelPromises)).flat();
|
|
if (models.length) {
|
|
await operator.batchRecords(models, 'switchToThread');
|
|
}
|
|
}
|
|
|
|
await NavigationStore.waitUntilScreenHasLoaded(Screens.CHANNEL_LIST);
|
|
navigateToScreen(Screens.THREAD, {rootId, channelName: channel.displayName});
|
|
DeviceEventEmitter.emit(Events.CLOSE_INPUT_ACCESSORY_VIEW);
|
|
|
|
return {};
|
|
} catch (error) {
|
|
logError('Failed switchToThread', error);
|
|
EphemeralStore.setCurrentThreadId('');
|
|
return {error};
|
|
}
|
|
};
|
|
|
|
// When new post arrives:
|
|
// 1. If a reply, then update the reply_count, add user as the participant
|
|
// 2. Else add the post as a thread
|
|
export async function createThreadFromNewPost(serverUrl: string, post: Post, prepareRecordsOnly = false) {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const models: Model[] = [];
|
|
if (post.root_id) {
|
|
const existingThread = await getThreadById(database, post.root_id);
|
|
|
|
if (existingThread) {
|
|
// Update the thread data: `reply_count` and auto-follow (replying auto-follows the thread)
|
|
const {model: threadModel} = await updateThread(serverUrl, post.root_id, {
|
|
reply_count: post.reply_count,
|
|
is_following: true,
|
|
}, true);
|
|
if (threadModel) {
|
|
models.push(threadModel);
|
|
}
|
|
} else {
|
|
const rootPost = await getPostById(database, post.root_id);
|
|
if (rootPost) {
|
|
const threadModels = await prepareThreadsFromReceivedPosts(operator, [{
|
|
...await rootPost.toApi(),
|
|
reply_count: post.reply_count,
|
|
is_following: true,
|
|
}], false);
|
|
models.push(...threadModels);
|
|
}
|
|
}
|
|
|
|
// Add user as a participant to the thread
|
|
const threadParticipantModels = await operator.handleThreadParticipants({
|
|
threadsParticipants: [{
|
|
thread_id: post.root_id,
|
|
participants: [{
|
|
thread_id: post.root_id,
|
|
id: post.user_id,
|
|
}],
|
|
}],
|
|
prepareRecordsOnly: true,
|
|
skipSync: true,
|
|
});
|
|
models.push(...threadParticipantModels);
|
|
} else { // If the post is a root post, then we need to add it to the thread table
|
|
const threadModels = await prepareThreadsFromReceivedPosts(operator, [post], false);
|
|
models.push(...threadModels);
|
|
}
|
|
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords(models, 'createThreadFromNewPost');
|
|
}
|
|
|
|
return {models};
|
|
} catch (error) {
|
|
logError('Failed createThreadFromNewPost', error);
|
|
return {error};
|
|
}
|
|
}
|
|
|
|
// On receiving threads, Along with the "threads" & "thread participants", extract and save "posts" & "users"
|
|
export async function processReceivedThreads(serverUrl: string, threads: Thread[], teamId: string, prepareRecordsOnly = false) {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const currentUserId = await getCurrentUserId(database);
|
|
|
|
const posts: Post[] = [];
|
|
const users: UserProfile[] = [];
|
|
const threadsToHandle: ThreadWithLastFetchedAt[] = [];
|
|
|
|
// Extract posts & users from the received threads
|
|
for (let i = 0; i < threads.length; i++) {
|
|
const {participants, post} = threads[i];
|
|
if (post) {
|
|
posts.push(post);
|
|
}
|
|
if (participants) {
|
|
participants.forEach((participant) => {
|
|
if (currentUserId !== participant.id) {
|
|
users.push(participant);
|
|
}
|
|
});
|
|
}
|
|
threadsToHandle.push({...threads[i], lastFetchedAt: post?.create_at ?? 0});
|
|
}
|
|
|
|
const postModels = await operator.handlePosts({
|
|
actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL,
|
|
order: [],
|
|
posts,
|
|
prepareRecordsOnly: true,
|
|
});
|
|
|
|
const threadModels = await operator.handleThreads({
|
|
threads: threadsToHandle,
|
|
teamId,
|
|
prepareRecordsOnly: true,
|
|
});
|
|
|
|
const models = [...postModels, ...threadModels];
|
|
|
|
if (users.length) {
|
|
const userModels = await operator.handleUsers({
|
|
users,
|
|
prepareRecordsOnly: true,
|
|
});
|
|
models.push(...userModels);
|
|
}
|
|
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords(models, 'processReceivedThreads');
|
|
}
|
|
return {models};
|
|
} catch (error) {
|
|
logError('Failed processReceivedThreads', error);
|
|
return {error};
|
|
}
|
|
}
|
|
|
|
export async function markTeamThreadsAsRead(serverUrl: string, teamId: string, prepareRecordsOnly = false) {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const threads = await queryThreadsInTeam(database, teamId, {onlyUnreads: true, hasReplies: true, isFollowing: true}).fetch();
|
|
const models = threads.map((thread) => thread.prepareUpdate((record) => {
|
|
record.unreadMentions = 0;
|
|
record.unreadReplies = 0;
|
|
record.lastViewedAt = Date.now();
|
|
record.viewedAt = Date.now();
|
|
}));
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords(models, 'markTeamThreadsAsRead');
|
|
}
|
|
return {models};
|
|
} catch (error) {
|
|
logError('Failed markTeamThreadsAsRead', error);
|
|
return {error};
|
|
}
|
|
}
|
|
|
|
export async function markThreadAsViewed(serverUrl: string, threadId: string, prepareRecordsOnly = false) {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const thread = await getThreadById(database, threadId);
|
|
if (!thread) {
|
|
return {error: 'Thread not found'};
|
|
}
|
|
|
|
thread.prepareUpdate((th) => {
|
|
th.viewedAt = thread.lastViewedAt;
|
|
th.lastViewedAt = Date.now();
|
|
});
|
|
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords([thread], 'markThreadAsViewed');
|
|
}
|
|
|
|
return {model: thread};
|
|
} catch (error) {
|
|
logError('Failed markThreadAsViewed', error);
|
|
return {error};
|
|
}
|
|
}
|
|
|
|
export async function updateThread(serverUrl: string, threadId: string, updatedThread: Partial<ThreadWithViewedAt>, prepareRecordsOnly = false) {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const thread = await getThreadById(database, threadId);
|
|
if (!thread) {
|
|
throw new Error('Thread not found');
|
|
}
|
|
|
|
const model = thread.prepareUpdate((record) => {
|
|
record.isFollowing = updatedThread.is_following ?? record.isFollowing;
|
|
record.replyCount = updatedThread.reply_count ?? record.replyCount;
|
|
record.lastViewedAt = updatedThread.last_viewed_at ?? record.lastViewedAt;
|
|
record.viewedAt = updatedThread.viewed_at ?? record.viewedAt;
|
|
record.unreadMentions = updatedThread.unread_mentions ?? record.unreadMentions;
|
|
record.unreadReplies = updatedThread.unread_replies ?? record.unreadReplies;
|
|
});
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords([model], 'updateThread');
|
|
}
|
|
return {model};
|
|
} catch (error) {
|
|
logError('Failed updateThread', error);
|
|
return {error};
|
|
}
|
|
}
|
|
|
|
export async function updateTeamThreadsSync(serverUrl: string, data: TeamThreadsSync, prepareRecordsOnly = false) {
|
|
try {
|
|
const {operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const models = await operator.handleTeamThreadsSync({data: [data], prepareRecordsOnly});
|
|
if (!prepareRecordsOnly) {
|
|
await operator.batchRecords(models, 'updateTeamThreadsSync');
|
|
}
|
|
return {models};
|
|
} catch (error) {
|
|
logError('Failed updateTeamThreadsSync', error);
|
|
return {error};
|
|
}
|
|
}
|