Page MenuHomePhabricator
Differential D11453

Revert "[native][web] Read integrity thread hashes from SQLite on app start"
AbandonedPublic
Actions

Authored by will on Mar 28 2024, 11:08 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 21, 2:55 AM
Unknown Object (File)
Fri, Apr 18, 12:32 AM
Unknown Object (File)
Thu, Apr 17, 2:25 PM
Unknown Object (File)
Thu, Apr 17, 7:40 AM
Unknown Object (File)
Thu, Apr 17, 1:58 AM
Unknown Object (File)
Wed, Apr 16, 12:06 AM
Unknown Object (File)
Fri, Apr 4, 3:24 PM
Unknown Object (File)
Mar 22 2025, 5:35 AM
View All 69 Files
Subscribers
tomek

Details

Reviewers
ashoat
ginsu
atul
Summary

This reverts commit 5695216e237f08eae63e3c845481ab791528b18e.

Depends on D11456

Test Plan

Reverts reading sqlite on app start to fix an urgent issue with compiling on native

Context: https://linear.app/comm/issue/ENG-7597/app-crashes-when-running-migration-65#comment-8b4375fe

Diff Detail

Repository
rCOMM Comm
Branch
sqlite/integrityStore
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

will created this revision.Mar 28 2024, 11:08 AM
Herald added a subscriber: tomek. · View Herald TranscriptMar 28 2024, 11:08 AM
will edited the summary of this revision. (Show Details)Mar 28 2024, 11:10 AM
will added a parent revision: D11454: [sqlite] downgrade migration version on native from '65' to '64'.
Harbormaster returned this revision to the author for changes because remote builds failed.Mar 28 2024, 11:19 AM
Harbormaster failed remote builds in B27791: Diff 38486!
will updated this revision to Diff 38490.Mar 28 2024, 11:26 AM
will edited the summary of this revision. (Show Details)

rebase

will edited the summary of this revision. (Show Details)Mar 28 2024, 11:27 AM
will added a parent revision: D11456: Revert "[lib] integrity reducer tests".
Harbormaster completed remote builds in B27795: Diff 38490.Mar 28 2024, 11:42 AM
will requested review of this revision.Mar 28 2024, 11:42 AM
ashoat accepted this revision.Mar 28 2024, 11:46 AM
This revision is now accepted and ready to land.Mar 28 2024, 11:46 AM
will abandoned this revision.Mar 28 2024, 1:48 PM

https://linear.app/comm/issue/ENG-7597/app-crashes-when-running-migration-65#comment-8b4375fe resolved

Revision Contents
Changeset List

PathSize
lib/
reducers/
41 lines
1 line
1 line
types/
2 lines
native/
data/
7 lines
web/
shared-worker/
utils/
9 lines

Diff 38486

View Options

lib/reducers/integrity-reducer.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 Linesimport {
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 };
View Options

lib/reducers/master-reducer.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 Linesimport {
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 };
View Options

lib/reducers/message-reducer.test.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 Linesimport {
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 };
View Options

lib/types/store-ops-types.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 Linesimport {
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 };
View Options

native/data/sqlite-data-handler.js

Loading...
View Options

web/shared-worker/utils/store.js

Loading...