refactor(federation): ♻️ More federation logic cleanup

api/api/v1/accounts/lookup/index.ts

@@ -117,6 +117,10 @@ export default apiRoute((app) =>
 
         const uri = await User.webFinger(manager, username, domain);
 
+        if (!uri) {
+            return context.json({ error: "Account not found" }, 404);
+        }
+
         const foundAccount = await User.resolve(uri);
 
         if (foundAccount) {

api/api/v1/accounts/search/index.ts

@@ -1,4 +1,10 @@
-import { apiRoute, applyConfig, auth, userAddressValidator } from "@/api";
+import {
+    apiRoute,
+    applyConfig,
+    auth,
+    parseUserAddress,
+    userAddressValidator,
+} from "@/api";
 import { createRoute } from "@hono/zod-openapi";
 import { User } from "@versia/kit/db";
 import { RolePermissions, Users } from "@versia/kit/tables";
@@ -77,20 +83,22 @@ export default apiRoute((app) =>
             return context.json({ error: "Unauthorized" }, 401);
         }
 
-        const [username, host] = q.replace(/^@/, "").split("@");
+        const { username, domain } = parseUserAddress(q);
 
         const accounts: User[] = [];
 
-        if (resolve && username && host) {
+        if (resolve && domain) {
             const manager = await (self ?? User).getFederationRequester();
 
-            const uri = await User.webFinger(manager, username, host);
+            const uri = await User.webFinger(manager, username, domain);
 
+            if (uri) {
                 const resolvedUser = await User.resolve(uri);
 
                 if (resolvedUser) {
                     accounts.push(resolvedUser);
                 }
+            }
         } else {
             accounts.push(
                 ...(await User.manyFromSql(

api/api/v1/statuses/:id/reblog.ts

@@ -138,7 +138,7 @@ export default apiRoute((app) =>
         }
 
         if (note.author.isLocal() && user.isLocal()) {
-            await note.author.createNotification("reblog", user, newReblog);
+            await note.author.notify("reblog", user, newReblog);
         }
 
         return context.json(await finalNewReblog.toApi(user), 201);

api/api/v2/search/index.ts

@@ -163,6 +163,7 @@ export default apiRoute((app) =>
 
                     const uri = await User.webFinger(manager, username, domain);
 
+                    if (uri) {
                         const newUser = await User.resolve(uri);
 
                         if (newUser) {
@@ -177,6 +178,7 @@ export default apiRoute((app) =>
                         }
                     }
                 }
+            }
 
             accountResults = await searchManager.searchAccounts(
                 q,

classes/database/emoji.ts

@@ -3,7 +3,7 @@ import { proxyUrl } from "@/response";
 import type { Emoji as APIEmoji } from "@versia/client/types";
 import type { CustomEmojiExtension } from "@versia/federation/types";
 import { type Instance, db } from "@versia/kit/db";
-import { Emojis, Instances } from "@versia/kit/tables";
+import { Emojis, type Instances } from "@versia/kit/tables";
 import {
     type InferInsertModel,
     type InferSelectModel,
@@ -137,26 +137,15 @@ export class Emoji extends BaseInterface<typeof Emojis, EmojiWithInstance> {
         emojiToFetch: CustomEmojiExtension["emojis"][0],
         instance: Instance,
     ): Promise<Emoji> {
-        const existingEmoji = await db
+        const existingEmoji = await Emoji.fromSql(
-            .select()
-            .from(Emojis)
-            .innerJoin(Instances, eq(Emojis.instanceId, Instances.id))
-            .where(
             and(
                 eq(Emojis.shortcode, emojiToFetch.name),
-                    eq(Instances.id, instance.id),
+                eq(Emojis.instanceId, instance.id),
             ),
-            )
+        );
-            .limit(1);
 
-        if (existingEmoji[0]) {
+        if (existingEmoji) {
-            const found = await Emoji.fromId(existingEmoji[0].Emojis.id);
+            return existingEmoji;
-
-            if (!found) {
-                throw new Error("Failed to fetch emoji");
-            }
-
-            return found;
         }
 
         return await Emoji.fromVersia(emojiToFetch, instance);

classes/database/note.ts

@@ -492,11 +492,7 @@ export class Note extends BaseInterface<typeof Notes, NoteTypeWithRelations> {
         // Send notifications for mentioned local users
         for (const mention of parsedMentions) {
             if (mention.isLocal()) {
-                await mention.createNotification(
+                await mention.notify("mention", data.author, newNote);
-                    "mention",
-                    data.author,
-                    newNote,
-                );
             }
         }
 

classes/database/user.ts

@@ -275,7 +275,7 @@ export class User extends BaseInterface<typeof Users, UserWithRelations> {
                 senderId: this.id,
             });
         } else {
-            await otherUser.createNotification(
+            await otherUser.notify(
                 otherUser.data.isLocked ? "follow_request" : "follow",
                 this,
             );
@@ -362,19 +362,31 @@ export class User extends BaseInterface<typeof Users, UserWithRelations> {
         });
     }
 
-    public static async webFinger(
+    /**
+     * Perform a WebFinger lookup to find a user's URI
+     * @param manager
+     * @param username
+     * @param hostname
+     * @returns URI, or null if not found
+     */
+    public static webFinger(
         manager: FederationRequester,
         username: string,
         hostname: string,
-    ): Promise<string> {
+    ): Promise<string | null> {
-        return (
+        try {
-            (await manager.webFinger(username, hostname).catch(() => null)) ??
+            return manager.webFinger(username, hostname);
-            (await manager.webFinger(
+        } catch {
+            try {
+                return manager.webFinger(
                     username,
                     hostname,
                     "application/activity+json",
-            ))
                 );
+            } catch {
+                return Promise.resolve(null);
+            }
+        }
     }
 
     public static getCount(): Promise<number> {
@@ -511,7 +523,7 @@ export class User extends BaseInterface<typeof Users, UserWithRelations> {
 
         if (this.isLocal() && note.author.isLocal()) {
             // Notify the user that their post has been favourited
-            await note.author.createNotification("favourite", this, note);
+            await note.author.notify("favourite", this, note);
         } else if (this.isLocal() && note.author.isRemote()) {
             // Federate the like
             this.federateToFollowers(newLike.toVersia());
@@ -547,7 +559,7 @@ export class User extends BaseInterface<typeof Users, UserWithRelations> {
         }
     }
 
-    public async createNotification(
+    public async notify(
         type: "mention" | "follow_request" | "follow" | "favourite" | "reblog",
         relatedUser: User,
         note?: Note,

classes/functions/status.ts

@@ -218,9 +218,9 @@ export const parseTextMentions = async (
     }
 
     const baseUrlHost = new URL(config.http.base_url).host;
-
     const isLocal = (host?: string): boolean => host === baseUrlHost || !host;
 
+    // Find local and matching users
     const foundUsers = await db
         .select({
             id: Users.id,
@@ -233,47 +233,46 @@ export const parseTextMentions = async (
             or(
                 ...mentionedPeople.map((person) =>
                     and(
-                        eq(Users.username, person?.[1] ?? ""),
+                        eq(Users.username, person[1] ?? ""),
-                        isLocal(person?.[2])
+                        isLocal(person[2])
                             ? isNull(Users.instanceId)
-                            : eq(Instances.baseUrl, person?.[2] ?? ""),
+                            : eq(Instances.baseUrl, person[2] ?? ""),
                     ),
                 ),
             ),
         );
 
-    const notFoundRemoteUsers = mentionedPeople.filter(
+    // Separate found and unresolved users
-        (person) =>
+    const finalList = await User.manyFromSql(
-            !(
-                isLocal(person?.[2]) ||
-                foundUsers.find(
-                    (user) =>
-                        user.username === person?.[1] &&
-                        user.baseUrl === person?.[2],
-                )
-            ),
-    );
-
-    const finalList =
-        foundUsers.length > 0
-            ? await User.manyFromSql(
         inArray(
             Users.id,
             foundUsers.map((u) => u.id),
         ),
-              )
+    );
-            : [];
 
-    // Attempt to resolve mentions that were not found
+    // Every remote user that isn't in database
+    const notFoundRemoteUsers = mentionedPeople.filter(
+        (p) =>
+            !(
+                foundUsers.some(
+                    (user) => user.username === p[1] && user.baseUrl === p[2],
+                ) || isLocal(p[2])
+            ),
+    );
+
+    // Resolve remote mentions not in database
     for (const person of notFoundRemoteUsers) {
         const manager = await author.getFederationRequester();
-
         const uri = await User.webFinger(
             manager,
-            person?.[1] ?? "",
+            person[1] ?? "",
-            person?.[2] ?? "",
+            person[2] ?? "",
         );
 
+        if (!uri) {
+            continue;
+        }
+
         const user = await User.resolve(uri);
 
         if (user) {
@@ -285,51 +284,35 @@ export const parseTextMentions = async (
 };
 
 export const replaceTextMentions = (text: string, mentions: User[]): string => {
-    let finalText = text;
+    return mentions.reduce((finalText, mention) => {
-    for (const mention of mentions) {
+        const { username, instance } = mention.data;
-        const user = mention.data;
+        const uri = mention.getUri();
-        // Replace @username and @username@domain
+        const baseHost = new URL(config.http.base_url).host;
-        if (user.instance) {
+        const linkTemplate = (displayText: string): string =>
-            finalText = finalText.replace(
+            `<a class="u-url mention" rel="nofollow noopener noreferrer" target="_blank" href="${uri}">${displayText}</a>`;
-                createRegExp(
+
-                    exactly(`@${user.username}@${user.instance.baseUrl}`),
+        if (mention.isRemote()) {
-                    [global],
+            return finalText.replaceAll(
-                ),
+                `@${username}@${instance?.baseUrl}`,
-                `<a class="u-url mention" rel="nofollow noopener noreferrer" target="_blank" href="${mention.getUri()}">@${
+                linkTemplate(`@${username}@${instance?.baseUrl}`),
-                    user.username
-                }@${user.instance.baseUrl}</a>`,
             );
-        } else {
+        }
-            finalText = finalText.replace(
+
-                // Only replace @username if it doesn't have another @ right after
+        return finalText
+            .replace(
                 createRegExp(
-                    exactly(`@${user.username}`)
+                    exactly(`@${username}`)
                         .notBefore(anyOf(letter, digit, charIn("@")))
                         .notAfter(anyOf(letter, digit, charIn("@"))),
                     [global],
                 ),
-                `<a class="u-url mention" rel="nofollow noopener noreferrer" target="_blank" href="${mention.getUri()}">@${
+                linkTemplate(`@${username}@${baseHost}`),
-                    user.username
+            )
-                }</a>`,
+            .replaceAll(
+                `@${username}@${baseHost}`,
+                linkTemplate(`@${username}@${baseHost}`),
             );
-
+    }, text);
-            finalText = finalText.replace(
-                createRegExp(
-                    exactly(
-                        `@${user.username}@${
-                            new URL(config.http.base_url).host
-                        }`,
-                    ),
-                    [global],
-                ),
-                `<a class="u-url mention" rel="nofollow noopener noreferrer" target="_blank" href="${mention.getUri()}">@${
-                    user.username
-                }</a>`,
-            );
-        }
-    }
-
-    return finalText;
 };
 
 export const contentToHtml = async (
@@ -337,8 +320,8 @@ export const contentToHtml = async (
     mentions: User[] = [],
     inline = false,
 ): Promise<string> => {
-    let htmlContent: string;
     const sanitizer = inline ? sanitizeHtmlInline : sanitizeHtml;
+    let htmlContent = "";
 
     if (content["text/html"]) {
         htmlContent = await sanitizer(content["text/html"].content);
@@ -347,29 +330,20 @@ export const contentToHtml = async (
             await markdownParse(content["text/markdown"].content),
         );
     } else if (content["text/plain"]?.content) {
-        // Split by newline and add <p> tags
         htmlContent = (await sanitizer(content["text/plain"].content))
             .split("\n")
             .map((line) => `<p>${line}</p>`)
             .join("\n");
-    } else {
-        htmlContent = "";
     }
 
-    // Replace mentions text
+    htmlContent = replaceTextMentions(htmlContent, mentions);
-    htmlContent = await replaceTextMentions(htmlContent, mentions ?? []);
 
-    // Linkify
+    return linkifyHtml(htmlContent, {
-    htmlContent = linkifyHtml(htmlContent, {
         defaultProtocol: "https",
-        validate: {
+        validate: { email: (): false => false },
-            email: (): false => false,
-        },
         target: "_blank",
         rel: "nofollow noopener noreferrer",
     });
-
-    return htmlContent;
 };
 
 export const markdownParse = async (content: string): Promise<string> => {

classes/inbox/processor.ts

@@ -333,7 +333,7 @@ export class InboxProcessor {
             languages: [],
         });
 
-        await followee.createNotification(
+        await followee.notify(
             followee.data.isLocked ? "follow_request" : "follow",
             author,
         );

cli/commands/federation/user/fetch.ts

@@ -49,6 +49,12 @@ export default class FederationUserFetch extends BaseCommand<
 
         const uri = await User.webFinger(manager, username, host);
 
+        if (!uri) {
+            spinner.fail();
+            this.log(chalk.red("User not found"));
+            this.exit(1);
+        }
+
         const newUser = await User.resolve(uri);
 
         if (newUser) {