Page MenuHomePhabricator
Differential D13316

[lib] DMOperationSpec for create entry operation
ClosedPublic
Actions

Authored by will on Sep 12 2024, 10:33 PM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Mar 12, 8:28 PM
Unknown Object (File)
Tue, Mar 11, 7:54 PM
Unknown Object (File)
Tue, Mar 11, 9:46 AM
Unknown Object (File)
Wed, Mar 5, 8:16 AM
Unknown Object (File)
Tue, Mar 4, 1:37 PM
Unknown Object (File)
Fri, Feb 28, 5:46 AM
Unknown Object (File)
Fri, Feb 28, 5:46 AM
Unknown Object (File)
Fri, Feb 28, 5:46 AM
View All 84 Files
Subscribers
None

Details

Reviewers
marcin
tomek
ashoat
Commits
rCOMM9d065f191067: [lib] DMOperationSpec for create entry operation
Summary

Create the spec for create entyr operation and getting initial feedback

Depends on D13315

Test Plan

Flow. Testing later in stack

Diff Detail

Repository
rCOMM Comm
Branch
thick-threaded-entries
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

will created this revision.Sep 12 2024, 10:33 PM
Harbormaster completed remote builds in B31583: Diff 44116.Sep 12 2024, 10:50 PM
will requested review of this revision.Sep 12 2024, 10:50 PM
tomek accepted this revision.Sep 13 2024, 2:51 AM
tomek added inline comments.
lib/shared/dm-ops/create-entry-spec.js
75–77

We need to check that the thread exists.

lib/types/dm-ops.js
354–356

It is a bit confusing to see time next to a date because it feels like they represent two parts of the same timestamp. I think we should make it explicit that the date relates to an entry while time to the operation.

This revision is now accepted and ready to land.Sep 13 2024, 2:51 AM
marcin added inline comments.Sep 13 2024, 5:21 AM
lib/shared/dm-ops/create-entry-spec.js
28

Could you please amend the test plan to check for notifs? In order to test notifs simply flip NEXT_CODE_VERSION to 0 and notifs shoudl work automatically.

75

You use methodName() {} syntext here while you use methodName: () => {} syntax for other methods. Could you please, use consistent approach for all methods in this spec? Ideally you would copy the approach that is used in other specs.

ashoat added inline comments.Sep 13 2024, 1:53 PM
lib/shared/dm-ops/create-entry-spec.js
75

Our general approach on picking between these is usually not about consistency in a single file. We opt for methodName() {} when we don't need methodName: () => {} because it's slightly better for performance. We use methodName: () => {} when we want to pass this.methodName somewhere without losing the bound this variable

will updated this revision to Diff 44193.Sep 16 2024, 1:15 AM

rebase

will added a child revision: D13340: [lib] DMOperationSpec for delete entry operation.Sep 16 2024, 1:17 AM
Harbormaster completed remote builds in B31621: Diff 44193.Sep 16 2024, 1:33 AM
Closed by commit rCOMM9d065f191067: [lib] DMOperationSpec for create entry operation (authored by will). · Explain WhySep 16 2024, 2:27 PM
This revision was automatically updated to reflect the committed changes.
will added a commit: rCOMM9d065f191067: [lib] DMOperationSpec for create entry operation.
will marked an inline comment as done.Sep 16 2024, 2:32 PM
will added inline comments.
lib/shared/dm-ops/create-entry-spec.js
75–77

Addressed in rebase

lib/types/dm-ops.js
354–356

Addressed in rebase

will marked an inline comment as done and an inline comment as not done.Sep 16 2024, 3:56 PM
will added inline comments.Sep 16 2024, 3:59 PM
lib/types/dm-ops.js
354–356

Actually, this didn't. Creating a follow up for this: https://linear.app/comm/issue/ENG-9307/rename-create-entry-spec-date-field-to-entrydate-to-avoid-confusing

will added inline comments.Sep 16 2024, 4:01 PM
lib/shared/dm-ops/create-entry-spec.js
28

Addressing in https://linear.app/comm/issue/ENG-9304/verify-notifications-are-working-properly-for-e2ee-entries

Revision Contents
Changeset List

PathSize
lib/
shared/
dm-ops/
81 lines
types/
28 lines

Diff 44116

View Options

