commit 5b66a1f49bdd97c57d00353805c7d3840d83deee · gmstn.systems/gemstone-app

+1 -1

src/providers/authed/ChannelsProvider.tsx

···

       25
       25
        
           const channelsValue = useContext(ChannelsContext);

     

       26
       26
        
           if (!channelsValue)

     

       27
       27
        
               throw new Error(

     

       28
       28
       -
                   "Channels context was null. Did you try to access this outside of the authed providers? ChannelsProvider must be below OAuth provider.",

     

       28
       28
       +
                   "Channels context was null. Did you try to access this outside of the authed providers? ChannelsProvider must be below MembershipsProvider.",

     

       29
       29
        
               );

     

       30
       30
        
           return channelsValue;

     

       31
       31
        
       };

+29 -39

src/providers/authed/LatticeSessionsProvider.tsx src/providers/authed/HandshakesProvider.tsx

···

       19
       19
        
       import type { ReactNode } from "react";

     

       20
       20
        
       import { createContext, useContext, useMemo } from "react";

     

       21
       21
        
       

     

       22
       22
       -
       type LatticeSessionsMap = Map<Did, LatticeSessionInfo>;

     

       22
       22
       +
       type HandshakesMap = Map<Did, LatticeSessionInfo>;

     

       23
       23
        
       

     

       24
       24
       -
       interface LatticeSessionContextValue {

     

       25
       25
       -
           sessions: LatticeSessionsMap;

     

       24
       24
       +
       interface HandshakeContextValue {

     

       25
       25
       +
           handshakesMap: HandshakesMap;

     

       26
       26
        
           isInitialising: boolean;

     

       27
       27
        
           error: Error | null;

     

       28
       28
       -
           getSession: (latticeDid: Did) => LatticeSessionInfo | undefined;

     

       28
       28
       +
           getHandshake: (latticeDid: Did) => LatticeSessionInfo | undefined;

     

       29
       29
        
       }

     

       30
       30
        
       

     

       31
       31
       -
       const LatticeSessionsContext = createContext<LatticeSessionContextValue | null>(

     

       32
       32
       -
           null,

     

       33
       33
       -
       );

     

       31
       31
       +
       const HandshakesContext = createContext<HandshakeContextValue | null>(null);

     

       34
       32
        
       

     

       35
       35
       -
       export const useLatticeSession = () => {

     

       36
       36
       -
           const value = useContext(LatticeSessionsContext);

     

       37
       37
       -
           if (value === null)

     

       33
       33
       +
       export const useHandshakes = () => {

     

       34
       34
       +
           const handshakesValue = useContext(HandshakesContext);

     

       35
       35
       +
           if (!handshakesValue)

     

       38
       36
        
               throw new Error(

     

       39
       39
       -
                   "Lattice session context not inited. Or ordering of providers was wrong.",

     

       37
       37
       +
                   "Handshakes context was null. Did you try to access this outside of the authed providers? HandshakesProvider(Inner) must be below ChannelsProvider.",

     

       40
       38
        
               );

     

       41
       41
       -
           return value.sessions;

     

       39
       39
       +
           return handshakesValue;

     

       42
       40
        
       };

     

       43
       41
        
       

     

       44
       44
       -
       const LatticeSessionsProviderInner = ({

     

       45
       45
       -
           children,

     

       46
       46
       -
       }: {

     

       47
       47
       -
           children: ReactNode;

     

       48
       48
       -
       }) => {

     

       42
       42
       +
       const HandshakesProviderInner = ({ children }: { children: ReactNode }) => {

     

       49
       43
        
           const {

     

       50
       44
        
               memberships,

     

       51
       45
        
               isInitialising: membershipsInitialising,

     
···

       64
       58
        
                   "LatticeSessionsProvider must be used within an OAuth provider.",

     

       65
       59
        
               );

     

       66
       60
        
       

     

       67
       67
       -
           const { session, isLoading, agent, client } = oauth;

     

       68
       68
       -
           const isOAuthReady = !isLoading && !!agent && !!client && !!session;

     

       61
       61
       +
           const {

     

       62
       62
       +
               session: oAuthSession,

     

       63
       63
       +
               isLoading: isOauthLoading,

     

       64
       64
       +
               agent: oAuthAgent,

     

       65
       65
       +
               client: oAuthClient,

     

       66
       66
       +
           } = oauth;

     

       67
       67
       +
           const isOAuthReady =

     

       68
       68
       +
               !isOauthLoading && !!oAuthAgent && !!oAuthClient && !!oAuthSession;

     

       69
       69
        
       

     

       70
       70
        
           const handshakeQueries = useQueries({

     

       71
       71
        
               queries: channels.map((channelObj) => ({

     
···

       94
       94
        
               handshakeQueries.find((q) => q.error)?.error ??

     

       95
       95
        
               null;

     

       96
       96
        
       

     

       97
       97
       -
           const sessions = useMemo(() => {

     

       98
       98
       -
               const sessionsMap = new Map<Did, LatticeSessionInfo>();

     

       97
       97
       +
           const handshakes = useMemo(() => {

     

       98
       98
       +
               const handshakesMap = new Map<Did, LatticeSessionInfo>();

     

       99
       99
        
               handshakeQueries.forEach((queryResult) => {

     

       100
       100
        
                   if (queryResult.data) {

     

       101
       101
        
                       const { did, sessionInfo } = queryResult.data;

     

       102
       102
       -
                       sessionsMap.set(did, sessionInfo);

     

       102
       102
       +
                       handshakesMap.set(did, sessionInfo);

     

       103
       103
        
                   }

     

       104
       104
        
               });

     

       105
       105
       -
               return sessionsMap;

     

       105
       105
       +
               return handshakesMap;

     

       106
       106
        
           }, [handshakeQueries]);

     

       107
       107
        
       

     

       108
       108
       -
           const value: LatticeSessionContextValue = {

     

       108
       108
       +
           const value: HandshakeContextValue = {

     

       109
       109
        
               isInitialising,

     

       110
       110
        
               error,

     

       111
       111
       -
               sessions,

     

       112
       112
       -
               getSession: (latticeDid) => sessions.get(latticeDid),

     

       111
       111
       +
               handshakesMap: handshakes,

     

       112
       112
       +
               getHandshake: (latticeDid) => handshakes.get(latticeDid),

     

       113
       113
        
           };

     

       114
       114
        
       

     

       115
       115
       -
           return (

     

       116
       116
       -
               <LatticeSessionsContext value={value}>

     

       117
       117
       -
                   {children}

     

       118
       118
       -
               </LatticeSessionsContext>

     

       119
       119
       -
           );

     

       115
       115
       +
           return <HandshakesContext value={value}>{children}</HandshakesContext>;

     

       120
       116
        
       };

     

       121
       117
        
       

     

       122
       118
        
       const handshakesQueryFn = async ({

     
···

       163
       159
        
           };

     

       164
       160
        
       };

     

       165
       161
        
       

     

       166
       166
       -
       export const LatticeSessionsProvider = ({

     

       167
       167
       -
           children,

     

       168
       168
       -
       }: {

     

       169
       169
       -
           children: ReactNode;

     

       170
       170
       -
       }) => {

     

       162
       162
       +
       export const HandshakesProvider = ({ children }: { children: ReactNode }) => {

     

       171
       163
        
           // Memberships must be above channels

     

       172
       164
        
           // channels must be above lattice sessions inner

     

       173
       165
        
           // do it this way to preserve the order if we need to move them around some day

     

       174
       166
        
           return (

     

       175
       167
        
               <MembershipsProvider>

     

       176
       168
        
                   <ChannelsProvider>

     

       177
       177
       -
                       <LatticeSessionsProviderInner>

     

       178
       178
       -
                           {children}

     

       179
       179
       -
                       </LatticeSessionsProviderInner>

     

       169
       169
       +
                       <HandshakesProviderInner>{children}</HandshakesProviderInner>

     

       180
       170
        
                   </ChannelsProvider>

     

       181
       171
        
               </MembershipsProvider>

     

       182
       172
        
           );

+1 -1

src/providers/authed/MembershipsProvider.tsx

···

       24
       24
        
           const membershipsValue = useContext(MembershipsContext);

     

       25
       25
        
           if (!membershipsValue)

     

       26
       26
        
               throw new Error(

     

       27
       27
       -
                   "Memberships context was null. Did you try to access this outside of the authed providers? MembershipsProvider must be below OAuth provider.",

     

       27
       27
       +
                   "Memberships context was null. Did you try to access this outside of the authed providers? MembershipsProvider must be below OAuthProvider.",

     

       28
       28
        
               );

     

       29
       29
        
           return membershipsValue;

     

       30
       30
        
       };

+2 -2

src/providers/authed/index.tsx

···

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

     

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

     

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

     

       3
       3
        
       

     

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

     

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

     

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

     

       6
       6
        
       };