Page MenuHomePhabricator
Differential D13218

[lib] Check the timestamps when adding the viewer to thread members
ClosedPublic
Actions

Authored by tomek on Sep 2 2024, 7:15 AM.
Tags
None
Referenced Files
F5105397: D13218.id43934.diff
Tue, Apr 1, 7:10 AM
Unknown Object (File)
Sat, Mar 29, 11:05 PM
Unknown Object (File)
Fri, Mar 28, 10:50 AM
Unknown Object (File)
Thu, Mar 27, 2:48 PM
Unknown Object (File)
Sat, Mar 22, 11:32 PM
Unknown Object (File)
Sun, Mar 9, 10:14 PM
Unknown Object (File)
Thu, Mar 6, 6:13 AM
Unknown Object (File)
Wed, Mar 5, 4:01 AM
View All 71 Files
Subscribers
ashoat

Details

Reviewers
kamil
inka
Commits
rCOMM2a7c9bc65f1a: [lib] Check the timestamps when adding the viewer to thread members
Summary

Check the timestamp and update the membership only when necessary.

https://linear.app/comm/issue/ENG-9114/update-addviewertothreadmembersspec

Depends on D13217

Test Plan

Created two add_viewer_to_thread_members operations and checked if the resulting timestamps are correct (all the timestamps should equal the first operation time except the membership.role timestamp).

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

tomek created this revision.Sep 2 2024, 7:15 AM
Herald added a subscriber: ashoat. · View Herald TranscriptSep 2 2024, 7:15 AM
tomek updated this revision to Diff 43830.Sep 2 2024, 7:23 AM

Rebase

