Fixed 267U.pre2

packages/backend/built/remote/activitypub/models/icon.js

@@ -0,0 +1 @@
+export { };

packages/backend/built/remote/activitypub/models/identifier.js

@@ -0,0 +1 @@
+export { };

packages/backend/built/remote/activitypub/models/image.js

@@ -0,0 +1,59 @@
+import { uploadFromUrl } from "../../../services/drive/upload-from-url.js";
+import Resolver from "../resolver.js";
+import { fetchMeta } from "../../../misc/fetch-meta.js";
+import { apLogger } from "../logger.js";
+import { DriveFiles } from "../../../models/index.js";
+import { truncate } from "../../../misc/truncate.js";
+import { DB_MAX_IMAGE_COMMENT_LENGTH } from "../../../misc/hard-limits.js";
+const logger = apLogger;
+/**
+ * create an Image.
+ */ export async function createImage(actor, value) {
+    // Skip if author is frozen.
+    if (actor.isSuspended) {
+        throw new Error("actor has been suspended");
+    }
+    const image = await new Resolver().resolve(value);
+    if (image.url == null) {
+        throw new Error("Invalid image, URL not provided");
+    }
+    if (!image.url.startsWith("https://") && !image.url.startsWith("http://")) {
+        throw new Error(`Invalid image, unexpected schema: ${image.url}`);
+    }
+    logger.info(`Creating the Image: ${image.url}`);
+    const instance = await fetchMeta();
+    let file = await uploadFromUrl({
+        url: image.url,
+        user: actor,
+        uri: image.url,
+        sensitive: image.sensitive,
+        isLink: !instance.cacheRemoteFiles,
+        comment: truncate(image.name, DB_MAX_IMAGE_COMMENT_LENGTH)
+    });
+    if (file.isLink) {
+        // If the URL is different, it means that the same image was previously
+        // registered with a different URL, so update the URL
+        if (file.url !== image.url) {
+            await DriveFiles.update({
+                id: file.id
+            }, {
+                url: image.url,
+                uri: image.url
+            });
+            file = await DriveFiles.findOneByOrFail({
+                id: file.id
+            });
+        }
+    }
+    return file;
+}
+/**
+ * Resolve Image.
+ *
+ * If the target Image is registered in Iceshrimp, return it, otherwise
+ * Fetch from remote server, register with Iceshrimp and return it.
+ */ export async function resolveImage(actor, value) {
+    // TODO
+    // Fetch from remote server and register
+    return await createImage(actor, value);
+}

packages/backend/built/remote/activitypub/models/mention.js

@@ -0,0 +1,17 @@
+import promiseLimit from "promise-limit";
+import { toArray, unique } from "../../../prelude/array.js";
+import { isMention } from "../type.js";
+import Resolver from "../resolver.js";
+import { resolvePerson } from "./person.js";
+import { RecursionLimiter } from "../../../models/repositories/user-profile.js";
+export async function extractApMentions(tags, limiter = new RecursionLimiter()) {
+    const hrefs = unique(extractApMentionObjects(tags).map((x)=>x.href));
+    const resolver = new Resolver();
+    const limit = promiseLimit(2);
+    const mentionedUsers = (await Promise.all(hrefs.map((x)=>limit(()=>resolvePerson(x, resolver, limiter).catch(()=>null))))).filter((x)=>x != null);
+    return mentionedUsers;
+}
+export function extractApMentionObjects(tags) {
+    if (tags == null) return [];
+    return toArray(tags).filter(isMention);
+}

packages/backend/built/remote/activitypub/models/note.js

