mirror of
https://github.com/outline/outline.git
synced 2026-11-21 05:24:03 +03:00
* Migrate Backlink model to generic Relationship model - Create new Relationship model with type field to support different relationship types - Add database migration to create relationships table and migrate existing backlinks - Update Backlink model to delegate to Relationship model for backward compatibility - Update BacklinksProcessor to use Relationship model with backlink type - Update API routes to use new Relationship model - Update test files to use Relationship model - Maintain backward compatibility through database view and model delegation Fixes #9366 * Update migration to rename table instead of creating new one - Rename existing backlinks table to relationships instead of creating new table - Add type column with default value to existing table - Update existing rows to have type='backlink' - Avoid expensive data migration by keeping existing data in place - Maintain backward compatibility with database view - Update rollback to reverse table rename and column addition This approach is much more efficient for large datasets as it avoids copying millions of rows. * Remove unnecessary UPDATE statement from migration The UPDATE statement is not needed since defaultValue automatically applies to existing rows when adding a column with a default value. Thanks @tommoor for catching this! * Wrap up migration in transaction - Wrap all migration operations in a transaction for atomicity - Add transaction parameter to all queryInterface calls - Follow the same pattern as other migrations in the codebase - Ensures all operations succeed or fail together * Remove Backlink class entirely and use Relationship everywhere - Delete server/models/Backlink.ts - Remove Backlink export from server/models/index.ts - Remove Backlink import and association from Document model - All functionality now uses Relationship model with RelationshipType.Backlink - Maintains same API through Relationship model methods - Cleaner architecture with single relationship model * Update documents.test.ts to use RelationshipType enum instead of string - Import RelationshipType from Relationship model - Replace type: "backlink" with type: RelationshipType.Backlink - Improves type safety and consistency with enum usage * Address code review feedback - Add transaction wrapper to migration down method for safer rollback - Remove unused findByTypeForUser method from Relationship model - Method wasn't used and won't work for all relationship types (e.g., user mentions) - Clean up code structure and improve safety * Restore imports --------- Co-authored-by: codegen-sh[bot] <131295404+codegen-sh[bot]@users.noreply.github.com> Co-authored-by: Tom Moor <tom@getoutline.com>
119 lines
3.4 KiB
TypeScript
119 lines
3.4 KiB
TypeScript
import { Op } from "sequelize";
|
|
import { Document, Relationship } from "@server/models";
|
|
import { RelationshipType } from "@server/models/Relationship";
|
|
import { DocumentHelper } from "@server/models/helpers/DocumentHelper";
|
|
import { Event, DocumentEvent, RevisionEvent } from "@server/types";
|
|
import BaseProcessor from "./BaseProcessor";
|
|
|
|
export default class BacklinksProcessor extends BaseProcessor {
|
|
static applicableEvents: Event["name"][] = [
|
|
"documents.publish",
|
|
"documents.update",
|
|
"documents.delete",
|
|
];
|
|
|
|
async perform(event: DocumentEvent | RevisionEvent) {
|
|
switch (event.name) {
|
|
case "documents.publish": {
|
|
const document = await Document.findByPk(event.documentId);
|
|
if (!document) {
|
|
return;
|
|
}
|
|
const linkIds = DocumentHelper.parseDocumentIds(document);
|
|
await Promise.all(
|
|
linkIds.map(async (linkId) => {
|
|
const linkedDocument = await Document.findByPk(linkId);
|
|
|
|
if (!linkedDocument || linkedDocument.id === event.documentId) {
|
|
return;
|
|
}
|
|
|
|
await Relationship.findOrCreate({
|
|
where: {
|
|
documentId: linkedDocument.id,
|
|
reverseDocumentId: event.documentId,
|
|
type: RelationshipType.Backlink,
|
|
},
|
|
defaults: {
|
|
userId: document.lastModifiedById,
|
|
type: RelationshipType.Backlink,
|
|
},
|
|
});
|
|
})
|
|
);
|
|
break;
|
|
}
|
|
|
|
case "documents.update": {
|
|
const document = await Document.findByPk(event.documentId);
|
|
if (!document) {
|
|
return;
|
|
}
|
|
|
|
// backlinks are only created for published documents
|
|
if (!document.publishedAt) {
|
|
return;
|
|
}
|
|
|
|
const linkIds = DocumentHelper.parseDocumentIds(document);
|
|
const linkedDocumentIds: string[] = [];
|
|
|
|
// create or find existing backlink records for referenced docs
|
|
await Promise.all(
|
|
linkIds.map(async (linkId) => {
|
|
const linkedDocument = await Document.findByPk(linkId);
|
|
|
|
if (!linkedDocument || linkedDocument.id === event.documentId) {
|
|
return;
|
|
}
|
|
|
|
await Relationship.findOrCreate({
|
|
where: {
|
|
documentId: linkedDocument.id,
|
|
reverseDocumentId: event.documentId,
|
|
type: RelationshipType.Backlink,
|
|
},
|
|
defaults: {
|
|
userId: document.lastModifiedById,
|
|
type: RelationshipType.Backlink,
|
|
},
|
|
});
|
|
linkedDocumentIds.push(linkedDocument.id);
|
|
})
|
|
);
|
|
|
|
// delete any backlinks that no longer exist
|
|
await Relationship.destroy({
|
|
where: {
|
|
documentId: {
|
|
[Op.notIn]: linkedDocumentIds,
|
|
},
|
|
reverseDocumentId: event.documentId,
|
|
type: RelationshipType.Backlink,
|
|
},
|
|
});
|
|
break;
|
|
}
|
|
|
|
case "documents.delete": {
|
|
await Relationship.destroy({
|
|
where: {
|
|
[Op.or]: [
|
|
{
|
|
reverseDocumentId: event.documentId,
|
|
},
|
|
{
|
|
documentId: event.documentId,
|
|
},
|
|
],
|
|
type: RelationshipType.Backlink,
|
|
},
|
|
});
|
|
break;
|
|
}
|
|
|
|
default:
|
|
}
|
|
}
|
|
}
|