Page MenuHomePhabricator
Differential D14186

[native] Set SIWE backup secrets during restoration
ClosedPublic
Actions

Authored by tomek on Jan 8 2025, 9:55 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 9, 8:57 PM
Unknown Object (File)
Sun, Mar 9, 8:57 PM
Unknown Object (File)
Sun, Mar 9, 8:57 PM
Unknown Object (File)
Sun, Mar 9, 8:57 PM
Unknown Object (File)
Mar 4 2025, 1:06 AM
Unknown Object (File)
Feb 28 2025, 6:16 AM
Unknown Object (File)
Feb 16 2025, 3:49 PM
Unknown Object (File)
Jan 28 2025, 7:42 AM
View All 27 Files
Subscribers
ashoat

Details

Reviewers
kamil
bartek
Commits
rCOMM7906402fc739: [native] Set SIWE backup secrets during restoration
Summary

We should set these secrets to make sure a new backup message isn't generated.

https://linear.app/comm/issue/ENG-10073/avoid-generating-a-new-backup-message-after-restoration

Depends on D14183

Test Plan

Restore a SIWE user and check that the missing SIWE message modal isn't shown.

Diff Detail

Repository
rCOMM Comm
Branch
restore4
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
native/
account/
5 lines

Diff 46614

View Options

native/account/restore-backup-screen.react.js

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines processDMOperation: async (
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) => { ) => {
const { joinerID, time, messageID, existingThreadDetails } = dmOperation; const { joinerID, time, messageID, existingThreadDetails } = dmOperation;
const currentThreadInfo = const currentThreadInfo =
utilities.threadInfos[existingThreadDetails.threadID]; utilities.threadInfos[existingThreadDetails.threadID];
if (currentThreadInfo && !currentThreadInfo.thick) {
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const messageData = createMessageDataFromDMOperation(dmOperation); const messageData = createMessageDataFromDMOperation(dmOperation);
const joinThreadMessageInfos = [ const joinThreadMessageInfos = [
rawMessageInfoFromMessageData(messageData, messageID), rawMessageInfoFromMessageData(messageData, messageID),
]; ];
if (userIsMember(currentThreadInfo, joinerID)) { const memberTimestamps = { ...currentThreadInfo?.timestamps?.members };
if (!memberTimestamps[joinerID]) {
memberTimestamps[joinerID] = {
isMember: time,
subscription: existingThreadDetails.creationTime,
};
}
if (memberTimestamps[joinerID].isMember > time) {
inkaUnsubmitted
Not Done
Inline Actions

Same as in the previous diff we should probably handle timestamp collision

inka: Same as in the previous diff we should probably handle timestamp collision
tomekAuthorUnsubmitted
Done
Inline Actions

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

tomek: https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution
return { return {
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
updateInfos: [], updateInfos: [],
}; };
} }
memberTimestamps[joinerID] = {
...memberTimestamps[joinerID],
isMember: time,
};
const updateInfos: Array<ClientUpdateInfo> = []; const updateInfos: Array<ClientUpdateInfo> = [];
const rawMessageInfos: Array<RawMessageInfo> = []; const rawMessageInfos: Array<RawMessageInfo> = [];
if (viewerID === joinerID) {
if (userIsMember(currentThreadInfo, joinerID)) {
rawMessageInfos.push(...joinThreadMessageInfos);
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: {
...currentThreadInfo,
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
},
});
} else if (viewerID === joinerID) {
const newThreadInfo = createThickRawThreadInfo( const newThreadInfo = createThickRawThreadInfo(
{ {
...existingThreadDetails, ...existingThreadDetails,
allMemberIDsWithSubscriptions: [ allMemberIDsWithSubscriptions: [
...existingThreadDetails.allMemberIDsWithSubscriptions, ...existingThreadDetails.allMemberIDsWithSubscriptions,
{ id: joinerID, subscription: joinThreadSubscription }, { id: joinerID, subscription: joinThreadSubscription },
], ],
}, },
viewerID, viewerID,
); );
updateInfos.push({ updateInfos.push({
type: updateTypes.JOIN_THREAD, type: updateTypes.JOIN_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: newThreadInfo, threadInfo: {
...newThreadInfo,
timestamps: {
...newThreadInfo.timestamps,
members: memberTimestamps,
},
},
rawMessageInfos: joinThreadMessageInfos, rawMessageInfos: joinThreadMessageInfos,
truncationStatus: messageTruncationStatus.EXHAUSTIVE, truncationStatus: messageTruncationStatus.EXHAUSTIVE,
rawEntryInfos: [], rawEntryInfos: [],
}); });
} else { } else {
invariant(currentThreadInfo.thick, 'Thread should be thick');
rawMessageInfos.push(...joinThreadMessageInfos); rawMessageInfos.push(...joinThreadMessageInfos);
const defaultRoleID = values(currentThreadInfo.roles).find(role => const defaultRoleID = values(currentThreadInfo.roles).find(role =>
roleIsDefaultRole(role), roleIsDefaultRole(role),
)?.id; )?.id;
invariant(defaultRoleID, 'Default role ID must exist'); invariant(defaultRoleID, 'Default role ID must exist');
const { membershipPermissions } = createRoleAndPermissionForThickThreads( const { membershipPermissions } = createRoleAndPermissionForThickThreads(
currentThreadInfo.type, currentThreadInfo.type,
currentThreadInfo.id, currentThreadInfo.id,
defaultRoleID, defaultRoleID,
); );
const member = minimallyEncodeMemberInfo<ThickMemberInfo>({ const member = minimallyEncodeMemberInfo<ThickMemberInfo>({
id: joinerID, id: joinerID,
role: defaultRoleID, role: defaultRoleID,
permissions: membershipPermissions, permissions: membershipPermissions,
isSender: joinerID === viewerID, isSender: joinerID === viewerID,
subscription: joinThreadSubscription, subscription: joinThreadSubscription,
}); });
const updatedThreadInfo = { const updatedThreadInfo = {
...currentThreadInfo, ...currentThreadInfo,
members: [...currentThreadInfo.members, member], members: [...currentThreadInfo.members, member],
timestamps: {
...currentThreadInfo.timestamps,
members: memberTimestamps,
},
}; };
updateInfos.push({ updateInfos.push({
type: updateTypes.UPDATE_THREAD, type: updateTypes.UPDATE_THREAD,
id: uuid.v4(), id: uuid.v4(),
time, time,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}); });
} }
return { return {
rawMessageInfos, rawMessageInfos,
updateInfos, updateInfos,
}; };
}, },
canBeProcessed( canBeProcessed(
dmOperation: DMJoinThreadOperation, dmOperation: DMJoinThreadOperation,
viewerID: string, viewerID: string,
utilities: ProcessDMOperationUtilities, utilities: ProcessDMOperationUtilities,
) { ) {
if (utilities.threadInfos[dmOperation.existingThreadDetails.threadID]) { if (
utilities.threadInfos[dmOperation.existingThreadDetails.threadID] ||
dmOperation.joinerID === viewerID
) {
return { isProcessingPossible: true }; return { isProcessingPossible: true };
} }
return { return {
isProcessingPossible: false, isProcessingPossible: false,
reason: { reason: {
type: 'missing_thread', type: 'missing_thread',
threadID: dmOperation.existingThreadDetails.threadID, threadID: dmOperation.existingThreadDetails.threadID,
}, },
}; };
}, },
supportsAutoRetry: true, supportsAutoRetry: true,
}); });
export { joinThreadSpec }; export { joinThreadSpec };