Try to resolve emails before creating a DM (#10164)

src/components/views/dialogs/InviteDialog.tsx

@@ -469,10 +469,14 @@ export default class InviteDialog extends React.PureComponent<Props, IInviteDial
     }
 
     private startDm = async (): Promise<void> => {
+        this.setState({
+            busy: true,
+        });
+
         try {
             const cli = MatrixClientPeg.get();
             const targets = this.convertFilter();
-            startDmOnFirstMessage(cli, targets);
+            await startDmOnFirstMessage(cli, targets);
             this.props.onFinished(true);
         } catch (err) {
             logger.error(err);

src/utils/direct-messages.ts

@@ -28,9 +28,19 @@ import { findDMRoom } from "./dm/findDMRoom";
 import { privateShouldBeEncrypted } from "./rooms";
 import { createDmLocalRoom } from "./dm/createDmLocalRoom";
 import { startDm } from "./dm/startDm";
+import { resolveThreePids } from "./threepids";
 
 export async function startDmOnFirstMessage(client: MatrixClient, targets: Member[]): Promise<Room> {
-    const existingRoom = findDMRoom(client, targets);
+    let resolvedTargets = targets;
+
+    try {
+        resolvedTargets = await resolveThreePids(targets, client);
+    } catch (e) {
+        logger.warn("Error resolving 3rd-party members", e);
+    }
+
+    const existingRoom = findDMRoom(client, resolvedTargets);
+
     if (existingRoom) {
         dis.dispatch<ViewRoomPayload>({
             action: Action.ViewRoom,
@@ -42,12 +52,12 @@ export async function startDmOnFirstMessage(client: MatrixClient, targets: Membe
         return existingRoom;
     }
 
-    const room = await createDmLocalRoom(client, targets);
+    const room = await createDmLocalRoom(client, resolvedTargets);
     dis.dispatch({
         action: Action.ViewRoom,
         room_id: room.roomId,
         joining: false,
-        targets,
+        targets: resolvedTargets,
     });
     return room;
 }

src/utils/threepids.ts

@@ -0,0 +1,106 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixClient } from "matrix-js-sdk/src/matrix";
+
+import { DirectoryMember, Member, ThreepidMember } from "./direct-messages";
+
+/**
+ * Tries to resolve the ThreepidMembers to DirectoryMembers.
+ *
+ * @param members - List of members to resolve
+ * @returns {Promise<Member[]>} Same list with ThreepidMembers replaced by DirectoryMembers if succesfully resolved
+ */
+export const resolveThreePids = async (members: Member[], client: MatrixClient): Promise<Member[]> => {
+    const threePidMembers = members.filter((m) => m instanceof ThreepidMember) as ThreepidMember[];
+
+    // Nothing to do here
+    if (threePidMembers.length === 0) return members;
+
+    const lookedUpProfiles = await lookupThreePidProfiles(threePidMembers, client);
+
+    return members.map((member: Member) => {
+        if (!(member instanceof ThreepidMember)) return member;
+
+        const lookedUpProfile = lookedUpProfiles.find((r) => r.threePidId === member.userId);
+
+        // No profile found for this member; use the ThreepidMember.
+        if (!lookedUpProfile) return member;
+
+        return new DirectoryMember({
+            user_id: lookedUpProfile.mxid,
+            avatar_url: lookedUpProfile?.profile?.avatar_url,
+            display_name: lookedUpProfile?.profile?.displayname,
+        });
+    });
+};
+
+/**
+ * Tries to look up the ThreepidMembers.
+ *
+ * @param threePids - List of 3rd-party members to look up
+ * @returns  List of resolved 3rd-party IDs with their MXIDs
+ */
+export const lookupThreePids = async (
+    threePids: ThreepidMember[],
+    client: MatrixClient,
+): Promise<{ threePidId: string; mxid: string }[]> => {
+    // No identity server configured. Unable to resolve any 3rd party member.
+    if (!client.identityServer) return [];
+
+    // Nothing we can search, return null
+    if (threePids.length === 0) return [];
+
+    const token = await client.identityServer.getAccessToken();
+    const lookedUp = await client.bulkLookupThreePids(
+        threePids.map((t) => [t.isEmail ? "email" : "msisdn", t.userId]),
+        token,
+    );
+
+    return lookedUp.threepids.map(([_threePidType, threePidId, mxid]: [string, string, string]) => ({
+        threePidId,
+        mxid,
+    }));
+};
+
+/**
+ * Tries to look up the MXIDs and profiles of the ThreepidMembers.
+ *
+ * @param threePids - List of 3rd-prty members to look up
+ * @returns List of resolved 3rd-party members with their MXIDs and profile (if found)
+ */
+export const lookupThreePidProfiles = async (
+    threePids: ThreepidMember[],
+    client: MatrixClient,
+): Promise<{ threePidId: string; mxid: string; profile: null | { avatar_url?: string; displayname?: string } }[]> => {
+    const lookedUpThreePids = await lookupThreePids(threePids, client);
+    const promises = lookedUpThreePids.map(async (t) => {
+        let profile: null | { avatar_url?: string; display_name?: string } = null;
+
+        try {
+            profile = await client.getProfileInfo(t.mxid);
+        } catch {
+            // ignore any lookup error
+        }
+
+        return {
+            threePidId: t.threePidId,
+            mxid: t.mxid,
+            profile,
+        };
+    });
+    return Promise.all(promises);
+};