lib/shared/dm-ops/create-entry-spec.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { ENSCacheContext } from 'lib/components/ens-cache-provider.react'; import { ENSCacheContext } from 'lib/components/ens-cache-provider.react';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import { createPendingSidebar } from 'lib/shared/thread-utils'; import { createPendingSidebar } from 'lib/shared/thread-utils';
import type { import type {
ComposableMessageInfo, ComposableMessageInfo,
RobotextMessageInfo, RobotextMessageInfo,
} from 'lib/types/message-types'; } from 'lib/types/message-types';
import type { ThreadInfo } from 'lib/types/thread-types'; import type { ThreadInfo, RawThreadInfo } from 'lib/types/thread-types';
import { values } from 'lib/utils/objects';
import { getDefaultTextMessageRules } from '../markdown/rules.react'; import { getDefaultTextMessageRules } from '../markdown/rules.react';
import { updateNavInfoActionType } from '../redux/action-types'; import { updateNavInfoActionType } from '../redux/action-types';
import type { AppState } from '../redux/redux-setup';
import { useSelector } from '../redux/redux-utils'; import { useSelector } from '../redux/redux-utils';
function useOnClickThread( function useOnClickThread(
thread: ?ThreadInfo, thread: ?ThreadInfo,
): (event: SyntheticEvent<HTMLElement>) => void { ): (event: SyntheticEvent<HTMLElement>) => void {
const dispatch = useDispatch(); const dispatch = useDispatch();
return React.useCallback( return React.useCallback(
(event: SyntheticEvent<HTMLElement>) => { (event: SyntheticEvent<HTMLElement>) => {
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines (event: SyntheticEvent<HTMLElement>) => {
selectedUserList: [], selectedUserList: [],
}, },
}); });
}, },
[dispatch], [dispatch],
); );
} }
function filteredCommunityThreadIDs(
communityID: string,
threadInfosObj: { +[id: string]: ThreadInfo | RawThreadInfo },
): $ReadOnlySet<string> {
const threadInfos = values(threadInfosObj);
const threadIDs = threadInfos
.filter(
thread => thread.community === communityID || thread.id === communityID,
)
.map(item => item.id);
return new Set(threadIDs);
}
const filteredCommunityThreadIDsSelector: (
state: AppState,
) => ?$ReadOnlySet<string> = createSelector(
(state: AppState) => state.communityIDFilter,
threadInfoSelector,
(
communityIDFilter: ?string,
threadInfos: { +[id: string]: ThreadInfo },
): ?$ReadOnlySet<string> => {
kamilUnsubmitted
Not Done
Inline Actions

This type could be skipped since it's obvious this will be the same as the return type of the entire selector but I saw in codebase versions with/without type in last callback so deffering to you

kamil: This type could be skipped since it's obvious this will be the same as the return type of the…
if (!communityIDFilter) {
return null;
}
return filteredCommunityThreadIDs(communityIDFilter, threadInfos);
},
);
export { export {
useOnClickThread, useOnClickThread,
useThreadIsActive, useThreadIsActive,
useOnClickPendingSidebar, useOnClickPendingSidebar,
useOnClickNewThread, useOnClickNewThread,
filteredCommunityThreadIDsSelector,
filteredCommunityThreadIDs,
}; };
View Options

lib/types/dm-ops.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { ENSCacheContext } from 'lib/components/ens-cache-provider.react'; import { ENSCacheContext } from 'lib/components/ens-cache-provider.react';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import { createPendingSidebar } from 'lib/shared/thread-utils'; import { createPendingSidebar } from 'lib/shared/thread-utils';
import type { import type {
ComposableMessageInfo, ComposableMessageInfo,
RobotextMessageInfo, RobotextMessageInfo,
} from 'lib/types/message-types'; } from 'lib/types/message-types';
import type { ThreadInfo } from 'lib/types/thread-types'; import type { ThreadInfo, RawThreadInfo } from 'lib/types/thread-types';
import { values } from 'lib/utils/objects';
import { getDefaultTextMessageRules } from '../markdown/rules.react'; import { getDefaultTextMessageRules } from '../markdown/rules.react';
import { updateNavInfoActionType } from '../redux/action-types'; import { updateNavInfoActionType } from '../redux/action-types';
import type { AppState } from '../redux/redux-setup';
import { useSelector } from '../redux/redux-utils'; import { useSelector } from '../redux/redux-utils';
function useOnClickThread( function useOnClickThread(
thread: ?ThreadInfo, thread: ?ThreadInfo,
): (event: SyntheticEvent<HTMLElement>) => void { ): (event: SyntheticEvent<HTMLElement>) => void {
const dispatch = useDispatch(); const dispatch = useDispatch();
return React.useCallback( return React.useCallback(
(event: SyntheticEvent<HTMLElement>) => { (event: SyntheticEvent<HTMLElement>) => {
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines (event: SyntheticEvent<HTMLElement>) => {
selectedUserList: [], selectedUserList: [],
}, },
}); });
}, },
[dispatch], [dispatch],
); );
} }
function filteredCommunityThreadIDs(
communityID: string,
threadInfosObj: { +[id: string]: ThreadInfo | RawThreadInfo },
): $ReadOnlySet<string> {
const threadInfos = values(threadInfosObj);
const threadIDs = threadInfos
.filter(
thread => thread.community === communityID || thread.id === communityID,
)
.map(item => item.id);
return new Set(threadIDs);
}
const filteredCommunityThreadIDsSelector: (
state: AppState,
) => ?$ReadOnlySet<string> = createSelector(
(state: AppState) => state.communityIDFilter,
threadInfoSelector,
(
communityIDFilter: ?string,
threadInfos: { +[id: string]: ThreadInfo },
): ?$ReadOnlySet<string> => {
kamilUnsubmitted
Not Done
Inline Actions

This type could be skipped since it's obvious this will be the same as the return type of the entire selector but I saw in codebase versions with/without type in last callback so deffering to you

kamil: This type could be skipped since it's obvious this will be the same as the return type of the…
if (!communityIDFilter) {
return null;
}
return filteredCommunityThreadIDs(communityIDFilter, threadInfos);
},
);
export { export {
useOnClickThread, useOnClickThread,
useThreadIsActive, useThreadIsActive,
useOnClickPendingSidebar, useOnClickPendingSidebar,
useOnClickNewThread, useOnClickNewThread,
filteredCommunityThreadIDsSelector,
filteredCommunityThreadIDs,
}; };