if (
  action.type === logInActionTypes.success ||
  action.type === siweAuthActionTypes.success ||
  action.type === keyserverRegisterActionTypes.success ||
  action.type === fullStateSyncActionType ||
  (action.type === setClientDBStoreActionType &&
    !!action.payload.threadStore &&
    state.threadHashingStatus !== 'completed')
) {
  return { threadHashes: {}, threadHashingStatus: 'starting' };
} else if (action.type === keyserverAuthActionTypes.success) {
  return { ...state, threadHashingStatus: 'starting' };
}

These currently just return either the current state or an empty threadHashes object. Do we have to refactor this in anyway with sqlite ops or is it fine as is?

will retitled this revision from [sqlite] [lib] refactor integrity reducer add new thread hashes to use sqlite ops to [lib] refactor integrity reducer add new thread hashes to use sqlite ops.Mar 11 2024, 3:11 PM

kamil accepted this revision.Mar 12 2024, 9:42 AM

kamil added a reviewer: michal.

In D11287#326127, @will wrote:
The reduceIntegrityStore function starts with:
if (
  action.type === logInActionTypes.success ||
  action.type === siweAuthActionTypes.success ||
  action.type === keyserverRegisterActionTypes.success ||
  action.type === fullStateSyncActionType ||
  (action.type === setClientDBStoreActionType &&
    !!action.payload.threadStore &&
    state.threadHashingStatus !== 'completed')
) {
  return { threadHashes: {}, threadHashingStatus: 'starting' };
} else if (action.type === keyserverAuthActionTypes.success) {
  return { ...state, threadHashingStatus: 'starting' };
}
These currently just return either the current state or an empty threadHashes object. Do we have to refactor this in anyway with sqlite ops or is it fine as is?

If it returns empty object we should generate remove_all_integrity_thread_hashes operation - you could do it in a separate diff

If it returns empty object we should generate remove_all_integrity_thread_hashes operation - you could do it in a separate diff

Agree.

This revision is now accepted and ready to land.Mar 13 2024, 4:20 AM

will mentioned this in D11322: refactor integrity reducer starting state to use processStoreOps.Mar 13 2024, 11:33 PM

Closed by commit rCOMM7f4bc14754de: [lib] refactor integrity reducer add new thread hashes to use sqlite ops (authored by will). · Explain WhyMar 25 2024, 2:10 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM7f4bc14754de: [lib] refactor integrity reducer add new thread hashes to use sqlite ops.

will mentioned this in rCOMM2107c0a14ea4: refactor integrity reducer starting state to use processStoreOps.

Revision Contents
Changeset List

Path

Size

lib/

reducers/

integrity-reducer.js

15 lines

Diff 37977

View Options

lib/reducers/integrity-reducer.js

This file was copied to lib/keyserver-conn/call-keyserver-endpoint-provider.react.js.

// @flow		// @flow

import invariant from 'invariant';		import invariant from 'invariant';
import _memoize from 'lodash/memoize.js';
import * as React from 'react';		import * as React from 'react';
import { createSelector } from 'reselect';

import callServerEndpoint from './call-server-endpoint.js';
import type {
CallServerEndpoint,
CallServerEndpointOptions,
} from './call-server-endpoint.js';
import { useSelector, useDispatch } from './redux-utils.js';		import { useSelector, useDispatch } from './redux-utils.js';
import { ashoatKeyserverID } from './validation-utils.js';		import { ashoatKeyserverID } from './validation-utils.js';
import { setNewSession } from '../keyserver-conn/keyserver-conn-types.js';
import {		import {
canResolveKeyserverSessionInvalidation,		type ActionFunc,
resolveKeyserverSessionInvalidation,		type BindServerCallsParams,
} from '../keyserver-conn/recovery-utils.js';		createBoundServerCallsSelector,
		} from '../keyserver-conn/call-keyserver-endpoint-provider.react.js';
import { serverCallStateSelector } from '../selectors/server-calls.js';		import { serverCallStateSelector } from '../selectors/server-calls.js';
import { logInActionSources } from '../types/account-types.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
import type { Dispatch } from '../types/redux-types.js';
import type { ClientSessionChange } from '../types/session-types.js';
import type { CurrentUserInfo } from '../types/user-types.js';

let currentlyWaitingForNewCookie = false;
let serverEndpointCallsWaitingForNewCookie: ((
callServerEndpoint: ?CallServerEndpoint,
) => void)[] = [];

