commit a69482a3f2c53f0bf058bae2301faed1303b3dd0 · gmstn.systems/gemstone-app

+2 -7

src/app/(protected)/index.tsx

···

       1
       1
        
       import ChatComponentProfiled from "@/components/ChatComponentProfiled";

     

       2
       2
       -
       import { useLatticeSession } from "@/providers/authed/LatticeSessionsProvider";

     

       3
       2
        
       import { useOAuthSession } from "@/providers/OAuthProvider";

     

       4
       3
        
       import { Redirect } from "expo-router";

     

       5
       5
       -
       import { Text, View } from "react-native";

     

       4
       4
       +
       import { View } from "react-native";

     

       6
       5
        
       

     

       7
       6
        
       export default function Index() {

     

       8
       7
        
           const oAuthSession = useOAuthSession();

     

       9
       9
       -
           const sessionsMap = useLatticeSession();

     

       10
       10
       -
           const sessions = sessionsMap.values().toArray();

     

       8
       8
       +
       

     

       11
       9
        
           return (

     

       12
       10
        
               <View

     

       13
       11
        
                   style={{

     
···

       21
       19
        
                   ) : (

     

       22
       20
        
                       <Redirect href={"/login"} />

     

       23
       21
        
                   )}

     

       24
       24
       -
                   {sessions.map((session, idx) => (

     

       25
       25
       -
                       <Text key={idx}>{session.latticeDid}</Text>

     

       26
       26
       -
                   ))}

     

       27
       22
        
               </View>

     

       28
       23
        
           );

     

       29
       24
        
       }

+1 -3

src/components/ChatComponentProfiled.tsx

