Paths

Table of Contentst

-
lib/
-
actions/
1
activity-actions.js
-
reducers/
1
connection-reducer.js
1
keyserver-reducer.js
-
socket/
1
activity-handler.react.js
-
socket.react.js
-
types/
-
activity-types.js
-
redux-types.js
-
socket-types.js

[lib] Inline reduceConnectionInfo pt.1
ClosedPublic
Actions

Authored by inka on Nov 9 2023, 7:30 AM.

Details

Reviewers

michal
kamil
ginsu

Commits

rCOMMdb03af5eaae3: [lib] Inline reduceConnectionInfo pt.1

Summary

issue: https://linear.app/comm/issue/ENG-5352/inline-reduceconnectioninfo
This reducer is big, so I will do this in two parts. Some actions needed to have their payloads updated.

Socket is keyserver specific. ActivityHandler is only used in socket, so it is also keyserver specific

Test Plan

Dispatched updateConnectionStatusActionType, queueActivityUpdatesActionType, updateActivityActionTypes.success action and checked that the store is updated as expected. Assuming that unsupervisedBackgroundActionType works by symmetry with updateConnectionStatusActionType
Ran yarn flow-all

Diff Detail

Repository

rCOMM Comm

Branch

inka/reducers

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

inka created this revision.Nov 9 2023, 7:30 AM

Herald added subscribers: will, tomek, ashoat. · View Herald TranscriptNov 9 2023, 7:30 AM

inka added a parent revision: D9764: [lib] Inline reduceLastCommunicatedPlatformDetails.Nov 9 2023, 7:30 AM

inka edited the summary of this revision. (Show Details)

Harbormaster completed remote builds in B23963: Diff 33015.Nov 9 2023, 7:48 AM

inka requested review of this revision.Nov 9 2023, 7:48 AM

inka added a child revision: D9815: [lib] Inline reduceConnectionInfo pt.2.Nov 10 2023, 3:43 AM

michal accepted this revision.Nov 14 2023, 5:25 AM

michal added inline comments.

lib/actions/activity-actions.js
46	nit

This revision is now accepted and ready to land.Nov 14 2023, 5:25 AM

Address review

Harbormaster completed remote builds in B24114: Diff 33214.Nov 14 2023, 7:43 AM

Closed by commit rCOMMdb03af5eaae3: [lib] Inline reduceConnectionInfo pt.1 (authored by inka). · Explain WhyNov 22 2023, 7:24 AM

This revision was automatically updated to reflect the committed changes.

inka added a commit: rCOMMdb03af5eaae3: [lib] Inline reduceConnectionInfo pt.1.

Revision Contents
Changeset List

Path

Size

lib/

actions/

activity-actions.js

8 lines

reducers/

connection-reducer.js

39 lines

keyserver-reducer.js

91 lines

socket/

activity-handler.react.js

2 lines

socket.react.js

19 lines

types/

activity-types.js

3 lines

redux-types.js

2 lines

socket-types.js

1 line

Diff 33015

View Options

lib/actions/activity-actions.js

// @flow

import _memoize from 'lodash/memoize.js';

import * as React from 'react';

import { useDispatch } from 'react-redux';

import { createSelector } from 'reselect';

import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint.js';

import type { BindServerCallsParams } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint';

import { useSelector } from './redux-utils.js';

import type { PlatformDetails } from '../types/device-types.js';

import type { Endpoint } from '../types/endpoints.js';

import type { KeyserverInfo } from '../types/keyserver-types.js';

import type { Dispatch } from '../types/redux-types.js';

import type { ConnectionStatus } from '../types/socket-types.js';

import type { CurrentUserInfo } from '../types/user-types.js';

export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (

endpoint: Endpoint,

input: any,

args: Args,

options?: ?CallServerEndpointOptions,

) => Promise<any>;

Show All 9 Lines

| {

+keyserverIDExtractor: (...Args) => string,

};

