Page MenuHomePhabricator
Differential D11429

[landing] introduce /connect-farcaster route
ClosedPublic
Actions

Authored by ginsu on Mar 27 2024, 9:19 PM.
Tags
None
Referenced Files
F6288560: D11429.id.diff
Fri, Apr 25, 11:33 PM
Unknown Object (File)
Thu, Apr 24, 10:37 PM
Unknown Object (File)
Thu, Apr 3, 3:11 AM
Unknown Object (File)
Mon, Mar 31, 5:32 PM
Unknown Object (File)
Sat, Mar 29, 7:54 PM
Unknown Object (File)
Fri, Mar 28, 12:33 PM
Unknown Object (File)
Mar 25 2025, 11:26 PM
Unknown Object (File)
Mar 4 2025, 3:48 AM
View All 63 Files
Subscribers
ashoat
tomek

Details

Reviewers
atul
Commits
rCOMM1aceccccbaf3: [landing] introduce /connect-farcaster route
Summary

After introducing the ConnectFarcaster component we should implement the necessary routing logic to route to it whenever the url is BASE_LANDING_URL/connect-farcaster

Depends on D11428

Test Plan

Confirmed that I was able to route to BASE_LANDING_URL/connect-farcaster + tested the entire sign in flow during the hackathon

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
landing/
6 lines

Diff 38483

View Options

landing/landing.react.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,
};