Page MenuHomePhabricator
Differential D13975

[keyserver][native][web] Use FCCache instead of calling fetchFarcasterChannelByID directly
ClosedPublic
Actions

Authored by ashoat on Nov 20 2024, 6:39 AM.
Tags
None
Referenced Files
F5123482: D13975.id45899.diff
Thu, Apr 3, 3:56 PM
Unknown Object (File)
Wed, Apr 2, 2:05 PM
Unknown Object (File)
Wed, Apr 2, 6:43 AM
Unknown Object (File)
Mon, Mar 31, 9:33 PM
Unknown Object (File)
Tue, Mar 11, 3:53 PM
Unknown Object (File)
Tue, Mar 11, 3:38 PM
Unknown Object (File)
Mar 2 2025, 1:48 PM
Unknown Object (File)
Feb 28 2025, 3:19 AM
View All 54 Files
Subscribers
tomek

Details

Reviewers
varun
will
Commits
rCOMM7fcd70ef376b: [keyserver][native][web] Use FCCache instead of calling…
Summary

Noticed some places we could be using the cache but aren't.

Depends on D13974

Test Plan

Tested in combination with later diffs

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
keyserver/
src/
creators/
6 lines
responders/
4 lines
updaters/
4 lines
utils/
10 lines
native/
community-settings/
tag-farcaster-channel/
4 lines
web/
tag-farcaster-channel/
8 lines

Diff 45899

View Options

keyserver/src/creators/farcaster-channel-tag-creator.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 };
View Options

keyserver/src/responders/farcaster-webhook-responders.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 };
View Options

keyserver/src/updaters/thread-updaters.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 };
View Options

keyserver/src/utils/fc-cache.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 };
View Options

native/community-settings/tag-farcaster-channel/tag-farcaster-channel-by-name.react.js

Loading...
View Options

web/tag-farcaster-channel/create-farcaster-channel-tag-modal.react.js

Loading...