commit a1f4f43cd8504206b4fecc1e1204f7d5af725af3 · gmstn.systems/gemstone-app

+11 -8

src/providers/authed/ChannelsProvider.tsx

···

       63
        
           const { memberships, isInitialising: membershipsInitialising } =

     

       64
        
               useMemberships();

     

       65
        
       

     

       66
       -
           // TODO: group channel memberships by

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
       

     

       68
       -
           const channelsQueries = useQueries({

     

       69
       -
               queries: memberships.map((membershipObjects) => ({

     

       70
       -
                   enabled: !membershipsInitialising,

     

       71
       -
                   queryKey: ["channel", membershipObjects.membership.channel.uri],

     

       72
       -
                   queryFn: () => channelQueryFn(membershipObjects.channelAtUri),

     

       73
       -
                   staleTime: DEFAULT_STALE_TIME,

     

       74
       -
               })),

     

       75
        
           });

     

       76
        
       

     

       77
        
           const isInitialising = channelsQueries.some((q) => q.isLoading);

···

       63
        
           const { memberships, isInitialising: membershipsInitialising } =

     

       64
        
               useMemberships();

     

       65
        
       

     

       66
       +
           // TODO: group channel memberships by lattices

     

       67
       +
           // TODO: move this to own query hook

     

       68
       +
           const channelsQueries = useQueries({

     

       69
       +
               queries: memberships.map((membershipObjects) => {

     

       70
        
       

     

       71
       +
                   return {

     

       72
       +
                       enabled: !membershipsInitialising,

     

       73
       +
                       queryKey: ["channel", membershipObjects.membership.channel.uri],

     

       74
       +
                       queryFn: () => channelQueryFn(membershipObjects.channelAtUri),

     

       75
       +
                       staleTime: DEFAULT_STALE_TIME,

     

       76
       +
                   };

     

       77
       +
               }),

     

       78
        
           });

     

       79
        
       

     

       80
        
           const isInitialising = channelsQueries.some((q) => q.isLoading);

+28 -13

src/providers/authed/HandshakesProvider.tsx

···

       64
        
           } = oauth;

     

       65
        
           const isOAuthReady = !isOauthLoading && !!oAuthAgent && !!oAuthSession;

     

       66
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
           const handshakeQueries = useQueries({

     

       68
       -
               queries: channels.map((channelObj) => ({

     

       69
       -
                   enabled: !channelsInitialising && !membershipsInitialising,

     

       70
       -
                   queryKey: ["handshakes", channelObj.channel.name],

     

       71
       -
                   queryFn: () =>

     

       72
       -
                       handshakesQueryFn({

     

       73
       -
                           channel: channelObj.channel,

     

       74
       -
                           memberships: memberships.map(

     

       75
       -
                               ({ membership }) => membership,

     

       76
       -
                           ),

     

       77
       -
                           oauth,

     

       78
       -
                       }),

     

       79
       -
                   staleTime: Infinity,

     

       80
       -
               })),

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       81
        
           });

     

       82
        
       

     

       83
        
           const isInitialising =

···

       64
        
           } = oauth;

     

       65
        
           const isOAuthReady = !isOauthLoading && !!oAuthAgent && !!oAuthSession;

     

       66
        
       

     

       67
       +
           const channelsMap = new Map<string, typeof channels>();

     

       68
       +
           channels.forEach((channelData) => {

     

       69
       +
               const key = channelData.channel.routeThrough.cid;

     

       70
       +
       

     

       71
       +
               const existingGroup = channelsMap.get(key) ?? [];

     

       72
       +
       

     

       73
       +
               existingGroup.push(channelData);

     

       74
       +
       

     

       75
       +
               channelsMap.set(key, existingGroup);

     

       76
       +
           });

     

       77
       +
       

     

       78
       +
           // TODO: move this to own query hook

     

       79
        
           const handshakeQueries = useQueries({

     

       80
       +
               queries: channelsMap

     

       81
       +
                   .values()

     

       82
       +
                   .map((channelObjs) => ({

     

       83
       +
                       enabled: !channelsInitialising && !membershipsInitialising,

     

       84
       +
                       queryKey: ["handshakes", channelObjs[0].channel.name],

     

       85
       +
                       queryFn: () =>

     

       86
       +
                           handshakesQueryFn({

     

       87
       +
                               channel: channelObjs[0].channel,

     

       88
       +
                               memberships: memberships.map(

     

       89
       +
                                   ({ membership }) => membership,

     

       90
       +
                               ),

     

       91
       +
                               oauth,

     

       92
       +
                           }),

     

       93
       +
                       staleTime: Infinity,

     

       94
       +
                   }))

     

       95
       +
                   .toArray(),

     

       96
        
           });

     

       97
        
       

     

       98
        
           const isInitialising =

+1

src/providers/authed/MembershipsProvider.tsx

···

       94
        
           const { session, isLoading, agent } = oauth;

     

       95
        
           const isOAuthReady = !isLoading && !!agent && !!session;

     

       96
        
       

     

       0
        
       
     

       97
        
           const membershipsQuery = useQuery({

     

       98
        
               queryKey: ["membership", session?.did],

     

       99
        
               enabled: isOAuthReady,

···

       94
        
           const { session, isLoading, agent } = oauth;

     

       95
        
           const isOAuthReady = !isLoading && !!agent && !!session;

     

       96
        
       

     

       97
       +
           // TODO: move this to own query hook

     

       98
        
           const membershipsQuery = useQuery({

     

       99
        
               queryKey: ["membership", session?.did],

     

       100
        
               enabled: isOAuthReady,

+1 -2

src/providers/authed/SessionsProvider.tsx

···

       37
        
               useHandshakes();

     

       38
        
           const handshakes = handshakesMap.entries().toArray();

     

       39
        
       

     

       0
        
       
     

       40
        
           const endpointQueries = useQueries({

     

       41
        
               queries: handshakes.map((handshake) => ({

     

       42
        
                   enabled: !handshakesInitialising,

     
···

       47
        
                   staleTime: DEFAULT_STALE_TIME,

     

       48
        
               })),

     

       49
        
           });

     

       50
       -
       

     

       51
       -
           console.log(endpointQueries);

     

       52
        
       

     

       53
        
           const isInitialising =

     

       54
        
               handshakesInitialising || endpointQueries.some((q) => q.isLoading);

···

       37
        
               useHandshakes();

     

       38
        
           const handshakes = handshakesMap.entries().toArray();

     

       39
        
       

     

       40
       +
           // TODO: move this to own query hook

     

       41
        
           const endpointQueries = useQueries({

     

       42
        
               queries: handshakes.map((handshake) => ({

     

       43
        
                   enabled: !handshakesInitialising,

     
···

       48
        
                   staleTime: DEFAULT_STALE_TIME,

     

       49
        
               })),

     

       50
        
           });

     

       0
        
       
     

       0
        
       
     

       51
        
       

     

       52
        
           const isInitialising =

     

       53
        
               handshakesInitialising || endpointQueries.some((q) => q.isLoading);