Page MenuHomePhabricator
Differential D12169

[web] Replace persisted entries with the ones from initial redux state
ClosedPublic
Actions

Authored by tomek on May 22 2024, 4:34 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 24, 3:26 AM
Unknown Object (File)
Fri, Mar 14, 12:43 PM
Unknown Object (File)
Tue, Mar 11, 5:45 PM
Unknown Object (File)
Thu, Mar 6, 10:26 PM
Unknown Object (File)
Thu, Mar 6, 5:18 PM
Unknown Object (File)
Thu, Mar 6, 1:25 PM
Unknown Object (File)
Thu, Mar 6, 1:15 PM
Unknown Object (File)
Thu, Mar 6, 1:11 PM
View All 100 Files
Subscribers
ashoat
inka

Details

Reviewers
kamil
marcin
Commits
rCOMM70681d12e108: [web] Replace persisted entries with the ones from initial redux state
Summary

After we conclude that the migration was successful, we will replace this code with the one that replaces the entries only when they are missing from the store.

Depends on D12164

https://linear.app/comm/issue/ENG-3486/move-entrystore-to-sqlite

Test Plan

Run console.log(entryStoreOperations) from tis code.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

tomek created this revision.May 22 2024, 4:34 AM
Herald added a subscriber: ashoat. · View Herald TranscriptMay 22 2024, 4:34 AM
tomek added a child revision: D12153: [native] Persist only lastUserInteractionCalendar from the entry store.May 22 2024, 4:34 AM
Harbormaster completed remote builds in B29154: Diff 40525.May 22 2024, 4:50 AM
tomek requested review of this revision.May 22 2024, 4:50 AM
marcin accepted this revision.May 22 2024, 7:14 AM
This revision is now accepted and ready to land.May 22 2024, 7:14 AM
inka added a subscriber: inka.May 24 2024, 9:01 AM
inka added inline comments.
web/redux/initial-state-gate.js
160–162 ↗(On Diff #40525)

We should probably also check if entryStoreOperations.length > 0

marcin edited the test plan for this revision. (Show Details)May 24 2024, 9:14 AM
ashoat added inline comments.May 25 2024, 7:21 AM
web/redux/initial-state-gate.js
160–162 ↗(On Diff #40525)

Good catch – we definitely need to check that here

tomek updated this revision to Diff 40657.May 27 2024, 4:28 AM
tomek marked 2 inline comments as done.

Check if there are some entry store ops

Harbormaster completed remote builds in B29251: Diff 40657.May 27 2024, 4:44 AM
Closed by commit rCOMM70681d12e108: [web] Replace persisted entries with the ones from initial redux state (authored by tomek). · Explain WhyMay 27 2024, 5:51 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMM70681d12e108: [web] Replace persisted entries with the ones from initial redux state.

Revision Contents
Changeset List

PathSize
web/
redux/
13 lines

Diff 40669

View Options

web/redux/initial-state-gate.js

Show All 34 Linesimport {
newThreadActionTypes, newThreadActionTypes,
} from '../actions/thread-actions.js'; } from '../actions/thread-actions.js';
import { import {
keyserverAuthActionTypes, keyserverAuthActionTypes,
deleteKeyserverAccountActionTypes, deleteKeyserverAccountActionTypes,
legacyLogInActionTypes, legacyLogInActionTypes,
} from '../actions/user-actions.js'; } from '../actions/user-actions.js';
import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js'; import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
import type { EntryStoreOperation } from '../ops/entries-store-ops.js';
import { entryID } from '../shared/entry-utils.js'; import { entryID } from '../shared/entry-utils.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js'; import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { threadInFilterList } from '../shared/thread-utils.js'; import { threadInFilterList } from '../shared/thread-utils.js';
import { updateSpecs } from '../shared/updates/update-specs.js'; import { updateSpecs } from '../shared/updates/update-specs.js';
import type { RawEntryInfo, EntryStore } from '../types/entry-types.js'; import type { RawEntryInfo, EntryStore } from '../types/entry-types.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js'; import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js';
import { import {
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines) {
const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos; const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos;
return [entryInfos, daysToEntries]; return [entryInfos, daysToEntries];
} }
function reduceEntryInfos( function reduceEntryInfos(
entryStore: EntryStore, entryStore: EntryStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos, newThreadInfos: RawThreadInfos,
): [EntryStore, $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>] { ): {
+entryStore: EntryStore,
+entryStoreOperations: $ReadOnlyArray<EntryStoreOperation>,
+reportCreationRequests: $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>,
} {
const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore; const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore;
if ( if (
action.type === deleteKeyserverAccountActionTypes.success || action.type === deleteKeyserverAccountActionTypes.success ||
action.type === deleteThreadActionTypes.success || action.type === deleteThreadActionTypes.success ||
action.type === leaveThreadActionTypes.success action.type === leaveThreadActionTypes.success
) { ) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos); const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy( const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID], (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos); )(entryInfos);
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) { if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [ return {
{ entryStore: {
entryInfos, entryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos( const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries, daysToEntries,
newEntryInfos, newEntryInfos,
); );
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === setNewSessionActionType) { } else if (action.type === setNewSessionActionType) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos); const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy( const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID], (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos); )(entryInfos);
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos( const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries, daysToEntries,
newEntryInfos, newEntryInfos,
); );
let newLastUserInteractionCalendar = lastUserInteractionCalendar; let newLastUserInteractionCalendar = lastUserInteractionCalendar;
if ( if (
action.payload.sessionChange.cookieInvalidated && action.payload.sessionChange.cookieInvalidated &&
action.payload.keyserverID === authoritativeKeyserverID() && action.payload.keyserverID === authoritativeKeyserverID() &&
relyingOnAuthoritativeKeyserver relyingOnAuthoritativeKeyserver
) { ) {
newLastUserInteractionCalendar = 0; newLastUserInteractionCalendar = 0;
} }
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) { if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [ return {
{ entryStore: {
entryInfos, entryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar, lastUserInteractionCalendar: newLastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar, lastUserInteractionCalendar: newLastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === fetchEntriesActionTypes.success) { } else if (action.type === fetchEntriesActionTypes.success) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
action.payload.rawEntryInfos, action.payload.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === updateCalendarQueryActionTypes.started && action.type === updateCalendarQueryActionTypes.started &&
action.payload && action.payload &&
action.payload.calendarQuery action.payload.calendarQuery
) { ) {
return [ return {
{ entryStore: {
entryInfos, entryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === updateCalendarQueryActionTypes.success) { } else if (action.type === updateCalendarQueryActionTypes.success) {
const newLastUserInteractionCalendar = action.payload.calendarQuery const newLastUserInteractionCalendar = action.payload.calendarQuery
? Date.now() ? Date.now()
: lastUserInteractionCalendar; : lastUserInteractionCalendar;
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
action.payload.rawEntryInfos, action.payload.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
const deletionMarkedEntryInfos = markDeletedEntries( const deletionMarkedEntryInfos = markDeletedEntries(
updatedEntryInfos, updatedEntryInfos,
action.payload.deletedEntryIDs, action.payload.deletedEntryIDs,
); );
return [ return {
{ entryStore: {
entryInfos: deletionMarkedEntryInfos, entryInfos: deletionMarkedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar, lastUserInteractionCalendar: newLastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === createLocalEntryActionType) { } else if (action.type === createLocalEntryActionType) {
const entryInfo = action.payload; const entryInfo = action.payload;
const localID = entryInfo.localID; const localID = entryInfo.localID;
invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY'); invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY');
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[(localID: string)]: entryInfo, [(localID: string)]: entryInfo,
}; };
const dayString = dateString( const dayString = dateString(
entryInfo.year, entryInfo.year,
entryInfo.month, entryInfo.month,
entryInfo.day, entryInfo.day,
); );
const newDaysToEntries = { const newDaysToEntries = {
...daysToEntries, ...daysToEntries,
[dayString]: _union([localID])(daysToEntries[dayString]), [dayString]: _union([localID])(daysToEntries[dayString]),
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === createEntryActionTypes.success) { } else if (action.type === createEntryActionTypes.success) {
const localID = action.payload.localID; const localID = action.payload.localID;
const serverID = action.payload.entryID; const serverID = action.payload.entryID;
// If an entry with this serverID already got into the store somehow // If an entry with this serverID already got into the store somehow
// (likely through an unrelated request), we need to dedup them. // (likely through an unrelated request), we need to dedup them.
let rekeyedEntryInfos; let rekeyedEntryInfos;
if (entryInfos[serverID]) { if (entryInfos[serverID]) {
// It's fair to assume the serverID entry is newer than the localID // It's fair to assume the serverID entry is newer than the localID
// entry, and this probably won't happen often, so for now we can just // entry, and this probably won't happen often, so for now we can just
// keep the serverID entry. // keep the serverID entry.
rekeyedEntryInfos = _omitBy( rekeyedEntryInfos = _omitBy(
(candidate: RawEntryInfo) => (candidate: RawEntryInfo) =>
!candidate.id && candidate.localID === localID, !candidate.id && candidate.localID === localID,
)(entryInfos); )(entryInfos);
} else if (entryInfos[localID]) { } else if (entryInfos[localID]) {
rekeyedEntryInfos = _mapKeys((oldKey: string) => rekeyedEntryInfos = _mapKeys((oldKey: string) =>
entryInfos[oldKey].localID === localID ? serverID : oldKey, entryInfos[oldKey].localID === localID ? serverID : oldKey,
)(entryInfos); )(entryInfos);
} else { } else {
// This happens if the entry is deauthorized before it's saved // This happens if the entry is deauthorized before it's saved
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
rekeyedEntryInfos, rekeyedEntryInfos,
null, null,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return {
return [ entryStore: {
{
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === saveEntryActionTypes.success) { } else if (action.type === saveEntryActionTypes.success) {
const serverID = action.payload.entryID; const serverID = action.payload.entryID;
if ( if (
!entryInfos[serverID] || !entryInfos[serverID] ||
!threadInFilterList(newThreadInfos[entryInfos[serverID].threadID]) !threadInFilterList(newThreadInfos[entryInfos[serverID].threadID])
) { ) {
// This happens if the entry is deauthorized before it's saved // This happens if the entry is deauthorized before it's saved
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === concurrentModificationResetActionType) { } else if (action.type === concurrentModificationResetActionType) {
const { payload } = action; const { payload } = action;
if ( if (
!entryInfos[payload.id] || !entryInfos[payload.id] ||
!threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID]) !threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID])
) { ) {
// This happens if the entry is deauthorized before it's restored // This happens if the entry is deauthorized before it's restored
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[payload.id]: { [payload.id]: {
...entryInfos[payload.id], ...entryInfos[payload.id],
text: payload.dbText, text: payload.dbText,
}, },
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === deleteEntryActionTypes.started) { } else if (action.type === deleteEntryActionTypes.started) {
const payload = action.payload; const payload = action.payload;
const id = const id =
payload.serverID && entryInfos[payload.serverID] payload.serverID && entryInfos[payload.serverID]
? payload.serverID ? payload.serverID
: payload.localID; : payload.localID;
invariant(id, 'either serverID or localID should be set'); invariant(id, 'either serverID or localID should be set');
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[(id: string)]: { [(id: string)]: {
...entryInfos[id], ...entryInfos[id],
deleted: true, deleted: true,
}, },
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === deleteEntryActionTypes.success) { } else if (action.type === deleteEntryActionTypes.success) {
const { payload } = action; const { payload } = action;
if (payload) { if (payload) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
} else if (action.type === fetchRevisionsForEntryActionTypes.success) { } else if (action.type === fetchRevisionsForEntryActionTypes.success) {
const id = action.payload.entryID; const id = action.payload.entryID;
if ( if (
!entryInfos[id] || !entryInfos[id] ||
!threadInFilterList(newThreadInfos[entryInfos[id].threadID]) !threadInFilterList(newThreadInfos[entryInfos[id].threadID])
) { ) {
// This happens if the entry is deauthorized before it's restored // This happens if the entry is deauthorized before it's restored
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
// Make sure the entry is in sync with its latest revision // Make sure the entry is in sync with its latest revision
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[id]: { [id]: {
...entryInfos[id], ...entryInfos[id],
text: action.payload.text, text: action.payload.text,
deleted: action.payload.deleted, deleted: action.payload.deleted,
}, },
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === restoreEntryActionTypes.success) { } else if (action.type === restoreEntryActionTypes.success) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === legacyLogInActionTypes.success || action.type === legacyLogInActionTypes.success ||
action.type === legacySiweAuthActionTypes.success || action.type === legacySiweAuthActionTypes.success ||
action.type === keyserverAuthActionTypes.success action.type === keyserverAuthActionTypes.success
) { ) {
const { calendarResult } = action.payload; const { calendarResult } = action.payload;
if (calendarResult) { if (calendarResult) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
calendarResult.rawEntryInfos, calendarResult.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
} else if (action.type === incrementalStateSyncActionType) { } else if (action.type === incrementalStateSyncActionType) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos( mergeUpdateEntryInfos(
action.payload.deltaEntryInfos, action.payload.deltaEntryInfos,
action.payload.updatesResult.newUpdates, action.payload.updatesResult.newUpdates,
), ),
newThreadInfos, newThreadInfos,
); );
const deletionMarkedEntryInfos = markDeletedEntries( const deletionMarkedEntryInfos = markDeletedEntries(
updatedEntryInfos, updatedEntryInfos,
action.payload.deletedEntryIDs, action.payload.deletedEntryIDs,
); );
return [ return {
{ entryStore: {
entryInfos: deletionMarkedEntryInfos, entryInfos: deletionMarkedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === processUpdatesActionType || action.type === processUpdatesActionType ||
action.type === joinThreadActionTypes.success || action.type === joinThreadActionTypes.success ||
action.type === newThreadActionTypes.success action.type === newThreadActionTypes.success
) { ) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === fullStateSyncActionType) { } else if (action.type === fullStateSyncActionType) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
action.payload.rawEntryInfos, action.payload.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === changeThreadSettingsActionTypes.success || action.type === changeThreadSettingsActionTypes.success ||
action.type === removeUsersFromThreadActionTypes.success || action.type === removeUsersFromThreadActionTypes.success ||
action.type === changeThreadMemberRolesActionTypes.success action.type === changeThreadMemberRolesActionTypes.success
) { ) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos); const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy( const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID], (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos); )(entryInfos);
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) { if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos( const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries, daysToEntries,
newEntryInfos, newEntryInfos,
); );
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === processServerRequestsActionType) { } else if (action.type === processServerRequestsActionType) {
const checkStateRequest = action.payload.serverRequests.find( const checkStateRequest = action.payload.serverRequests.find(
candidate => candidate.type === serverRequestTypes.CHECK_STATE, candidate => candidate.type === serverRequestTypes.CHECK_STATE,
); );
if (!checkStateRequest || !checkStateRequest.stateChanges) { if (!checkStateRequest || !checkStateRequest.stateChanges) {
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges; const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges;
if (!rawEntryInfos && !deleteEntryIDs) { if (!rawEntryInfos && !deleteEntryIDs) {
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos }; const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos };
if (deleteEntryIDs) { if (deleteEntryIDs) {
for (const deleteEntryID of deleteEntryIDs) { for (const deleteEntryID of deleteEntryIDs) {
delete updatedEntryInfos[deleteEntryID]; delete updatedEntryInfos[deleteEntryID];
} }
} }
Show All 15 Lines ) {
} }
const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies( const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies(
action, action,
entryInfos, entryInfos,
mergedEntryInfos, mergedEntryInfos,
); );
return [ return {
{ entryStore: {
entryInfos: mergedEntryInfos, entryInfos: mergedEntryInfos,
daysToEntries: mergedDaysToEntries, daysToEntries: mergedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
newInconsistencies, entryStoreOperations: [],
]; reportCreationRequests: newInconsistencies,
};
} }
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
function mergeUpdateEntryInfos( function mergeUpdateEntryInfos(
entryInfos: $ReadOnlyArray<RawEntryInfo>, entryInfos: $ReadOnlyArray<RawEntryInfo>,
newUpdates: $ReadOnlyArray<ClientUpdateInfo>, newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
): RawEntryInfo[] { ): RawEntryInfo[] {
const entryIDs = new Set( const entryIDs = new Set(
entryInfos.map(entryInfo => entryInfo.id).filter(Boolean), entryInfos.map(entryInfo => entryInfo.id).filter(Boolean),
Show All 34 Lines