Page MenuHomePhabricator
Differential D10638

[lib] Rename `MinimallyEncodedRawThreadInfos` to `RawThreadInfos`
ClosedPublic
Actions

Authored by atul on Jan 15 2024, 10:58 AM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Feb 21, 10:24 PM
Unknown Object (File)
Fri, Feb 21, 10:24 PM
Unknown Object (File)
Fri, Feb 21, 10:24 PM
Unknown Object (File)
Fri, Feb 21, 10:24 PM
Unknown Object (File)
Fri, Feb 21, 10:24 PM
Unknown Object (File)
Feb 20 2025, 2:38 PM
Unknown Object (File)
Jan 25 2025, 7:57 AM
Unknown Object (File)
Jan 22 2025, 5:25 PM
View All 79 Files
Subscribers
None

Details

Reviewers
ashoat
ginsu
tomek
Commits
rCOMM84ddabe734d6: [lib] Rename `MinimallyEncodedRawThreadInfos` to `RawThreadInfos`
Summary

Part of https://linear.app/comm/issue/ENG-6366/rename-minimallyencodedrawthreadinfo-to-rawthreadinfo

Depends on D10637

Test Plan

flow

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

Diff 35999

View Options

lib/actions/user-actions.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/ops/thread-store-ops.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/reducers/calendar-filters-reducer.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/reducers/entry-reducer.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/reducers/message-reducer.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/reducers/thread-reducer.js

Loading...
View Options

lib/selectors/thread-selectors.js

Loading...
View Options

lib/selectors/user-selectors.js

Loading...
View Options

lib/shared/updates/delete-account-spec.js

Loading...
View Options

lib/shared/updates/join-thread-spec.js

Loading...
View Options

lib/shared/updates/update-spec.js

Loading...
View Options

lib/shared/updates/update-thread-read-status-spec.js

Loading...
View Options

lib/shared/updates/update-thread-spec.js

Loading...
View Options

lib/types/account-types.js

Loading...
View Options

lib/types/socket-types.js

Loading...
View Options

lib/types/thread-types.js

Loading...
View Options

native/selectors/message-selectors.js

Loading...
View Options

web/redux/nav-reducer.js

Loading...
View Options

web/selectors/thread-selectors.js

Loading...