Harbormaster completed remote builds in B31381: Diff 43826.Sep 2 2024, 7:32 AM
tomek added a child revision: D13219: [lib] Include `timestamps` inside `CreateThickRawThreadInfoInput`.Sep 2 2024, 7:41 AM
Harbormaster completed remote builds in B31385: Diff 43830.Sep 2 2024, 7:41 AM
tomek requested review of this revision.Sep 2 2024, 7:41 AM
inka added inline comments.Sep 3 2024, 3:50 AM
lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
76 ↗(On Diff #43830)

Same as in previous diffs, we should probably handle timestamp collisions

90–117 ↗(On Diff #43830)

Why don't we make createThickRawThreadInfo take timestamps?

tomek added inline comments.Sep 5 2024, 3:15 AM
lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
76 ↗(On Diff #43830)

https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution

90–117 ↗(On Diff #43830)

In the next diff D13219 I add this parameter. I'm going to update this spec in that diff.

inka accepted this revision.Sep 5 2024, 6:41 AM
This revision is now accepted and ready to land.Sep 5 2024, 6:41 AM
Closed by commit rCOMM2a7c9bc65f1a: [lib] Check the timestamps when adding the viewer to thread members (authored by tomek). · Explain WhySep 6 2024, 8:10 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMM2a7c9bc65f1a: [lib] Check the timestamps when adding the viewer to thread members.

Revision Contents
Changeset List

PathSize
lib/
shared/
dm-ops/
13 lines
131 lines

Diff 43934

View Options

lib/shared/dm-ops/add-members-spec.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import uuid from 'uuid'; import uuid from 'uuid';
import { createRoleAndPermissionForThickThreads } from './create-thread-spec.js'; import { createRoleAndPermissionForThickThreads } from './create-thread-spec.js';
import type { import type {
DMOperationSpec, DMOperationSpec,
ProcessDMOperationUtilities, ProcessDMOperationUtilities,
} from './dm-op-spec.js'; } from './dm-op-spec.js';
import type { DMAddMembersOperation } from '../../types/dm-ops.js'; import type { DMAddMembersOperation } from '../../types/dm-ops.js';
import { messageTypes } from '../../types/message-types-enum.js'; import { messageTypes } from '../../types/message-types-enum.js';
import { type RawMessageInfo } from '../../types/message-types.js';
import type { AddMembersMessageData } from '../../types/messages/add-members.js'; import type { AddMembersMessageData } from '../../types/messages/add-members.js';
import { import { minimallyEncodeMemberInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
minimallyEncodeMemberInfo,
type ThickRawThreadInfo,
} from '../../types/minimally-encoded-thread-permissions-types.js';
import { joinThreadSubscription } from '../../types/subscription-types.js'; import { joinThreadSubscription } from '../../types/subscription-types.js';
import type { ThickMemberInfo } from '../../types/thread-types.js'; import type { ThickMemberInfo } from '../../types/thread-types.js';
import { updateTypes } from '../../types/update-types-enum.js'; import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js';
import { values } from '../../utils/objects.js'; import { values } from '../../utils/objects.js';
import { rawMessageInfoFromMessageData } from '../message-utils.js'; import { rawMessageInfoFromMessageData } from '../message-utils.js';
import { roleIsDefaultRole, userIsMember } from '../thread-utils.js'; import { roleIsDefaultRole, userIsMember } from '../thread-utils.js';
export type AddMembersResult = {
rawMessageInfos: Array<RawMessageInfo>,
updateInfos: Array<ClientUpdateInfo>,
threadInfo: ?ThickRawThreadInfo,
};
function createAddNewMembersMessageDataFromDMOperation( function createAddNewMembersMessageDataFromDMOperation(
dmOperation: DMAddMembersOperation, dmOperation: DMAddMembersOperation,
): AddMembersMessageData { ): AddMembersMessageData {
const { editorID, time, addedUserIDs, threadID } = dmOperation; const { editorID, time, addedUserIDs, threadID } = dmOperation;
return { return {
type: messageTypes.ADD_MEMBERS, type: messageTypes.ADD_MEMBERS,
threadID, threadID,
creatorID: editorID, creatorID: editorID,
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines
View Options

lib/shared/dm-ops/add-viewer-to-thread-members-spec.js

// @flow // @flow
import uuid from 'uuid'; import uuid from 'uuid';
import type { AddMembersResult } from './add-members-spec.js';
import { createThickRawThreadInfo } from './create-thread-spec.js'; import { createThickRawThreadInfo } from './create-thread-spec.js';
import type { DMOperationSpec } from './dm-op-spec.js'; import type {
DMOperationSpec,
ProcessDMOperationUtilities,
} from './dm-op-spec.js';
import type { DMAddViewerToThreadMembersOperation } from '../../types/dm-ops.js'; import type { DMAddViewerToThreadMembersOperation } from '../../types/dm-ops.js';
import { messageTypes } from '../../types/message-types-enum.js'; import { messageTypes } from '../../types/message-types-enum.js';
import { messageTruncationStatus } from '../../types/message-types.js'; import { messageTruncationStatus } from '../../types/message-types.js';
import type { AddMembersMessageData } from '../../types/messages/add-members.js'; import type { AddMembersMessageData } from '../../types/messages/add-members.js';
import { joinThreadSubscription } from '../../types/subscription-types.js'; import { joinThreadSubscription } from '../../types/subscription-types.js';
import { updateTypes } from '../../types/update-types-enum.js'; import { updateTypes } from '../../types/update-types-enum.js';
import { rawMessageInfoFromMessageData } from '../message-utils.js'; import { rawMessageInfoFromMessageData } from '../message-utils.js';
import { userIsMember } from '../thread-utils.js';
function createAddViewerToThreadMembersMessageDataFromDMOp( function createAddViewerToThreadMembersMessageDataFromDMOp(
dmOperation: DMAddViewerToThreadMembersOperation, dmOperation: DMAddViewerToThreadMembersOperation,
): AddMembersMessageData { ): AddMembersMessageData {
const { editorID, time, addedUserIDs, existingThreadDetails } = dmOperation; const { editorID, time, addedUserIDs, existingThreadDetails } = dmOperation;
return { return {
type: messageTypes.ADD_MEMBERS, type: messageTypes.ADD_MEMBERS,
threadID: existingThreadDetails.threadID, threadID: existingThreadDetails.threadID,
creatorID: editorID, creatorID: editorID,
time, time,
addedUserIDs: [...addedUserIDs], addedUserIDs: [...addedUserIDs],
}; };
} }
function createAddViewerToThreadMembersResults( const addViewerToThreadMembersSpec: DMOperationSpec<DMAddViewerToThreadMembersOperation> =
Object.freeze({
notificationsCreationData: async (
dmOperation: DMAddViewerToThreadMembersOperation,
) => {
const messageData =
createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
return { messageDatas: [messageData] };
},
processDMOperation: async (
dmOperation: DMAddViewerToThreadMembersOperation, dmOperation: DMAddViewerToThreadMembersOperation,
viewerID: string, viewerID: string,
): AddMembersResult { utilities: ProcessDMOperationUtilities,
const { time, messageID, addedUserIDs, existingThreadDetails } = dmOperation; ) => {
const { time, messageID, addedUserIDs, existingThreadDetails } =
dmOperation;
const messageData = const messageData =
createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation); createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
const rawMessageInfos = [ const rawMessageInfos = [
rawMessageInfoFromMessageData(messageData, messageID), rawMessageInfoFromMessageData(messageData, messageID),
]; ];
const threadID = existingThreadDetails.threadID;
const currentThreadInfo = utilities.threadInfos[threadID];
if (currentThreadInfo && !currentThreadInfo.thick) {
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const memberTimestamps = {
...currentThreadInfo?.timestamps?.members,
};
const newMembers = [];
for (const userID of addedUserIDs) {
if (!memberTimestamps[userID]) {
memberTimestamps[userID] = {
isMember: time,
subscription: existingThreadDetails.creationTime,
};
}
if (memberTimestamps[userID].isMember > time) {
continue;
}
memberTimestamps[userID] = {
...memberTimestamps[userID],
isMember: time,
};
if (!userIsMember(currentThreadInfo, userID)) {
newMembers.push(userID);
}
}
const resultThreadInfo = createThickRawThreadInfo( const resultThreadInfo = createThickRawThreadInfo(
{ {
...existingThreadDetails, ...existingThreadDetails,
allMemberIDsWithSubscriptions: [ allMemberIDsWithSubscriptions: [
...existingThreadDetails.allMemberIDsWithSubscriptions, ...existingThreadDetails.allMemberIDsWithSubscriptions,
...addedUserIDs.map(id => ({ ...newMembers.map(id => ({
id, id,
subscription: joinThreadSubscription, subscription: joinThreadSubscription,
})), })),
], ],
}, },
viewerID, viewerID,
); );
const updateInfos = [ const updateInfos = [
{ {
type: updateTypes.JOIN_THREAD, type: updateTypes.JOIN_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: resultThreadInfo, threadInfo: {
...resultThreadInfo,
timestamps: {
...resultThreadInfo.timestamps,
members: {
...resultThreadInfo.timestamps.members,
...memberTimestamps,
},
},
},
rawMessageInfos, rawMessageInfos,
truncationStatus: messageTruncationStatus.EXHAUSTIVE, truncationStatus: messageTruncationStatus.EXHAUSTIVE,
rawEntryInfos: [], rawEntryInfos: [],
}, },
]; ];
return {
rawMessageInfos: [],
updateInfos,
threadInfo: resultThreadInfo,
};
}
const addViewerToThreadMembersSpec: DMOperationSpec<DMAddViewerToThreadMembersOperation> =
Object.freeze({
notificationsCreationData: async (
dmOperation: DMAddViewerToThreadMembersOperation,
) => {
const messageData =
createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
return { messageDatas: [messageData] };
},
processDMOperation: async (
dmOperation: DMAddViewerToThreadMembersOperation,
viewerID: string,
) => {
const { rawMessageInfos, updateInfos } =
createAddViewerToThreadMembersResults(dmOperation, viewerID);
return { rawMessageInfos, updateInfos }; return { rawMessageInfos, updateInfos };
}, },
canBeProcessed( canBeProcessed(
dmOperation: DMAddViewerToThreadMembersOperation, dmOperation: DMAddViewerToThreadMembersOperation,
viewerID: string, viewerID: string,
) { ) {
if (dmOperation.addedUserIDs.includes(viewerID)) { if (dmOperation.addedUserIDs.includes(viewerID)) {
return { isProcessingPossible: true }; return { isProcessingPossible: true };
} }
console.log('Invalid DM operation', dmOperation); console.log('Invalid DM operation', dmOperation);
return { return {
isProcessingPossible: false, isProcessingPossible: false,
reason: { reason: {
type: 'invalid', type: 'invalid',
}, },
}; };
}, },
supportsAutoRetry: true, supportsAutoRetry: true,
}); });
export { export {
addViewerToThreadMembersSpec, addViewerToThreadMembersSpec,
createAddViewerToThreadMembersResults,
createAddViewerToThreadMembersMessageDataFromDMOp, createAddViewerToThreadMembersMessageDataFromDMOp,
}; };