Page MenuHomePhabricator
Differential D13197

[lib] implement adding thread members for DMs
ClosedPublic
Actions

Authored by kamil on Aug 28 2024, 8:37 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Apr 19, 10:17 AM
Unknown Object (File)
Sat, Apr 19, 1:51 AM
Unknown Object (File)
Fri, Apr 18, 11:08 PM
Unknown Object (File)
Fri, Apr 18, 11:07 PM
Unknown Object (File)
Fri, Apr 18, 8:27 PM
Unknown Object (File)
Fri, Apr 18, 6:24 AM
Unknown Object (File)
Fri, Apr 18, 12:03 AM
Unknown Object (File)
Sat, Apr 12, 9:19 PM
View All Files
Subscribers
ashoat

Details

Reviewers
tomek
inka
Commits
rCOMM80bd999464a2: [lib] implement adding thread members for DMs
Summary

ENG-8568

This hook which wraps two needed operations together, add_viewer_to_thread_members and add_members.

Doing this in parallel, not at once is bad, created a task to fix this: ENG-9103, as this is complex change.

Depends on D13182, D13193

Test Plan

Tested later in the stack

Diff Detail

Repository
rCOMM Comm
Branch
logic-5
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

kamil created this revision.Aug 28 2024, 8:37 AM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptAug 28 2024, 8:37 AM
kamil updated this revision to Diff 43766.Aug 28 2024, 8:45 AM

update recipients

Harbormaster failed remote builds in B31347: Diff 43765!Aug 28 2024, 8:46 AM
kamil added a child revision: D13198: [native] implement adding thread members in `AddUsersModal`.Aug 28 2024, 8:47 AM
Harbormaster failed remote builds in B31348: Diff 43766!Aug 28 2024, 8:51 AM
Harbormaster completed remote builds in B31348: Diff 43766.Aug 28 2024, 9:03 AM
kamil published this revision for review.Aug 28 2024, 9:33 AM
kamil edited the summary of this revision. (Show Details)
tomek accepted this revision.Aug 28 2024, 9:56 AM
tomek added inline comments.
lib/shared/dm-ops/dm-op-utils.js
172
222

Maybe await?

This revision is now accepted and ready to land.Aug 28 2024, 9:56 AM
kamil updated this revision to Diff 43779.Aug 29 2024, 12:21 AM

address review

Harbormaster completed remote builds in B31359: Diff 43779.Aug 29 2024, 12:46 AM
Closed by commit rCOMM80bd999464a2: [lib] implement adding thread members for DMs (authored by kamil). · Explain WhyAug 29 2024, 1:16 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMM80bd999464a2: [lib] implement adding thread members for DMs.

Revision Contents
Changeset List

PathSize
lib/
shared/
dm-ops/
117 lines

Diff 43766

View Options

lib/shared/dm-ops/dm-op-utils.js

