2023-01-13 04:40:33 +00:00
|
|
|
import config from "@/config/index.js";
|
|
|
|
import { getJson } from "@/misc/fetch.js";
|
|
|
|
import type { ILocalUser } from "@/models/entities/user.js";
|
|
|
|
import { getInstanceActor } from "@/services/instance-actor.js";
|
|
|
|
import { fetchMeta } from "@/misc/fetch-meta.js";
|
|
|
|
import { extractDbHost, isSelfHost } from "@/misc/convert-host.js";
|
|
|
|
import { signedGet } from "./request.js";
|
|
|
|
import type { IObject, ICollection, IOrderedCollection } from "./type.js";
|
|
|
|
import { isCollectionOrOrderedCollection, getApId } from "./type.js";
|
|
|
|
import {
|
|
|
|
FollowRequests,
|
|
|
|
Notes,
|
|
|
|
NoteReactions,
|
|
|
|
Polls,
|
|
|
|
Users,
|
|
|
|
} from "@/models/index.js";
|
|
|
|
import { parseUri } from "./db-resolver.js";
|
|
|
|
import renderNote from "@/remote/activitypub/renderer/note.js";
|
|
|
|
import { renderLike } from "@/remote/activitypub/renderer/like.js";
|
|
|
|
import { renderPerson } from "@/remote/activitypub/renderer/person.js";
|
|
|
|
import renderQuestion from "@/remote/activitypub/renderer/question.js";
|
|
|
|
import renderCreate from "@/remote/activitypub/renderer/create.js";
|
|
|
|
import { renderActivity } from "@/remote/activitypub/renderer/index.js";
|
|
|
|
import renderFollow from "@/remote/activitypub/renderer/follow.js";
|
|
|
|
import { shouldBlockInstance } from "@/misc/should-block-instance.js";
|
2018-03-31 10:55:00 +00:00
|
|
|
|
2018-04-01 12:56:11 +00:00
|
|
|
export default class Resolver {
|
2018-04-04 14:12:35 +00:00
|
|
|
private history: Set<string>;
|
2020-10-17 16:46:40 +00:00
|
|
|
private user?: ILocalUser;
|
2022-12-01 07:45:08 +00:00
|
|
|
private recursionLimit?: number;
|
2018-04-01 12:56:11 +00:00
|
|
|
|
2022-12-01 07:45:08 +00:00
|
|
|
constructor(recursionLimit = 100) {
|
2018-04-04 14:12:35 +00:00
|
|
|
this.history = new Set();
|
2022-12-01 07:45:08 +00:00
|
|
|
this.recursionLimit = recursionLimit;
|
2018-03-31 10:55:00 +00:00
|
|
|
}
|
|
|
|
|
2019-03-04 05:02:42 +00:00
|
|
|
public getHistory(): string[] {
|
|
|
|
return Array.from(this.history);
|
|
|
|
}
|
|
|
|
|
2023-01-13 04:40:33 +00:00
|
|
|
public async resolveCollection(
|
|
|
|
value: string | IObject,
|
|
|
|
): Promise<ICollection | IOrderedCollection> {
|
2022-12-24 23:01:58 +00:00
|
|
|
const collection = await this.resolve(value);
|
2018-04-04 14:12:35 +00:00
|
|
|
|
2019-09-26 19:58:28 +00:00
|
|
|
if (isCollectionOrOrderedCollection(collection)) {
|
|
|
|
return collection;
|
|
|
|
} else {
|
2020-09-17 12:05:47 +00:00
|
|
|
throw new Error(`unrecognized collection type: ${collection.type}`);
|
2018-04-04 14:12:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-26 19:58:28 +00:00
|
|
|
public async resolve(value: string | IObject): Promise<IObject> {
|
2018-04-05 13:49:41 +00:00
|
|
|
if (value == null) {
|
2023-01-13 04:40:33 +00:00
|
|
|
throw new Error("resolvee is null (or undefined)");
|
2018-04-05 13:49:41 +00:00
|
|
|
}
|
|
|
|
|
2023-01-13 04:40:33 +00:00
|
|
|
if (typeof value !== "string") {
|
|
|
|
if (typeof value.id !== "undefined") {
|
2022-12-25 20:10:33 +00:00
|
|
|
const host = extractDbHost(getApId(value));
|
|
|
|
if (await shouldBlockInstance(host)) {
|
2023-01-13 04:40:33 +00:00
|
|
|
throw new Error("instance is blocked");
|
2022-12-25 20:10:33 +00:00
|
|
|
}
|
|
|
|
}
|
2018-04-04 14:12:35 +00:00
|
|
|
return value;
|
2018-04-01 12:56:11 +00:00
|
|
|
}
|
2018-03-31 10:55:00 +00:00
|
|
|
|
2023-01-13 04:40:33 +00:00
|
|
|
if (value.includes("#")) {
|
2022-06-04 02:29:20 +00:00
|
|
|
// URLs with fragment parts cannot be resolved correctly because
|
|
|
|
// the fragment part does not get transmitted over HTTP(S).
|
|
|
|
// Avoid strange behaviour by not trying to resolve these at all.
|
|
|
|
throw new Error(`cannot resolve URL with fragment: ${value}`);
|
|
|
|
}
|
|
|
|
|
2018-04-04 14:12:35 +00:00
|
|
|
if (this.history.has(value)) {
|
2023-01-13 04:40:33 +00:00
|
|
|
throw new Error("cannot resolve already resolved one");
|
2018-04-04 14:12:35 +00:00
|
|
|
}
|
2022-12-01 07:45:08 +00:00
|
|
|
if (this.recursionLimit && this.history.size > this.recursionLimit) {
|
2023-01-13 04:40:33 +00:00
|
|
|
throw new Error("hit recursion limit");
|
2022-12-01 07:45:08 +00:00
|
|
|
}
|
2018-04-04 14:12:35 +00:00
|
|
|
this.history.add(value);
|
2018-03-31 10:55:00 +00:00
|
|
|
|
2021-09-18 06:45:02 +00:00
|
|
|
const host = extractDbHost(value);
|
2022-06-04 02:29:20 +00:00
|
|
|
if (isSelfHost(host)) {
|
|
|
|
return await this.resolveLocal(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
const meta = await fetchMeta();
|
2022-12-24 19:39:54 +00:00
|
|
|
if (await shouldBlockInstance(host, meta)) {
|
2023-01-13 04:40:33 +00:00
|
|
|
throw new Error("Instance is blocked");
|
2021-09-18 06:45:02 +00:00
|
|
|
}
|
2021-07-20 16:45:41 +00:00
|
|
|
|
2023-01-13 04:40:33 +00:00
|
|
|
if (
|
|
|
|
meta.privateMode &&
|
|
|
|
config.host !== host &&
|
|
|
|
!meta.allowedHosts.includes(host)
|
|
|
|
) {
|
|
|
|
throw new Error("Instance is not allowed");
|
2021-07-20 16:45:41 +00:00
|
|
|
}
|
2021-09-18 06:45:02 +00:00
|
|
|
|
2022-10-28 17:52:13 +00:00
|
|
|
if (!this.user) {
|
2020-10-17 16:46:40 +00:00
|
|
|
this.user = await getInstanceActor();
|
|
|
|
}
|
|
|
|
|
2023-01-13 04:40:33 +00:00
|
|
|
const object = (
|
|
|
|
this.user
|
|
|
|
? await signedGet(value, this.user)
|
|
|
|
: await getJson(value, "application/activity+json, application/ld+json")
|
|
|
|
) as IObject;
|
|
|
|
|
|
|
|
if (
|
|
|
|
object == null ||
|
|
|
|
(Array.isArray(object["@context"])
|
|
|
|
? !(object["@context"] as unknown[]).includes(
|
|
|
|
"https://www.w3.org/ns/activitystreams",
|
|
|
|
)
|
|
|
|
: object["@context"] !== "https://www.w3.org/ns/activitystreams")
|
|
|
|
) {
|
|
|
|
throw new Error("invalid response");
|
2018-03-31 10:55:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-04 14:12:35 +00:00
|
|
|
return object;
|
2018-03-31 10:55:00 +00:00
|
|
|
}
|
2022-06-04 02:29:20 +00:00
|
|
|
|
|
|
|
private resolveLocal(url: string): Promise<IObject> {
|
|
|
|
const parsed = parseUri(url);
|
2023-01-13 04:40:33 +00:00
|
|
|
if (!parsed.local) throw new Error("resolveLocal: not local");
|
2022-06-04 02:29:20 +00:00
|
|
|
|
|
|
|
switch (parsed.type) {
|
2023-01-13 04:40:33 +00:00
|
|
|
case "notes":
|
|
|
|
return Notes.findOneByOrFail({ id: parsed.id }).then((note) => {
|
|
|
|
if (parsed.rest === "activity") {
|
2022-06-04 02:29:20 +00:00
|
|
|
// this refers to the create activity and not the note itself
|
|
|
|
return renderActivity(renderCreate(renderNote(note)));
|
|
|
|
} else {
|
|
|
|
return renderNote(note);
|
|
|
|
}
|
|
|
|
});
|
2023-01-13 04:40:33 +00:00
|
|
|
case "users":
|
|
|
|
return Users.findOneByOrFail({ id: parsed.id }).then((user) =>
|
|
|
|
renderPerson(user as ILocalUser),
|
|
|
|
);
|
|
|
|
case "questions":
|
2022-06-04 02:29:20 +00:00
|
|
|
// Polls are indexed by the note they are attached to.
|
|
|
|
return Promise.all([
|
|
|
|
Notes.findOneByOrFail({ id: parsed.id }),
|
|
|
|
Polls.findOneByOrFail({ noteId: parsed.id }),
|
2023-01-13 04:40:33 +00:00
|
|
|
]).then(([note, poll]) =>
|
|
|
|
renderQuestion({ id: note.userId }, note, poll),
|
|
|
|
);
|
|
|
|
case "likes":
|
|
|
|
return NoteReactions.findOneByOrFail({ id: parsed.id }).then(
|
|
|
|
(reaction) => renderActivity(renderLike(reaction, { uri: null })),
|
|
|
|
);
|
|
|
|
case "follows":
|
2022-06-04 02:29:20 +00:00
|
|
|
// rest should be <followee id>
|
2023-01-13 04:40:33 +00:00
|
|
|
if (parsed.rest == null || !/^\w+$/.test(parsed.rest))
|
|
|
|
throw new Error("resolveLocal: invalid follow URI");
|
2022-06-04 02:29:20 +00:00
|
|
|
|
|
|
|
return Promise.all(
|
2023-01-13 04:40:33 +00:00
|
|
|
[parsed.id, parsed.rest].map((id) => Users.findOneByOrFail({ id })),
|
|
|
|
).then(([follower, followee]) =>
|
|
|
|
renderActivity(renderFollow(follower, followee, url)),
|
|
|
|
);
|
2022-06-04 02:29:20 +00:00
|
|
|
default:
|
|
|
|
throw new Error(`resolveLocal: type ${type} unhandled`);
|
|
|
|
}
|
|
|
|
}
|
2018-03-31 10:55:00 +00:00
|
|
|
}
|