commit eed792ad477131f1229d68b9cb3803a9aa5eda9f · gmstn.systems/gemstone-app

+44 -3

src/lib/hooks/useChannel.ts

···

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

     

       2
       2
       -
       import { shardMessageSchema, type ShardMessage } from "@/lib/types/messages";

     

       2
       2
       +
       import type { RequestHistoryMessage, ShardMessage } from "@/lib/types/messages";

     

       3
       3
       +
       import { historyMessageSchema, shardMessageSchema } from "@/lib/types/messages";

     

       3
       4
        
       import { atUriEquals, atUriToString, stringToAtUri } from "@/lib/utils/atproto";

     

       4
       5
        
       import { sendShardMessage } from "@/lib/utils/messages";

     

       5
       6
        
       import {

     
···

       30
       31
        
       

     

       31
       32
        
               // attach handlers here

     

       32
       33
        
       

     

       33
       33
       -
               socket.addEventListener("open", () => {

     

       34
       34
       +
               const handleOpen = () => {

     

       34
       35
        
                   console.log("Connected to WebSocket");

     

       35
       36
        
                   setIsConnected(true);

     

       36
       36
       -
               });

     

       37
       37
       +
                   const requestHistoryMessage: RequestHistoryMessage = {

     

       38
       38
       +
                       type: "shard/requestHistory",

     

       39
       39
       +
                       channel: atUriToString(channel),

     

       40
       40
       +
                       requestedBy: sessionInfo.clientDid,

     

       41
       41
       +
                   };

     

       42
       42
       +
                   console.log(

     

       43
       43
       +
                       "requested history from lattice",

     

       44
       44
       +
                       requestHistoryMessage,

     

       45
       45
       +
                   );

     

       46
       46
       +
                   socket.send(JSON.stringify(requestHistoryMessage));

     

       47
       47
       +
               };

     

       48
       48
       +
       

     

       49
       49
       +
               if (socket.readyState === WebSocket.OPEN) {

     

       50
       50
       +
                   handleOpen();

     

       51
       51
       +
               }

     

       52
       52
       +
       

     

       53
       53
       +
               socket.addEventListener("open", handleOpen);

     

       37
       54
        
       

     

       38
       55
        
               socket.addEventListener("message", (event) => {

     

       39
       56
        
                   console.log("received message", event);

     
···

       63
       80
        
                               setMessages((prev) => [...prev, shardMessage]);

     

       64
       81
        
                           break;

     

       65
       82
        
                       }

     

       83
       83
       +
                       case "shard/history": {

     

       84
       84
       +
                           console.log(

     

       85
       85
       +
                               "received history from lattice",

     

       86
       86
       +
                               validateTypeResult.data,

     

       87
       87
       +
                           );

     

       88
       88
       +
                           const { success, data: historyMessage } =

     

       89
       89
       +
                               historyMessageSchema.safeParse(validateTypeResult.data);

     

       90
       90
       +
                           if (!success) return;

     

       91
       91
       +
                           if (!historyMessage.messages) return;

     

       92
       92
       +
       

     

       93
       93
       +
                           const parseChannelResult = stringToAtUri(

     

       94
       94
       +
                               historyMessage.channel,

     

       95
       95
       +
                           );

     

       96
       96
       +
       

     

       97
       97
       +
                           if (!parseChannelResult.ok) return;

     

       98
       98
       +
                           const { data: channelAtUri } = parseChannelResult;

     

       99
       99
       +
       

     

       100
       100
       +
                           if (atUriEquals(channelAtUri, channel))

     

       101
       101
       +
                               setMessages([...historyMessage.messages]);

     

       102
       102
       +
                       }

     

       66
       103
        
                   }

     

       67
       104
        
               });

     

       68
       105
        
       

     
···

       74
       111
        
                   console.log("Disconnected from WebSocket");

     

       75
       112
        
                   setIsConnected(false);

     

       76
       113
        
               });

     

       114
       114
       +
               socket.addEventListener("open", handleOpen);

     

       115
       115
       +
               return () => {

     

       116
       116
       +
                   socket.removeEventListener("open", handleOpen);

     

       117
       117
       +
               };

     

       77
       118
        
           }, [socket, sessionInfo, channel]);

     

       78
       119
        
       

     

       79
       120
        
           if (!oAuthSession) throw new Error("No OAuth session");

src/lib/types/messages.ts

···

       29
       29
        
               type: z.literal("shard/history"),

     

       30
       30
        
               messages: z.optional(z.array(shardMessageSchema)),

     

       31
       31
        
               channel: z.string(),

     

       32
       32
       +
               forClient: didSchema,

     

       32
       33
        
           })

     

       33
       34
        
           .strict();

     

       34
       35
        
       export type HistoryMessage = z.infer<typeof historyMessageSchema>;

     
···

       37
       38
        
           .safeExtend({

     

       38
       39
        
               type: z.literal("shard/requestHistory"),

     

       39
       40
        
               channel: z.string(),

     

       41
       41
       +
               requestedBy: didSchema,

     

       40
       42
        
           })

     

       41
       43
        
           .strict();

     

       42
       44
        
       export type RequestHistoryMessage = z.infer<typeof requestHistoryMessageSchema>;