Page MenuHomePhabricator
Differential D12957

[lib] Correctly handle generating ops from multiple updates
ClosedPublic
Actions

Authored by tomek on Aug 2 2024, 4:35 AM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Mar 14, 7:25 PM
Unknown Object (File)
Feb 18 2025, 3:26 AM
Unknown Object (File)
Feb 18 2025, 3:26 AM
Unknown Object (File)
Feb 18 2025, 3:26 AM
Unknown Object (File)
Feb 18 2025, 3:26 AM
Unknown Object (File)
Jan 15 2025, 9:24 AM
Unknown Object (File)
Jan 5 2025, 8:19 AM
Unknown Object (File)
Jan 5 2025, 4:17 AM
View All 66 Files
Subscribers
ashoat

Details

Reviewers
kamil
inka
Commits
rCOMMb1919741e731: [lib] Correctly handle generating ops from multiple updates
Summary

We have to apply the ops from each update before generating ops for the next update.

https://linear.app/comm/issue/ENG-8932/thread-updates-are-incorrectly-reduced

Depends on D12956

Test Plan

Modified the code so that a change_thread_settings operation, that updates name, color and unread status of a thread, is processed. Made sure that the changes were correctly applied on web.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
reducers/
63 lines

Diff 43054

View Options

lib/reducers/thread-reducer.js

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
import { import {
type ClientUpdateInfo, type ClientUpdateInfo,
processUpdatesActionType, processUpdatesActionType,
} from '../types/update-types.js'; } from '../types/update-types.js';
const { processStoreOperations: processThreadStoreOperations } = const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers; threadStoreOpsHandlers;
function generateOpsForThreadUpdates( function generateOpsAndProcessThreadUpdates(
threadInfos: RawThreadInfos, threadStore: ThreadStore,
newUpdates: $ReadOnlyArray<ClientUpdateInfo>, newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
): $ReadOnlyArray<ThreadStoreOperation> { ): {
return newUpdates +threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
.map(update => +updatedThreadStore: ThreadStore,
updateSpecs[update.type].generateOpsForThreadUpdates?.( } {
threadInfos, const operations: Array<ThreadStoreOperation> = [];
let store = threadStore;
for (const update of newUpdates) {
const ops = updateSpecs[update.type].generateOpsForThreadUpdates?.(
store.threadInfos,
update, update,
), );
) if (!ops || ops.length === 0) {
.filter(Boolean) continue;
.flat(); }
operations.push(...ops);
store = processThreadStoreOperations(store, ops);
}
return { threadStoreOperations: operations, updatedThreadStore: store };
} }
type ReduceThreadInfosResult = { type ReduceThreadInfosResult = {
threadStore: ThreadStore, threadStore: ThreadStore,
newThreadInconsistencies: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>, newThreadInconsistencies: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>, threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
}; };
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines ) {
const { newUpdates } = action.payload.updatesResult; const { newUpdates } = action.payload.updatesResult;
if (newUpdates.length === 0) { if (newUpdates.length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = generateOpsForThreadUpdates( const { threadStoreOperations, updatedThreadStore } =
state.threadInfos, generateOpsAndProcessThreadUpdates(state, newUpdates);
newUpdates,
);
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else if ( } else if (
action.type === fetchPendingUpdatesActionTypes.success && action.type === fetchPendingUpdatesActionTypes.success &&
action.payload.type === stateSyncPayloadTypes.INCREMENTAL action.payload.type === stateSyncPayloadTypes.INCREMENTAL
) { ) {
const { newUpdates } = action.payload.updatesResult; const { newUpdates } = action.payload.updatesResult;
if (newUpdates.length === 0) { if (newUpdates.length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = generateOpsForThreadUpdates( const { threadStoreOperations, updatedThreadStore } =
state.threadInfos, generateOpsAndProcessThreadUpdates(state, newUpdates);
newUpdates,
);
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === updateSubscriptionActionTypes.success) { } else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload; const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
▲ Show 20 Lines • Show All 234 Lines • ▼ Show 20 Lines ) {
const { updateInfos } = action.payload; const { updateInfos } = action.payload;
if (updateInfos.length === 0) { if (updateInfos.length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = generateOpsForThreadUpdates( const { threadStoreOperations, updatedThreadStore } =
state.threadInfos, generateOpsAndProcessThreadUpdates(state, updateInfos);
updateInfos,
);
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} }
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
export { reduceThreadInfos }; export { reduceThreadInfos };