Skip to content

Node.js based forum software built for the modern web

feat(activitypub): add severity 3 (filter) queuing for blocklisted posts

Julian Lam80f40aeb2c67
diff --git a/src/activitypub/inbox.js b/src/activitypub/inbox.js
index 99cbe5eba7..b0cc260885 100644
--- a/src/activitypub/inbox.js
+++ b/src/activitypub/inbox.js
@@ -55,7 +55,7 @@ inbox.create = async (req) => {
cid = Array.from(cids)[0];
}
- const asserted = await activitypub.notes.assert(0, object, { cid });
+ const asserted = await activitypub.notes.assert(0, object, { cid, blocklist: req?.res?.locals?.['ap:blocklist'] });
if (asserted) {
await activitypub.feps.announce(object.id, req.body);
// api.activitypub.add(req, { pid: object.id });
@@ -216,7 +216,7 @@ inbox.update = async (req) => {
cid = Array.from(cids)[0];
}
- const asserted = await activitypub.notes.assert(0, object.id, { cid });
+ const asserted = await activitypub.notes.assert(0, object.id, { cid, blocklist: req?.res?.locals?.['ap:blocklist'] });
if (asserted) {
activitypub.feps.announce(object.id, req.body);
}
@@ -363,7 +363,7 @@ inbox.like = async (req) => {
exists = await posts.exists(object.id);
if (!exists) {
// Proactively pull in the note
- const asserted = await activitypub.notes.assert(0, object.id, { skipChecks: 1 });
+ const asserted = await activitypub.notes.assert(0, object.id, { skipChecks: 1, blocklist: req?.res?.locals?.['ap:blocklist'] });
if (!asserted) {
throw new Error('[[error:invalid-pid]]');
}
@@ -540,7 +540,7 @@ inbox.announce = async (req) => {
return;
}
- const assertion = await activitypub.notes.assert(0, pid, { cid, skipChecks: true });
+ const assertion = await activitypub.notes.assert(0, pid, { cid, skipChecks: true, blocklist: req?.res?.locals?.['ap:blocklist'] });
if (!assertion) {
return;
}
diff --git a/src/activitypub/notes.js b/src/activitypub/notes.js
index e43e5425f5..822dfbef70 100644
--- a/src/activitypub/notes.js
+++ b/src/activitypub/notes.js
@@ -254,7 +254,26 @@ Notes.assert = async (uid, input, options = { skipChecks: false }) => {
const count = unprocessed.length;
activitypub.helpers.log(`[notes/assert] ${count} new note(s) found.`);
+ const shouldQueue = options.blocklist?.severity === 3;
+
if (!hasTid) {
+ if (shouldQueue) {
+ activitypub.helpers.log(`[activitypub/notes.assert] Queuing main post (${mainPid}) due to blocklist severity 3`);
+ await posts.addToQueue({
+ uid: authorId,
+ cid: options.cid || cid,
+ pid: mainPid,
+ title,
+ timestamp,
+ content: mainPost.content,
+ sourceContent: mainPost.sourceContent,
+ generatedTitle,
+ _activitypub: mainPost._activitypub,
+ });
+ // Drop the rest of the chain — replies without OP don't make sense
+ return { tid: null, queued: 1 };
+ }
+
const { to, cc } = mainPost._activitypub;
const tags = await Notes._normalizeTags(mainPost._activitypub.tag || []);
@@ -302,10 +321,26 @@ Notes.assert = async (uid, input, options = { skipChecks: false }) => {
unprocessed = unprocessed.filter(post => !banned.includes(post.uid));
let added = [];
+ let queued = 0;
await Promise.all(unprocessed.map(async (post) => {
const { to, cc } = post._activitypub;
try {
+ if (shouldQueue) {
+ activitypub.helpers.log(`[activitypub/notes.assert] Queuing reply (${post.pid}) due to blocklist severity 3`);
+ await posts.addToQueue({
+ uid: post.uid,
+ tid,
+ pid: post.pid,
+ content: post.content,
+ sourceContent: post.sourceContent,
+ timestamp: post.timestamp,
+ _activitypub: post._activitypub,
+ });
+ queued += 1;
+ return;
+ }
+
const postData = await topics.reply(post);
added.push(postData);
await Notes.updateLocalRecipients(post.pid, { to, cc });
@@ -335,7 +370,7 @@ Notes.assert = async (uid, input, options = { skipChecks: false }) => {
await activitypub.out.announce.topic(tid);
}
- return { tid, count };
+ return { tid, count, queued };
} catch (e) {
winston.warn(`[activitypub/notes.assert] Could not assert ${id} (${e.message}).`);
return null;
diff --git a/src/middleware/activitypub.js b/src/middleware/activitypub.js
index 65105859e2..a794ee4218 100644
--- a/src/middleware/activitypub.js
+++ b/src/middleware/activitypub.js
@@ -115,7 +115,7 @@ middleware.assertPayload = helpers.try(async function (req, res, next) {
// Store blocklist info for severity-based handling (silence, filter)
if (result.severity !== null && result.severity >= 2) {
- req.locals['ap:blocklist'] = {
+ res.locals['ap:blocklist'] = {
severity: result.severity,
listUrl: result.listUrl,
};
diff --git a/test/activitypub/notes.js b/test/activitypub/notes.js
index 8e0ce76d6a..a8be6a55f3 100644
--- a/test/activitypub/notes.js
+++ b/test/activitypub/notes.js
@@ -422,4 +422,185 @@ describe('Notes', () => {
assert(!inboxed);
});
});
+
+ describe('Blocklist severity 3 (filter)', () => {
+ /**
+ * Clear the post queue between tests.
+ */
+ async function clearQueue() {
+ const queuedIds = await db.getSortedSetMembers('post:queue');
+ await Promise.all(queuedIds.map(async (id) => {
+ await db.delete(`post:queue:${id}`);
+ }));
+ await db.delete('post:queue');
+ }
+
+ beforeEach(async () => {
+ await clearQueue();
+ });
+
+ describe('!hasTid — new topic', () => {
+ it('should queue the main post instead of creating it', async () => {
+ const { id } = helpers.mocks.note();
+ const assertion = await activitypub.notes.assert(0, id, {
+ skipChecks: true,
+ blocklist: { severity: 3 },
+ });
+
+ assert(assertion);
+ assert.strictEqual(assertion.tid, null);
+ assert.strictEqual(assertion.queued, 1);
+ assert.strictEqual(assertion.count, undefined);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 1);
+ });
+
+ it('should queue parent and also queue replies when hasTid is false', async () => {
+ const { id: parentId } = helpers.mocks.note();
+ const { id: replyId } = helpers.mocks.note({
+ inReplyTo: parentId,
+ });
+
+ // Assert the parent with severity 3 — should queue and return tid: null
+ const parentAssertion = await activitypub.notes.assert(0, parentId, {
+ skipChecks: true,
+ blocklist: { severity: 3 },
+ });
+
+ assert(parentAssertion);
+ assert.strictEqual(parentAssertion.tid, null);
+ assert.strictEqual(parentAssertion.queued, 1);
+
+ // Assert the reply with severity 3 — parent has no tid, so hasTid is false
+ const replyAssertion = await activitypub.notes.assert(0, replyId, {
+ skipChecks: true,
+ blocklist: { severity: 3 },
+ });
+
+ assert(replyAssertion);
+ assert.strictEqual(replyAssertion.tid, null);
+ assert.strictEqual(replyAssertion.queued, 1);
+
+ // Verify neither post was created as a real topic/reply
+ assert.strictEqual(await posts.exists(parentId), false);
+ assert.strictEqual(await posts.exists(replyId), false);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 2);
+ });
+ });
+
+ describe('hasTid — existing topic', () => {
+ let tid;
+ let mainPid;
+ let cid;
+
+ before(async () => {
+ const uid = await user.create({ username: utils.generateUUID().slice(0, 10) });
+ ({ cid } = await categories.create({ name: utils.generateUUID() }));
+ const { topicData, postData } = await topics.post({
+ cid,
+ uid,
+ title: utils.generateUUID(),
+ content: utils.generateUUID(),
+ });
+ tid = topicData.tid;
+ mainPid = postData.pid;
+ });
+
+ it('should queue replies when severity is 3', async () => {
+ const { id } = helpers.mocks.note({
+ inReplyTo: `${nconf.get('url')}/post/${mainPid}`,
+ });
+ const assertion = await activitypub.notes.assert(0, id, {
+ skipChecks: true,
+ blocklist: { severity: 3 },
+ });
+
+ assert(assertion);
+ assert.strictEqual(assertion.tid, tid);
+ assert.strictEqual(assertion.queued, 1);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 1);
+ });
+
+ it('should queue multiple replies', async () => {
+ const { id: id1 } = helpers.mocks.note({
+ inReplyTo: `${nconf.get('url')}/post/${mainPid}`,
+ });
+ const { id: id2 } = helpers.mocks.note({
+ inReplyTo: `${nconf.get('url')}/post/${mainPid}`,
+ });
+
+ const assertion1 = await activitypub.notes.assert(0, id1, {
+ skipChecks: true,
+ blocklist: { severity: 3 },
+ });
+ const assertion2 = await activitypub.notes.assert(0, id2, {
+ skipChecks: true,
+ blocklist: { severity: 3 },
+ });
+
+ assert(assertion1);
+ assert(assertion2);
+ assert.strictEqual(assertion1.tid, tid);
+ assert.strictEqual(assertion1.queued, 1);
+ assert.strictEqual(assertion2.tid, tid);
+ assert.strictEqual(assertion2.queued, 1);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 2);
+ });
+ });
+
+ describe('null case', () => {
+ it('should NOT queue posts when blocklist is undefined', async () => {
+ const { id } = helpers.mocks.note();
+ const assertion = await activitypub.notes.assert(0, id, {
+ skipChecks: true,
+ });
+
+ assert(assertion);
+ assert(assertion.tid);
+ assert.strictEqual(assertion.queued, 0);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 0);
+ });
+ });
+
+ describe('Severity 1 and 2', () => {
+ it('should NOT queue posts with severity 1 (suspend)', async () => {
+ const { id } = helpers.mocks.note();
+ const assertion = await activitypub.notes.assert(0, id, {
+ skipChecks: true,
+ blocklist: { severity: 1 },
+ });
+
+ assert(assertion);
+ assert(assertion.tid);
+ assert.strictEqual(assertion.queued, 0);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 0);
+ });
+
+ it('should NOT queue posts with severity 2 (silence)', async () => {
+ const { id } = helpers.mocks.note();
+ const assertion = await activitypub.notes.assert(0, id, {
+ skipChecks: true,
+ blocklist: { severity: 2 },
+ });
+
+ assert(assertion);
+ assert(assertion.tid);
+ assert.strictEqual(assertion.queued, 0);
+
+ const queueCount = await db.sortedSetCard('post:queue');
+ assert.strictEqual(queueCount, 0);
+ });
+ });
+ });
});