Page MenuHomePhabricator
Differential D14205

rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos
ClosedPublic
Actions

Authored by varun on Jan 14 2025, 2:57 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 24, 3:53 AM
Unknown Object (File)
Mon, Apr 21, 2:32 PM
Unknown Object (File)
Mon, Apr 21, 9:36 AM
Unknown Object (File)
Mon, Apr 21, 6:46 AM
Unknown Object (File)
Mon, Apr 21, 6:43 AM
Unknown Object (File)
Sun, Apr 20, 6:46 AM
Unknown Object (File)
Wed, Apr 16, 3:56 AM
Unknown Object (File)
Mar 22 2025, 8:50 AM
View All 49 Files
Subscribers
tomek

Details

Reviewers
ashoat
Commits
rCOMM2634be67d26f: rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos
Summary

Depends on D14204

Test Plan

was still able to call endpoint from community drawer

this API isn't being used anywhere yet so no need to worry about older clients

Diff Detail

Repository
rCOMM Comm
Branch
directory (branched from master)
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

varun created this revision.Jan 14 2025, 2:57 PM
varun held this revision as a draft.
Herald added a subscriber: tomek. · View Herald TranscriptJan 14 2025, 2:57 PM
Harbormaster failed remote builds in B33243: Diff 46685!Jan 14 2025, 3:11 PM
varun updated this revision to Diff 46847.Jan 29 2025, 5:36 PM

CI

varun edited the test plan for this revision. (Show Details)Jan 29 2025, 5:36 PM
varun edited the test plan for this revision. (Show Details)
Harbormaster completed remote builds in B33350: Diff 46847.Jan 29 2025, 5:56 PM
varun published this revision for review.Jan 29 2025, 5:57 PM
ashoat accepted this revision.Jan 30 2025, 10:55 AM
ashoat added inline comments.
keyserver/src/endpoints.js
509

Is it definitely safe to rename this? No calls from production?

This revision is now accepted and ready to land.Jan 30 2025, 10:55 AM
varun added inline comments.Feb 3 2025, 4:32 PM
keyserver/src/endpoints.js
509

yeah

varun added a child revision: D14378: [keyserver] boost certain community IDs.Feb 17 2025, 3:46 PM
Closed by commit rCOMM2634be67d26f: rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos (authored by varun). · Explain WhyMar 1 2025, 2:25 PM
This revision was automatically updated to reflect the committed changes.
varun added a commit: rCOMM2634be67d26f: rename fetchAllCommunityInfosWithNames -> fetchNativeDrawerAndDirectoryInfos.

Revision Contents
Changeset List

PathSize
keyserver/
src/
6 lines
fetchers/
4 lines
responders/
12 lines
scripts/
4 lines
lib/
actions/
20 lines
reducers/
4 lines
types/
4 lines
3 lines
10 lines
validators/
6 lines
6 lines
native/
components/
8 lines
navigation/
14 lines

Diff 46847

View Options

keyserver/src/endpoints.js

