Follow tombstone and predecessor history

package.json

@@ -12,7 +12,7 @@
     "start": "node server/server.js",
     "start-dev": "node server/start-dev.js",
     "test": "npm run mocha -- test/**/*-tests.js --timeout 15000",
-    "test-e2e-interactive": "npm run mocha -- test/e2e-tests.js --timeout 15000 --interactive",
+    "test-e2e-interactive": "npm run mocha -- test/e2e-tests.js --timeout 15000 --bail --interactive",
     "nodemon": "nodemon",
     "vite": "vite",
     "mocha": "mocha",
@@ -23,6 +23,7 @@
     "node": ">=16.0.0"
   },
   "devDependencies": {
+    "chalk": "^4.1.2",
     "escape-string-regexp": "^4.0.0",
     "eslint": "^8.37.0",
     "eslint-config-prettier": "^8.8.0",

server/lib/matrix-utils/fetch-room-data.js

@@ -4,89 +4,204 @@ const assert = require('assert');
 
 const urlJoin = require('url-join');
 const { fetchEndpointAsJson } = require('../fetch-endpoint');
+const parseViaServersFromUserInput = require('../parse-via-servers-from-user-input');
 const { traceFunction } = require('../../tracing/trace-utilities');
 
 const config = require('../config');
 const matrixServerUrl = config.get('matrixServerUrl');
 assert(matrixServerUrl);
 
-async function fetchRoomData(accessToken, roomId) {
-  assert(accessToken);
-  assert(roomId);
-
-  const stateNameEndpoint = urlJoin(
-    matrixServerUrl,
-    `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/state/m.room.name`
-  );
-  const canoncialAliasEndpoint = urlJoin(
-    matrixServerUrl,
-    `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/state/m.room.canonical_alias`
-  );
-  const stateAvatarEndpoint = urlJoin(
+function getStateEndpointForRoomIdAndEventType(roomId, eventType) {
+  return urlJoin(
     matrixServerUrl,
-    `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/state/m.room.avatar`
+    `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/state/${encodeURIComponent(
+      eventType
+    )}?format=event`
   );
-  const stateHistoryVisibilityEndpoint = urlJoin(
-    matrixServerUrl,
-    `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/state/m.room.history_visibility`
-  );
-  const stateJoinRulesEndpoint = urlJoin(
-    matrixServerUrl,
-    `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/state/m.room.join_rules`
+}
+
+// Unfortunately, we can't just get the event ID from the `/state?format=event`
+// endpoint, so we have to do this trick. Related to
+// https://github.com/matrix-org/synapse/issues/15454
+//
+// TODO: Remove this when we have MSC3999 (because it's the only usage)
+const removeMe_fetchRoomCreateEventId = traceFunction(async function (matrixAccessToken, roomId) {
+  const { data } = await fetchEndpointAsJson(
+    urlJoin(
+      matrixServerUrl,
+      `_matrix/client/r0/rooms/${encodeURIComponent(roomId)}/messages?dir=f&limit1`
+    ),
+    {
+      accessToken: matrixAccessToken,
+    }
   );
 
+  const roomCreateEventId = data?.chunk?.[0]?.event_id;
+
+  return roomCreateEventId;
+});
+
+const fetchRoomCreationInfo = traceFunction(async function (matrixAccessToken, roomId) {
+  const [stateCreateResDataOutcome] = await Promise.allSettled([
+    fetchEndpointAsJson(getStateEndpointForRoomIdAndEventType(roomId, 'm.room.create'), {
+      accessToken: matrixAccessToken,
+    }),
+  ]);
+
+  let roomCreationTs;
+  let predecessorRoomId;
+  let predecessorLastKnownEventId;
+  if (stateCreateResDataOutcome.reason === undefined) {
+    const { data } = stateCreateResDataOutcome.value;
+    roomCreationTs = data?.origin_server_ts;
+    predecessorLastKnownEventId = data?.content?.event_id;
+    predecessorRoomId = data?.content?.predecessor?.room_id;
+  }
+
+  return { roomCreationTs, predecessorRoomId, predecessorLastKnownEventId };
+});
+
+const fetchPredecessorInfo = traceFunction(async function (matrixAccessToken, roomId) {
+  const [roomCreationInfoOutcome, statePredecessorResDataOutcome] = await Promise.allSettled([
+    fetchRoomCreationInfo(matrixAccessToken, roomId),
+    fetchEndpointAsJson(
+      getStateEndpointForRoomIdAndEventType(roomId, 'org.matrix.msc3946.room_predecessor'),
+      {
+        accessToken: matrixAccessToken,
+      }
+    ),
+  ]);
+
+  let predecessorRoomId;
+  let predecessorLastKnownEventId;
+  let predecessorViaServers;
+  // Prefer the dynamic predecessor from the dedicated state event
+  if (statePredecessorResDataOutcome.reason === undefined) {
+    const { data } = statePredecessorResDataOutcome.value;
+    predecessorRoomId = data?.content?.predecessor_room_id;
+    predecessorLastKnownEventId = data?.content?.last_known_event_id;
+    predecessorViaServers = parseViaServersFromUserInput(data?.content?.via_servers);
+  }
+  // Then fallback to the predecessor defined by the room creation event
+  else if (roomCreationInfoOutcome.reason === undefined) {
+    ({ predecessorRoomId, predecessorLastKnownEventId } = roomCreationInfoOutcome.value);
+  }
+
+  const { roomCreationTs: currentRoomCreationTs } = roomCreationInfoOutcome;
+
+  return {
+    // This is prefixed with "current" so we don't get this confused with the
+    // predecessor room creation timestamp.
+    currentRoomCreationTs,
+    predecessorRoomId,
+    predecessorLastKnownEventId,
+    predecessorViaServers,
+  };
+});
+
+const fetchSuccessorInfo = traceFunction(async function (matrixAccessToken, roomId) {
+  const [stateTombstoneResDataOutcome] = await Promise.allSettled([
+    fetchEndpointAsJson(getStateEndpointForRoomIdAndEventType(roomId, 'm.room.tombstone'), {
+      accessToken: matrixAccessToken,
+    }),
+  ]);
+
+  let successorRoomId;
+  let successorSetTs;
+  if (stateTombstoneResDataOutcome.reason === undefined) {
+    const { data } = stateTombstoneResDataOutcome.value;
+    successorRoomId = data?.content?.replacement_room;
+    successorSetTs = data?.origin_server_ts;
+  }
+
+  return {
+    successorRoomId,
+    successorSetTs,
+  };
+});
+
+// eslint-disable-next-line max-statements
+const fetchRoomData = traceFunction(async function (matrixAccessToken, roomId) {
+  assert(matrixAccessToken);
+  assert(roomId);
+
   const [
     stateNameResDataOutcome,
     stateCanonicalAliasResDataOutcome,
     stateAvatarResDataOutcome,
     stateHistoryVisibilityResDataOutcome,
     stateJoinRulesResDataOutcome,
+    predecessorInfoOutcome,
+    successorInfoOutcome,
   ] = await Promise.allSettled([
-    fetchEndpointAsJson(stateNameEndpoint, {
-      accessToken,
+    fetchEndpointAsJson(getStateEndpointForRoomIdAndEventType(roomId, 'm.room.name'), {
+      accessToken: matrixAccessToken,
     }),
-    fetchEndpointAsJson(canoncialAliasEndpoint, {
-      accessToken,
+    fetchEndpointAsJson(getStateEndpointForRoomIdAndEventType(roomId, 'm.room.canonical_alias'), {
+      accessToken: matrixAccessToken,
     }),
-    fetchEndpointAsJson(stateAvatarEndpoint, {
-      accessToken,
+    fetchEndpointAsJson(getStateEndpointForRoomIdAndEventType(roomId, 'm.room.avatar'), {
+      accessToken: matrixAccessToken,
     }),
-    fetchEndpointAsJson(stateHistoryVisibilityEndpoint, {
-      accessToken,
-    }),
-    fetchEndpointAsJson(stateJoinRulesEndpoint, {
-      accessToken,
+    fetchEndpointAsJson(
+      getStateEndpointForRoomIdAndEventType(roomId, 'm.room.history_visibility'),
+      {
+        accessToken: matrixAccessToken,
+      }
+    ),
+    fetchEndpointAsJson(getStateEndpointForRoomIdAndEventType(roomId, 'm.room.join_rules'), {
+      accessToken: matrixAccessToken,
     }),
+    fetchPredecessorInfo(matrixAccessToken, roomId),
+    fetchSuccessorInfo(matrixAccessToken, roomId),
   ]);
 
   let name;
   if (stateNameResDataOutcome.reason === undefined) {
     const { data } = stateNameResDataOutcome.value;
-    name = data.name;
+    name = data?.content?.name;
   }
 
   let canonicalAlias;
   if (stateCanonicalAliasResDataOutcome.reason === undefined) {
     const { data } = stateCanonicalAliasResDataOutcome.value;
-    canonicalAlias = data.alias;
+    canonicalAlias = data?.content?.alias;
   }
 
   let avatarUrl;
   if (stateAvatarResDataOutcome.reason === undefined) {
     const { data } = stateAvatarResDataOutcome.value;
-    avatarUrl = data.url;
+    avatarUrl = data?.content?.url;
   }
 
   let historyVisibility;
   if (stateHistoryVisibilityResDataOutcome.reason === undefined) {
     const { data } = stateHistoryVisibilityResDataOutcome.value;
-    historyVisibility = data.history_visibility;
+    historyVisibility = data?.content?.history_visibility;
   }
 
   let joinRule;
   if (stateJoinRulesResDataOutcome.reason === undefined) {
     const { data } = stateJoinRulesResDataOutcome.value;
-    joinRule = data.join_rule;
+    joinRule = data?.content?.join_rule;
+  }
+
+  let roomCreationTs;
+  let predecessorRoomId;
+  let predecessorLastKnownEventId;
+  let predecessorViaServers;
+  if (predecessorInfoOutcome.reason === undefined) {
+    ({
+      currentRoomCreationTs: roomCreationTs,
+      predecessorRoomId,
+      predecessorLastKnownEventId,
+      predecessorViaServers,
+    } = predecessorInfoOutcome.value);
+  }
+  let successorRoomId;
+  let successorSetTs;
+  if (successorInfoOutcome.reason === undefined) {
+    ({ successorRoomId, successorSetTs } = successorInfoOutcome.value);
   }
 
   return {
@@ -96,7 +211,19 @@ async function fetchRoomData(accessToken, roomId) {
     avatarUrl,
     historyVisibility,
     joinRule,
+    roomCreationTs,
+    predecessorRoomId,
+    predecessorLastKnownEventId,
+    predecessorViaServers,
+    successorRoomId,
+    successorSetTs,
   };
-}
+});
 
-module.exports = traceFunction(fetchRoomData);
+module.exports = {
+  fetchRoomData,
+  fetchRoomCreationInfo,
+  fetchPredecessorInfo,
+  fetchSuccessorInfo,
+  removeMe_fetchRoomCreateEventId,
+};

server/lib/matrix-utils/get-server-name-from-matrix-room-id-or-alias.js

@@ -4,6 +4,9 @@ const assert = require('assert');
 
 // See https://spec.matrix.org/v1.5/appendices/#server-name
 function getServerNameFromMatrixRoomIdOrAlias(roomIdOrAlias) {
+  // `roomIdOrAlias` looks like `!foo:matrix.org` or `#foo:matrix.org` or even something
+  // as crazy as `!foo:[1234:5678::abcd]:1234` where `[1234:5678::abcd]:1234` is the
+  // server name part we're trying to parse out (see tests for more examples)
   assert(roomIdOrAlias);
 
   const pieces = roomIdOrAlias.split(':');