Skip room join until we run into a 403 Forbidden and peek into world_readable rooms

server/lib/matrix-utils/create-retry-fn-if-not-joined.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const assert = require('assert');
+
+const { HTTPResponseError } = require('../fetch-endpoint');
+const ensureRoomJoined = require('./ensure-room-joined');
+
+const JOIN_STATES = {
+  unknown: 'unknown',
+  joining: 'joining',
+  joined: 'joined',
+  failed: 'failed',
+};
+const joinStateValues = Object.values(JOIN_STATES);
+
+// Optimistically use the Matrix API assuming you're already joined to the room or
+// accessing a `world_readable` room that doesn't require joining. If we see a 403
+// Forbidden, then try joining the room and retrying the API call.
+//
+// Usage: Call this once to first create a helper utility that will retry a given
+// function appropriately.
+function createRetryFnIfNotJoined(
+  accessToken,
+  roomIdOrAlias,
+  { viaServers = new Set(), abortSignal } = {}
+) {
+  assert(accessToken);
+  assert(roomIdOrAlias);
+  // We use a `Set` to ensure that we don't have duplicate servers in the list
+  assert(viaServers instanceof Set);
+
+  let joinState = JOIN_STATES.unknown;
+  let joinPromise = null;
+
+  return async function retryFnIfNotJoined(fn) {
+    assert(
+      joinStateValues.includes(joinState),
+      `Unexpected internal join state when using createRetryFnIfNotJoined(...) (joinState=${joinState}). ` +
+        `This is a bug in the Matrix Public Archive. Please report`
+    );
+
+    if (joinState === JOIN_STATES.joining) {
+      // Wait for the join to finish before trying
+      await joinPromise;
+    } else if (joinState === JOIN_STATES.failed) {
+      // If we failed to join the room, then there is no way any other call is going
+      // to succeed so just immediately return an error. We return `joinPromise`
+      // which will resolve to the join error that occured
+      return joinPromise;
+    }
+
+    try {
+      return await Promise.resolve(fn());
+    } catch (errFromFn) {
+      const isForbiddenError =
+        errFromFn instanceof HTTPResponseError && errFromFn.response.status === 403;
+
+      // If we're in the middle of joining, try again
+      if (joinState === JOIN_STATES.joining) {
+        return await retryFnIfNotJoined(fn);
+      }
+      // Try joining the room if we see a 403 Forbidden error as we may just not
+      // be part of the room yet. We can't distinguish between a room that has
+      // banned us vs a room we haven't joined yet so we just try joining the
+      // room in any case.
+      else if (
+        isForbiddenError &&
+        // Only try joining if we haven't tried joining yet
+        joinState === JOIN_STATES.unknown
+      ) {
+        joinState = JOIN_STATES.joining;
+        joinPromise = ensureRoomJoined(accessToken, roomIdOrAlias, {
+          viaServers,
+          abortSignal,
+        });
+
+        try {
+          await joinPromise;
+          joinState = JOIN_STATES.joined;
+          return await retryFnIfNotJoined(fn);
+        } catch (err) {
+          joinState = JOIN_STATES.failed;
+          throw err;
+        }
+      }
+
+      throw errFromFn;
+    }
+  };
+}
+
+module.exports = createRetryFnIfNotJoined;

server/lib/matrix-utils/ensure-room-joined.js

@@ -21,6 +21,8 @@ async function ensureRoomJoined(
   roomIdOrAlias,
   { viaServers = new Set(), abortSignal } = {}
 ) {
+  assert(accessToken);
+  assert(roomIdOrAlias);
   // We use a `Set` to ensure that we don't have duplicate servers in the list
   assert(viaServers instanceof Set);
 

server/lib/matrix-utils/fetch-public-rooms.js

@@ -40,11 +40,12 @@ async function fetchPublicRooms(
     abortSignal,
   });
 
-  // We only want to see public rooms in the archive
+  // We only want to see public or world_readable rooms in the archive. A room can be
+  // world_readable without being public. For example someone might have an invite only
+  // room where only privileged users are allowed to join and talk but anyone can view
+  // the room.
   const accessibleRooms = publicRoomsRes.chunk.filter((room) => {
-    // `room.world_readable` is also accessible here but we only use history
-    // `world_readable` to determine search indexing.
-    return room.join_rule === 'public';
+    return room.world_readable || room.join_rule === 'public';
   });
 
   return {