Files
outline/server/queues/processors/NotificationsProcessor.ts
T
Tom MoorandClaude Opus 5 7f54d5ea10 Re-authorize collaboration connections when access changes (#13454)
* feat: Re-authorize collaboration connections when access changes

Collaboration connections are authorized once, when the websocket is first
established, so a connection outlives changes to the access it was granted.

Add a processor that publishes access changes to the collaboration servers
over Redis. Each server closes the connections it holds within the scope of
the change and clients reconnect, at which point they are authorized as
normal. Authorization stays in one place, the published scope only has to
cover the connections that may be affected.

The API update subscriber now shares a single Redis connection rather than
opening its own.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* refactor: Log an access change once rather than per connection

Every closed connection is already logged by LoggerExtension, so record the
reason and the number of connections affected once instead. The count also
makes a scope that matches nothing visible.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-16 12:49:34 -04:00

138 lines
4.6 KiB
TypeScript

import type {
AccessRequestEvent,
CollectionEvent,
RevisionEvent,
Event,
DocumentEvent,
CommentEvent,
CollectionUserEvent,
DocumentUserEvent,
DocumentGroupEvent,
CommentReactionEvent,
} from "@server/types";
import CollectionAddUserNotificationsTask from "../tasks/CollectionAddUserNotificationsTask";
import CollectionCreatedNotificationsTask from "../tasks/CollectionCreatedNotificationsTask";
import CommentCreatedNotificationsTask from "../tasks/CommentCreatedNotificationsTask";
import CommentUpdatedNotificationsTask from "../tasks/CommentUpdatedNotificationsTask";
import ReactionCreatedNotificationsTask from "../tasks/ReactionCreatedNotificationsTask";
import ReactionRemovedNotificationsTask from "../tasks/ReactionRemovedNotificationsTask";
import DocumentAccessRequestNotificationsTask from "../tasks/DocumentAccessRequestNotificationsTask";
import DocumentAddGroupNotificationsTask from "../tasks/DocumentAddGroupNotificationsTask";
import DocumentAddUserNotificationsTask from "../tasks/DocumentAddUserNotificationsTask";
import DocumentPublishedNotificationsTask from "../tasks/DocumentPublishedNotificationsTask";
import RevisionCreatedNotificationsTask from "../tasks/RevisionCreatedNotificationsTask";
import ShareSubscriptionNotificationsTask from "../tasks/ShareSubscriptionNotificationsTask";
import BaseProcessor from "./BaseProcessor";
export default class NotificationsProcessor extends BaseProcessor {
static applicableEvents: Event["name"][] = [
"documents.publish",
"documents.add_user",
"documents.add_group",
"access_requests.create",
"revisions.create",
"collections.create",
"collections.add_user",
"comments.create",
"comments.update",
"comments.add_reaction",
"comments.remove_reaction",
];
async perform(event: Event) {
switch (event.name) {
case "documents.publish":
return this.documentPublished(event);
case "documents.add_user":
return this.documentAddUser(event);
case "documents.add_group":
return this.documentAddGroup(event);
case "access_requests.create":
return this.documentAccessRequest(event);
case "revisions.create":
return this.revisionCreated(event);
case "collections.create":
return this.collectionCreated(event);
case "collections.add_user":
return this.collectionAddUser(event);
case "comments.create":
return this.commentCreated(event);
case "comments.update":
return this.commentUpdated(event);
case "comments.add_reaction":
return this.reactionCreated(event);
case "comments.remove_reaction":
return this.reactionRemoved(event);
default:
}
}
async documentPublished(event: DocumentEvent) {
// never send notifications when batch importing
if (event.name === "documents.publish" && event.data?.source === "import") {
return;
}
await new DocumentPublishedNotificationsTask().schedule(event);
}
async documentAddUser(event: DocumentUserEvent) {
if (!event.data?.isNew || event.userId === event.actorId) {
return;
}
await new DocumentAddUserNotificationsTask().schedule(event);
}
async documentAddGroup(event: DocumentGroupEvent) {
if (!event.data.isNew) {
return;
}
await new DocumentAddGroupNotificationsTask().schedule(event);
}
async documentAccessRequest(event: AccessRequestEvent) {
await new DocumentAccessRequestNotificationsTask().schedule(event);
}
async revisionCreated(event: RevisionEvent) {
await new RevisionCreatedNotificationsTask().schedule(event);
await new ShareSubscriptionNotificationsTask().schedule(event);
}
async collectionCreated(event: CollectionEvent) {
// never send notifications when batch importing
if (
!!event.changes?.attributes.apiImportId ||
!!event.changes?.attributes.importId
) {
return;
}
await new CollectionCreatedNotificationsTask().schedule(event);
}
async collectionAddUser(event: CollectionUserEvent) {
if (!event.data?.isNew || event.userId === event.actorId) {
return;
}
await new CollectionAddUserNotificationsTask().schedule(event);
}
async commentCreated(event: CommentEvent) {
await new CommentCreatedNotificationsTask().schedule(event);
}
async commentUpdated(event: CommentEvent) {
await new CommentUpdatedNotificationsTask().schedule(event);
}
async reactionCreated(event: CommentReactionEvent) {
await new ReactionCreatedNotificationsTask().schedule(event);
}
async reactionRemoved(event: CommentReactionEvent) {
await new ReactionRemovedNotificationsTask().schedule(event);
}
}