2022-02-27 02:07:39 +00:00
|
|
|
import config from '@/config/index.js';
|
|
|
|
import { getJson } from '@/misc/fetch.js';
|
|
|
|
import { ILocalUser } from '@/models/entities/user.js';
|
|
|
|
import { getInstanceActor } from '@/services/instance-actor.js';
|
|
|
|
import { fetchMeta } from '@/misc/fetch-meta.js';
|
2022-06-04 02:29:20 +00:00
|
|
|
import { extractDbHost, isSelfHost } from '@/misc/convert-host.js';
|
2022-04-17 04:26:31 +00:00
|
|
|
import { signedGet } from './request.js';
|
|
|
|
import { IObject, isCollectionOrOrderedCollection, ICollection, IOrderedCollection } from './type.js';
|
2022-06-04 02:29:20 +00:00
|
|
|
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';
|
2022-12-24 19:39:54 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-09-26 19:58:28 +00:00
|
|
|
public async resolveCollection(value: string | IObject): Promise<ICollection | IOrderedCollection> {
|
2018-04-04 14:12:35 +00:00
|
|
|
const collection = typeof value === 'string'
|
|
|
|
? await this.resolve(value)
|
|
|
|
: value;
|
|
|
|
|
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) {
|
|
|
|
throw new Error('resolvee is null (or undefined)');
|
|
|
|
}
|
|
|
|
|
2018-04-01 12:56:11 +00:00
|
|
|
if (typeof value !== 'string') {
|
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
|
|
|
|
2022-06-04 02:29:20 +00:00
|
|
|
if (value.includes('#')) {
|
|
|
|
// 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)) {
|
|
|
|
throw new Error('cannot resolve already resolved one');
|
|
|
|
}
|
2022-12-01 07:45:08 +00:00
|
|
|
if (this.recursionLimit && this.history.size > this.recursionLimit) {
|
|
|
|
throw new Error('hit recursion limit');
|
|
|
|
}
|
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)) {
|
2021-09-18 06:45:02 +00:00
|
|
|
throw new Error('Instance is blocked');
|
|
|
|
}
|
2021-07-20 16:45:41 +00:00
|
|
|
|
|
|
|
if (meta.privateMode && config.host !== host && !meta.allowedHosts.includes(host)) {
|
|
|
|
throw new Error('Instance is not allowed');
|
|
|
|
}
|
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();
|
|
|
|
}
|
|
|
|
|
2022-04-17 04:26:31 +00:00
|
|
|
const object = (this.user
|
2020-10-17 16:46:40 +00:00
|
|
|
? await signedGet(value, this.user)
|
2022-04-17 04:26:31 +00:00
|
|
|
: await getJson(value, 'application/activity+json, application/ld+json')) as IObject;
|
2018-03-31 10:55:00 +00:00
|
|
|
|
2019-04-07 12:50:36 +00:00
|
|
|
if (object == null || (
|
2018-04-01 12:56:11 +00:00
|
|
|
Array.isArray(object['@context']) ?
|
2022-04-17 04:26:31 +00:00
|
|
|
!(object['@context'] as unknown[]).includes('https://www.w3.org/ns/activitystreams') :
|
2018-04-01 12:56:11 +00:00
|
|
|
object['@context'] !== 'https://www.w3.org/ns/activitystreams'
|
|
|
|
)) {
|
2018-04-04 14:12:35 +00:00
|
|
|
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);
|
|
|
|
if (!parsed.local) throw new Error('resolveLocal: not local');
|
|
|
|
|
|
|
|
switch (parsed.type) {
|
|
|
|
case 'notes':
|
|
|
|
return Notes.findOneByOrFail({ id: parsed.id })
|
|
|
|
.then(note => {
|
|
|
|
if (parsed.rest === 'activity') {
|
|
|
|
// this refers to the create activity and not the note itself
|
|
|
|
return renderActivity(renderCreate(renderNote(note)));
|
|
|
|
} else {
|
|
|
|
return renderNote(note);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
case 'users':
|
|
|
|
return Users.findOneByOrFail({ id: parsed.id })
|
|
|
|
.then(user => renderPerson(user as ILocalUser));
|
|
|
|
case 'questions':
|
|
|
|
// Polls are indexed by the note they are attached to.
|
|
|
|
return Promise.all([
|
|
|
|
Notes.findOneByOrFail({ id: parsed.id }),
|
|
|
|
Polls.findOneByOrFail({ noteId: parsed.id }),
|
|
|
|
])
|
|
|
|
.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':
|
|
|
|
// rest should be <followee id>
|
|
|
|
if (parsed.rest == null || !/^\w+$/.test(parsed.rest)) throw new Error('resolveLocal: invalid follow URI');
|
|
|
|
|
|
|
|
return Promise.all(
|
|
|
|
[parsed.id, parsed.rest].map(id => Users.findOneByOrFail({ id }))
|
|
|
|
)
|
|
|
|
.then(([follower, followee]) => renderActivity(renderFollow(follower, followee, url)));
|
|
|
|
default:
|
|
|
|
throw new Error(`resolveLocal: type ${type} unhandled`);
|
|
|
|
}
|
|
|
|
}
|
2018-03-31 10:55:00 +00:00
|
|
|
}
|