mirror of
https://github.com/outline/outline.git
synced 2026-11-20 21:23:06 +03:00
* feat: Add get_document_changes MCP tool to diff document history * fix: Bound document changes to the loaded snapshot and diff raw markdown * perf: Replace structuredPatch with an integer ID line diff (#14246) * fix: Update get_document_changes for MCP SDK v2
305 lines
7.7 KiB
TypeScript
305 lines
7.7 KiB
TypeScript
import type { InferAttributes, InferCreationAttributes } from "sequelize";
|
|
import { sortBy } from "es-toolkit/compat";
|
|
import { Op } from "sequelize";
|
|
import { isUUID } from "validator";
|
|
import {
|
|
AllowNull,
|
|
DataType,
|
|
BelongsTo,
|
|
Column,
|
|
DefaultScope,
|
|
ForeignKey,
|
|
Table,
|
|
IsNumeric,
|
|
Length as SimpleLength,
|
|
BeforeDestroy,
|
|
} from "sequelize-typescript";
|
|
import type { ProsemirrorData, SourceMetadata } from "@shared/types";
|
|
import { DocumentValidation, RevisionValidation } from "@shared/validations";
|
|
import type { APIContext } from "@server/types";
|
|
import Document from "./Document";
|
|
import User from "./User";
|
|
import ParanoidModel from "./base/ParanoidModel";
|
|
import IsHexColor from "./validators/IsHexColor";
|
|
import Length from "./validators/Length";
|
|
import { SkipChangeset } from "./decorators/Changeset";
|
|
|
|
@DefaultScope(() => ({
|
|
include: [
|
|
{
|
|
model: User,
|
|
as: "user",
|
|
paranoid: false,
|
|
},
|
|
],
|
|
}))
|
|
@Table({ tableName: "revisions", modelName: "revision" })
|
|
class Revision extends ParanoidModel<
|
|
InferAttributes<Revision>,
|
|
Partial<InferCreationAttributes<Revision>>
|
|
> {
|
|
@IsNumeric
|
|
@Column(DataType.SMALLINT)
|
|
@SkipChangeset
|
|
version?: number | null;
|
|
|
|
/** The editor version at the time of the revision */
|
|
@SimpleLength({
|
|
max: 255,
|
|
msg: `editorVersion must be 255 characters or less`,
|
|
})
|
|
@Column(DataType.STRING)
|
|
@SkipChangeset
|
|
editorVersion: string | null;
|
|
|
|
/** The document title at the time of the revision */
|
|
@Length({
|
|
max: DocumentValidation.maxTitleLength,
|
|
msg: `Revision title must be ${DocumentValidation.maxTitleLength} characters or less`,
|
|
})
|
|
@Column(DataType.STRING)
|
|
@SkipChangeset
|
|
title: string;
|
|
|
|
/** An optional name for the revision */
|
|
@Length({
|
|
max: RevisionValidation.maxNameLength,
|
|
msg: `Revision name must be ${RevisionValidation.maxNameLength} characters or less`,
|
|
})
|
|
@Column(DataType.STRING)
|
|
@SkipChangeset
|
|
name: string | null;
|
|
|
|
/**
|
|
* The content of the revision as Markdown.
|
|
*
|
|
* @deprecated Use `content` instead, or `DocumentHelper.toMarkdown` if
|
|
* exporting lossy markdown. This column will be removed in a future migration
|
|
* and is no longer being written.
|
|
*/
|
|
@Column(DataType.TEXT)
|
|
@SkipChangeset
|
|
text: string | null;
|
|
|
|
/** The content of the revision as JSON. */
|
|
@Column(DataType.JSONB)
|
|
@SkipChangeset
|
|
content: ProsemirrorData | null;
|
|
|
|
/** The icon at the time of the revision. */
|
|
@Column(DataType.STRING)
|
|
@SkipChangeset
|
|
icon: string | null;
|
|
|
|
/** The color at the time of the revision. */
|
|
@IsHexColor
|
|
@Column(DataType.STRING)
|
|
@SkipChangeset
|
|
color: string | null;
|
|
|
|
/** Metadata about how the revision came to be, such as the authentication type used. */
|
|
@AllowNull
|
|
@Column(DataType.JSONB)
|
|
@SkipChangeset
|
|
sourceMetadata: SourceMetadata | null;
|
|
|
|
// associations
|
|
|
|
@BelongsTo(() => Document, "documentId")
|
|
document: Document;
|
|
|
|
@ForeignKey(() => Document)
|
|
@Column(DataType.UUID)
|
|
documentId: string;
|
|
|
|
@BelongsTo(() => User, "userId")
|
|
user: User;
|
|
|
|
@ForeignKey(() => User)
|
|
@Column(DataType.UUID)
|
|
userId: string;
|
|
|
|
/** Array of user IDs who collaborated on this revision */
|
|
@Column(DataType.ARRAY(DataType.UUID))
|
|
@SkipChangeset
|
|
collaboratorIds: string[];
|
|
|
|
/**
|
|
* Get the collaborators for this revision, with the author first and the
|
|
* others in the order they were recorded.
|
|
*/
|
|
get collaborators() {
|
|
const otherCollaboratorIds = (this.collaboratorIds ?? []).filter(
|
|
(id) => id !== this.userId
|
|
);
|
|
|
|
if (otherCollaboratorIds.length === 0) {
|
|
return [this.user];
|
|
}
|
|
|
|
return User.findAll({
|
|
where: {
|
|
id: {
|
|
[Op.in]: otherCollaboratorIds,
|
|
},
|
|
},
|
|
paranoid: false,
|
|
}).then((others) => [
|
|
this.user,
|
|
...sortBy(others, [(user) => otherCollaboratorIds.indexOf(user.id)]),
|
|
]);
|
|
}
|
|
|
|
// hooks
|
|
|
|
@BeforeDestroy
|
|
static async clearData(model: Revision) {
|
|
model.content = null;
|
|
model.text = null;
|
|
model.title = "";
|
|
}
|
|
|
|
// static methods
|
|
|
|
/**
|
|
* Find the latest revision for a given document
|
|
*
|
|
* @param documentId The document id to find the latest revision for
|
|
* @returns A Promise that resolves to a Revision model
|
|
*/
|
|
static findLatest(documentId: string) {
|
|
return this.findOne({
|
|
where: {
|
|
documentId,
|
|
},
|
|
order: [["createdAt", "DESC"]],
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Find a revision by id that belongs to the given document.
|
|
*
|
|
* @param id The id of the revision.
|
|
* @param documentId The id of the document the revision must belong to.
|
|
* @returns A Promise that resolves to a Revision model, or null if not found.
|
|
*/
|
|
static async findByIdForDocument(id: string, documentId: string) {
|
|
if (!isUUID(id)) {
|
|
return null;
|
|
}
|
|
|
|
return this.findOne({
|
|
where: {
|
|
id,
|
|
documentId,
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Find the latest revision of a document that a user authored or
|
|
* collaborated on.
|
|
*
|
|
* @param documentId The id of the document.
|
|
* @param userId The id of the user.
|
|
* @returns A Promise that resolves to a Revision model, or null if not found.
|
|
*/
|
|
static findLatestByUser(documentId: string, userId: string) {
|
|
return this.findOne({
|
|
where: {
|
|
documentId,
|
|
[Op.or]: [{ userId }, { collaboratorIds: { [Op.contains]: [userId] } }],
|
|
},
|
|
order: [["createdAt", "DESC"]],
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Find the revision that shows a document as it was at a given time, the
|
|
* latest revision created at or before that time.
|
|
*
|
|
* @param documentId The id of the document.
|
|
* @param date The point in time.
|
|
* @returns A Promise that resolves to a Revision model, or null if the
|
|
* document had no revision at that time.
|
|
*/
|
|
static findAt(documentId: string, date: Date) {
|
|
return this.findOne({
|
|
where: {
|
|
documentId,
|
|
createdAt: {
|
|
[Op.lte]: date,
|
|
},
|
|
},
|
|
order: [["createdAt", "DESC"]],
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Build a Revision model from a Document model
|
|
*
|
|
* @param document The document to build from
|
|
* @returns A Revision model
|
|
*/
|
|
static buildFromDocument(document: Document) {
|
|
return this.build({
|
|
title: document.title,
|
|
icon: document.icon,
|
|
color: document.color,
|
|
content: document.content,
|
|
userId: document.lastModifiedById,
|
|
editorVersion: document.editorVersion,
|
|
version: document.version,
|
|
documentId: document.id,
|
|
// revision time is set to the last time document was touched as this
|
|
// handler can be debounced in the case of an update
|
|
createdAt: document.updatedAt,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create a Revision model from a Document model and save it to the database
|
|
*
|
|
* @param ctx context to use for DB operations
|
|
* @param document The document to create from
|
|
* @param collaboratorIds Optional array of user IDs who authored this revision
|
|
* @returns A Promise that resolves when saved
|
|
*/
|
|
static createFromDocument(
|
|
ctx: APIContext,
|
|
document: Document,
|
|
collaboratorIds?: string[]
|
|
) {
|
|
const revision = this.buildFromDocument(document);
|
|
const authType = ctx.context.auth?.type;
|
|
revision.sourceMetadata = authType ? { authType } : null;
|
|
|
|
if (collaboratorIds) {
|
|
revision.collaboratorIds = collaboratorIds;
|
|
}
|
|
|
|
return revision.saveWithCtx(ctx);
|
|
}
|
|
|
|
// instance methods
|
|
|
|
/**
|
|
* Find the revision for the document before this one.
|
|
*
|
|
* @returns A Promise that resolves to a Revision, or null if this is the first revision.
|
|
*/
|
|
before(): Promise<Revision | null> {
|
|
return (this.constructor as typeof Revision).findOne({
|
|
where: {
|
|
documentId: this.documentId,
|
|
createdAt: {
|
|
[Op.lt]: this.createdAt,
|
|
},
|
|
},
|
|
order: [["createdAt", "DESC"]],
|
|
});
|
|
}
|
|
}
|
|
|
|
export default Revision;
|