// @flow // @flow
import invariant from 'invariant';
import { import {
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
updateActivityActionTypes, updateActivityActionTypes,
} from '../actions/activity-actions.js'; } from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js'; import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js'; import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js'; import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import { import {
Show All 15 Linesimport {
updateSubscriptionActionTypes, updateSubscriptionActionTypes,
} from '../actions/user-actions.js'; } from '../actions/user-actions.js';
import { import {
type ThreadStoreOperation, type ThreadStoreOperation,
threadStoreOpsHandlers, threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js'; } from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js'; import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js'; import { updateSpecs } from '../shared/updates/update-specs.js';
import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js'; import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import { import {
serverRequestTypes, serverRequestTypes,
processServerRequestsActionType, processServerRequestsActionType,
} from '../types/request-types.js'; } from '../types/request-types.js';
import { import {
fullStateSyncActionType, fullStateSyncActionType,
incrementalStateSyncActionType, incrementalStateSyncActionType,
} from '../types/socket-types.js'; } from '../types/socket-types.js';
import type { import type {
RawThreadInfo, MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore, ThreadStore,
} from '../types/thread-types.js'; } from '../types/thread-types.js';
import { import {
type ClientUpdateInfo, type ClientUpdateInfo,
processUpdatesActionType, processUpdatesActionType,
} from '../types/update-types.js'; } from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js'; import { setNewSessionActionType } from '../utils/action-utils.js';
const { processStoreOperations: processThreadStoreOperations } = const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers; threadStoreOpsHandlers;
function generateOpsForThreadUpdates( function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos, threadInfos: MinimallyEncodedRawThreadInfos,
payload: { payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... }, +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
... ...
}, },
): $ReadOnlyArray<ThreadStoreOperation> { ): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates return payload.updatesResult.newUpdates
.map(update => .map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.( updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines if (
action.type === registerActionTypes.success || action.type === registerActionTypes.success ||
action.type === fullStateSyncActionType action.type === fullStateSyncActionType
) { ) {
const newThreadInfos = action.payload.threadInfos; const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'remove_all', type: 'remove_all',
}, },
...Object.keys(newThreadInfos).map((id: string) => ({ ...Object.keys(newThreadInfos).map((id: string) => {
invariant(
newThreadInfos[id].minimallyEncoded,
'newThreadInfos must be minimallyEncoded for current clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

I thought putting an invariant here was a reasonable trade-off vs. refactoring the types in the fullStateSyncActionType payload (specifically StateSyncFullActionPayload which is derived from ClientFullStateSync which is derived from BaseFullStateSync) which are used across clients and keyserver.

Open to re-exploring if that would be preferred.

atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
return {
type: 'replace', type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] }, payload: { id, threadInfo: newThreadInfos[id] },
})), };
}),
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines ) {
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];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = { const newThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
subscription, subscription,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: newThreadInfo, threadInfo: newThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === saveMessagesActionType) { } else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>(); const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) { for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID); const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current || current < messageInfo.time) { if (!current || current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time); threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
} }
} }
const changedThreadInfos: { [string]: RawThreadInfo } = {}; const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) { for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
if ( if (
!threadInfo || !threadInfo ||
threadInfo.currentUser.unread || threadInfo.currentUser.unread ||
action.payload.updatesCurrentAsOf > mostRecentTime action.payload.updatesCurrentAsOf > mostRecentTime
) { ) {
continue; continue;
} }
const changedThreadInfo = state.threadInfos[threadID]; const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = { changedThreadInfos[threadID] = {
...changedThreadInfo, ...changedThreadInfo,
currentUser: { currentUser: {
...changedThreadInfo.currentUser, ...changedThreadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
}
if (Object.keys(changedThreadInfos).length !== 0) { if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace', type: 'replace',
payload: { payload: {
id, id,
threadInfo: changedThreadInfos[id], threadInfo: changedThreadInfos[id],
}, },
})); }));
Show All 25 Lines if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations: ThreadStoreOperation[] = []; const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) { if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) { for (const rawThreadInfo of rawThreadInfos) {
invariant(
rawThreadInfo.minimallyEncoded,
'rawThreadInfo must be minimallyEncoded on new clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism.

Open to re-exploring if that would be preferred.

atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({ threadStoreOperations.push({
type: 'replace', type: 'replace',
payload: { payload: {
id: rawThreadInfo.id, id: rawThreadInfo.id,
threadInfo: rawThreadInfo, threadInfo: rawThreadInfo,
}, },
}); });
} }
Show All 20 Lines const newThreadInconsistencies =
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies, newThreadInconsistencies,
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === updateActivityActionTypes.success) { } else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {}; const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) { for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread]; const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) { if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = { updatedThreadInfos[setToUnread] = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
} }
}
if (Object.keys(updatedThreadInfos).length === 0) { if (Object.keys(updatedThreadInfos).length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines ) {
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === setThreadUnreadStatusActionTypes.started) { } else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload; const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = { const updatedThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread, unread,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) { } else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload; const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser; const currentUser = state.threadInfos[threadID].currentUser;
if (!resetToUnread || currentUser.unread) { if (!resetToUnread || currentUser.unread) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = { const updatedThread = {
...threadInfo, ...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true }, currentUser: { ...threadInfo.currentUser, unread: true },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThread, threadInfo: updatedThread,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) { } else if (action.type === setClientDBStoreActionType) {
return { return {
threadStore: action.payload.threadStore ?? state, threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
export { reduceThreadInfos }; export { reduceThreadInfos };
View Options

keyserver/src/fetchers/community-fetchers.js

// @flow // @flow
import invariant from 'invariant';
import { import {
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
updateActivityActionTypes, updateActivityActionTypes,
} from '../actions/activity-actions.js'; } from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js'; import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js'; import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js'; import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import { import {
Show All 15 Linesimport {
updateSubscriptionActionTypes, updateSubscriptionActionTypes,
} from '../actions/user-actions.js'; } from '../actions/user-actions.js';
import { import {
type ThreadStoreOperation, type ThreadStoreOperation,
threadStoreOpsHandlers, threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js'; } from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js'; import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js'; import { updateSpecs } from '../shared/updates/update-specs.js';
import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js'; import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import { import {
serverRequestTypes, serverRequestTypes,
processServerRequestsActionType, processServerRequestsActionType,
} from '../types/request-types.js'; } from '../types/request-types.js';
import { import {
fullStateSyncActionType, fullStateSyncActionType,
incrementalStateSyncActionType, incrementalStateSyncActionType,
} from '../types/socket-types.js'; } from '../types/socket-types.js';
import type { import type {
RawThreadInfo, MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore, ThreadStore,
} from '../types/thread-types.js'; } from '../types/thread-types.js';
import { import {
type ClientUpdateInfo, type ClientUpdateInfo,
processUpdatesActionType, processUpdatesActionType,
} from '../types/update-types.js'; } from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js'; import { setNewSessionActionType } from '../utils/action-utils.js';
const { processStoreOperations: processThreadStoreOperations } = const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers; threadStoreOpsHandlers;
function generateOpsForThreadUpdates( function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos, threadInfos: MinimallyEncodedRawThreadInfos,
payload: { payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... }, +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
... ...
}, },
): $ReadOnlyArray<ThreadStoreOperation> { ): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates return payload.updatesResult.newUpdates
.map(update => .map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.( updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines if (
action.type === registerActionTypes.success || action.type === registerActionTypes.success ||
action.type === fullStateSyncActionType action.type === fullStateSyncActionType
) { ) {
const newThreadInfos = action.payload.threadInfos; const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'remove_all', type: 'remove_all',
}, },
...Object.keys(newThreadInfos).map((id: string) => ({ ...Object.keys(newThreadInfos).map((id: string) => {
invariant(
newThreadInfos[id].minimallyEncoded,
'newThreadInfos must be minimallyEncoded for current clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

I thought putting an invariant here was a reasonable trade-off vs. refactoring the types in the fullStateSyncActionType payload (specifically StateSyncFullActionPayload which is derived from ClientFullStateSync which is derived from BaseFullStateSync) which are used across clients and keyserver.

Open to re-exploring if that would be preferred.

atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
return {
type: 'replace', type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] }, payload: { id, threadInfo: newThreadInfos[id] },
})), };
}),
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines ) {
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];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = { const newThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
subscription, subscription,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: newThreadInfo, threadInfo: newThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === saveMessagesActionType) { } else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>(); const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) { for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID); const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current || current < messageInfo.time) { if (!current || current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time); threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
} }
} }
const changedThreadInfos: { [string]: RawThreadInfo } = {}; const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) { for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
if ( if (
!threadInfo || !threadInfo ||
threadInfo.currentUser.unread || threadInfo.currentUser.unread ||
action.payload.updatesCurrentAsOf > mostRecentTime action.payload.updatesCurrentAsOf > mostRecentTime
) { ) {
continue; continue;
} }
const changedThreadInfo = state.threadInfos[threadID]; const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = { changedThreadInfos[threadID] = {
...changedThreadInfo, ...changedThreadInfo,
currentUser: { currentUser: {
...changedThreadInfo.currentUser, ...changedThreadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
}
if (Object.keys(changedThreadInfos).length !== 0) { if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace', type: 'replace',
payload: { payload: {
id, id,
threadInfo: changedThreadInfos[id], threadInfo: changedThreadInfos[id],
}, },
})); }));
Show All 25 Lines if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations: ThreadStoreOperation[] = []; const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) { if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) { for (const rawThreadInfo of rawThreadInfos) {
invariant(
rawThreadInfo.minimallyEncoded,
'rawThreadInfo must be minimallyEncoded on new clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism.

Open to re-exploring if that would be preferred.

atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({ threadStoreOperations.push({
type: 'replace', type: 'replace',
payload: { payload: {
id: rawThreadInfo.id, id: rawThreadInfo.id,
threadInfo: rawThreadInfo, threadInfo: rawThreadInfo,
}, },
}); });
} }
Show All 20 Lines const newThreadInconsistencies =
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies, newThreadInconsistencies,
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === updateActivityActionTypes.success) { } else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {}; const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) { for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread]; const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) { if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = { updatedThreadInfos[setToUnread] = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
} }
}
if (Object.keys(updatedThreadInfos).length === 0) { if (Object.keys(updatedThreadInfos).length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines ) {
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === setThreadUnreadStatusActionTypes.started) { } else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload; const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = { const updatedThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread, unread,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) { } else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload; const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser; const currentUser = state.threadInfos[threadID].currentUser;
if (!resetToUnread || currentUser.unread) { if (!resetToUnread || currentUser.unread) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = { const updatedThread = {
...threadInfo, ...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true }, currentUser: { ...threadInfo.currentUser, unread: true },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThread, threadInfo: updatedThread,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) { } else if (action.type === setClientDBStoreActionType) {
return { return {
threadStore: action.payload.threadStore ?? state, threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
export { reduceThreadInfos }; export { reduceThreadInfos };
View Options

keyserver/src/responders/community-responders.js

// @flow // @flow
import invariant from 'invariant';
import { import {
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
updateActivityActionTypes, updateActivityActionTypes,
} from '../actions/activity-actions.js'; } from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js'; import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js'; import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js'; import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import { import {
Show All 15 Linesimport {
updateSubscriptionActionTypes, updateSubscriptionActionTypes,
} from '../actions/user-actions.js'; } from '../actions/user-actions.js';
import { import {
type ThreadStoreOperation, type ThreadStoreOperation,
threadStoreOpsHandlers, threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js'; } from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js'; import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js'; import { updateSpecs } from '../shared/updates/update-specs.js';
import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js'; import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import { import {
serverRequestTypes, serverRequestTypes,
processServerRequestsActionType, processServerRequestsActionType,
} from '../types/request-types.js'; } from '../types/request-types.js';
import { import {
fullStateSyncActionType, fullStateSyncActionType,
incrementalStateSyncActionType, incrementalStateSyncActionType,
} from '../types/socket-types.js'; } from '../types/socket-types.js';
import type { import type {
RawThreadInfo, MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore, ThreadStore,
} from '../types/thread-types.js'; } from '../types/thread-types.js';
import { import {
type ClientUpdateInfo, type ClientUpdateInfo,
processUpdatesActionType, processUpdatesActionType,
} from '../types/update-types.js'; } from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js'; import { setNewSessionActionType } from '../utils/action-utils.js';
const { processStoreOperations: processThreadStoreOperations } = const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers; threadStoreOpsHandlers;
function generateOpsForThreadUpdates( function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos, threadInfos: MinimallyEncodedRawThreadInfos,
payload: { payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... }, +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
... ...
}, },
): $ReadOnlyArray<ThreadStoreOperation> { ): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates return payload.updatesResult.newUpdates
.map(update => .map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.( updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines if (
action.type === registerActionTypes.success || action.type === registerActionTypes.success ||
action.type === fullStateSyncActionType action.type === fullStateSyncActionType
) { ) {
const newThreadInfos = action.payload.threadInfos; const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'remove_all', type: 'remove_all',
}, },
...Object.keys(newThreadInfos).map((id: string) => ({ ...Object.keys(newThreadInfos).map((id: string) => {
invariant(
newThreadInfos[id].minimallyEncoded,
'newThreadInfos must be minimallyEncoded for current clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

I thought putting an invariant here was a reasonable trade-off vs. refactoring the types in the fullStateSyncActionType payload (specifically StateSyncFullActionPayload which is derived from ClientFullStateSync which is derived from BaseFullStateSync) which are used across clients and keyserver.

Open to re-exploring if that would be preferred.

atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
return {
type: 'replace', type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] }, payload: { id, threadInfo: newThreadInfos[id] },
})), };
}),
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines ) {
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];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = { const newThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
subscription, subscription,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: newThreadInfo, threadInfo: newThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === saveMessagesActionType) { } else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>(); const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) { for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID); const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current || current < messageInfo.time) { if (!current || current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time); threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
} }
} }
const changedThreadInfos: { [string]: RawThreadInfo } = {}; const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) { for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
if ( if (
!threadInfo || !threadInfo ||
threadInfo.currentUser.unread || threadInfo.currentUser.unread ||
action.payload.updatesCurrentAsOf > mostRecentTime action.payload.updatesCurrentAsOf > mostRecentTime
) { ) {
continue; continue;
} }
const changedThreadInfo = state.threadInfos[threadID]; const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = { changedThreadInfos[threadID] = {
...changedThreadInfo, ...changedThreadInfo,
currentUser: { currentUser: {
...changedThreadInfo.currentUser, ...changedThreadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
}
if (Object.keys(changedThreadInfos).length !== 0) { if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace', type: 'replace',
payload: { payload: {
id, id,
threadInfo: changedThreadInfos[id], threadInfo: changedThreadInfos[id],
}, },
})); }));
Show All 25 Lines if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations: ThreadStoreOperation[] = []; const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) { if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) { for (const rawThreadInfo of rawThreadInfos) {
invariant(
rawThreadInfo.minimallyEncoded,
'rawThreadInfo must be minimallyEncoded on new clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism.

Open to re-exploring if that would be preferred.

atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({ threadStoreOperations.push({
type: 'replace', type: 'replace',
payload: { payload: {
id: rawThreadInfo.id, id: rawThreadInfo.id,
threadInfo: rawThreadInfo, threadInfo: rawThreadInfo,
}, },
}); });
} }
Show All 20 Lines const newThreadInconsistencies =
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies, newThreadInconsistencies,
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === updateActivityActionTypes.success) { } else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {}; const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) { for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread]; const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) { if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = { updatedThreadInfos[setToUnread] = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
} }
}
if (Object.keys(updatedThreadInfos).length === 0) { if (Object.keys(updatedThreadInfos).length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines ) {
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === setThreadUnreadStatusActionTypes.started) { } else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload; const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = { const updatedThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread, unread,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) { } else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload; const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser; const currentUser = state.threadInfos[threadID].currentUser;
if (!resetToUnread || currentUser.unread) { if (!resetToUnread || currentUser.unread) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = { const updatedThread = {
...threadInfo, ...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true }, currentUser: { ...threadInfo.currentUser, unread: true },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThread, threadInfo: updatedThread,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) { } else if (action.type === setClientDBStoreActionType) {
return { return {
threadStore: action.payload.threadStore ?? state, threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
export { reduceThreadInfos }; export { reduceThreadInfos };
View Options

keyserver/src/scripts/delete-all-fc-channel-tags.js

// @flow // @flow
import invariant from 'invariant';
import { import {
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
updateActivityActionTypes, updateActivityActionTypes,
} from '../actions/activity-actions.js'; } from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js'; import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js'; import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js'; import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import { import {
Show All 15 Linesimport {
updateSubscriptionActionTypes, updateSubscriptionActionTypes,
} from '../actions/user-actions.js'; } from '../actions/user-actions.js';
import { import {
type ThreadStoreOperation, type ThreadStoreOperation,
threadStoreOpsHandlers, threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js'; } from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js'; import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js'; import { updateSpecs } from '../shared/updates/update-specs.js';
import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js'; import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import { import {
serverRequestTypes, serverRequestTypes,
processServerRequestsActionType, processServerRequestsActionType,
} from '../types/request-types.js'; } from '../types/request-types.js';
import { import {
fullStateSyncActionType, fullStateSyncActionType,
incrementalStateSyncActionType, incrementalStateSyncActionType,
} from '../types/socket-types.js'; } from '../types/socket-types.js';
import type { import type {
RawThreadInfo, MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore, ThreadStore,
} from '../types/thread-types.js'; } from '../types/thread-types.js';
import { import {
type ClientUpdateInfo, type ClientUpdateInfo,
processUpdatesActionType, processUpdatesActionType,
} from '../types/update-types.js'; } from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js'; import { setNewSessionActionType } from '../utils/action-utils.js';
const { processStoreOperations: processThreadStoreOperations } = const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers; threadStoreOpsHandlers;
function generateOpsForThreadUpdates( function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos, threadInfos: MinimallyEncodedRawThreadInfos,
payload: { payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... }, +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
... ...
}, },
): $ReadOnlyArray<ThreadStoreOperation> { ): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates return payload.updatesResult.newUpdates
.map(update => .map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.( updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines if (
action.type === registerActionTypes.success || action.type === registerActionTypes.success ||
action.type === fullStateSyncActionType action.type === fullStateSyncActionType
) { ) {
const newThreadInfos = action.payload.threadInfos; const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'remove_all', type: 'remove_all',
}, },
...Object.keys(newThreadInfos).map((id: string) => ({ ...Object.keys(newThreadInfos).map((id: string) => {
invariant(
newThreadInfos[id].minimallyEncoded,
'newThreadInfos must be minimallyEncoded for current clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

I thought putting an invariant here was a reasonable trade-off vs. refactoring the types in the fullStateSyncActionType payload (specifically StateSyncFullActionPayload which is derived from ClientFullStateSync which is derived from BaseFullStateSync) which are used across clients and keyserver.

Open to re-exploring if that would be preferred.

atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
return {
type: 'replace', type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] }, payload: { id, threadInfo: newThreadInfos[id] },
})), };
}),
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines ) {
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];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = { const newThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
subscription, subscription,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: newThreadInfo, threadInfo: newThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === saveMessagesActionType) { } else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>(); const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) { for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID); const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current || current < messageInfo.time) { if (!current || current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time); threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
} }
} }
const changedThreadInfos: { [string]: RawThreadInfo } = {}; const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) { for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
if ( if (
!threadInfo || !threadInfo ||
threadInfo.currentUser.unread || threadInfo.currentUser.unread ||
action.payload.updatesCurrentAsOf > mostRecentTime action.payload.updatesCurrentAsOf > mostRecentTime
) { ) {
continue; continue;
} }
const changedThreadInfo = state.threadInfos[threadID]; const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = { changedThreadInfos[threadID] = {
...changedThreadInfo, ...changedThreadInfo,
currentUser: { currentUser: {
...changedThreadInfo.currentUser, ...changedThreadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
}
if (Object.keys(changedThreadInfos).length !== 0) { if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace', type: 'replace',
payload: { payload: {
id, id,
threadInfo: changedThreadInfos[id], threadInfo: changedThreadInfos[id],
}, },
})); }));
Show All 25 Lines if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations: ThreadStoreOperation[] = []; const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) { if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) { for (const rawThreadInfo of rawThreadInfos) {
invariant(
rawThreadInfo.minimallyEncoded,
'rawThreadInfo must be minimallyEncoded on new clients',
);
atulAuthorUnsubmitted
Done
Inline Actions

Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism.

Open to re-exploring if that would be preferred.

atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({ threadStoreOperations.push({
type: 'replace', type: 'replace',
payload: { payload: {
id: rawThreadInfo.id, id: rawThreadInfo.id,
threadInfo: rawThreadInfo, threadInfo: rawThreadInfo,
}, },
}); });
} }
Show All 20 Lines const newThreadInconsistencies =
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies, newThreadInconsistencies,
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === updateActivityActionTypes.success) { } else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {}; const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) { for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread]; const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) { if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = { updatedThreadInfos[setToUnread] = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread: true, unread: true,
}, },
}; };
} }
} }
}
if (Object.keys(updatedThreadInfos).length === 0) { if (Object.keys(updatedThreadInfos).length === 0) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({ const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines ) {
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else if (action.type === setThreadUnreadStatusActionTypes.started) { } else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload; const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = { const updatedThreadInfo = {
...threadInfo, ...threadInfo,
currentUser: { currentUser: {
...threadInfo.currentUser, ...threadInfo.currentUser,
unread, unread,
}, },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThreadInfo, threadInfo: updatedThreadInfo,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) { } else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload; const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser; const currentUser = state.threadInfos[threadID].currentUser;
if (!resetToUnread || currentUser.unread) { if (!resetToUnread || currentUser.unread) {
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
const threadInfo = state.threadInfos[threadID]; const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = { const updatedThread = {
...threadInfo, ...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true }, currentUser: { ...threadInfo.currentUser, unread: true },
}; };
const threadStoreOperations = [ const threadStoreOperations = [
{ {
type: 'replace', type: 'replace',
payload: { payload: {
id: threadID, id: threadID,
threadInfo: updatedThread, threadInfo: updatedThread,
}, },
}, },
]; ];
const updatedThreadStore = processThreadStoreOperations( const updatedThreadStore = processThreadStoreOperations(
state, state,
threadStoreOperations, threadStoreOperations,
); );
return { return {
threadStore: updatedThreadStore, threadStore: updatedThreadStore,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations, threadStoreOperations,
}; };
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) { } else if (action.type === setClientDBStoreActionType) {
return { return {
threadStore: action.payload.threadStore ?? state, threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
return { return {
threadStore: state, threadStore: state,
newThreadInconsistencies: [], newThreadInconsistencies: [],
threadStoreOperations: [], threadStoreOperations: [],
}; };
} }
export { reduceThreadInfos }; export { reduceThreadInfos };
View Options

lib/actions/community-actions.js

Loading...
View Options

lib/reducers/community-reducer.js

Loading...
View Options

lib/types/community-types.js

Loading...
View Options

lib/types/endpoints.js

Loading...
View Options

lib/types/redux-types.js

Loading...
View Options

lib/types/validators/community-validators.js

Loading...
View Options

lib/types/validators/endpoint-validators.js

Loading...
View Options

native/components/display-community-directory-prompt.react.js

Loading...
View Options

native/navigation/community-drawer-content.react.js

Loading...