@@ -0,0 +1,563 @@
+import promiseLimit from "promise-limit";
+import * as mfm from "mfm-js";
+import config from "../../../config/index.js";
+import Resolver from "../resolver.js";
+import post from "../../../services/note/create.js";
+import { extractMentionedUsers } from "../../../services/note/create.js";
+import { resolvePerson } from "./person.js";
+import { resolveImage } from "./image.js";
+import { htmlToMfm } from "../misc/html-to-mfm.js";
+import { extractApHashtags } from "./tag.js";
+import { unique, toArray, toSingle } from "../../../prelude/array.js";
+import { extractPollFromQuestion } from "./question.js";
+import vote from "../../../services/note/polls/vote.js";
+import { apLogger } from "../logger.js";
+import { extractDbHost, toPuny } from "../../../misc/convert-host.js";
+import { Emojis, Polls, MessagingMessages, Notes, NoteEdits, DriveFiles, PollVotes } from "../../../models/index.js";
+import { getOneApId, getApId, getOneApHrefNullable, validPost, isEmoji, getApType } from "../type.js";
+import { genId } from "../../../misc/gen-id.js";
+import { getApLock } from "../../../misc/app-lock.js";
+import { createMessage } from "../../../services/messages/create.js";
+import { parseAudience } from "../audience.js";
+import { extractApMentions } from "./mention.js";
+import DbResolver from "../db-resolver.js";
+import { StatusError } from "../../../misc/fetch.js";
+import { shouldBlockInstance } from "../../../misc/should-block-instance.js";
+import { publishNoteStream, publishNoteUpdatesStream } from "../../../services/stream.js";
+import { extractHashtags } from "../../../misc/extract-hashtags.js";
+import { UserProfiles } from "../../../models/index.js";
+import { In } from "typeorm";
+import { DB_MAX_IMAGE_COMMENT_LENGTH } from "../../../misc/hard-limits.js";
+import { truncate } from "../../../misc/truncate.js";
+import { getEmojiSize } from "../../../misc/emoji-meta.js";
+import { RecursionLimiter } from "../../../models/repositories/user-profile.js";
+const logger = apLogger;
+export function validateNote(object, uri) {
+    const expectHost = extractDbHost(uri);
+    if (object == null) {
+        return new Error("invalid Note: object is null");
+    }
+    if (!validPost.includes(getApType(object))) {
+        return new Error(`invalid Note: invalid object type ${getApType(object)}`);
+    }
+    if (object.id && extractDbHost(object.id) !== expectHost) {
+        return new Error(`invalid Note: id has different host. expected: ${expectHost}, actual: ${extractDbHost(object.id)}`);
+    }
+    if (object.attributedTo && extractDbHost(getOneApId(object.attributedTo)) !== expectHost) {
+        return new Error(`invalid Note: attributedTo has different host. expected: ${expectHost}, actual: ${extractDbHost(object.attributedTo)}`);
+    }
+    return null;
+}
+/**
+ * Fetch Notes.
+ *
+ * If the target Note is registered in Iceshrimp, it will be returned.
+ */ export async function fetchNote(object) {
+    const dbResolver = new DbResolver();
+    return await dbResolver.getNoteFromApId(object);
+}
+/**
+ * Create a Note.
+ */ export async function createNote(value, resolver, silent = false, limiter = new RecursionLimiter()) {
+    if (resolver == null) resolver = new Resolver();
+    const object = await resolver.resolve(value);
+    const entryUri = getApId(value);
+    const err = validateNote(object, entryUri);
+    if (err) {
+        logger.error(`${err.message}`, {
+            resolver: {
+                history: resolver.getHistory()
+            },
+            value: value,
+            object: object
+        });
+        throw new Error("invalid note");
+    }
+    const note = object;
+    if (note.id == null) {
+        throw new Error('Note must have an id');
+    }
+    const idUrl = new URL(note.id);
+    if (idUrl.protocol != 'https:') {
+        throw new Error(`unexpected schema of note.id: ${note.id}`);
+    }
+    let url = getOneApHrefNullable(note.url);
+    const urlUrl = url != null ? new URL(url) : null;
+    if (urlUrl != null && urlUrl.protocol != 'https:') {
+        throw new Error(`unexpected schema of note url: ${url}`);
+    }
+    logger.debug(`Note fetched: ${JSON.stringify(note, null, 2)}`);
+    logger.info(`Creating the Note: ${note.id}`);
+    // Skip if note is made before 2007 (1yr before Fedi was created)
+    // OR skip if note is made 3 days in advance
+    if (note.published) {
+        const DateChecker = new Date(note.published);
+        const FutureCheck = new Date();
+        FutureCheck.setDate(FutureCheck.getDate() + 3); // Allow some wiggle room for misconfigured hosts
+        if (DateChecker.getFullYear() < 2007) {
+            logger.warn("Note somehow made before Activitypub was created; discarding");
+            return null;
+        }
+        if (DateChecker > FutureCheck) {
+            logger.warn("Note somehow made after today; discarding");
+            return null;
+        }
+    }
+    // Fetch author
+    const actor = await resolvePerson(getOneApId(note.attributedTo), resolver, limiter);
+    if (actor.uri == null) {
+        logger.warn('Note actor uri is null, discarding');
+        return null;
+    }
+    const actorUri = new URL(actor.uri);
+    if (idUrl.host != actorUri.host) {
+        logger.warn("Note id host doesn't match actor host, discarding");
+        return null;
+    }
+    if (urlUrl != null && urlUrl.host != actorUri.host) {
+        logger.debug("Note url host doesn't match actor host, clearing variable");
+        url = undefined;
+    }
+    // Skip if author is suspended.
+    if (actor.isSuspended) {
+        logger.debug(`User ${actor.usernameLower}@${actor.host} suspended; discarding.`);
+        return null;
+    }
+    const noteAudience = await parseAudience(actor, note.to, note.cc, undefined, limiter);
+    let visibility = noteAudience.visibility;
+    const visibleUsers = noteAudience.visibleUsers;
+    // If Audience (to, cc) was not specified
+    if (visibility === "specified" && visibleUsers.length === 0) {
+        if (typeof value === "string") {
+            // If the input is a string, GET occurs in resolver
+            // Public if you can GET anonymously from here
+            visibility = "public";
+        }
+    }
+    let isTalk = note._misskey_talk && visibility === "specified";
+    const apMentions = await extractApMentions(note.tag, limiter);
+    const apHashtags = extractApHashtags(note.tag);
+    // Attachments
+    // TODO: attachmentは必ずしもImageではない
+    // TODO: attachmentは必ずしも配列ではない
+    // Noteがsensitiveなら添付もsensitiveにする
+    const limit = promiseLimit(2);
+    note.attachment = Array.isArray(note.attachment) ? note.attachment : note.attachment ? [
+        note.attachment
+    ] : [];
+    note.attachment = note.attachment.filter((attach)=>[
+            "Document",
+            "Image",
+            "Audio",
+            "Video"
+        ].includes(attach.type));
+    const files = note.attachment.map((attach)=>attach.sensitive = note.sensitive) ? (await Promise.all(note.attachment.map((x)=>limit(()=>resolveImage(actor, x))))).filter((image)=>image != null) : [];
+    // Reply
+    const reply = note.inReplyTo ? await resolveNote(note.inReplyTo, resolver, limiter).then((x)=>{
+        if (x == null) {
+            logger.warn("Specified inReplyTo, but nout found");
+            throw new Error("inReplyTo not found");
+        } else {
+            return x;
+        }
+    }).catch(async (e)=>{
+        // トークだったらinReplyToのエラーは無視
+        const uri = getApId(note.inReplyTo);
+        if (uri.startsWith(`${config.url}/`)) {
+            const id = uri.split("/").pop();
+            const talk = await MessagingMessages.findOneBy({
+                id
+            });
+            if (talk) {
+                isTalk = true;
+                return null;
+            }
+        }
+        logger.warn(`Error in inReplyTo ${note.inReplyTo} - ${e.statusCode || e}`);
+        throw e;
+    }) : null;
+    // Quote
+    let quote;
+    if (note._misskey_quote || note.quoteUrl || note.quoteUri || note.quote) {
+        const tryResolveNote = async (uri)=>{
+            if (typeof uri !== "string" || !uri.match(/^https?:/)) return {
+                status: "permerror"
+            };
+            try {
+                const res = await resolveNote(uri, undefined, limiter);
+                if (res) {
+                    return {
+                        status: "ok",
+                        res
+                    };
+                } else {
+                    return {
+                        status: "permerror"
+                    };
+                }
+            } catch (e) {
+                return {
+                    status: e instanceof StatusError && !e.isRetryable ? "permerror" : "temperror"
+                };
+            }
+        };
+        const uris = unique([
+            note._misskey_quote,
+            note.quoteUrl,
+            note.quoteUri,
+            note.quote
+        ].filter((x)=>typeof x === "string"));
+        const results = await Promise.all(uris.map((uri)=>tryResolveNote(uri)));
+        quote = results.filter((x)=>x.status === "ok").map((x)=>x.res).find((x)=>x);
+        if (!quote) {
+            if (results.some((x)=>x.status === "temperror")) {
+                throw new Error("quote resolve failed");
+            }
+        }
+    }
+    const cw = note.summary === "" ? null : note.summary;
+    // Text parsing
+    let text = null;
+    if (note.source?.mediaType === "text/x.misskeymarkdown" && typeof note.source?.content === "string") {
+        text = note.source.content;
+    } else if (typeof note._misskey_content !== "undefined") {
+        text = note._misskey_content;
+    } else if (typeof note.content === "string") {
+        text = await htmlToMfm(note.content, note.tag);
+    }
+    // vote
+    if (reply?.hasPoll) {
+        const poll = await Polls.findOneByOrFail({
+            noteId: reply.id
+        });
+        const tryCreateVote = async (name, index)=>{
+            if (poll.expiresAt && Date.now() > new Date(poll.expiresAt).getTime()) {
+                logger.warn(`vote to expired poll from AP: actor=${actor.username}@${actor.host}, note=${note.id}, choice=${name}`);
+            } else if (index >= 0) {
+                logger.info(`vote from AP: actor=${actor.username}@${actor.host}, note=${note.id}, choice=${name}`);
+                await vote(actor, reply, index);
+            }
+            return null;
+        };
+        if (note.name) {
+            return await tryCreateVote(note.name, poll.choices.findIndex((x)=>x === note.name));
+        }
+    }
+    const emojis = await extractEmojis(note.tag || [], actor.host).catch((e)=>{
+        logger.info(`extractEmojis: ${e}`);
+        return [];
+    });
+    const apEmojis = emojis.map((emoji)=>emoji.name);
+    const poll = await extractPollFromQuestion(note, resolver).catch(()=>undefined);
+    if (isTalk) {
+        for (const recipient of visibleUsers){
+            await createMessage(actor, recipient, undefined, text || undefined, files && files.length > 0 ? files[0] : null, object.id);
+            return null;
+        }
+    }
+    return await post(actor, {
+        createdAt: note.published ? new Date(note.published) : null,
+        files,
+        reply,
+        renote: quote,
+        name: note.name,
+        cw,
+        text,
+        localOnly: false,
+        visibility,
+        visibleUsers,
+        apMentions,
+        apHashtags,
+        apEmojis,
+        poll,
+        uri: note.id,
+        url: url,
+        canQuote: !!note.interactionPolicy?.canQuote
+    }, silent, limiter);
+}
+/**
+ * Resolve Note.
+ *
+ * If the target Note is registered in Iceshrimp, return it, otherwise
+ * Fetch from remote server, register with Iceshrimp and return it.
+ */ export async function resolveNote(value, resolver, limiter = new RecursionLimiter()) {
+    const uri = typeof value === "string" ? value : value.id;
+    if (uri == null) throw new Error("missing uri");
+    // Abort if origin host is blocked
+    if (await shouldBlockInstance(extractDbHost(uri))) throw new StatusError("host blocked", 451, `host ${extractDbHost(uri)} is blocked`);
+    const unlock = await getApLock(uri);
+    try {
+        //#region Returns if already registered with this server
+        const exist = await fetchNote(uri);
+        if (exist) {
+            return exist;
+        }
+        //#endregion
+        if (extractDbHost(uri) === toPuny(config.host)) {
+            throw new StatusError("cannot resolve local note", 400, "cannot resolve local note");
+        }
+        // Fetch from remote server and register
+        // If the attached `Note` Object is specified here instead of the uri, the note will be generated without going through the server fetch.
+        // Since the attached Note Object may be disguised, always specify the uri and fetch it from the server.
+        return await createNote(uri, resolver, true, limiter);
+    } finally{
+        unlock();
+    }
+}
+export async function extractEmojis(tags, host) {
+    host = toPuny(host);
+    if (!tags) return [];
+    const eomjiTags = toArray(tags).filter(isEmoji);
+    return await Promise.all(eomjiTags.map(async (tag)=>{
+        const name = tag.name.replace(/^:/, "").replace(/:$/, "");
+        tag.icon = toSingle(tag.icon);
+        const exists = await Emojis.findOneBy({
+            host,
+            name
+        });
+        if (exists) {
+            if (tag.updated != null && exists.updatedAt == null || tag.id != null && exists.uri == null || tag.updated != null && exists.updatedAt != null && new Date(tag.updated) > exists.updatedAt || tag.icon.url !== exists.originalUrl || !(exists.width && exists.height)) {
+                let size = {
+                    width: 0,
+                    height: 0
+                };
+                try {
+                    size = await getEmojiSize(tag.icon.url);
+                } catch  {
+                /* skip if any error happens */ }
+                await Emojis.update({
+                    host,
+                    name
+                }, {
+                    uri: tag.id,
+                    originalUrl: tag.icon.url,
+                    publicUrl: tag.icon.url,
+                    updatedAt: new Date(),
+                    width: size.width || null,
+                    height: size.height || null
+                });
+                return await Emojis.findOneBy({
+                    host,
+                    name
+                });
+            }
+            return exists;
+        }
+        logger.info(`register emoji host=${host}, name=${name}`);
+        let size = {
+            width: 0,
+            height: 0
+        };
+        try {
+            size = await getEmojiSize(tag.icon.url);
+        } catch  {
+        /* skip if any error happens */ }
+        return await Emojis.insert({
+            id: genId(),
+            host,
+            name,
+            uri: tag.id,
+            originalUrl: tag.icon.url,
+            publicUrl: tag.icon.url,
+            updatedAt: new Date(),
+            aliases: [],
+            glyph: tag.icon?.type === "image/svg+xml",
+            width: size.width || null,
+            height: size.height || null
+        }).then((x)=>Emojis.findOneByOrFail(x.identifiers[0]));
+    }));
+}
+function notEmpty(partial) {
+    return Object.keys(partial).length > 0;
+}
+export async function updateNote(value, actor, resolver) {
+    const uri = typeof value === "string" ? value : value.id;
+    if (!uri) throw new Error("Missing note uri");
+    // Skip if URI points to this server
+    if (extractDbHost(uri) === toPuny(config.host)) throw new Error("uri points local");
+    // A new resolver is created if not specified
+    if (resolver == null) resolver = new Resolver();
+    // Resolve the updated Note object
+    const post1 = await resolver.resolve(value);
+    if (getOneApId(post1.attributedTo) !== actor.uri || actor.uri == null) {
+        throw new Error('Refusing to ingest update for note with mismatching actor');
+    }
+    // Already registered with this server?
+    const note = await Notes.findOneBy({
+        uri
+    });
+    if (note == null) {
+        return await createNote(post1, resolver);
+    }
+    if (note.userId !== actor.id) {
+        throw new Error('Refusing to ingest update for note of different user');
+    }
+    // Whether to tell clients the note has been updated and requires refresh.
+    let updating = false;
+    // Text parsing
+    let text = null;
+    if (post1.source?.mediaType === "text/x.misskeymarkdown" && typeof post1.source?.content === "string") {
+        text = post1.source.content;
+    } else if (typeof post1._misskey_content !== "undefined") {
+        text = post1._misskey_content;
+    } else if (typeof post1.content === "string") {
+        text = await htmlToMfm(post1.content, post1.tag);
+    }
+    const cw = post1.summary === "" ? null : post1.summary;
+    // File parsing
+    const fileList = post1.attachment ? Array.isArray(post1.attachment) ? post1.attachment : [
+        post1.attachment
+    ] : [];
+    // Fetch files
+    const limit = promiseLimit(2);
+    const driveFiles = (await Promise.all(fileList.map((x)=>limit(async ()=>{
+            const file = await resolveImage(actor, x);
+            const update = {};
+            const altText = truncate(x.name, DB_MAX_IMAGE_COMMENT_LENGTH) ?? null;
+            if (file.comment !== altText) {
+                update.comment = altText;
+            }
+            // Don't unmark previously marked sensitive files,
+            // but if edited post contains sensitive marker, update it.
+            if (post1.sensitive && !file.isSensitive) {
+                update.isSensitive = post1.sensitive;
+            }
+            if (notEmpty(update)) {
+                await DriveFiles.update(file.id, update);
+                updating = true;
+            }
+            return file;
+        })))).filter((file)=>file != null);
+    const fileIds = driveFiles.map((file)=>file.id);
+    const fileTypes = driveFiles.map((file)=>file.type);
+    const apEmojis = (await extractEmojis(post1.tag || [], actor.host).catch((e)=>[])).map((emoji)=>emoji.name);
+    const apMentions = await extractApMentions(post1.tag);
+    const apHashtags = await extractApHashtags(post1.tag);
+    const poll = await extractPollFromQuestion(post1, resolver).catch(()=>undefined);
+    const choices = poll?.choices.flatMap((choice)=>mfm.parse(choice)) ?? [];
+    const tokens = mfm.parse(text || "").concat(mfm.parse(cw || "")).concat(choices);
+    const hashTags = apHashtags || extractHashtags(tokens);
+    const mentionUsers = apMentions || await extractMentionedUsers(actor, tokens);
+    const mentionUserIds = mentionUsers.map((user)=>user.id);
+    const remoteUsers = mentionUsers.filter((user)=>user.host != null);
+    const remoteUserIds = remoteUsers.map((user)=>user.id);
+    const remoteProfiles = await UserProfiles.findBy({
+        userId: In(remoteUserIds)
+    });
+    const mentionedRemoteUsers = remoteUsers.map((user)=>{
+        const profile = remoteProfiles.find((profile)=>profile.userId === user.id);
+        return {
+            username: user.username,
+            host: user.host ?? null,
+            uri: user.uri,
+            url: profile ? profile.url : undefined
+        };
+    });
+    const update = {};
+    if (text && text !== note.text) {
+        update.text = text;
+    }
+    if (cw !== note.cw) {
+        update.cw = cw ? cw : null;
+    }
+    if (fileIds.sort().join(",") !== note.fileIds.sort().join(",")) {
+        update.fileIds = fileIds;
+        update.attachedFileTypes = fileTypes;
+    }
+    if (hashTags.sort().join(",") !== note.tags.sort().join(",")) {
+        update.tags = hashTags;
+    }
+    if (mentionUserIds.sort().join(",") !== note.mentions.sort().join(",")) {
+        update.mentions = mentionUserIds;
+        update.mentionedRemoteUsers = JSON.stringify(mentionedRemoteUsers);
+    }
+    if (apEmojis.sort().join(",") !== note.emojis.sort().join(",")) {
+        update.emojis = apEmojis;
+    }
+    if (note.hasPoll !== !!poll) {
+        update.hasPoll = !!poll;
+    }
+    if (poll) {
+        const dbPoll = await Polls.findOneBy({
+            noteId: note.id
+        });
+        if (poll?.votes != null && poll.votes.find((p)=>!Number.isInteger(p) || p < 0) !== undefined) {
+            throw new Error('Refusing to ingest poll with non-integer or negative vote count');
+        }
+        if (dbPoll == null) {
+            await Polls.insert({
+                noteId: note.id,
+                choices: poll?.choices,
+                multiple: poll?.multiple,
+                votes: poll?.votes,
+                expiresAt: poll?.expiresAt,
+                noteVisibility: note.visibility === "hidden" ? "home" : note.visibility,
+                userId: actor.id,
+                userHost: actor.host
+            });
+            updating = true;
+        } else {
+            const choicesChanged = JSON.stringify(dbPoll.choices) !== JSON.stringify(poll.choices);
+            if (dbPoll.multiple !== poll.multiple || dbPoll.expiresAt !== poll.expiresAt || dbPoll.noteVisibility !== note.visibility || choicesChanged) {
+                await Polls.update({
+                    noteId: note.id
+                }, {
+                    choices: poll?.choices,
+                    multiple: poll?.multiple,
+                    votes: poll?.votes,
+                    expiresAt: poll?.expiresAt,
+                    noteVisibility: note.visibility === "hidden" ? "home" : note.visibility
+                });
+                // Reset votes
+                if (choicesChanged) {
+                    await PollVotes.delete({
+                        noteId: dbPoll.noteId
+                    });
+                }
+                updating = true;
+            } else {
+                for(let i = 0; i < poll.choices.length; i++){
+                    if (dbPoll.votes[i] !== poll.votes?.[i]) {
+                        await Polls.update({
+                            noteId: note.id
+                        }, {
+                            votes: poll?.votes
+                        });
+                        updating = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // Update Note
+    if (notEmpty(update)) {
+        update.updatedAt = new Date();
+        // Save updated note to the database
+        await Notes.update({
+            uri
+        }, update);
+        // Save an edit history for the previous note
+        await NoteEdits.insert({
+            id: genId(),
+            noteId: note.id,
+            text: note.text,
+            cw: note.cw,
+            fileIds: note.fileIds,
+            updatedAt: update.updatedAt
+        });
+        updating = true;
+    }
+    if (updating) {
+        // Publish update event for the updated note details
+        publishNoteStream(note.id, "updated", {
+            updatedAt: update.updatedAt
+        });
+        const updatedNote = {
+            ...note,
+            ...update
+        };
+        publishNoteUpdatesStream("updated", updatedNote);
+    }
+    return null;
+}

packages/backend/built/remote/activitypub/models/person.js

@@ -0,0 +1,638 @@
+import { URL } from "node:url";
+import promiseLimit from "promise-limit";
+import config from "../../../config/index.js";
+import { registerOrFetchInstanceDoc } from "../../../services/register-or-fetch-instance-doc.js";
+import { updateUsertags } from "../../../services/update-hashtag.js";
+import { Users, Instances, DriveFiles, Followings, UserProfiles, UserPublickeys } from "../../../models/index.js";
+import { User } from "../../../models/entities/user.js";
+import { UserNotePining } from "../../../models/entities/user-note-pining.js";
+import { genId } from "../../../misc/gen-id.js";
+import { instanceChart, usersChart } from "../../../services/chart/index.js";
+import { UserPublickey } from "../../../models/entities/user-publickey.js";
+import { isDuplicateKeyValueError } from "../../../misc/is-duplicate-key-value-error.js";
+import { extractDbHost, toPuny } from "../../../misc/convert-host.js";
+import { UserProfile } from "../../../models/entities/user-profile.js";
+import { toArray } from "../../../prelude/array.js";
+import { fetchInstanceMetadata } from "../../../services/fetch-instance-metadata.js";
+import { normalizeForSearch } from "../../../misc/normalize-for-search.js";
+import { truncate } from "../../../misc/truncate.js";
+import { StatusError } from "../../../misc/fetch.js";
+import { uriPersonCache } from "../../../services/user-cache.js";
+import { publishInternalEvent } from "../../../services/stream.js";
+import { db } from "../../../db/postgre.js";
+import { apLogger } from "../logger.js";
+import { htmlToMfm } from "../misc/html-to-mfm.js";
+import { fromHtml } from "../../../mfm/from-html.js";
+import { isCollectionOrOrderedCollection, isCollection, getApId, getOneApHrefNullable, isPropertyValue, getApType, isActor } from "../type.js";
+import Resolver from "../resolver.js";
+import { extractApHashtags } from "./tag.js";
+import { resolveNote, extractEmojis } from "./note.js";
+import { resolveImage } from "./image.js";
+import { getSubjectHostFromUri, getSubjectHostFromRemoteUser, getSubjectHostFromAcctParts } from "../../resolve-user.js";
+import { RecursionLimiter } from "../../../models/repositories/user-profile.js";
+import { UserConverter } from "../../../server/api/mastodon/converters/user.js";
+import fetch from "node-fetch";
+const logger = apLogger;
+const nameLength = 128;
+const summaryLength = 2048;
+/**
+ * Validate and convert to actor object
+ * @param x Fetched object
+ * @param uri Fetch target URI
+ */ function validateActor(x, uri) {
+    const expectHost = extractDbHost(uri);
+    if (x == null) {
+        throw new Error("invalid Actor: object is null");
+    }
+    if (!isActor(x)) {
+        throw new Error(`invalid Actor type '${x.type}'`);
+    }
+    if (!(typeof x.id === "string" && x.id.length > 0)) {
+        throw new Error("invalid Actor: wrong id");
+    }
+    if (!(typeof x.inbox === "string" && x.inbox.length > 0 && extractDbHost(x.inbox) === expectHost)) {
+        throw new Error("invalid Actor: wrong inbox");
+    }
+    if (!(typeof x.outbox === "string" && x.outbox.length > 0 && extractDbHost(getApId(x.outbox)) === expectHost)) {
+        throw new Error("invalid Actor: wrong outbox");
+    }
+    const sharedInboxObject = x.sharedInbox ?? (x.endpoints ? x.endpoints.sharedInbox : undefined);
+    if (sharedInboxObject != null) {
+        const sharedInbox = getApId(sharedInboxObject);
+        if (!(typeof sharedInbox === "string" && sharedInbox.length > 0 && extractDbHost(sharedInbox) === expectHost)) {
+            throw new Error("invalid Actor: wrong shared inbox");
+        }
+    }
+    if (x.followers != null) {
+        x.followers = getApId(x.followers);
+        if (!(typeof x.followers === "string" && x.followers.length > 0 && extractDbHost(x.followers) === expectHost)) {
+            throw new Error("invalid Actor: wrong followers");
+        }
+    }
+    if (x.following != null) {
+        x.following = getApId(x.following);
+        if (!(typeof x.following === "string" && x.following.length > 0 && extractDbHost(x.following) === expectHost)) {
+            throw new Error("invalid Actor: wrong following");
+        }
+    }
+    if (!(typeof x.preferredUsername === "string" && x.preferredUsername.length > 0 && x.preferredUsername.length <= 128 && /^\w([\w-.]*\w)?$/.test(x.preferredUsername))) {
+        throw new Error("invalid Actor: wrong username");
+    }
+    // These fields are only informational, and some AP software allows these
+    // fields to be very long. If they are too long, we cut them off. This way
+    // we can at least see these users and their activities.
+    if (x.name) {
+        if (!(typeof x.name === "string" && x.name.length > 0)) {
+            throw new Error("invalid Actor: wrong name");
+        }
+        x.name = truncate(x.name, nameLength);
+    }
+    if (x.summary) {
+        if (!(typeof x.summary === "string" && x.summary.length > 0)) {
+            throw new Error("invalid Actor: wrong summary");
+        }
+        x.summary = truncate(x.summary, summaryLength);
+    }
+    const idHost = toPuny(new URL(x.id).host);
+    if (idHost !== expectHost) {
+        throw new Error("invalid Actor: id has different host");
+    }
+    if (x.publicKey) {
+        if (typeof x.publicKey.id !== "string") {
+            throw new Error("invalid Actor: publicKey.id is not a string");
+        }
+        const publicKeyIdHost = toPuny(new URL(x.publicKey.id).host);
+        if (publicKeyIdHost !== expectHost) {
+            throw new Error("invalid Actor: publicKey.id has different host");
+        }
+    }
+    if (x.pronouns) {
+        if (typeof x.pronouns !== "object") {
+            throw new Error("invalid Actor: pronouns is not an object");
+        }
+        for (const key of Object.keys(x.pronouns)){
+            if (typeof x.pronouns[key] !== "string") {
+                throw new Error(`invalid Actor: pronouns.${key} is not a string`);
+            }
+        }
+    }
+    if (x.canBite && typeof x.canBite !== "string") {
+        throw new Error("invalid Actor: canBite is not a string");
+    }
+    return x;
+}
+/**
+ * Fetch a Person.
+ *
+ * If the target Person is registered in Iceshrimp, it will be returned.
+ */ export async function fetchPerson(uri, resolver) {
+    if (typeof uri !== "string") throw new Error("uri is not string");
+    const cached = await uriPersonCache.get(uri, true);
+    if (cached) return cached;
+    // Fetch from the database if the URI points to this server
+    if (extractDbHost(uri) === toPuny(config.host)) {
+        const id = uri.split("/").pop();
+        const u = await Users.findOneBy({
+            id
+        });
+        if (u) await uriPersonCache.set(uri, u);
+        return u;
+    }
+    //#region Returns if already registered with this server
+    const user = await Users.findOneBy({
+        uri
+    });
+    if (user != null) {
+        await uriPersonCache.set(uri, user);
+        return user;
+    }
+    //#endregion
+    return null;
+}
+/**
+ * Create Person.
+ */ export async function createPerson(uri, resolver, subjectHost, limiter = new RecursionLimiter()) {
+    if (typeof uri !== "string") throw new Error("uri is not string");
+    if (extractDbHost(uri) === toPuny(config.host)) {
+        throw new StatusError("cannot resolve local user", 400, "cannot resolve local user");
+    }
+    if (resolver == null) resolver = new Resolver();
+    let object = await resolver.resolve(uri);
+    let person;
+    try {
+        person = validateActor(object, uri);
+    } catch (e) {
+        // Work around GoToSocial issue #1186 (ref: https://github.com/superseriousbusiness/gotosocial/issues/1186)
+        if (typeof object.publicKey?.owner !== 'string' || object.inbox != null) throw e;
+        logger.info(`Received stub actor, re-resolving with key owner uri: ${object.publicKey.owner}`);
+        object = await resolver.resolve(object.publicKey.owner);
+        person = validateActor(object, uri);
+    }
+    logger.info(`Creating the Person: ${person.id}`);
+    const usernameLower = person.preferredUsername?.toLowerCase();
+    const urlHostname = toPuny(new URL(object.id).hostname);
+    const host = subjectHost ?? await getSubjectHostFromUri(object.id) ?? await getSubjectHostFromAcctParts(usernameLower, urlHostname) ?? urlHostname;
+    if (usernameLower !== null) {
+        let checkUser = await Users.findOneBy({
+            usernameLower: usernameLower,
+            host: toPuny(new URL(object.id).hostname)
+        });
+        if (checkUser != null) {
+            logger.info('Person already exists');
+            if (host != checkUser.host) {
+                logger.info(`Updating existing person with canonical account domain (${usernameLower}@${checkUser.host} -> ${usernameLower}@${host})`);
+                await Users.update({
+                    usernameLower: usernameLower,
+                    host: checkUser.host
+                }, {
+                    host: host
+                });
+                checkUser.host = host;
+            }
+            logger.info('Returning existing person');
+            return checkUser;
+        }
+        if (host != toPuny(new URL(object.id).hostname)) {
+            checkUser = await Users.findOneBy({
+                usernameLower: usernameLower,
+                host: host
+            });
+            if (checkUser != null) {
+                logger.info('Person already exists');
+                logger.info('Returning existing person');
+                return checkUser;
+            }
+        }
+    }
+    const { fields } = await analyzeAttachments(person.attachment || []);
+    const tags = extractApHashtags(person.tag).map((tag)=>normalizeForSearch(tag)).splice(0, 32);
+    const isBot = getApType(object) === "Service";
+    const bday = person["vcard:bday"]?.match(/^\d{4}-\d{2}-\d{2}/);
+    let url = getOneApHrefNullable(person.url);
+    const urlUrl = url != null ? new URL(url) : null;
+    const uriUrl = new URL(uri);
+    if (urlUrl != null && urlUrl.protocol != 'https:') {
+        throw new Error(`unexpected schema of person url: ${url}`);
+    }
+    if (urlUrl != null && urlUrl.host != uriUrl.host) {
+        logger.debug("Person url host doesn't match person uri host, clearing variable");
+        url = undefined;
+    }
+    let followersCount;
+    if (typeof person.followers === "string") {
+        try {
+            let data = await fetch(person.followers, {
+                headers: {
+                    Accept: "application/json"
+                },
+                size: 1024 * 1024
+            });
+            let json_data = JSON.parse(await data.text());
+            followersCount = json_data.totalItems;
+        } catch  {
+            followersCount = undefined;
+        }
+    }
+    let followingCount;
+    if (typeof person.following === "string") {
+        try {
+            let data = await fetch(person.following, {
+                headers: {
+                    Accept: "application/json"
+                },
+                size: 1024 * 1024
+            });
+            let json_data = JSON.parse(await data.text());
+            followingCount = json_data.totalItems;
+        } catch (e) {
+            followingCount = undefined;
+        }
+    }
+    let canBite = "nobody";
+    if (person.canBite) {
+        if (person.canBite === "https://www.w3.org/ns/activitystreams#Public") {
+            canBite = "anyone";
+        } else if (person.followers && person.canBite === getApId(person.followers)) {
+            canBite = "followers";
+        }
+    }
+    // Prepare objects
+    let user = new User({
+        id: genId(),
+        avatarId: null,
+        bannerId: null,
+        createdAt: new Date(),
+        lastFetchedAt: new Date(),
+        name: truncate(person.name, nameLength),
+        isLocked: !!person.manuallyApprovesFollowers,
+        movedToUri: person.movedTo,
+        alsoKnownAs: person.alsoKnownAs,
+        isExplorable: !!person.discoverable,
+        username: person.preferredUsername,
+        usernameLower: person.preferredUsername.toLowerCase(),
+        host,
+        inbox: person.inbox,
+        sharedInbox: person.sharedInbox || (person.endpoints ? person.endpoints.sharedInbox : undefined),
+        followersUri: person.followers ? getApId(person.followers) : undefined,
+        followersCount: followersCount !== undefined ? followersCount : person.followers && typeof person.followers !== "string" && isCollectionOrOrderedCollection(person.followers) ? person.followers.totalItems : undefined,
+        followingCount: followingCount !== undefined ? followingCount : person.following && typeof person.following !== "string" && isCollectionOrOrderedCollection(person.following) ? person.following.totalItems : undefined,
+        featured: person.featured ? getApId(person.featured) : undefined,
+        uri: person.id,
+        tags,
+        isBot,
+        isCat: person.isCat === true,
+        canBite
+    });
+    const profile = new UserProfile({
+        userId: user.id,
+        description: person.summary ? await htmlToMfm(truncate(person.summary, summaryLength), person.tag) : null,
+        url: url,
+        fields,
+        birthday: bday ? bday[0] : null,
+        location: person["vcard:Address"] || null,
+        userHost: host,
+        pronouns: person.pronouns || {}
+    });
+    const publicKey = person.publicKey ? new UserPublickey({
+        userId: user.id,
+        keyId: person.publicKey.id,
+        keyPem: person.publicKey.publicKeyPem
+    }) : null;
+    try {
+        // Save the objects atomically using a db transaction, note that we should never run any code in a transaction block directly
+        await db.transaction(async (transactionalEntityManager)=>{
+            await transactionalEntityManager.save(user);
+            await transactionalEntityManager.save(profile);
+            if (publicKey) await transactionalEntityManager.save(publicKey);
+        });
+    } catch (e) {
+        // duplicate key error
+        if (isDuplicateKeyValueError(e)) {
+            // /users/@a => /users/:id Corresponds to an error that may occur when the input is an alias like
+            const u = await Users.findOneBy({
+                uri: person.id
+            });
+            if (u) {
+                user = u;
+            } else {
+                throw new Error("already registered");
+            }
+        } else {
+            logger.error(e instanceof Error ? e : new Error(e));
+            throw e;
+        }
+    }
+    // Register host
+    registerOrFetchInstanceDoc(host).then((i)=>{
+        Instances.increment({
+            id: i.id
+        }, "usersCount", 1);
+        instanceChart.newUser(i.host);
+        fetchInstanceMetadata(i);
+    });
+    usersChart.update(user, true);
+    // Hashtag update
+    updateUsertags(user, tags);
+    // Mentions update, then prewarm html cache
+    if (await limiter.shouldContinue()) UserProfiles.updateMentions(user.id, limiter).then((_)=>UserConverter.prewarmCacheById(user.id));
+    //#region Fetch avatar and header image
+    const [avatar, banner] = await Promise.all([
+        person.icon,
+        person.image
+    ].map((img)=>img == null ? Promise.resolve(null) : resolveImage(user, img).catch(()=>null)));
+    const avatarId = avatar?.id ?? null;
+    const avatarBlurhash = avatar?.blurhash ?? null;
+    const avatarUrl = avatar ? DriveFiles.getDatabasePrefetchUrl(avatar, true) : null;
+    const bannerId = banner?.id ?? null;
+    const bannerBlurhash = banner?.blurhash ?? null;
+    const bannerUrl = banner ? DriveFiles.getDatabasePrefetchUrl(banner, false) : null;
+    await Users.update(user.id, {
+        avatarId,
+        avatarBlurhash,
+        avatarUrl,
+        bannerId,
+        bannerBlurhash,
+        bannerUrl
+    });
+    user.avatarId = avatarId;
+    user.avatarBlurhash = avatarBlurhash;
+    user.avatarUrl = avatarUrl;
+    user.bannerId = bannerId;
+    user.bannerBlurhash = bannerBlurhash;
+    user.bannerUrl = bannerUrl;
+    //#endregion
+    //#region Get custom emoji
+    const emojis = await extractEmojis(person.tag || [], host).catch((e)=>{
+        logger.info(`extractEmojis: ${e}`);
+        return [];
+    });
+    const emojiNames = emojis.map((emoji)=>emoji.name);
+    await Users.update(user.id, {
+        emojis: emojiNames
+    });
+    //#endregion
+    await updateFeatured(user.id, resolver, limiter).catch((err)=>logger.error(err));
+    return user;
+}
+/**
+ * Update Person data from remote.
+ * If the target Person is not registered in Iceshrimp, it is ignored.
+ * @param uri URI of Person
+ * @param resolver Resolver
+ * @param hint Hint of Person object (If this value is a valid Person, it is used for updating without Remote resolve)
+ * @param userHint Hint of IRemoteUser object, used for updating user information for remotes that only support webfinger with acct: query
+ */ export async function updatePerson(uri, resolver, hint, userHint) {
+    if (typeof uri !== "string") throw new Error("uri is not string");
+    // Skip if the URI points to this server
+    if (extractDbHost(uri) === toPuny(config.host)) {
+        return;
+    }
+    //#region Already registered on this server?
+    const user = await Users.findOneBy({
+        uri
+    });
+    if (user == null) {
+        return;
+    }
+    //#endregion
+    if (resolver == null) resolver = new Resolver();
+    const object = hint || await resolver.resolve(uri);
+    const person = validateActor(object, uri);
+    logger.info(`Updating the Person: ${person.id}`);
+    const host = await getSubjectHostFromUri(uri) ?? await getSubjectHostFromRemoteUser(userHint);
+    // Fetch avatar and header image
+    const [avatar, banner] = await Promise.all([
+        person.icon,
+        person.image
+    ].map((img)=>img == null ? Promise.resolve(null) : resolveImage(user, img).catch(()=>null)));
+    // Custom pictogram acquisition
+    const emojis = await extractEmojis(person.tag || [], user.host).catch((e)=>{
+        logger.info(`extractEmojis: ${e}`);
+        return [];
+    });
+    const emojiNames = emojis.map((emoji)=>emoji.name);
+    const { fields } = await analyzeAttachments(person.attachment || []);
+    const tags = extractApHashtags(person.tag).map((tag)=>normalizeForSearch(tag)).splice(0, 32);
+    const bday = person["vcard:bday"]?.match(/^\d{4}-\d{2}-\d{2}/);
+    const url = getOneApHrefNullable(person.url);
+    if (url && !url.startsWith("https://")) {
+        throw new Error(`unexpected schema of person url: ${url}`);
+    }
+    let followersCount;
+    if (typeof person.followers === "string") {
+        try {
+            let data = await fetch(person.followers, {
+                headers: {
+                    Accept: "application/json"
+                },
+                size: 1024 * 1024
+            });
+            let json_data = JSON.parse(await data.text());
+            followersCount = json_data.totalItems;
+        } catch  {
+            followersCount = undefined;
+        }
+    }
+    let followingCount;
+    if (typeof person.following === "string") {
+        try {
+            let data = await fetch(person.following, {
+                headers: {
+                    Accept: "application/json"
+                },
+                size: 1024 * 1024
+            });
+            let json_data = JSON.parse(await data.text());
+            followingCount = json_data.totalItems;
+        } catch  {
+            followingCount = undefined;
+        }
+    }
+    let canBite = "nobody";
+    if (person.canBite) {
+        if (person.canBite === "https://www.w3.org/ns/activitystreams#Public") {
+            canBite = "anyone";
+        } else if (person.followers && person.canBite === getApId(person.followers)) {
+            canBite = "followers";
+        }
+    }
+    const updates = {
+        lastFetchedAt: new Date(),
+        inbox: person.inbox,
+        sharedInbox: person.sharedInbox || (person.endpoints ? person.endpoints.sharedInbox : undefined),
+        followersUri: person.followers ? getApId(person.followers) : undefined,
+        followersCount: followersCount !== undefined ? followersCount : person.followers && typeof person.followers !== "string" && isCollectionOrOrderedCollection(person.followers) ? person.followers.totalItems : undefined,
+        followingCount: followingCount !== undefined ? followingCount : person.following && typeof person.following !== "string" && isCollectionOrOrderedCollection(person.following) ? person.following.totalItems : undefined,
+        featured: person.featured,
+        emojis: emojiNames,
+        name: truncate(person.name, nameLength),
+        tags,
+        isBot: getApType(object) === "Service",
+        isCat: person.isCat === true,
+        isLocked: !!person.manuallyApprovesFollowers,
+        movedToUri: person.movedTo || null,
+        alsoKnownAs: person.alsoKnownAs || null,
+        isExplorable: !!person.discoverable,
+        canBite
+    };
+    if (avatar) {
+        updates.avatarId = avatar.id;
+        updates.avatarUrl = DriveFiles.getDatabasePrefetchUrl(avatar, true);
+        updates.avatarBlurhash = avatar.blurhash;
+    }
+    if (banner) {
+        updates.bannerId = banner.id;
+        updates.bannerUrl = DriveFiles.getDatabasePrefetchUrl(banner, false);
+        updates.bannerBlurhash = banner.blurhash;
+    }
+    if (host) {
+        updates.host = host;
+    }
+    // Update user
+    await Users.update(user.id, updates);
+    if (person.publicKey) {
+        await UserPublickeys.update({
+            userId: user.id
+        }, {
+            keyId: person.publicKey.id,
+            keyPem: person.publicKey.publicKeyPem
+        });
+    }
+    // Get old profile to see if we need to update any matching html cache entries
+    const oldProfile = await UserProfiles.findOneBy({
+        userId: user.id
+    });
+    const newProfile = {
+        url: url,
+        fields,
+        description: person._misskey_summary ? truncate(person._misskey_summary, summaryLength) : person.summary ? await htmlToMfm(truncate(person.summary, summaryLength), person.tag) : null,
+        birthday: bday ? bday[0] : null,
+        location: person["vcard:Address"] || null,
+        pronouns: person.pronouns || {}
+    };
+    await UserProfiles.update({
+        userId: user.id
+    }, newProfile);
+    publishInternalEvent("remoteUserUpdated", {
+        id: user.id
+    });
+    // Hashtag Update
+    updateUsertags(user, tags);
+    // Mentions update, then prewarm html cache
+    UserProfiles.updateMentions(user.id).then((_)=>UserConverter.prewarmCacheById(user.id, oldProfile));
+    // If the user in question is a follower, followers will also be updated.
+    await Followings.update({
+        followerId: user.id
+    }, {
+        followerSharedInbox: person.sharedInbox || (person.endpoints ? person.endpoints.sharedInbox : null)
+    });
+    await updateFeatured(user.id, resolver).catch((err)=>logger.error(err));
+}
+/**
+ * Resolve Person.
+ *
+ * If the target person is registered in Iceshrimp, it returns it;
+ * otherwise, it fetches it from the remote server, registers it in Iceshrimp, and returns it.
+ */ export async function resolvePerson(uri, resolver, limiter = new RecursionLimiter()) {
+    if (typeof uri !== "string") throw new Error("uri is not string");
+    //#region If already registered on this server, return it.
+    const user = await fetchPerson(uri);
+    if (user != null) {
+        return user;
+    }
+    //#endregion
+    // Fetched from remote server and registered
+    if (resolver == null) resolver = new Resolver();
+    return await createPerson(uri, resolver, undefined, limiter);
+}
+const services = {
+    "misskey:authentication:github": (id, login)=>({
+            id,
+            login
+        }),
+    "misskey:authentication:discord": (id, name)=>$discord(id, name)
+};
+const $discord = (id, name)=>{
+    if (typeof name !== "string") {
+        name = "unknown#0000";
+    }
+    const [username, discriminator] = name.split("#");
+    return {
+        id,
+        username,
+        discriminator
+    };
+};
+function addService(target, source) {
+    const service = services[source.name];
+    if (typeof source.value !== "string") {
+        source.value = "unknown";
+    }
+    const [id, username] = source.value.split("@");
+    if (service) {
+        target[source.name.split(":")[2]] = service(id, username);
+    }
+}
+export async function analyzeAttachments(attachments) {
+    const fields = [];
+    const services = {};
+    if (Array.isArray(attachments)) {
+        for (const attachment of attachments.filter(isPropertyValue)){
+            if (isPropertyValue(attachment.identifier)) {
+                addService(services, attachment.identifier);
+            } else {
+                fields.push({
+                    name: attachment.name,
+                    value: await fromHtml(attachment.value)
+                });
+            }
+        }
+    }
+    return {
+        fields,
+        services
+    };
+}
+export async function updateFeatured(userId, resolver, limiter = new RecursionLimiter()) {
+    const user = await Users.findOneByOrFail({
+        id: userId
+    });
+    if (!Users.isRemoteUser(user)) return;
+    if (!user.featured) return;
+    logger.info(`Updating the featured: ${user.uri}`);
+    if (resolver == null) resolver = new Resolver();
+    // Attempt to get a local user that follows the remote user
+    const follower = await Users.getRandomFollower(userId);
+    if (follower) resolver.setUser(follower);
+    // Resolve to (Ordered)Collection Object
+    const collection = await resolver.resolveCollection(user.featured);
+    if (!isCollectionOrOrderedCollection(collection)) throw new Error("Object is not Collection or OrderedCollection");
+    // Resolve to Object(may be Note) arrays
+    const unresolvedItems = isCollection(collection) ? collection.items : collection.orderedItems;
+    const items = await Promise.all(toArray(unresolvedItems).map((x)=>resolver.resolve(x)));
+    // Resolve and register Notes
+    resolver.reset();
+    const limit = promiseLimit(2);
+    const featuredNotes = await Promise.all(items.filter((item)=>getApType(item) === "Note") // TODO: Maybe it doesn't have to be a Note.
+    .slice(0, 5).map((item)=>limit(()=>resolveNote(item, resolver, limiter))));
+    // Prepare the objects
+    // For now, generate the id at a different time and maintain the order.
+    const data = [];
+    let td = 0;
+    for (const note of featuredNotes.filter((note)=>note != null)){
+        td -= 1000;
+        data.push({
+            id: genId(new Date(Date.now() + td)),
+            createdAt: new Date(),
+            userId: user.id,
+            noteId: note.id
+        });
+    }
+    // Save the objects atomically using a db transaction, note that we should never run any code in a transaction block directly
+    await db.transaction(async (transactionalEntityManager)=>{
+        await transactionalEntityManager.delete(UserNotePining, {
+            userId: user.id
+        });
+        await transactionalEntityManager.insert(UserNotePining, data);
+    });
+}

packages/backend/built/remote/activitypub/models/question.js

@@ -0,0 +1,64 @@
+import config from "../../../config/index.js";
+import { getApId, isQuestion } from "../type.js";
+import { apLogger } from "../logger.js";
+import { Notes, Polls } from "../../../models/index.js";
+import { extractDbHost, toPuny } from "../../../misc/convert-host.js";
+export async function extractPollFromQuestion(source, resolver) {
+    const question = await resolver.resolve(source);
+    if (!isQuestion(question)) {
+        throw new Error("invalid type");
+    }
+    const multiple = !question.oneOf;
+    const expiresAt = question.endTime ? new Date(question.endTime) : question.closed ? new Date(question.closed) : null;
+    if (multiple && !question.anyOf) {
+        throw new Error("invalid question");
+    }
+    const choices = question[multiple ? "anyOf" : "oneOf"].map((x, i)=>x.name);
+    const votes = question[multiple ? "anyOf" : "oneOf"].map((x, i)=>x.replies?.totalItems || x._misskey_votes || 0);
+    return {
+        choices,
+        votes,
+        multiple,
+        expiresAt
+    };
+}
+/**
+ * Update votes of Question
+ * @param value URI of AP Question object or object itself
+ * @returns true if updated
+ */ export async function updateQuestion(value, resolver) {
+    const uri = typeof value === "string" ? value : getApId(value);
+    // Skip if URI points to this server
+    if (extractDbHost(uri) === toPuny(config.host)) throw new Error("uri points local");
+    //#region Already registered with this server?
+    const note = await Notes.findOneBy({
+        uri
+    });
+    if (note == null) throw new Error("Question is not registed");
+    const poll = await Polls.findOneBy({
+        noteId: note.id
+    });
+    if (poll == null) throw new Error("Question is not registed");
+    //#endregion
+    // resolve new Question object
+    const question = await resolver.resolve(value);
+    apLogger.debug(`fetched question: ${JSON.stringify(question, null, 2)}`);
+    if (question.type !== "Question") throw new Error("object is not a Question");
+    const apChoices = question.oneOf || question.anyOf;
+    if (!apChoices) return false;
+    let changed = false;
+    for (const choice of poll.choices){
+        const oldCount = poll.votes[poll.choices.indexOf(choice)];
+        const newCount = apChoices.filter((ap)=>ap.name === choice)[0]?.replies?.totalItems;
+        if (newCount !== undefined && oldCount !== newCount) {
+            changed = true;
+            poll.votes[poll.choices.indexOf(choice)] = newCount;
+        }
+    }
+    await Polls.update({
+        noteId: note.id
+    }, {
+        votes: poll.votes
+    });
+    return changed;
+}

packages/backend/built/remote/activitypub/models/tag.js

@@ -0,0 +1,14 @@
+import { toArray } from "../../../prelude/array.js";
+import { isHashtag } from "../type.js";
+export function extractApHashtags(tags) {
+    if (tags == null) return [];
+    const hashtags = extractApHashtagObjects(tags);
+    return hashtags.map((tag)=>{
+        const m = tag.name.match(/^#(.+)/);
+        return m ? m[1] : null;
+    }).filter((x)=>x != null);
+}
+export function extractApHashtagObjects(tags) {
+    if (tags == null) return [];
+    return toArray(tags).filter(isHashtag);
+}