Page MenuHomePhabricator
Differential D12162

[lib] Replace merging entries with an ops approach
ClosedPublic
Actions

Authored by tomek on May 21 2024, 12:23 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 29, 3:45 PM
Unknown Object (File)
Wed, Mar 19, 1:39 AM
Unknown Object (File)
Tue, Mar 18, 8:15 AM
Unknown Object (File)
Wed, Mar 12, 10:41 PM
Unknown Object (File)
Tue, Mar 11, 5:38 PM
Unknown Object (File)
Thu, Mar 6, 9:16 AM
Unknown Object (File)
Thu, Mar 6, 2:44 AM
Unknown Object (File)
Tue, Mar 4, 6:25 PM
View All Files
Subscribers
ashoat

Details

Reviewers
kamil
marcin
Commits
rCOMM493a05d77625: [lib] Replace merging entries with an ops approach
Summary

Merging the entries now returns the ops which are later processed

Depends on D12156

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

Test Plan

Be on the latest diff if this stack to ensure there is no mechanism from the keyserver that would aid entry persistence. After testing each actions kill the app and reopen it to ensure that changes are correctly persisted.

  1. To test fetchEntriesActionTypes.success: click history on a day in calendar on Web
  2. To test updateCalendarQueryActionTypes.success: create entry on web in a distant month in the past and then scrolling calendar in native to that date. Ensure that new entry appeared in the DB after scrolling close to the date.
  3. To test saveEntryActionTypes.success: edit and save entry on web.
  4. To test deleteEntryActionTypes: delete entry and check in SQLite that deleted property is marked as true and entry is not visible across app restarts.
  5. To test restoreEntryActionTypes.success: Delete and restore on web. Reopen the app between steps, and ensure that changes are persisted.
  6. To test legacyLogInActionTypes.success, legacySiweAuthActionTypes.success, keyserverAuthActionTypes.success: log in and log out and seeing that entries are in db after logging in back.
  7. To test incrementalStateSyncActionType: background mobile app, do something in calendar on web and foreground the app again.
  8. To test processUpdatesActionType, joinThreadActionTypes.success, newThreadActionTypes.success: modify entry on web and see immediate update (UI and DB) on native.
  9. To test fullStateSyncActionType by a hack: Go to socket.js  in keyserver, change condition in line 515 to be true, kill the native app, modify calendar on web an open the native app.
  10. To test processServerRequestsActionType: This actions is dispatched a short while after creating entry when it transitions from local to remote.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

tomek created this revision.May 21 2024, 12:23 PM
Herald added a subscriber: ashoat. · View Herald TranscriptMay 21 2024, 12:23 PM
tomek edited parent revisions, added: D12156: [lib] Update delete keyserver, delete thread, leave thread and set new session actions with the ops approach; removed: D12157: [native] Add a migration that moves entries to SQLite.May 21 2024, 12:23 PM
tomek retitled this revision from [native] Replace merging entries with an ops approach to [lib] Replace merging entries with an ops approach.May 21 2024, 12:28 PM
tomek added a parent revision: D12157: [native] Add a migration that moves entries to SQLite.
tomek removed a parent revision: D12157: [native] Add a migration that moves entries to SQLite.May 21 2024, 12:33 PM
Harbormaster returned this revision to the author for changes because remote builds failed.May 21 2024, 12:40 PM
Harbormaster failed remote builds in B29131: Diff 40499!
tomek updated this revision to Diff 40511.May 21 2024, 12:44 PM
tomek added a parent revision: D12157: [native] Add a migration that moves entries to SQLite.

Rebase

tomek edited the summary of this revision. (Show Details)May 21 2024, 12:44 PM
tomek removed a parent revision: D12157: [native] Add a migration that moves entries to SQLite.
tomek added a child revision: D12163: [lib] Migrate creating local entries, concurrent modification and delete entries actions to ops.May 21 2024, 12:51 PM
Harbormaster completed remote builds in B29143: Diff 40511.May 21 2024, 1:12 PM
tomek requested review of this revision.May 21 2024, 1:12 PM
marcin added inline comments.May 22 2024, 6:49 AM
lib/reducers/entry-reducer.js
287 ↗(On Diff #40511)

Tested works. Tested by clicking history on calendar entry in Web.

313 ↗(On Diff #40511)

Tested works. Tested by creating entry on web in a distant month in the past and then scrolling calendar in native to that date. Ensure that new entry appeared in the DB after scrolling close to the date.

340 ↗(On Diff #40511)

Tested works. Tested by creating entry and ensuring that it appears in the DB immediately and has local id

407 ↗(On Diff #40511)

Tested works. Tested by editing and saving entry on web.

488 ↗(On Diff #40511)

Tested. Works. Tested by deleting entry and checking in SQLite that deleted property is marked and entry is not visible across app restarts.

537 ↗(On Diff #40511)

Tested works. Deleted and restored on web. Reopened app between steps,

552 ↗(On Diff #40511)

Tested works. Tested by logging in and logging out and seeing that entries are in db after logging in.

marcin added inline comments.May 22 2024, 7:06 AM
lib/reducers/entry-reducer.js
598 ↗(On Diff #40511)

Tested works. Tested by modifying entry on web and seeing immediate update (UI and DB) on native.

marcin added inline comments.May 22 2024, 7:26 AM
lib/reducers/entry-reducer.js
716 ↗(On Diff #40511)

Tested works. Texted by restarting the app and seeing that entries are in calendar.

marcin added inline comments.May 22 2024, 8:25 AM
lib/reducers/entry-reducer.js
626 ↗(On Diff #40511)

Tested works. Created community as user A, added user B, created entry and deleted user B. Checked that entry disappeared from B database.

marcin added inline comments.May 23 2024, 3:54 AM
lib/reducers/entry-reducer.js
574 ↗(On Diff #40511)

Tested works. Tested by backgrounding mobile app, doing something in calendar on web and foregrounding the app again.

marcin added inline comments.May 23 2024, 4:32 AM
lib/reducers/entry-reducer.js
655 ↗(On Diff #40511)

Tested works. This actions is dispatched a short while after creating entry when it transitions from local to remote.

marcin added inline comments.May 23 2024, 5:16 AM
lib/reducers/entry-reducer.js
614 ↗(On Diff #40511)

Tested works. I had to hack it. I went to socket.js in keyserver, changed condition in line 515 to be true, kill the native app, modify calendar on web an open the native app.

marcin accepted this revision.May 23 2024, 5:28 AM
This revision is now accepted and ready to land.May 23 2024, 5:28 AM
marcin edited the test plan for this revision. (Show Details)May 24 2024, 7:31 AM
marcin edited the test plan for this revision. (Show Details)May 24 2024, 7:34 AM
marcin edited the test plan for this revision. (Show Details)May 24 2024, 7:38 AM
marcin edited the test plan for this revision. (Show Details)May 24 2024, 8:01 AM
marcin edited the test plan for this revision. (Show Details)May 24 2024, 8:16 AM
Closed by commit rCOMM493a05d77625: [lib] Replace merging entries with an ops approach (authored by tomek). · Explain WhyMay 27 2024, 5:50 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMM493a05d77625: [lib] Replace merging entries with an ops approach.

Revision Contents
Changeset List

PathSize
lib/
reducers/
215 lines

Diff 40666

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