Show All 23 Lines
function reduceIntegrityStore( function reduceIntegrityStore(
state: IntegrityStore, state: IntegrityStore,
action: BaseAction, action: BaseAction,
threadInfos: { threadInfos: {
+[string]: RawThreadInfo, +[string]: RawThreadInfo,
}, },
threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>, threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
): IntegrityStore { ): {
+integrityStore: IntegrityStore,
+integrityStoreOperations: $ReadOnlyArray<IntegrityStoreOperation>,
} {
if (action.type === fullStateSyncActionType) { if (action.type === fullStateSyncActionType) {
const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' }; const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' };
const threadHashesArray = Object.entries(state.threadHashes).filter( const threadHashesArray = Object.entries(state.threadHashes).filter(
([key]) => extractKeyserverIDFromID(key) !== action.payload.keyserverID, ([key]) => extractKeyserverIDFromID(key) !== action.payload.keyserverID,
); );
const threadHashes = Object.fromEntries(threadHashesArray);
const replaceOperation = { const replaceOperation = {
type: 'replace_integrity_thread_hashes', type: 'replace_integrity_thread_hashes',
payload: { threadHashes }, payload: { threadHashes: Object.fromEntries(threadHashesArray) },
}; };
return { return {
integrityStore: {
threadHashes: processStoreOps(state, [ threadHashes: processStoreOps(state, [
removeAllOperation, removeAllOperation,
replaceOperation, replaceOperation,
]).threadHashes, ]).threadHashes,
threadHashingStatus: 'starting', threadHashingStatus: 'starting',
},
integrityStoreOperations: [removeAllOperation, replaceOperation],
}; };
} else if ( } else if (
action.type === logInActionTypes.success || action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success || action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success || action.type === keyserverRegisterActionTypes.success ||
(action.type === setClientDBStoreActionType && (action.type === setClientDBStoreActionType &&
!!action.payload.threadStore && !!action.payload.threadStore &&
state.threadHashingStatus !== 'completed') state.threadHashingStatus !== 'completed')
) { ) {
const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' }; const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' };
return { return {
integrityStore: {
threadHashes: processStoreOps(state, [removeAllOperation]).threadHashes, threadHashes: processStoreOps(state, [removeAllOperation]).threadHashes,
threadHashingStatus: 'starting', threadHashingStatus: 'starting',
},
integrityStoreOperations: [removeAllOperation],
}; };
} else if (action.type === keyserverAuthActionTypes.success) { } else if (action.type === keyserverAuthActionTypes.success) {
return { return {
integrityStore: {
threadHashes: processStoreOps(state, []).threadHashes, threadHashes: processStoreOps(state, []).threadHashes,
threadHashingStatus: 'starting', threadHashingStatus: 'starting',
},
integrityStoreOperations: [],
}; };
} }
let newState = state; let newState = state;
const integrityOperations: IntegrityStoreOperation[] = [];
if (action.type === updateIntegrityStoreActionType) { if (action.type === updateIntegrityStoreActionType) {
if (action.payload.threadIDsToHash) { if (action.payload.threadIDsToHash) {
const newThreadHashes = Object.fromEntries( const newThreadHashes = Object.fromEntries(
action.payload.threadIDsToHash action.payload.threadIDsToHash
.map(id => [id, threadInfos[id]]) .map(id => [id, threadInfos[id]])
.filter(([, info]) => !!info) .filter(([, info]) => !!info)
.map(([id, info]) => [id, hash(info)]), .map(([id, info]) => [id, hash(info)]),
); );
const replaceOperation = { const replaceOperation = {
type: 'replace_integrity_thread_hashes', type: 'replace_integrity_thread_hashes',
payload: { threadHashes: newThreadHashes }, payload: { threadHashes: newThreadHashes },
}; };
newState = processStoreOps(state, [replaceOperation]); newState = processStoreOps(state, [replaceOperation]);
integrityOperations.push(replaceOperation);
} }
if (action.payload.threadHashingStatus) { if (action.payload.threadHashingStatus) {
newState = { newState = {
...newState, ...newState,
threadHashingStatus: action.payload.threadHashingStatus, threadHashingStatus: action.payload.threadHashingStatus,
}; };
} }
} }
if (threadStoreOperations.length === 0) { if (threadStoreOperations.length === 0) {
return newState; return {
integrityStore: newState,
integrityStoreOperations: integrityOperations,
};
} }
const integrityOperations: IntegrityStoreOperation[] = [];
let threadHashingStatus = newState.threadHashingStatus; let threadHashingStatus = newState.threadHashingStatus;
for (const operation of threadStoreOperations) { for (const operation of threadStoreOperations) {
if (operation.type === 'replace') { if (operation.type === 'replace') {
const newIntegrityThreadHash = hash(operation.payload.threadInfo); const newIntegrityThreadHash = hash(operation.payload.threadInfo);
integrityOperations.push({ integrityOperations.push({
type: 'replace_integrity_thread_hashes', type: 'replace_integrity_thread_hashes',
payload: { payload: {
threadHashes: { [operation.payload.id]: newIntegrityThreadHash }, threadHashes: { [operation.payload.id]: newIntegrityThreadHash },
}, },
}); });
} else if (operation.type === 'remove') { } else if (operation.type === 'remove') {
for (const id of operation.payload.ids) { for (const id of operation.payload.ids) {
integrityOperations.push({ integrityOperations.push({
type: 'remove_integrity_thread_hashes', type: 'remove_integrity_thread_hashes',
payload: { ids: [id] }, payload: { ids: [id] },
}); });
} }
} else if (operation.type === 'remove_all') { } else if (operation.type === 'remove_all') {
integrityOperations.push({ type: 'remove_all_integrity_thread_hashes' }); integrityOperations.push({ type: 'remove_all_integrity_thread_hashes' });
threadHashingStatus = 'completed'; threadHashingStatus = 'completed';
} }
} }
return { return {
...newState, integrityStore: {
threadHashes: processStoreOps(newState, integrityOperations).threadHashes, threadHashes: processStoreOps(newState, integrityOperations).threadHashes,
threadHashingStatus, threadHashingStatus,
},
integrityStoreOperations: integrityOperations,
}; };
} }
export { reduceIntegrityStore }; export { reduceIntegrityStore };