commit eed792ad477131f1229d68b9cb3803a9aa5eda9f · gmstn.systems/gemstone-app

+44 -3

src/lib/hooks/useChannel.ts

···

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

     

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

     

       0
        
       
     

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

     

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

     

       5
        
       import {

     
···

       30
        
       

     

       31
        
               // attach handlers here

     

       32
        
       

     

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

     

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

     

       35
        
                   setIsConnected(true);

     

       36
       -
               });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
       

     

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

     

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

     
···

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

     

       64
        
                           break;

     

       65
        
                       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       66
        
                   }

     

       67
        
               });

     

       68
        
       

     
···

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

     

       75
        
                   setIsConnected(false);

     

       76
        
               });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       78
        
       

     

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

···

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

     

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

     

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

     

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

     

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

     

       6
        
       import {

     
···

       31
        
       

     

       32
        
               // attach handlers here

     

       33
        
       

     

       34
       +
               const handleOpen = () => {

     

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

     

       36
        
                   setIsConnected(true);

     

       37
       +
                   const requestHistoryMessage: RequestHistoryMessage = {

     

       38
       +
                       type: "shard/requestHistory",

     

       39
       +
                       channel: atUriToString(channel),

     

       40
       +
                       requestedBy: sessionInfo.clientDid,

     

       41
       +
                   };

     

       42
       +
                   console.log(

     

       43
       +
                       "requested history from lattice",

     

       44
       +
                       requestHistoryMessage,

     

       45
       +
                   );

     

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

     

       47
       +
               };

     

       48
       +
       

     

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

     

       50
       +
                   handleOpen();

     

       51
       +
               }

     

       52
       +
       

     

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

     

       54
        
       

     

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

     

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

     
···

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

     

       81
        
                           break;

     

       82
        
                       }

     

       83
       +
                       case "shard/history": {

     

       84
       +
                           console.log(

     

       85
       +
                               "received history from lattice",

     

       86
       +
                               validateTypeResult.data,

     

       87
       +
                           );

     

       88
       +
                           const { success, data: historyMessage } =

     

       89
       +
                               historyMessageSchema.safeParse(validateTypeResult.data);

     

       90
       +
                           if (!success) return;

     

       91
       +
                           if (!historyMessage.messages) return;

     

       92
       +
       

     

       93
       +
                           const parseChannelResult = stringToAtUri(

     

       94
       +
                               historyMessage.channel,

     

       95
       +
                           );

     

       96
       +
       

     

       97
       +
                           if (!parseChannelResult.ok) return;

     

       98
       +
                           const { data: channelAtUri } = parseChannelResult;

     

       99
       +
       

     

       100
       +
                           if (atUriEquals(channelAtUri, channel))

     

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

     

       102
       +
                       }

     

       103
        
                   }

     

       104
        
               });

     

       105
        
       

     
···

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

     

       112
        
                   setIsConnected(false);

     

       113
        
               });

     

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

     

       115
       +
               return () => {

     

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

     

       117
       +
               };

     

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

     

       119
        
       

     

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

src/lib/types/messages.ts

···

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

     

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

     

       31
        
               channel: z.string(),

     

       0
        
       
     

       32
        
           })

     

       33
        
           .strict();

     

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

     
···

       37
        
           .safeExtend({

     

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

     

       39
        
               channel: z.string(),

     

       0
        
       
     

       40
        
           })

     

       41
        
           .strict();

     

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

···

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

     

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

     

       31
        
               channel: z.string(),

     

       32
       +
               forClient: didSchema,

     

       33
        
           })

     

       34
        
           .strict();

     

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

     
···

       38
        
           .safeExtend({

     

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

     

       40
        
               channel: z.string(),

     

       41
       +
               requestedBy: didSchema,

     

       42
        
           })

     

       43
        
           .strict();

     

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