Page MenuHomePhabricator
Differential D12147

[lib] Handle setClientDBStoreActionType for entries
ClosedPublic
Actions

Authored by tomek on May 21 2024, 7:30 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 20, 10:03 PM
Unknown Object (File)
Fri, Mar 7, 3:33 AM
Unknown Object (File)
Thu, Mar 6, 2:45 AM
Unknown Object (File)
Wed, Mar 5, 3:07 PM
Unknown Object (File)
Tue, Mar 4, 8:25 PM
Unknown Object (File)
Tue, Mar 4, 5:59 PM
Unknown Object (File)
Feb 28 2025, 1:17 AM
Unknown Object (File)
Feb 26 2025, 11:41 AM
View All Files
Subscribers
ashoat

Details

Reviewers
kamil
marcin
Commits
rCOMM8a3e3534159a: [lib] Handle setClientDBStoreActionType for entries
Summary

Handle the action and check if the expected and processed store match

Depends on D12143

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

Test Plan

Created some entries, closed the app, killed the keyserver, opened the app, and checked if an alert with store difference wasn't shown.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

tomek created this revision.May 21 2024, 7:30 AM
Herald added a subscriber: ashoat. · View Herald TranscriptMay 21 2024, 7:30 AM
tomek updated this revision to Diff 40476.May 21 2024, 7:51 AM

Rebase

tomek updated this revision to Diff 40477.May 21 2024, 7:56 AM

Rebase

Harbormaster completed remote builds in B29105: Diff 40471.May 21 2024, 7:57 AM
Harbormaster failed remote builds in B29109: Diff 40476!May 21 2024, 8:02 AM
tomek added a child revision: D12152: [lib] Schedule entry store ops processing.May 21 2024, 8:11 AM
Harbormaster returned this revision to the author for changes because remote builds failed.May 21 2024, 8:39 AM
Harbormaster failed remote builds in B29110: Diff 40477!
tomek updated this revision to Diff 40501.May 21 2024, 12:35 PM

Rebase

Harbormaster completed remote builds in B29133: Diff 40501.May 21 2024, 12:51 PM
tomek requested review of this revision.May 21 2024, 12:51 PM
marcin accepted this revision.May 22 2024, 2:48 AM
marcin added inline comments.
lib/reducers/entry-reducer.js
724 ↗(On Diff #40501)

If we want to proceed with this we need to postpone landing D12153

This revision is now accepted and ready to land.May 22 2024, 2:48 AM
tomek added inline comments.May 22 2024, 3:55 AM
lib/reducers/entry-reducer.js
724 ↗(On Diff #40501)

I moved it to the top of the stack

tomek updated this revision to Diff 40524.May 22 2024, 4:06 AM

Return state from the store

tomek edited the test plan for this revision. (Show Details)May 22 2024, 4:10 AM
Harbormaster completed remote builds in B29153: Diff 40524.May 22 2024, 4:22 AM
Closed by commit rCOMM8a3e3534159a: [lib] Handle setClientDBStoreActionType for entries (authored by tomek). · Explain WhyMay 27 2024, 5:50 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMM8a3e3534159a: [lib] Handle setClientDBStoreActionType for entries.
ashoat mentioned this in D12177: [lib] Stop checking for entry store inconsistencies.May 28 2024, 12:06 PM

Revision Contents
Changeset List

PathSize
lib/
reducers/
52 lines
2 lines

Diff 40662

View Options

lib/reducers/entry-reducer.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
View Options

lib/reducers/master-reducer.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