export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {

+actionFunc: ActionFunc<Args, Return>,

+config: KeyserverCallConfig<Args>,

};

export type ExtractAndBindCookieAndUtilsParams<

const boundCallServerEndpointSelector = createSelector(

Args: $ReadOnlyArray<mixed>,

(state: BindServerCallsParams) => state.dispatch,

Return,

(state: BindServerCallsParams) => state.cookie,

> = {

(state: BindServerCallsParams) => state.urlPrefix,

(state: BindServerCallsParams) => state.sessionID,

(state: BindServerCallsParams) => state.currentUserInfo,

(state: BindServerCallsParams) => state.connectionStatus,

(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,

(

dispatch: Dispatch,

cookie: ?string,

urlPrefix: string,

sessionID: ?string,

currentUserInfo: ?CurrentUserInfo,

connectionStatus: ConnectionStatus,

lastCommunicatedPlatformDetails: ?PlatformDetails,

) => {

return bindCookieAndUtilsIntoCallServerEndpoint({

dispatch,

cookie,

urlPrefix,

sessionID,

currentUserInfo,

connectionStatus,

lastCommunicatedPlatformDetails,

});

ashoatUnsubmitted

Not Done

lastCommunicatedPlatformDetails: ?PlatformDetails,

- ) => {

- return bindCookieAndUtilsIntoCallServerEndpoint({

- dispatch,

- cookie,

- urlPrefix,

- sessionID,

- currentUserInfo,

- connectionStatus,

- lastCommunicatedPlatformDetails,

- });

- },

+ ) => bindCookieAndUtilsIntoCallServerEndpoint({

+ dispatch,

+ cookie,

+ urlPrefix,

+ sessionID,

+ currentUserInfo,

+ connectionStatus,

+ lastCommunicatedPlatformDetails,

+ }),

);

export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand

);

