Paths

Table of Contentst

-
native/
-
chat/
-
thread-screen-pruner.react.js
-
navigation/
2/2
navigation-utils.js

[native] fix assumption that in `ThreadScreenPruner` app route is defined
ClosedPublic
Actions

Authored by kamil on Dec 8 2022, 6:33 AM.

Details

Reviewers

tomek
inka
ashoat

Commits

rCOMMd3be11bcd319: [native] fix assumption that in `ThreadScreenPruner` app route is defined

Summary

Problem described in ENG-2427.
Probably we want to investigate deeper, maybe there is no need for invariant in other usages of getStateFromNavigatorRoute - if yes I can create an issue.

Test Plan

Invariant should not crash app in dev mode while ThreadScreenPruner is rendered but NavState wasn't fully propagated, e.g. because App Navigator isn't the top of the stack

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

kamil created this revision.Dec 8 2022, 6:33 AM

kamil held this revision as a draft.

Herald added subscribers: atul, ashoat. · View Herald TranscriptDec 8 2022, 6:33 AM

kamil added a parent revision: D5830: [web] policy acknowledgment handler.Dec 8 2022, 6:35 AM

kamil added a child revision: D5831: [native] Terms of Use & Privacy modal.

Harbormaster completed remote builds in B14065: Diff 19253.Dec 8 2022, 6:45 AM

kamil published this revision for review.Dec 8 2022, 6:48 AM

inka accepted this revision.Dec 8 2022, 7:32 AM

inka added 1 blocking reviewer(s): tomek.

I think PossiblyStaleRoute is not typed correctly... based on the Linear comment I seem to remember @kamil making, I think it was possible for state to not be set in some circumstances where our types think it must be set. We should fix this

This diff is still a good idea, but it should be forced by Flow types. Let's follow-up on that

tomek accepted this revision.Dec 9 2022, 9:50 AM

tomek added inline comments.

native/chat/thread-screen-pruner.react.js
54–57	This seems to be more or less equivalent to

This revision is now accepted and ready to land.Dec 9 2022, 9:50 AM

rebase

native/chat/thread-screen-pruner.react.js
54–57	Definitely, but looks like flow has a different opinion than we do 😄 `Cannot get chatRoute?.state because property state is missing in StaleLeafRoute [1]. [prop-missing]`

Harbormaster completed remote builds in B14124: Diff 19324.Dec 13 2022, 8:41 AM

Closed by commit rCOMMd3be11bcd319: [native] fix assumption that in `ThreadScreenPruner` app route is defined (authored by kamil). · Explain WhyDec 16 2022, 4:16 AM

This revision was automatically updated to reflect the committed changes.

kamil added a commit: rCOMMd3be11bcd319: [native] fix assumption that in `ThreadScreenPruner` app route is defined.

inka mentioned this in D5734: [native] Add community drawer to navigation hierarchy.Dec 20 2022, 2:21 AM

Revision Contents
Changeset List

Path

Size

native/

chat/

thread-screen-pruner.react.js

9 lines

navigation/

navigation-utils.js

7 lines

Diff 19253

View Options

native/chat/thread-screen-pruner.react.js

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };