app: clear oauth session stuff on rejection (#227)

* app: clear oauth session stuff on rejection

* app: handle changeURL action for anonPDS

js/app/features/bluesky/blueskySlice.tsx

···
   MessageViewHydrated,
   PlayersState,
 } from "features/player/playerSlice";
-import { StreamplaceState } from "features/streamplace/streamplaceSlice";
+import {
+  StreamplaceState,
+  setURL,
+} from "features/streamplace/streamplaceSlice";
 import {
   PlaceStreamChatMessage,
   PlaceStreamChatProfile,
···
   oauthState: null,
   oauthSession: null,
   pdsAgent: null,
+  anonPDSAgent: null,
   profiles: {},
   profileCache: {},
   client: null,
···
         storedKey: action.payload.storedKey,
       };
     });
+    builder.addCase(setURL, (state, action) => {
+      return {
+        ...state,
+        anonPDSAgent: new StreamplaceAgent(action.payload) as any,
+      };
+    });
+    builder.addDefaultCase((state, action) => {
+      const err = (action as any).error as { message: string };
+      if (
+        typeof err === "object" &&
+        typeof err?.message === "string" &&
+        err.message.includes("oauth session revoked")
+      ) {
+        Storage.removeItem("did").catch((e) => {
+          console.error("Error removing did", e);
+        });
+        Storage.removeItem(STORED_KEY_KEY).catch((e) => {
+          console.error("Error removing stored key", e);
+        });
+        const u = new URL(document.location.href);
+        return {
+          ...state,
+          oauthSession: null,
+          status: "loggedOut",
+          pdsAgent: null,
+        };
+      }
+      return state;
+    });
   },
   reducers: (create) => ({
     loadOAuthClient: create.asyncThunk(
       async (_, { getState }) => {
         const { streamplace } = getState() as { streamplace: StreamplaceState };
         const client = await createOAuthClient(streamplace.url);
+        const anonPDSAgent = new StreamplaceAgent(streamplace.url);
         let initResult = await client.init();
-        return { client, initResult };
+        return { client, initResult, anonPDSAgent };
       },
       {
         pending: (state) => {
           // state.status = "loading";
         },
         fulfilled: (state, action) => {
-          const { client, initResult } = action.payload;
+          const { client, initResult, anonPDSAgent } = action.payload;
           console.log("loadOAuthClient fulfilled", action.payload);
-          // sometimes the codes don't get removed from the url properly? so we do so here.
-          // const u = new URL(document.location.href);
-          // u.search = "";
-          // window.history.replaceState(null, "", u.toString());
           if (initResult && "session" in initResult) {
             return {
               ...state,
               client: client,
               oauthSession: initResult.session as any,
-              pdsAgent: new StreamplaceAgent(initResult.session),
+              pdsAgent: new StreamplaceAgent(initResult.session) as any, // idk why this is needed
+              anonPDSAgent: anonPDSAgent,
             };
           }
           return {
             ...state,
             status: "loggedOut",
             client: client,
+            anonPDSAgent: anonPDSAgent,
           };
         },
         rejected: (state, { error }) => {

js/app/features/bluesky/blueskyTypes.tsx

···
   oauthState: null | string;
   oauthSession: null | OAuthSession;
   pdsAgent: null | StreamplaceAgent;
+  anonPDSAgent: null | StreamplaceAgent;
   profiles: { [key: string]: ProfileViewDetailed };
   // for e.g. others' avatars
   profileCache: { [key: string]: ProfileViewDetailed };

js/app/features/streamplace/streamplaceSlice.tsx

···
     ),
 
     setURL: create.reducer((state, action: { payload: string }) => {
+      console.log("setURL", action);
       Storage.setItem(URL_KEY, action.payload).catch((err) => {
         console.error("setURL error", err);
       });
···
           bluesky: BlueskyState;
         };
 
-        let agent = bluesky.pdsAgent;
+        let agent = bluesky.anonPDSAgent;
 
         if (!agent) {
-          agent = new StreamplaceAgent(streamplace.url);
+          throw new Error("no anonPDSAgent");
         }
 
         let users = await agent.place.stream.live.getLiveUsers();