export type BindKeyserverCallParams = {

+dispatch: Dispatch,

+currentUserInfo: ?CurrentUserInfo,

+keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

+keyserverCall: KeyserverCall<Args, Return>,

};

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>(

export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {

params: ExtractAndBindCookieAndUtilsParams<Args, Return>,

...BindKeyserverCallParams,

): CallKeyserverEndpoint<Args> {

+keyserverCallConfig: KeyserverCallConfig<Args>,

const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params;

};

const { config: serverCallConfig } = keyserverCall;

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(

params: GetCallKeyserverEndpointParams<Args>,

): CallKeyserverEndpoint<Args> {

const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =

params;

return (

endpoint: Endpoint,

data: Object,

args: Args,

options?: ?CallServerEndpointOptions,

) => {

// TODO

if (serverCallConfig.keyserverSelection === 'fanout') {

if (keyserverCallConfig.keyserverSelection === 'fanout') {

return Promise.all([]);

}

const keyserverID = serverCallConfig.keyserverIDExtractor(...args);

const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);

const {

cookie,

urlPrefix,

sessionID,

connection,

lastCommunicatedPlatformDetails,

} = keyserverInfos[keyserverID];

const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({

const boundCallServerEndpoint = boundCallServerEndpointSelector({

dispatch,

currentUserInfo,

cookie,

urlPrefix,

sessionID,

connectionStatus: connection.status,

lastCommunicatedPlatformDetails,

});

return boundCallServerEndpoint(endpoint, data, options);

};

}

const baseCreateBoundKeyserverCallActionSelector = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>

createSelector(

(state: BindKeyserverCallParams) => state.dispatch,

(state: BindKeyserverCallParams) => state.currentUserInfo,

(state: BindKeyserverCallParams) => state.keyserverInfos,

(

dispatch: Dispatch,

currentUserInfo: ?CurrentUserInfo,

keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

) => {

const callKeyserverEndpoint = getCallKeyserverEndpoint({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCallConfig: keyserverCall.config,

});

return keyserverCall.actionFunc(callKeyserverEndpoint);

);

type CreateBoundKeyserverCallActionSelectorType = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

) => BindKeyserverCallParams => (...Args) => Promise<Return>;

const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =

_memoize(baseCreateBoundKeyserverCallActionSelector);

function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(

keyserverCall: KeyserverCall<Args, Return>,

paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>,

paramOverride?: ?$Shape<BindKeyserverCallParams>,

): (...Args) => Promise<Return> {

const dispatch = useDispatch();

const keyserverInfos = useSelector(

state => state.keyserverStore.keyserverInfos,

);

const currentUserInfo = useSelector(state => state.currentUserInfo);

return React.useMemo(() => {

return React.useMemo(

const callKeyserverEndpoint = getCallKeyserverEndpoint({

() =>

createBoundKeyserverCallActionSelector(keyserverCall)({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCall,

...paramOverride,

});

}),

return keyserverCall.actionFunc(callKeyserverEndpoint);

}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]);

[dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],

);

}

export { useKeyserverCall };

View Options

lib/reducers/connection-reducer.js

// @flow

import _memoize from 'lodash/memoize.js';

import * as React from 'react';

import { useDispatch } from 'react-redux';

import { createSelector } from 'reselect';

import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint.js';

import type { BindServerCallsParams } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint';

import { useSelector } from './redux-utils.js';

import type { PlatformDetails } from '../types/device-types.js';

import type { Endpoint } from '../types/endpoints.js';

import type { KeyserverInfo } from '../types/keyserver-types.js';

import type { Dispatch } from '../types/redux-types.js';

import type { ConnectionStatus } from '../types/socket-types.js';

import type { CurrentUserInfo } from '../types/user-types.js';

export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (

endpoint: Endpoint,

input: any,

args: Args,

options?: ?CallServerEndpointOptions,

) => Promise<any>;

Show All 9 Lines

| {

+keyserverIDExtractor: (...Args) => string,

};

export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {

+actionFunc: ActionFunc<Args, Return>,

+config: KeyserverCallConfig<Args>,

};

export type ExtractAndBindCookieAndUtilsParams<

const boundCallServerEndpointSelector = createSelector(

Args: $ReadOnlyArray<mixed>,

(state: BindServerCallsParams) => state.dispatch,

Return,

(state: BindServerCallsParams) => state.cookie,

> = {

(state: BindServerCallsParams) => state.urlPrefix,

(state: BindServerCallsParams) => state.sessionID,

(state: BindServerCallsParams) => state.currentUserInfo,

(state: BindServerCallsParams) => state.connectionStatus,

(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,

(

dispatch: Dispatch,

cookie: ?string,

urlPrefix: string,

sessionID: ?string,

currentUserInfo: ?CurrentUserInfo,

connectionStatus: ConnectionStatus,

lastCommunicatedPlatformDetails: ?PlatformDetails,

) => {

return bindCookieAndUtilsIntoCallServerEndpoint({

dispatch,

cookie,

urlPrefix,

sessionID,

currentUserInfo,

connectionStatus,

lastCommunicatedPlatformDetails,

});

ashoatUnsubmitted

Not Done

lastCommunicatedPlatformDetails: ?PlatformDetails,

- ) => {

- return bindCookieAndUtilsIntoCallServerEndpoint({

- dispatch,

- cookie,

- urlPrefix,

- sessionID,

- currentUserInfo,

- connectionStatus,

- lastCommunicatedPlatformDetails,

- });

- },

+ ) => bindCookieAndUtilsIntoCallServerEndpoint({

+ dispatch,

+ cookie,

+ urlPrefix,

+ sessionID,

+ currentUserInfo,

+ connectionStatus,

+ lastCommunicatedPlatformDetails,

+ }),

);

export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand

);

export type BindKeyserverCallParams = {

+dispatch: Dispatch,

+currentUserInfo: ?CurrentUserInfo,

+keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

+keyserverCall: KeyserverCall<Args, Return>,

};

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>(

export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {

params: ExtractAndBindCookieAndUtilsParams<Args, Return>,

...BindKeyserverCallParams,

): CallKeyserverEndpoint<Args> {

+keyserverCallConfig: KeyserverCallConfig<Args>,

const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params;

};

const { config: serverCallConfig } = keyserverCall;

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(

params: GetCallKeyserverEndpointParams<Args>,

): CallKeyserverEndpoint<Args> {

const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =

params;

return (

endpoint: Endpoint,

data: Object,

args: Args,

options?: ?CallServerEndpointOptions,

) => {

// TODO

if (serverCallConfig.keyserverSelection === 'fanout') {

if (keyserverCallConfig.keyserverSelection === 'fanout') {

return Promise.all([]);

}

const keyserverID = serverCallConfig.keyserverIDExtractor(...args);

const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);

const {

cookie,

urlPrefix,

sessionID,

connection,

lastCommunicatedPlatformDetails,

} = keyserverInfos[keyserverID];

const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({

const boundCallServerEndpoint = boundCallServerEndpointSelector({

dispatch,

currentUserInfo,

cookie,

urlPrefix,

sessionID,

connectionStatus: connection.status,

lastCommunicatedPlatformDetails,

});

return boundCallServerEndpoint(endpoint, data, options);

};

}

const baseCreateBoundKeyserverCallActionSelector = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>

createSelector(

(state: BindKeyserverCallParams) => state.dispatch,

(state: BindKeyserverCallParams) => state.currentUserInfo,

(state: BindKeyserverCallParams) => state.keyserverInfos,

(

dispatch: Dispatch,

currentUserInfo: ?CurrentUserInfo,

keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

) => {

const callKeyserverEndpoint = getCallKeyserverEndpoint({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCallConfig: keyserverCall.config,

});

return keyserverCall.actionFunc(callKeyserverEndpoint);

);

type CreateBoundKeyserverCallActionSelectorType = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

) => BindKeyserverCallParams => (...Args) => Promise<Return>;

const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =

_memoize(baseCreateBoundKeyserverCallActionSelector);

function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(

keyserverCall: KeyserverCall<Args, Return>,

paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>,

paramOverride?: ?$Shape<BindKeyserverCallParams>,

): (...Args) => Promise<Return> {

const dispatch = useDispatch();

const keyserverInfos = useSelector(

state => state.keyserverStore.keyserverInfos,

);

const currentUserInfo = useSelector(state => state.currentUserInfo);

return React.useMemo(() => {

return React.useMemo(

const callKeyserverEndpoint = getCallKeyserverEndpoint({

() =>

createBoundKeyserverCallActionSelector(keyserverCall)({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCall,

...paramOverride,

});

}),

return keyserverCall.actionFunc(callKeyserverEndpoint);

}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]);

[dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],

);

}

export { useKeyserverCall };

View Options

lib/reducers/keyserver-reducer.js

// @flow

import _memoize from 'lodash/memoize.js';

import * as React from 'react';

import { useDispatch } from 'react-redux';

import { createSelector } from 'reselect';

import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint.js';

import type { BindServerCallsParams } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint';

import { useSelector } from './redux-utils.js';

import type { PlatformDetails } from '../types/device-types.js';

import type { Endpoint } from '../types/endpoints.js';

import type { KeyserverInfo } from '../types/keyserver-types.js';

import type { Dispatch } from '../types/redux-types.js';

import type { ConnectionStatus } from '../types/socket-types.js';

import type { CurrentUserInfo } from '../types/user-types.js';

export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (

endpoint: Endpoint,

input: any,

args: Args,

options?: ?CallServerEndpointOptions,

) => Promise<any>;

Show All 9 Lines

| {

+keyserverIDExtractor: (...Args) => string,

};

export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {

+actionFunc: ActionFunc<Args, Return>,

+config: KeyserverCallConfig<Args>,

};

export type ExtractAndBindCookieAndUtilsParams<

const boundCallServerEndpointSelector = createSelector(

Args: $ReadOnlyArray<mixed>,

(state: BindServerCallsParams) => state.dispatch,

Return,

(state: BindServerCallsParams) => state.cookie,

> = {

(state: BindServerCallsParams) => state.urlPrefix,

(state: BindServerCallsParams) => state.sessionID,

(state: BindServerCallsParams) => state.currentUserInfo,

(state: BindServerCallsParams) => state.connectionStatus,

(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,

(

dispatch: Dispatch,

cookie: ?string,

urlPrefix: string,

sessionID: ?string,

currentUserInfo: ?CurrentUserInfo,

connectionStatus: ConnectionStatus,

lastCommunicatedPlatformDetails: ?PlatformDetails,

) => {

return bindCookieAndUtilsIntoCallServerEndpoint({

dispatch,

cookie,

urlPrefix,

sessionID,

currentUserInfo,

connectionStatus,

lastCommunicatedPlatformDetails,

});

ashoatUnsubmitted

Not Done

lastCommunicatedPlatformDetails: ?PlatformDetails,

- ) => {

- return bindCookieAndUtilsIntoCallServerEndpoint({

- dispatch,

- cookie,

- urlPrefix,

- sessionID,

- currentUserInfo,

- connectionStatus,

- lastCommunicatedPlatformDetails,

- });

- },

+ ) => bindCookieAndUtilsIntoCallServerEndpoint({

+ dispatch,

+ cookie,

+ urlPrefix,

+ sessionID,

+ currentUserInfo,

+ connectionStatus,

+ lastCommunicatedPlatformDetails,

+ }),

);

export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand

);

export type BindKeyserverCallParams = {

+dispatch: Dispatch,

+currentUserInfo: ?CurrentUserInfo,

+keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

+keyserverCall: KeyserverCall<Args, Return>,

};

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>(

export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {

params: ExtractAndBindCookieAndUtilsParams<Args, Return>,

...BindKeyserverCallParams,

): CallKeyserverEndpoint<Args> {

+keyserverCallConfig: KeyserverCallConfig<Args>,

const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params;

};

const { config: serverCallConfig } = keyserverCall;

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(

params: GetCallKeyserverEndpointParams<Args>,

): CallKeyserverEndpoint<Args> {

const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =

params;

return (

endpoint: Endpoint,

data: Object,

args: Args,

options?: ?CallServerEndpointOptions,

) => {

// TODO

if (serverCallConfig.keyserverSelection === 'fanout') {

if (keyserverCallConfig.keyserverSelection === 'fanout') {

return Promise.all([]);

}

const keyserverID = serverCallConfig.keyserverIDExtractor(...args);

const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);

const {

cookie,

urlPrefix,

sessionID,

connection,

lastCommunicatedPlatformDetails,

} = keyserverInfos[keyserverID];

const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({

const boundCallServerEndpoint = boundCallServerEndpointSelector({

dispatch,

currentUserInfo,

cookie,

urlPrefix,

sessionID,

connectionStatus: connection.status,

lastCommunicatedPlatformDetails,

});

return boundCallServerEndpoint(endpoint, data, options);

};

}

const baseCreateBoundKeyserverCallActionSelector = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>

createSelector(

(state: BindKeyserverCallParams) => state.dispatch,

(state: BindKeyserverCallParams) => state.currentUserInfo,

(state: BindKeyserverCallParams) => state.keyserverInfos,

(

dispatch: Dispatch,

currentUserInfo: ?CurrentUserInfo,

keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

) => {

const callKeyserverEndpoint = getCallKeyserverEndpoint({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCallConfig: keyserverCall.config,

});

return keyserverCall.actionFunc(callKeyserverEndpoint);

);

type CreateBoundKeyserverCallActionSelectorType = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

) => BindKeyserverCallParams => (...Args) => Promise<Return>;

const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =

_memoize(baseCreateBoundKeyserverCallActionSelector);

function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(

keyserverCall: KeyserverCall<Args, Return>,

paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>,

paramOverride?: ?$Shape<BindKeyserverCallParams>,

): (...Args) => Promise<Return> {

const dispatch = useDispatch();

const keyserverInfos = useSelector(

state => state.keyserverStore.keyserverInfos,

);

const currentUserInfo = useSelector(state => state.currentUserInfo);

return React.useMemo(() => {

return React.useMemo(

const callKeyserverEndpoint = getCallKeyserverEndpoint({

() =>

createBoundKeyserverCallActionSelector(keyserverCall)({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCall,

...paramOverride,

});

}),

return keyserverCall.actionFunc(callKeyserverEndpoint);

}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]);

[dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],

);

}

export { useKeyserverCall };

View Options

lib/socket/activity-handler.react.js

// @flow

import _memoize from 'lodash/memoize.js';

import * as React from 'react';

import { useDispatch } from 'react-redux';

import { createSelector } from 'reselect';

import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint.js';

import type { BindServerCallsParams } from './action-utils.js';

import type { CallServerEndpointOptions } from './call-server-endpoint';

import { useSelector } from './redux-utils.js';

import type { PlatformDetails } from '../types/device-types.js';

import type { Endpoint } from '../types/endpoints.js';

import type { KeyserverInfo } from '../types/keyserver-types.js';

import type { Dispatch } from '../types/redux-types.js';

import type { ConnectionStatus } from '../types/socket-types.js';

import type { CurrentUserInfo } from '../types/user-types.js';

export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (

endpoint: Endpoint,

input: any,

args: Args,

options?: ?CallServerEndpointOptions,

) => Promise<any>;

Show All 9 Lines

| {

+keyserverIDExtractor: (...Args) => string,

};

export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {

+actionFunc: ActionFunc<Args, Return>,

+config: KeyserverCallConfig<Args>,

};

export type ExtractAndBindCookieAndUtilsParams<

const boundCallServerEndpointSelector = createSelector(

Args: $ReadOnlyArray<mixed>,

(state: BindServerCallsParams) => state.dispatch,

Return,

(state: BindServerCallsParams) => state.cookie,

> = {

(state: BindServerCallsParams) => state.urlPrefix,

(state: BindServerCallsParams) => state.sessionID,

(state: BindServerCallsParams) => state.currentUserInfo,

(state: BindServerCallsParams) => state.connectionStatus,

(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,

(

dispatch: Dispatch,

cookie: ?string,

urlPrefix: string,

sessionID: ?string,

currentUserInfo: ?CurrentUserInfo,

connectionStatus: ConnectionStatus,

lastCommunicatedPlatformDetails: ?PlatformDetails,

) => {

return bindCookieAndUtilsIntoCallServerEndpoint({

dispatch,

cookie,

urlPrefix,

sessionID,

currentUserInfo,

connectionStatus,

lastCommunicatedPlatformDetails,

});

ashoatUnsubmitted

Not Done

lastCommunicatedPlatformDetails: ?PlatformDetails,

- ) => {

- return bindCookieAndUtilsIntoCallServerEndpoint({

- dispatch,

- cookie,

- urlPrefix,

- sessionID,

- currentUserInfo,

- connectionStatus,

- lastCommunicatedPlatformDetails,

- });

- },

+ ) => bindCookieAndUtilsIntoCallServerEndpoint({

+ dispatch,

+ cookie,

+ urlPrefix,

+ sessionID,

+ currentUserInfo,

+ connectionStatus,

+ lastCommunicatedPlatformDetails,

+ }),

);

export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand

);

export type BindKeyserverCallParams = {

+dispatch: Dispatch,

+currentUserInfo: ?CurrentUserInfo,

+keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

+keyserverCall: KeyserverCall<Args, Return>,

};

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>(

export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {

params: ExtractAndBindCookieAndUtilsParams<Args, Return>,

...BindKeyserverCallParams,

): CallKeyserverEndpoint<Args> {

+keyserverCallConfig: KeyserverCallConfig<Args>,

const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params;

};

const { config: serverCallConfig } = keyserverCall;

function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(

params: GetCallKeyserverEndpointParams<Args>,

): CallKeyserverEndpoint<Args> {

const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =

params;

return (

endpoint: Endpoint,

data: Object,

args: Args,

options?: ?CallServerEndpointOptions,

) => {

// TODO

if (serverCallConfig.keyserverSelection === 'fanout') {

if (keyserverCallConfig.keyserverSelection === 'fanout') {

return Promise.all([]);

}

const keyserverID = serverCallConfig.keyserverIDExtractor(...args);

const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);

const {

cookie,

urlPrefix,

sessionID,

connection,

lastCommunicatedPlatformDetails,

} = keyserverInfos[keyserverID];

const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({

const boundCallServerEndpoint = boundCallServerEndpointSelector({

dispatch,

currentUserInfo,

cookie,

urlPrefix,

sessionID,

connectionStatus: connection.status,

lastCommunicatedPlatformDetails,

});

return boundCallServerEndpoint(endpoint, data, options);

};

}

const baseCreateBoundKeyserverCallActionSelector = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>

createSelector(

(state: BindKeyserverCallParams) => state.dispatch,

(state: BindKeyserverCallParams) => state.currentUserInfo,

(state: BindKeyserverCallParams) => state.keyserverInfos,

(

dispatch: Dispatch,

currentUserInfo: ?CurrentUserInfo,

keyserverInfos: { +[keyserverID: string]: KeyserverInfo },

) => {

const callKeyserverEndpoint = getCallKeyserverEndpoint({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCallConfig: keyserverCall.config,

});

return keyserverCall.actionFunc(callKeyserverEndpoint);

);

type CreateBoundKeyserverCallActionSelectorType = <

Args: $ReadOnlyArray<mixed>,

Return,

keyserverCall: KeyserverCall<Args, Return>,

) => BindKeyserverCallParams => (...Args) => Promise<Return>;

const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =

_memoize(baseCreateBoundKeyserverCallActionSelector);

function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(

keyserverCall: KeyserverCall<Args, Return>,

paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>,

paramOverride?: ?$Shape<BindKeyserverCallParams>,

): (...Args) => Promise<Return> {

const dispatch = useDispatch();

const keyserverInfos = useSelector(

state => state.keyserverStore.keyserverInfos,

);

const currentUserInfo = useSelector(state => state.currentUserInfo);

return React.useMemo(() => {

return React.useMemo(

const callKeyserverEndpoint = getCallKeyserverEndpoint({

() =>

createBoundKeyserverCallActionSelector(keyserverCall)({

dispatch,

currentUserInfo,

keyserverInfos,

keyserverCall,

...paramOverride,

});

}),

return keyserverCall.actionFunc(callKeyserverEndpoint);

}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]);

[dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],

);

}

export { useKeyserverCall };

View Options

lib/socket/socket.react.js

View Options

lib/types/activity-types.js

View Options

lib/types/redux-types.js

View Options

[lib] Inline reduceConnectionInfo pt.1ClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 33015

lib/actions/activity-actions.js

lib/reducers/connection-reducer.js

lib/reducers/keyserver-reducer.js

lib/socket/activity-handler.react.js

lib/socket/socket.react.js

lib/types/activity-types.js

lib/types/redux-types.js

lib/types/socket-types.js

[lib] Inline reduceConnectionInfo pt.1
ClosedPublic
Actions

Revision Contents
Changeset List