···

       21
       21
        
           did: DidPlc | DidWeb;

     

       22
       22
        
       }) {

     

       23
       23
        
           const [inputText, setInputText] = useState("");

     

       24
       24
       -
           const { messages, isConnected, sendMessage } = useWebSocket(

     

       25
       25
       -
               "ws://localhost:8080",

     

       26
       26
       -
           );

     

       24
       24
       +
           const { messages, isConnected, sendMessage } = useWebSocket();

     

       27
       25
        
       

     

       28
       26
        
           const handleSend = () => {

     

       29
       27
        
               if (inputText.trim()) {

+15 -15

src/lib/hooks/useWebSocket.ts

···

       6
       6
        
           validateWsMessageString,

     

       7
       7
        
           validateWsMessageType,

     

       8
       8
        
       } from "@/lib/validators";

     

       9
       9
       -
       import { useEffect, useRef, useState } from "react";

     

       9
       9
       +
       import { useFirstSessionWsTemp } from "@/providers/authed/SessionsProvider";

     

       10
       10
       +
       import { useEffect, useState } from "react";

     

       10
       11
        
       

     

       11
       11
       -
       export function useWebSocket(url: string) {

     

       12
       12
       -
           const [messages, setMessages] = useState<ShardMessage[]>([]);

     

       12
       12
       +
       export function useWebSocket() {

     

       13
       13
       +
           const [messages, setMessages] = useState<Array<ShardMessage>>([]);

     

       13
       14
        
           const [isConnected, setIsConnected] = useState(false);

     

       14
       14
       -
           const ws = useRef<WebSocket | null>(null);

     

       15
       15
       +
           const ws = useFirstSessionWsTemp();

     

       15
       16
        
       

     

       16
       17
        
           useEffect(() => {

     

       17
       17
       -
               // Connect to WebSocket

     

       18
       18
       -
               ws.current = new WebSocket(url);

     

       19
       19
       -
       

     

       20
       20
       -
               ws.current.onopen = () => {

     

       18
       18
       +
               if(!ws) return;

     

       19
       19
       +
               ws.onopen = () => {

     

       21
       20
        
                   console.log("Connected to WebSocket");

     

       22
       21
        
                   setIsConnected(true);

     

       23
       22
        
               };

     

       24
       23
        
       

     

       25
       25
       -
               ws.current.onmessage = (event) => {

     

       24
       24
       +
               ws.onmessage = (event) => {

     

       26
       25
        
                   const eventData = validateWsMessageString(event.data);

     

       27
       26
        
                   if (!eventData) return;

     

       28
       27
        
       

     
···

       41
       40
        
                   }

     

       42
       41
        
               };

     

       43
       42
        
       

     

       44
       44
       -
               ws.current.onerror = (error) => {

     

       43
       43
       +
               ws.onerror = (error) => {

     

       45
       44
        
                   console.error("WebSocket error:", error);

     

       46
       45
        
               };

     

       47
       46
        
       

     

       48
       48
       -
               ws.current.onclose = () => {

     

       47
       47
       +
               ws.onclose = () => {

     

       49
       48
        
                   console.log("Disconnected from WebSocket");

     

       50
       49
        
                   setIsConnected(false);

     

       51
       50
        
               };

     

       52
       51
        
       

     

       53
       52
        
               // Cleanup on unmount

     

       54
       53
        
               return () => {

     

       55
       55
       -
                   ws.current?.close();

     

       54
       54
       +
                   ws.close();

     

       56
       55
        
               };

     

       57
       57
       -
           }, [url]);

     

       56
       56
       +
           }, [ws]);

     

       58
       57
        
       

     

       59
       58
        
           const sendMessage = ({ text, did }: SendMessageOpts) => {

     

       60
       60
       -
               if (ws.current?.readyState === WebSocket.OPEN) {

     

       61
       61
       -
                   ws.current.send(

     

       59
       59
       +
               if(!ws) return

     

       60
       60
       +
               if (ws.readyState === WebSocket.OPEN) {

     

       61
       61
       +
                   ws.send(

     

       62
       62
        
                       JSON.stringify({

     

       63
       63
        
                           type: "shard/message",

     

       64
       64
        
                           text,

+15

src/lib/utils/domains.ts

···

       1
       1
       +
       /**

     

       2
       2
       +
        * Checks if a string is a domain

     

       3
       3
       +
        * does NOT do TLD-level checks. Any domain/NSID-like string will pass this check

     

       4
       4
       +
        */

     

       5
       5
       +
       export const isDomain = (str: string) => {

     

       6
       6
       +
           try {

     

       7
       7
       +
               const url = new URL(str.includes("://") ? str : `https://${str}`);

     

       8
       8
       +
               return (

     

       9
       9
       +
                   (url.hostname.includes(".") && !url.hostname.startsWith(".")) ||

     

       10
       10
       +
                   url.hostname === "localhost"

     

       11
       11
       +
               );

     

       12
       12
       +
           } catch {

     

       13
       13
       +
               return false;

     

       14
       14
       +
           }

     

       15
       15
       +
       };

+1 -1

src/providers/authed/ChannelsProvider.tsx

···

       61
       61
        
       

     

       62
       62
        
           const channelsQueries = useQueries({

     

       63
       63
        
               queries: memberships.map((membershipObjects) => ({

     

       64
       64
       -
                   enabled: membershipsInitialising,

     

       64
       64
       +
                   enabled: !membershipsInitialising,

     

       65
       65
        
                   queryKey: ["channel", membershipObjects.membership.channel.uri],

     

       66
       66
        
                   queryFn: () => channelQueryFn(membershipObjects.channelAtUri),

     

       67
       67
        
                   staleTime: DEFAULT_STALE_TIME,

+99

src/providers/authed/SessionsProvider.tsx

···

       1
       1
       +
       import { DEFAULT_STALE_TIME } from "@/lib/consts";

     

       2
       2
       +
       import type { AtUri } from "@/lib/types/atproto";

     

       3
       3
       +
       import type { LatticeSessionInfo } from "@/lib/types/handshake";

     

       4
       4
       +
       import { isDomain } from "@/lib/utils/domains";

     

       5
       5
       +
       import { connectToLattice, getLatticeEndpointFromDid } from "@/lib/utils/gmstn";

     

       6
       6
       +
       import { useHandshakes } from "@/providers/authed/HandshakesProvider";

     

       7
       7
       +
       import { useQueries } from "@tanstack/react-query";

     

       8
       8
       +
       import type { ReactNode } from "react";

     

       9
       9
       +
       import { createContext, useContext } from "react";

     

       10
       10
       +
       

     

       11
       11
       +
       type SessionsMap = Map<LatticeSessionInfo, WebSocket>;

     

       12
       12
       +
       

     

       13
       13
       +
       interface SessionsContextValue {

     

       14
       14
       +
           sessionsMap: SessionsMap;

     

       15
       15
       +
           isInitialising: boolean;

     

       16
       16
       +
           error: Error | null;

     

       17
       17
       +
           getSession: (sessionInfo: LatticeSessionInfo) => WebSocket | undefined;

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       const SessionsContext = createContext<SessionsContextValue | null>(null);

     

       21
       21
       +
       

     

       22
       22
       +
       export const useSessions = () => {

     

       23
       23
       +
           const sessionsValue = useContext(SessionsContext);

     

       24
       24
       +
           if (!sessionsValue)

     

       25
       25
       +
               throw new Error(

     

       26
       26
       +
                   "Sessions context was null. Did you try to access this outside of the authed providers? SessionsProvider must be below HandshakesProvider.",

     

       27
       27
       +
               );

     

       28
       28
       +
           return sessionsValue;

     

       29
       29
       +
       };

     

       30
       30
       +
       

     

       31
       31
       +
       // TODO: remove this. temp testing function

     

       32
       32
       +
       export const useFirstSessionWsTemp = () => {

     

       33
       33
       +
           const wss = useSessions().sessionsMap.values().toArray();

     

       34
       34
       +
           if(wss.length === 0) return;

     

       35
       35
       +
           return wss[0];

     

       36
       36
       +
       };

     

       37
       37
       +
       

     

       38
       38
       +
       export const SessionsProvider = ({ children }: { children: ReactNode }) => {

     

       39
       39
       +
           const { handshakesMap } = useHandshakes();

     

       40
       40
       +
           const handshakes = handshakesMap.entries().toArray();

     

       41
       41
       +
       

     

       42
       42
       +
           const endpointQueries = useQueries({

     

       43
       43
       +
               queries: handshakes.map((handshake) => ({

     

       44
       44
       +
                   queryKey: ["lattice-endpoints", handshake[0].rKey],

     

       45
       45
       +
                   queryFn: async () => {

     

       46
       46
       +
                       return await endpointQueryFn(handshake);

     

       47
       47
       +
                   },

     

       48
       48
       +
                   staleTime: DEFAULT_STALE_TIME,

     

       49
       49
       +
               })),

     

       50
       50
       +
           });

     

       51
       51
       +
       

     

       52
       52
       +
           const isInitialising = endpointQueries.some((q) => q.isLoading);

     

       53
       53
       +
           const error = endpointQueries.find((q) => q.error)?.error ?? null;

     

       54
       54
       +
       

     

       55
       55
       +
           const sessionsMap = new Map<LatticeSessionInfo, WebSocket>();

     

       56
       56
       +
       

     

       57
       57
       +
           endpointQueries.forEach((q) => {

     

       58
       58
       +
               const endpoint = q.data;

     

       59
       59
       +
               if (!endpoint) return;

     

       60
       60
       +
               const { sessionInfo, shardUrl } = endpoint;

     

       61
       61
       +
               const websocket = connectToLattice({

     

       62
       62
       +
                   shardUrl,

     

       63
       63
       +
                   sessionToken: sessionInfo.token,

     

       64
       64
       +
               });

     

       65
       65
       +
               sessionsMap.set(sessionInfo, websocket);

     

       66
       66
       +
           });

     

       67
       67
       +
       

     

       68
       68
       +
           const value: SessionsContextValue = {

     

       69
       69
       +
               sessionsMap,

     

       70
       70
       +
               isInitialising,

     

       71
       71
       +
               error,

     

       72
       72
       +
               getSession: (sessionInfo: LatticeSessionInfo) =>

     

       73
       73
       +
                   sessionsMap.get(sessionInfo),

     

       74
       74
       +
           };

     

       75
       75
       +
       

     

       76
       76
       +
           return <SessionsContext value={value}>{children}</SessionsContext>;

     

       77
       77
       +
       };

     

       78
       78
       +
       

     

       79
       79
       +
       const endpointQueryFn = async (handshake: [AtUri, LatticeSessionInfo]) => {

     

       80
       80
       +
           const atUri = handshake[0];

     

       81
       81
       +
           const sessionInfo = handshake[1];

     

       82
       82
       +
           const rkey = atUri.rKey ?? "";

     

       83
       83
       +
           const shardDid = isDomain(rkey)

     

       84
       84
       +
               ? `did:web:${encodeURIComponent(rkey)}`

     

       85
       85
       +
               : `did:plc:${rkey}`;

     

       86
       86
       +
       

     

       87
       87
       +
           // TODO: again, implement proper did -> endpoint parsing here too.

     

       88
       88
       +
           // for now, we just assume did:web and construce a URL based on that.

     

       89
       89
       +
           // @ts-expect-error trust me bro it's a string

     

       90
       90
       +
           const shardUrlResult = await getLatticeEndpointFromDid(shardDid);

     

       91
       91
       +
       

     

       92
       92
       +
           if (!shardUrlResult.ok) return;

     

       93
       93
       +
       

     

       94
       94
       +
           return {

     

       95
       95
       +
               // TODO: xrpc and lexicon this endpoint

     

       96
       96
       +
               shardUrl: `${shardUrlResult.data.origin}/connect`,

     

       97
       97
       +
               sessionInfo,

     

       98
       98
       +
           };

     

       99
       99
       +
       };

+6 -1

src/providers/authed/index.tsx

···

       1
       1
        
       import { HandshakesProvider } from "@/providers/authed/HandshakesProvider";

     

       2
       2
       +
       import { SessionsProvider } from "@/providers/authed/SessionsProvider";

     

       2
       3
        
       import type { ReactNode } from "react";

     

       3
       4
        
       

     

       4
       5
        
       export const AuthedProviders = ({ children }: { children: ReactNode }) => {

     

       5
       5
       -
           return <HandshakesProvider>{children}</HandshakesProvider>;

     

       6
       6
       +
           return (

     

       7
       7
       +
               <HandshakesProvider>

     

       8
       8
       +
                   <SessionsProvider>{children}</SessionsProvider>

     

       9
       9
       +
               </HandshakesProvider>

     

       10
       10
       +
           );

     

       6
       11
        
       };