Page MenuHomePhorge
Files F32171757

D15203.1765061015.diff
No OneTemporary
Actions

Size
8 KB
Referenced Files
None
Subscribers
None

D15203.1765061015.diff
View Options

diff --git a/lib/shared/farcaster/farcaster-api.js b/lib/shared/farcaster/farcaster-api.js
new file mode 100644
--- /dev/null
+++ b/lib/shared/farcaster/farcaster-api.js
@@ -0,0 +1,270 @@
+// @flow
+
+import * as React from 'react';
+import type { TInterface } from 'tcomb';
+import t from 'tcomb';
+
+import type {
+ FarcasterConversation,
+ FarcasterInboxConversation,
+} from './farcaster-conversation-types.js';
+import {
+ farcasterConversationValidator,
+ farcasterInboxConversationValidator,
+} from './farcaster-conversation-types.js';
+import type { FarcasterMessage } from './farcaster-messages-types.js';
+import { farcasterMessageValidator } from './farcaster-messages-types.js';
+import { useTunnelbroker } from '../../tunnelbroker/tunnelbroker-context.js';
+import {
+ tShapeInexact,
+ assertWithValidator,
+} from '../../utils/validation-utils.js';
+
+export type SendFarcasterTextMessageInput =
+ | {
+ +groupId: string,
+ +message: string,
+ }
+ | { +recipientFid: string, +message: string };
+
+type SendFarcasterMessageResultData = {
+ +messageId: string,
+ ...
+};
+const sendFarcasterMessageResultDataValidator: TInterface<SendFarcasterMessageResultData> =
+ tShapeInexact({
+ messageId: t.String,
+ });
+
+type SendFarcasterMessageResult = {
+ +result: SendFarcasterMessageResultData,
+ ...
+};
+const sendFarcasterMessageResultValidator: TInterface<SendFarcasterMessageResult> =
+ tShapeInexact({
+ result: sendFarcasterMessageResultDataValidator,
+ });
+
+function useSendFarcasterTextMessage(): (
+ input: SendFarcasterTextMessageInput,
+) => Promise<SendFarcasterMessageResult> {
+ const { sendFarcasterRequest } = useTunnelbroker();
+ return React.useCallback(
+ async (input: SendFarcasterTextMessageInput) => {
+ const response = await sendFarcasterRequest({
+ apiVersion: 'fc',
+ endpoint: 'message',
+ method: { type: 'PUT' },
+ payload: JSON.stringify(input),
+ });
+
+ const parsedResult = JSON.parse(response);
+ const result: SendFarcasterMessageResult = assertWithValidator(
+ parsedResult,
+ sendFarcasterMessageResultValidator,
+ );
+ return result;
+ },
+ [sendFarcasterRequest],
+ );
+}
+
+export type FetchFarcasterMessageInput = {
+ +conversationId: string,
+ +cursor?: string,
+ +limit?: number,
+ +messageId?: string,
+};
+
+type FetchFarcasterMessageResultData = {
+ +messages: $ReadOnlyArray<FarcasterMessage>,
+ ...
+};
+const fetchFarcasterMessageResultDataValidator: TInterface<FetchFarcasterMessageResultData> =
+ tShapeInexact({
+ messages: t.list(farcasterMessageValidator),
+ });
+
+export type FetchFarcasterMessageResult = {
+ +result: FetchFarcasterMessageResultData,
+ ...
+};
+const fetchFarcasterMessageResultValidator: TInterface<FetchFarcasterMessageResult> =
+ tShapeInexact({
+ result: fetchFarcasterMessageResultDataValidator,
+ });
+
+function useFetchFarcasterMessage(): (
+ input: FetchFarcasterMessageInput,
+) => Promise<FetchFarcasterMessageResult> {
+ const { sendFarcasterRequest } = useTunnelbroker();
+ return React.useCallback(
+ async (input: FetchFarcasterMessageInput) => {
+ const { conversationId, cursor, limit, messageId } = input;
+ const params: { [string]: string } = {
+ conversationId,
+ };
+ if (cursor !== undefined && cursor !== null) {
+ params.cursor = cursor;
+ }
+ if (limit !== undefined && limit !== null) {
+ params.limit = limit.toString();
+ }
+ if (messageId !== undefined && messageId !== null) {
+ params.messageId = messageId;
+ }
+
+ const response = await sendFarcasterRequest({
+ apiVersion: 'v2',
+ endpoint: 'direct-cast-conversation-messages',
+ method: { type: 'GET' },
+ payload: new URLSearchParams(params).toString(),
+ });
+ const parsedResult = JSON.parse(response);
+ const result: FetchFarcasterMessageResult = assertWithValidator(
+ parsedResult,
+ fetchFarcasterMessageResultValidator,
+ );
+ return result;
+ },
+ [sendFarcasterRequest],
+ );
+}
+
+export type FetchFarcasterInboxInput = {
+ +limit?: number,
+ +category?: 'archived' | 'request',
+ +cursor?: string,
+ +filter?: 'unread' | 'group' | '1-1',
+};
+
+type FetchFarcasterInboxResultData = {
+ +conversations: $ReadOnlyArray<FarcasterInboxConversation>,
+ +hasArchived: boolean,
+ +hasUnreadRequests: boolean,
+ +requestsCount: number,
+ ...
+};
+const fetchFarcasterInboxResultDataValidator: TInterface<FetchFarcasterInboxResultData> =
+ tShapeInexact({
+ conversations: t.list(farcasterInboxConversationValidator),
+ hasArchived: t.Boolean,
+ hasUnreadRequests: t.Boolean,
+ requestsCount: t.Number,
+ });
+
+type FetchFarcasterInboxResultNext = {
+ +cursor?: string,
+ ...
+};
+const fetchFarcasterInboxResultNextValidator: TInterface<FetchFarcasterInboxResultNext> =
+ tShapeInexact({
+ cursor: t.maybe(t.String),
+ });
+
+export type FetchFarcasterInboxResult = {
+ +result: FetchFarcasterInboxResultData,
+ +next?: FetchFarcasterInboxResultNext,
+ ...
+};
+const fetchFarcasterInboxResultValidator: TInterface<FetchFarcasterInboxResult> =
+ tShapeInexact({
+ result: fetchFarcasterInboxResultDataValidator,
+ next: t.maybe(fetchFarcasterInboxResultNextValidator),
+ });
+
+function useFetchFarcasterInbox(): (
+ input: FetchFarcasterInboxInput,
+) => Promise<FetchFarcasterInboxResult> {
+ const { sendFarcasterRequest } = useTunnelbroker();
+ return React.useCallback(
+ async (input: FetchFarcasterInboxInput) => {
+ const { limit, category, cursor, filter } = input;
+
+ const params: { [string]: string } = {};
+ if (cursor !== undefined && cursor !== null) {
+ params.cursor = cursor;
+ }
+ if (limit !== undefined && limit !== null) {
+ params.limit = limit.toString();
+ }
+ if (category !== undefined && category !== null) {
+ params.category = category;
+ }
+ if (filter !== undefined && filter !== null) {
+ params.filter = filter;
+ }
+
+ const response = await sendFarcasterRequest({
+ apiVersion: 'v2',
+ endpoint: 'direct-cast-inbox',
+ method: { type: 'GET' },
+ payload: new URLSearchParams(params).toString(),
+ });
+ const parsedResult = JSON.parse(response);
+ const result: FetchFarcasterInboxResult = assertWithValidator(
+ parsedResult,
+ fetchFarcasterInboxResultValidator,
+ );
+ return result;
+ },
+ [sendFarcasterRequest],
+ );
+}
+
+export type FetchFarcasterConversationInput = {
+ +conversationId: string,
+};
+
+type FetchFarcasterConversationResultData = {
+ +conversation: FarcasterConversation,
+ ...
+};
+const fetchFarcasterConversationResultDataValidator: TInterface<FetchFarcasterConversationResultData> =
+ tShapeInexact({
+ conversation: farcasterConversationValidator,
+ });
+
+export type FetchFarcasterConversationResult = {
+ +result: FetchFarcasterConversationResultData,
+ ...
+};
+const fetchFarcasterConversationResultValidator: TInterface<FetchFarcasterConversationResult> =
+ tShapeInexact({
+ result: fetchFarcasterConversationResultDataValidator,
+ });
+
+function useFetchFarcasterConversation(): (
+ input: FetchFarcasterConversationInput,
+) => Promise<FetchFarcasterConversationResult> {
+ const { sendFarcasterRequest } = useTunnelbroker();
+ return React.useCallback(
+ async (input: FetchFarcasterConversationInput) => {
+ const { conversationId } = input;
+ const params = new URLSearchParams({
+ conversationId,
+ });
+
+ const response = await sendFarcasterRequest({
+ apiVersion: 'v2',
+ endpoint: 'direct-cast-conversation',
+ method: { type: 'GET' },
+ payload: params.toString(),
+ });
+ const parsedResult = JSON.parse(response);
+ const result: FetchFarcasterConversationResult = assertWithValidator(
+ parsedResult,
+ fetchFarcasterConversationResultValidator,
+ );
+ return result;
+ },
+ [sendFarcasterRequest],
+ );
+}
+
+export {
+ useSendFarcasterTextMessage,
+ useFetchFarcasterMessage,
+ useFetchFarcasterConversation,
+ useFetchFarcasterInbox,
+};

File Metadata

Mime Type
text/plain
Expires
Sat, Dec 6, 10:43 PM (5 h, 48 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5841230
Default Alt Text
D15203.1765061015.diff (8 KB)

Event Timeline