Paths

Table of Contentst

-
lib/types/
-
types/
-
relationship-types.js
-
relationship-types.test.js

[lib] Fix `farcasterRelationshipRequestValidator`
ClosedPublic
Actions

Authored by atul on Apr 10 2024, 12:47 PM.

Details

Reviewers

ginsu
tomek
will
varun

Commits

rCOMM003bf69d1b44: [lib] Fix `farcasterRelationshipRequestValidator`

Summary

exactlyTwoDictEntriesValidator is only relevant for UpdateRelationshipMessages, not for the request. Multiple farcaster mutuals can be included in single FarcasterRelationshipRequest.

Depends on D11612

Test Plan

Able to include multiple users in single request farcaster request (hard-coded dummy FIDs in request)

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

atul created this revision.Apr 10 2024, 12:47 PM

Herald added a subscriber: ashoat. · View Herald TranscriptApr 10 2024, 12:47 PM

Harbormaster completed remote builds in B28147: Diff 39015.Apr 10 2024, 1:25 PM

atul requested review of this revision.Apr 10 2024, 1:25 PM

tomek accepted this revision.Apr 11 2024, 8:27 AM

This revision is now accepted and ready to land.Apr 11 2024, 8:27 AM

Do we need a dedicated validator for UpdateRelationshipMessage?

atul added a child revision: D11641: [lib] Split `UpdateRelationshipMessageData` into `UpdateTraditionalMessageData` and `UpdateFarcasterMessageData`.Apr 11 2024, 8:05 PM

In D11624#334284, @tomek wrote:

Do we need a dedicated validator for UpdateRelationshipMessage?

Yeah, we introduced rawUpdateFarcasterRelationshipMessageInfoValidator to handle this (has been landed). We didn't end up needing exactlyTwoDictEntriesValidator because modified type to include creatorFID and targetFID instead.

rebase and land

This revision was landed with ongoing or failed builds.Apr 18 2024, 1:26 PM

Closed by commit rCOMM003bf69d1b44: [lib] Fix `farcasterRelationshipRequestValidator` (authored by atul). · Explain Why

This revision was automatically updated to reflect the committed changes.

atul added a commit: rCOMM003bf69d1b44: [lib] Fix `farcasterRelationshipRequestValidator`.

Harbormaster completed remote builds in B28312: Diff 39253.Apr 18 2024, 2:12 PM

Revision Contents
Changeset List

Path

Size

lib/

types/

relationship-types.js

7 lines

relationship-types.test.js

24 lines

Diff 39259

View Options

lib/types/relationship-types.js

// @flow		// @flow

import * as React from 'react';		import * as React from 'react';

import { useGetMessageAuthor } from './message-author.js';		import { useGetMessageAuthor } from './message-author.js';
import { messageInfoSelector } from '../selectors/chat-selectors.js';		import { messageInfoSelector } from '../selectors/chat-selectors.js';
import {		import {
getOldestNonLocalMessageID,		getOldestNonLocalMessageID,
useFetchMessages,		useFetchMessages,
} from '../shared/message-utils.js';		} from '../shared/message-utils.js';
import { messageSpecs } from '../shared/messages/message-specs.js';		import { messageSpecs } from '../shared/messages/message-specs.js';
import type { MessageInfo } from '../types/message-types.js';		import {
		type MessageInfo,
		defaultNumberPerThread,
		} from '../types/message-types.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';		import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import { useSelector } from '../utils/redux-utils.js';		import { useSelector } from '../utils/redux-utils.js';
import sleep from '../utils/sleep.js';		import sleep from '../utils/sleep.js';

function useOldestMessageServerID(threadID: string): ?string {		function useOldestMessageServerID(threadID: string): ?string {
return useSelector(state =>		return useSelector(state =>
getOldestNonLocalMessageID(threadID, state.messageStore),		getOldestNonLocalMessageID(threadID, state.messageStore),
);		);
}		}

type MessageInfoForPreview = {		type MessageInfoForPreview = {
+messageInfoForPreview: ?MessageInfo,		+messageInfoForPreview: ?MessageInfo,
// If showInMessagePreview rejects all of the messages in the local store,		// If showInMessagePreview rejects all of the messages in the local store,
// then we'll ignore it and return the most recent message (if there is one)		// then we'll ignore it and return the most recent message (if there is one)
// as messageInfoForPreview. In this case, we'll also set		// as messageInfoForPreview. In this case, we'll also set
// shouldFetchOlderMessages to tell the caller to fetch more messages.		// numOlderMessagesToFetch to tell the caller how many more messages to fetch.
+shouldFetchOlderMessages: boolean,		+numOlderMessagesToFetch: number,
};		};

const emptyMessageInfoForPreview = {		const emptyMessageInfoForPreview = {
messageInfoForPreview: undefined,		messageInfoForPreview: undefined,
shouldFetchOlderMessages: false,		numOlderMessagesToFetch: 0,
};		};

