mirror of
https://github.com/outline/outline.git
synced 2026-11-20 21:23:06 +03:00
* perf: Use FOR NO KEY UPDATE where locked rows are only updated Rows that other tables reference by foreign key are now locked with FOR NO KEY UPDATE when the transaction only updates or soft-deletes them, so concurrent inserts that reference the row are not blocked. * test: Collaborative save does not wait for foreign key inserts
358 lines
9.7 KiB
TypeScript
358 lines
9.7 KiB
TypeScript
import { Node } from "prosemirror-model";
|
|
import type {
|
|
CreateOptions,
|
|
InferAttributes,
|
|
InferCreationAttributes,
|
|
InstanceUpdateOptions,
|
|
WhereOptions,
|
|
} from "sequelize";
|
|
import { Op } from "sequelize";
|
|
import {
|
|
DataType,
|
|
BelongsTo,
|
|
BeforeCreate,
|
|
ForeignKey,
|
|
Column,
|
|
Table,
|
|
Length,
|
|
DefaultScope,
|
|
AfterDestroy,
|
|
AfterUpdate,
|
|
} from "sequelize-typescript";
|
|
import type { ProsemirrorData, ReactionSummary } from "@shared/types";
|
|
import { CommentStatusFilter } from "@shared/types";
|
|
import { ProsemirrorHelper } from "@shared/utils/ProsemirrorHelper";
|
|
import { CommentValidation } from "@shared/validations";
|
|
import { commentSchema, serializer } from "@server/editor";
|
|
import { ValidationError } from "@server/errors";
|
|
import { afterCommit } from "@server/storage/transaction";
|
|
import { CacheHelper } from "@server/utils/CacheHelper";
|
|
import { RedisPrefixHelper } from "@server/utils/RedisPrefixHelper";
|
|
import Document from "./Document";
|
|
import User from "./User";
|
|
import { type HookContext } from "./base/Model";
|
|
import ParanoidModel from "./base/ParanoidModel";
|
|
import TextLength from "./validators/TextLength";
|
|
import { SkipChangeset } from "./decorators/Changeset";
|
|
|
|
@DefaultScope(() => ({
|
|
include: [
|
|
{
|
|
model: User,
|
|
as: "createdBy",
|
|
paranoid: false,
|
|
},
|
|
{
|
|
model: User,
|
|
as: "resolvedBy",
|
|
paranoid: false,
|
|
},
|
|
],
|
|
}))
|
|
@Table({ tableName: "comments", modelName: "comment" })
|
|
class Comment extends ParanoidModel<
|
|
InferAttributes<Comment>,
|
|
Partial<InferCreationAttributes<Comment>>
|
|
> {
|
|
@TextLength({
|
|
max: CommentValidation.maxLength,
|
|
msg: `Comment must be less than ${CommentValidation.maxLength} characters`,
|
|
})
|
|
@Length({
|
|
max: CommentValidation.maxLength * 10,
|
|
msg: `Comment data is too large`,
|
|
})
|
|
@Column(DataType.JSONB)
|
|
@SkipChangeset
|
|
data: ProsemirrorData;
|
|
|
|
@Column(DataType.JSONB)
|
|
reactions: ReactionSummary[] | null;
|
|
|
|
// associations
|
|
|
|
@BelongsTo(() => User, "createdById")
|
|
createdBy: User;
|
|
|
|
@ForeignKey(() => User)
|
|
@Column(DataType.UUID)
|
|
createdById: string;
|
|
|
|
@Column(DataType.DATE)
|
|
resolvedAt: Date | null;
|
|
|
|
@BelongsTo(() => User, "resolvedById")
|
|
resolvedBy: User | null;
|
|
|
|
@ForeignKey(() => User)
|
|
@Column(DataType.UUID)
|
|
resolvedById: string | null;
|
|
|
|
@BelongsTo(() => Document, "documentId")
|
|
document: Document;
|
|
|
|
@ForeignKey(() => Document)
|
|
@Column(DataType.UUID)
|
|
documentId: string;
|
|
|
|
@BelongsTo(() => Comment, "parentCommentId")
|
|
parentComment: Comment;
|
|
|
|
@ForeignKey(() => Comment)
|
|
@Column(DataType.UUID)
|
|
parentCommentId: string;
|
|
|
|
// static methods
|
|
|
|
/**
|
|
* Finds the comments a user can access, restricted to a single document or
|
|
* collection when one is given, along with the total for pagination.
|
|
*
|
|
* @param user The user listing comments, whose collection access is applied.
|
|
* @param options Filters, ordering, and pagination for the query.
|
|
* @returns The matching comments and the total number that match.
|
|
*/
|
|
static async findAllForUser(
|
|
user: User,
|
|
options: {
|
|
/** Only comments on this document, which the caller has authorized. */
|
|
document?: Document | null;
|
|
/** Only comments in this collection, which the caller has authorized. */
|
|
collectionId?: string;
|
|
/** Only replies to this comment. */
|
|
parentCommentId?: string;
|
|
/** Only comments with these resolution states. */
|
|
statusFilter?: CommentStatusFilter[];
|
|
/** Whether to load and attach the document each comment belongs to. */
|
|
includeDocuments?: boolean;
|
|
sort?: string;
|
|
direction?: "ASC" | "DESC";
|
|
offset?: number;
|
|
limit?: number;
|
|
}
|
|
): Promise<{ comments: Comment[]; total: number }> {
|
|
const {
|
|
document,
|
|
collectionId,
|
|
parentCommentId,
|
|
statusFilter,
|
|
includeDocuments,
|
|
sort = "createdAt",
|
|
direction = "DESC",
|
|
offset,
|
|
limit,
|
|
} = options;
|
|
|
|
const statusQuery: WhereOptions<Comment>[] = [];
|
|
if (statusFilter?.includes(CommentStatusFilter.Resolved)) {
|
|
statusQuery.push({ resolvedById: { [Op.not]: null } });
|
|
}
|
|
if (statusFilter?.includes(CommentStatusFilter.Unresolved)) {
|
|
statusQuery.push({ resolvedById: null });
|
|
}
|
|
|
|
const and: WhereOptions<Comment>[] = [];
|
|
if (document) {
|
|
and.push({ documentId: document.id });
|
|
}
|
|
if (parentCommentId) {
|
|
and.push({ parentCommentId });
|
|
}
|
|
if (statusQuery.length) {
|
|
and.push({ [Op.or]: statusQuery });
|
|
}
|
|
|
|
// Without a document the join restricts results to documents the user
|
|
// can access. It loads no columns, the document is attached separately.
|
|
const include = document
|
|
? []
|
|
: [
|
|
{
|
|
model: Document.scope("published"),
|
|
required: true,
|
|
attributes: [],
|
|
where: {
|
|
teamId: user.teamId,
|
|
collectionId: collectionId ?? (await user.collectionIds()),
|
|
},
|
|
},
|
|
];
|
|
|
|
const { rows: comments, count: total } = await this.findAndCountAll({
|
|
where: { [Op.and]: and },
|
|
include,
|
|
order: [[sort, direction]],
|
|
offset,
|
|
limit,
|
|
});
|
|
|
|
if (document) {
|
|
comments.forEach((comment) => (comment.document = document));
|
|
} else if (includeDocuments) {
|
|
// Each document is loaded once so comments on the same document share
|
|
// an instance, and with it the memoized comment marks.
|
|
const documents = await Document.scope("withoutState").findAll({
|
|
where: {
|
|
id: [...new Set(comments.map((comment) => comment.documentId))],
|
|
},
|
|
});
|
|
const documentsById = new Map(documents.map((doc) => [doc.id, doc]));
|
|
comments.forEach((comment) => {
|
|
const doc = documentsById.get(comment.documentId);
|
|
if (doc) {
|
|
comment.document = doc;
|
|
}
|
|
});
|
|
}
|
|
|
|
return { comments, total };
|
|
}
|
|
|
|
// methods
|
|
|
|
/**
|
|
* Resolve the comment. Note this does not save the comment to the database.
|
|
*
|
|
* @param resolvedBy The user who resolved the comment
|
|
*/
|
|
public resolve(resolvedBy: User) {
|
|
if (this.isResolved) {
|
|
throw ValidationError("Comment is already resolved");
|
|
}
|
|
if (this.parentCommentId) {
|
|
throw ValidationError("Cannot resolve a reply");
|
|
}
|
|
|
|
this.resolvedById = resolvedBy.id;
|
|
this.resolvedBy = resolvedBy;
|
|
this.resolvedAt = new Date();
|
|
}
|
|
|
|
/**
|
|
* Unresolve the comment. Note this does not save the comment to the database.
|
|
*/
|
|
public unresolve() {
|
|
if (!this.isResolved) {
|
|
throw ValidationError("Comment is not resolved");
|
|
}
|
|
|
|
this.resolvedById = null;
|
|
this.resolvedBy = null;
|
|
this.resolvedAt = null;
|
|
}
|
|
|
|
/**
|
|
* Whether the comment is resolved
|
|
*/
|
|
public get isResolved() {
|
|
return !!this.resolvedAt;
|
|
}
|
|
|
|
/**
|
|
* Convert the comment data to plain text
|
|
*
|
|
* @returns The plain text representation of the comment data
|
|
*/
|
|
public toPlainText() {
|
|
const node = Node.fromJSON(commentSchema, this.data);
|
|
return ProsemirrorHelper.toPlainText(node);
|
|
}
|
|
|
|
/**
|
|
* Convert the comment data to markdown.
|
|
*
|
|
* @returns The markdown representation of the comment data
|
|
*/
|
|
public toMarkdown() {
|
|
const node = Node.fromJSON(commentSchema, this.data);
|
|
return serializer
|
|
.serialize(node)
|
|
.replace(/(^|\n)\\(\n|$)/g, "\n\n")
|
|
.trim();
|
|
}
|
|
|
|
// hooks
|
|
|
|
// A reply must belong to a thread root in the same document, so that a
|
|
// thread is never more than one level deep. A reply created on an
|
|
// already-resolved thread inherits the parent's resolved state so the
|
|
// resolvedAt column alone can answer "is this thread resolved?" — keeping
|
|
// read queries simple and the counter cache index-only.
|
|
@BeforeCreate
|
|
public static async validateParentComment(
|
|
model: Comment,
|
|
options: CreateOptions<InferAttributes<Comment>>
|
|
) {
|
|
if (!model.parentCommentId) {
|
|
return;
|
|
}
|
|
const parent = await this.unscoped().findOne({
|
|
where: {
|
|
id: model.parentCommentId,
|
|
documentId: model.documentId,
|
|
},
|
|
transaction: options.transaction,
|
|
lock: options.transaction
|
|
? { level: options.transaction.LOCK.NO_KEY_UPDATE, of: this }
|
|
: undefined,
|
|
});
|
|
if (!parent) {
|
|
throw ValidationError("Parent comment must belong to the same document");
|
|
}
|
|
if (parent.parentCommentId) {
|
|
throw ValidationError("Cannot reply to a reply");
|
|
}
|
|
if (!model.resolvedAt && parent.resolvedAt) {
|
|
model.resolvedAt = parent.resolvedAt;
|
|
model.resolvedById = parent.resolvedById;
|
|
}
|
|
}
|
|
|
|
// When a thread root is resolved or unresolved, propagate the same state to
|
|
// its replies and invalidate the document's commentCount counter cache.
|
|
@AfterUpdate
|
|
public static async cascadeResolvedToReplies(
|
|
model: Comment,
|
|
options: InstanceUpdateOptions<InferAttributes<Comment>>
|
|
) {
|
|
if (!model.changed("resolvedAt")) {
|
|
return;
|
|
}
|
|
|
|
if (model.parentCommentId === null) {
|
|
await this.update(
|
|
{
|
|
resolvedAt: model.resolvedAt,
|
|
resolvedById: model.resolvedById,
|
|
},
|
|
{
|
|
where: { parentCommentId: model.id, documentId: model.documentId },
|
|
transaction: options.transaction,
|
|
hooks: false,
|
|
}
|
|
);
|
|
}
|
|
|
|
await afterCommit(options.transaction, () =>
|
|
CacheHelper.removeData(
|
|
RedisPrefixHelper.getCounterCacheKey(
|
|
"Document",
|
|
"unresolvedComments",
|
|
model.documentId
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
@AfterDestroy
|
|
public static async deleteChildComments(model: Comment, ctx: HookContext) {
|
|
await this.destroy({
|
|
where: { parentCommentId: model.id, documentId: model.documentId },
|
|
transaction: ctx.transaction,
|
|
hooks: false,
|
|
});
|
|
}
|
|
}
|
|
|
|
export default Comment;
|