[lib] Schedule entry store ops processing
ClosedPublic
Actions

Show All 34 Lines	import {
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

[lib] Schedule entry store ops processingClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 40663

lib/reducers/master-reducer.js

[lib] Schedule entry store ops processing
ClosedPublic
Actions

Revision Contents
Changeset List