Page MenuHomePhabricator
Differential D12163

[lib] Migrate creating local entries, concurrent modification and delete entries actions to ops
ClosedPublic
Actions

Authored by tomek on May 21 2024, 12:51 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 24, 12:48 PM
Unknown Object (File)
Wed, Mar 12, 6:22 AM
Unknown Object (File)
Thu, Mar 6, 1:38 PM
Unknown Object (File)
Feb 28 2025, 1:17 AM
Unknown Object (File)
Feb 26 2025, 11:42 AM
Unknown Object (File)
Feb 26 2025, 11:42 AM
Unknown Object (File)
Feb 26 2025, 11:42 AM
Unknown Object (File)
Feb 16 2025, 2:56 PM
View All 97 Files
Subscribers
ashoat

Details

Reviewers
kamil
marcin
Commits
rCOMMfd32277bcaaa: [lib] Migrate creating local entries, concurrent modification and delete…
Summary

Migrate the actions

Depends on D12162

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

Test Plan
  1. To test createLocalEntryActionType: create entry and ensuring that it appears in the DB immediately and has local id.
  2. To test createEntryActionTypes.success: create entry and wait after it transitions from local id to id in the db.
  3. To test concurrentModificationResetActionType: Hack. override save function of native/entry.react to dispatch this actions with hardcoded string. Ensure that no matter what you type the result after saving is always hardcoded string.
  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.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

tomek created this revision.May 21 2024, 12:51 PM
Herald added a subscriber: ashoat. · View Herald TranscriptMay 21 2024, 12:51 PM
tomek added a child revision: D12164: [lib] Migrate remaining actions.May 21 2024, 1:00 PM
Harbormaster completed remote builds in B29144: Diff 40512.May 21 2024, 1:17 PM
tomek requested review of this revision.May 21 2024, 1:17 PM
marcin requested changes to this revision.May 22 2024, 3:14 AM
marcin added inline comments.
lib/reducers/entry-reducer.js
339 ↗(On Diff #40512)

Creating local entry tested - works correctly.

360 ↗(On Diff #40512)

This one is buggy - you don't delete local entry first and what we see is two entries after a couple of seconds.

460 ↗(On Diff #40512)

Deleting tested - works correctly.

This revision now requires changes to proceed.May 22 2024, 3:14 AM
tomek updated this revision to Diff 40523.May 22 2024, 3:45 AM

Delete local entry after successful creation

Harbormaster completed remote builds in B29152: Diff 40523.May 22 2024, 4:01 AM
marcin added inline comments.May 22 2024, 7:08 AM
lib/reducers/entry-reducer.js
339 ↗(On Diff #40523)

Tested works. Creating entry results in immediate row in the db.

360 ↗(On Diff #40523)

Tested works. Tested by creating entry and waiting after it transitions from local id to id in the db.

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

Tested works. I had to hack my way around this by overriding save function of native/entry.react to dispatch this actions with hardcoded string. No matter what I was typing the result after saving was always hardcoded string.

marcin accepted this revision.May 23 2024, 4:47 AM
This revision is now accepted and ready to land.May 23 2024, 4:47 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)
marcin edited the test plan for this revision. (Show Details)May 24 2024, 7:54 AM
Closed by commit rCOMMfd32277bcaaa: [lib] Migrate creating local entries, concurrent modification and delete… (authored by tomek). · Explain WhyMay 27 2024, 5:51 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMMfd32277bcaaa: [lib] Migrate creating local entries, concurrent modification and delete….

Revision Contents
Changeset List

PathSize
lib/
reducers/
95 lines

Diff 40667

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