function useGetMessageInfoForPreview(): (		function useGetMessageInfoForPreview(): (
threadInfo: ThreadInfo,		threadInfo: ThreadInfo,
) => Promise<MessageInfoForPreview> {		) => Promise<MessageInfoForPreview> {
const messageInfos = useSelector(messageInfoSelector);		const messageInfos = useSelector(messageInfoSelector);
const messageStore = useSelector(state => state.messageStore);		const messageStore = useSelector(state => state.messageStore);
const viewerID = useSelector(state => state.currentUserInfo?.id);		const viewerID = useSelector(state => state.currentUserInfo?.id);
Show All 20 Lines	async threadInfo => {
}		}
if (!mostRecentMessageInfo) {		if (!mostRecentMessageInfo) {
mostRecentMessageInfo = messageInfo;		mostRecentMessageInfo = messageInfo;
}		}
const { showInMessagePreview } = messageSpecs[messageInfo.type];		const { showInMessagePreview } = messageSpecs[messageInfo.type];
if (!showInMessagePreview) {		if (!showInMessagePreview) {
return {		return {
messageInfoForPreview: messageInfo,		messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false,		numOlderMessagesToFetch: 0,
};		};
}		}
let shouldShow = showInMessagePreview(		let shouldShow = showInMessagePreview(
messageInfo,		messageInfo,
showInMessagePreviewParams,		showInMessagePreviewParams,
);		);
if (shouldShow instanceof Promise) {		if (shouldShow instanceof Promise) {
shouldShow = await shouldShow;		shouldShow = await shouldShow;
}		}
if (shouldShow) {		if (shouldShow) {
return {		return {
messageInfoForPreview: messageInfo,		messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false,		numOlderMessagesToFetch: 0,
};		};
}		}
}		}
		const numOlderMessagesToFetch = Math.max(
		defaultNumberPerThread - thread.messageIDs.length,
		0,
		);
// If we get here, that means showInMessagePreview rejected all of the		// If we get here, that means showInMessagePreview rejected all of the
// messages in the local store		// messages in the local store
return {		return {
messageInfoForPreview: mostRecentMessageInfo,		messageInfoForPreview: mostRecentMessageInfo,
shouldFetchOlderMessages: true,		numOlderMessagesToFetch,
};		};
},		},
[messageInfos, messageStore, viewerID, getMessageAuthor],		[messageInfos, messageStore, viewerID, getMessageAuthor],
);		);
}		}

function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {		function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {
const [messageInfoForPreview, setMessageInfoForPreview] =		const [messageInfoForPreview, setMessageInfoForPreview] =
React.useState<?MessageInfoForPreview>();		React.useState<?MessageInfoForPreview>();

const getMessageInfoForPreview = useGetMessageInfoForPreview();		const getMessageInfoForPreview = useGetMessageInfoForPreview();
React.useEffect(() => {		React.useEffect(() => {
void (async () => {		void (async () => {
const newMessageInfoForPreview =		const newMessageInfoForPreview =
await getMessageInfoForPreview(threadInfo);		await getMessageInfoForPreview(threadInfo);
setMessageInfoForPreview(newMessageInfoForPreview);		setMessageInfoForPreview(newMessageInfoForPreview);
})();		})();
}, [threadInfo, getMessageInfoForPreview]);		}, [threadInfo, getMessageInfoForPreview]);

const shouldFetchOlderMessages =		const numOlderMessagesToFetch =
!!messageInfoForPreview?.shouldFetchOlderMessages;		messageInfoForPreview?.numOlderMessagesToFetch ?? 0;

const [canFetchOlderMessages, setCanFetchOlderMessages] =		const [canFetchOlderMessages, setCanFetchOlderMessages] =
React.useState(true);		React.useState(true);
const fetchMessages = useFetchMessages(threadInfo);		const fetchMessages = useFetchMessages(threadInfo);
React.useEffect(() => {		React.useEffect(() => {
if (!canFetchOlderMessages \|\| !shouldFetchOlderMessages) {		if (!canFetchOlderMessages \|\| numOlderMessagesToFetch === 0) {
return;		return;
}		}
setCanFetchOlderMessages(false);		setCanFetchOlderMessages(false);
void (async () => {		void (async () => {
await fetchMessages();		await fetchMessages({ numMessagesToFetch: numOlderMessagesToFetch });
await sleep(3000);		await sleep(3000);
setCanFetchOlderMessages(true);		setCanFetchOlderMessages(true);
})();		})();
}, [canFetchOlderMessages, shouldFetchOlderMessages, fetchMessages]);		}, [canFetchOlderMessages, numOlderMessagesToFetch, fetchMessages]);

return messageInfoForPreview?.messageInfoForPreview;		return messageInfoForPreview?.messageInfoForPreview;
}		}

export { useOldestMessageServerID, useMessageInfoForPreview };		export { useOldestMessageServerID, useMessageInfoForPreview };