// Third param is optional and gets called with newCookie if we get a new cookie
// Necessary to propagate cookie in cookieInvalidationRecovery below
function bindCookieAndUtilsIntoCallServerEndpoint(
params: BindServerCallsParams,
): CallServerEndpoint {
const {
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
isSocketConnected,
lastCommunicatedPlatformDetails,
keyserverID,
} = params;
const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
const boundSetNewSession = (
sessionChange: ClientSessionChange,
error: ?string,
) =>
setNewSession(
dispatch,
sessionChange,
{
currentUserInfo,
cookiesAndSessions: { [keyserverID]: { cookie, sessionID } },
},
error,
undefined,
keyserverID,
);
const canResolveInvalidation = canResolveKeyserverSessionInvalidation();
// This function gets called before callServerEndpoint sends a request,
// to make sure that we're not in the middle of trying to recover
// an invalidated cookie
const waitIfCookieInvalidated = () => {
if (!canResolveInvalidation) {
// If there is no way to resolve the session invalidation,
// just let the caller callServerEndpoint instance continue
return Promise.resolve(null);
}
if (!currentlyWaitingForNewCookie) {
// Our cookie seems to be valid
return Promise.resolve(null);
}
// Wait to run until we get our new cookie
return new Promise<?CallServerEndpoint>(r =>
serverEndpointCallsWaitingForNewCookie.push(r),
);
};
// This function is a helper for the next function defined below
const attemptToResolveInvalidation = async (
sessionChange: ClientSessionChange,
) => {
const newAnonymousCookie = sessionChange.cookie;
const newSessionChange = await resolveKeyserverSessionInvalidation(
dispatch,
newAnonymousCookie,
urlPrefix,
logInActionSources.cookieInvalidationResolutionAttempt,
keyserverID,
);

currentlyWaitingForNewCookie = false;
const currentWaitingCalls = serverEndpointCallsWaitingForNewCookie;
serverEndpointCallsWaitingForNewCookie = [];

const newCallServerEndpoint = newSessionChange
? bindCookieAndUtilsIntoCallServerEndpoint({
...params,
cookie: newSessionChange.cookie,
sessionID: newSessionChange.sessionID,
currentUserInfo: newSessionChange.currentUserInfo,
})
: null;
for (const func of currentWaitingCalls) {
func(newCallServerEndpoint);
}
return newCallServerEndpoint;
};
// If this function is called, callServerEndpoint got a response invalidating
// its cookie, and is wondering if it should just like... give up?
// Or if there's a chance at redemption
const cookieInvalidationRecovery = (sessionChange: ClientSessionChange) => {
if (!canResolveInvalidation) {
// If there is no way to resolve the session invalidation,
// just let the caller callServerEndpoint instance continue
return Promise.resolve(null);
}
if (!loggedIn) {
// We don't want to attempt any use native credentials of a logged out
// user to log-in after a cookieInvalidation while logged out
return Promise.resolve(null);
}
if (currentlyWaitingForNewCookie) {
return new Promise<?CallServerEndpoint>(r =>
serverEndpointCallsWaitingForNewCookie.push(r),
);
}
currentlyWaitingForNewCookie = true;
return attemptToResolveInvalidation(sessionChange);
};

return (
endpoint: Endpoint,
data: Object,
options?: ?CallServerEndpointOptions,
) =>
callServerEndpoint(
cookie,
boundSetNewSession,
waitIfCookieInvalidated,
cookieInvalidationRecovery,
urlPrefix,
sessionID,
isSocketConnected,
lastCommunicatedPlatformDetails,
socketAPIHandler,
endpoint,
data,
dispatch,
options,
loggedIn,
keyserverID,
);
}

export type ActionFunc<F> = (callServerEndpoint: CallServerEndpoint) => F;
export type BindServerCall = <F>(serverCall: ActionFunc<F>) => F;
export type BindServerCallsParams = {
+dispatch: Dispatch,
+cookie: ?string,
+urlPrefix: string,
+sessionID: ?string,
+currentUserInfo: ?CurrentUserInfo,
+isSocketConnected: boolean,
+lastCommunicatedPlatformDetails: ?PlatformDetails,
+keyserverID: string,
};

// All server calls needs to include some information from the Redux state
// (namely, the cookie). This information is used deep in the server call,
// at the point where callServerEndpoint is called. We don't want to bother
// propagating the cookie (and any future config info that callServerEndpoint
// needs) through to the server calls so they can pass it to callServerEndpoint.
// Instead, we "curry" the cookie onto callServerEndpoint within react-redux's
// connect's mapStateToProps function, and then pass that "bound"
// callServerEndpoint that no longer needs the cookie as a parameter on to
// the server call.
const baseCreateBoundServerCallsSelector = <F>(
actionFunc: ActionFunc<F>,
): (BindServerCallsParams => F) =>
createSelector(
(state: BindServerCallsParams) => state.dispatch,
(state: BindServerCallsParams) => state.cookie,
(state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.isSocketConnected,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(state: BindServerCallsParams) => state.keyserverID,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
isSocketConnected: boolean,
lastCommunicatedPlatformDetails: ?PlatformDetails,
keyserverID: string,
) => {
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
isSocketConnected,
lastCommunicatedPlatformDetails,
keyserverID,
});
return actionFunc(boundCallServerEndpoint);
},
);

type CreateBoundServerCallsSelectorType = <F>(
ActionFunc<F>,
) => BindServerCallsParams => F;
const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType =
(_memoize(baseCreateBoundServerCallsSelector): any);

function useServerCall<F>(		function useServerCall<F>(
serverCall: ActionFunc<F>,		serverCall: ActionFunc<F>,
paramOverride?: ?Partial<BindServerCallsParams>,		paramOverride?: ?Partial<BindServerCallsParams>,
): F {		): F {
const dispatch = useDispatch();		const dispatch = useDispatch();
const serverCallState = useSelector(		const serverCallState = useSelector(
serverCallStateSelector(ashoatKeyserverID),		serverCallStateSelector(ashoatKeyserverID),
Show All 13 Lines	return createBoundServerCallsSelector(serverCall)({
isSocketConnected,		isSocketConnected,
dispatch,		dispatch,
...paramOverride,		...paramOverride,
keyserverID: ashoatKeyserverID,		keyserverID: ashoatKeyserverID,
});		});
}, [serverCall, serverCallState, dispatch, paramOverride]);		}, [serverCall, serverCallState, dispatch, paramOverride]);
}		}

let socketAPIHandler: ?SocketAPIHandler = null;		export { useServerCall };
function registerActiveSocket(passedSocketAPIHandler: ?SocketAPIHandler) {
socketAPIHandler = passedSocketAPIHandler;
}

export {
createBoundServerCallsSelector,
registerActiveSocket,
useServerCall,
bindCookieAndUtilsIntoCallServerEndpoint,
};

[lib] refactor integrity reducer add new thread hashes to use sqlite opsClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 37977

lib/reducers/integrity-reducer.js

[lib] refactor integrity reducer add new thread hashes to use sqlite ops
ClosedPublic
Actions

Revision Contents
Changeset List