Files
outline/server/commands/documentUpdater.test.ts
Tom Moor aa454033ec fix: Keep callouts and rules nested when serialized to Markdown (#14528)
* fix: Keep notices and rules nested in lists and quotes when serialized to Markdown

* fix: Keep the blank line above notices and rules, written per line
2026-11-11 08:09:35 -05:00

2467 lines
72 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { randomUUID } from "node:crypto";
import * as Y from "yjs";
import { yDocToProsemirrorJSON } from "y-prosemirror";
import {
TextEditMode,
MentionType,
type ProsemirrorData,
type ProsemirrorMark,
} from "@shared/types";
import { APIUpdateExtension } from "@server/collaboration/APIUpdateExtension";
import { Document, Event } from "@server/models";
import { parser, schema } from "@server/editor";
import { DocumentHelper } from "@server/models/helpers/DocumentHelper";
import { ProsemirrorHelper } from "@server/models/helpers/ProsemirrorHelper";
import {
buildCollection,
buildDocument,
buildUser,
} from "@server/test/factories";
import { withAPIContext } from "@server/test/support";
import documentUpdater from "./documentUpdater";
describe("documentUpdater", () => {
it.each(Object.values(TextEditMode))(
"should attribute new mentions and preserve existing actors in %s mode",
async (editMode) => {
const user = await buildUser();
const originalActor = await buildUser({ teamId: user.teamId });
const mentionId = randomUUID();
const originalMention = `@[Original](mention://${mentionId}/user/${originalActor.id})`;
const initialDoc = ProsemirrorHelper.assignMentionActors(
parser.parse(`${originalMention} replace me`),
originalActor.id
);
let document = await buildDocument({
teamId: user.teamId,
content: initialDoc.toJSON(),
state: Buffer.from(
Y.encodeStateAsUpdate(ProsemirrorHelper.toYDoc(initialDoc.toJSON()))
),
});
const newMention = `@[Writer](mention://user/${user.id})`;
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
document,
text:
editMode === TextEditMode.Replace
? `${originalMention} ${newMention}`
: newMention,
editMode,
findText: editMode === TextEditMode.Patch ? "replace me" : undefined,
})
);
document = await Document.findByPk(document.id, {
includeState: true,
rejectOnEmpty: true,
});
expect(
DocumentHelper.parseMentions(document, { type: MentionType.User })
).toEqual(
expect.arrayContaining([
expect.objectContaining({ id: mentionId, actorId: originalActor.id }),
expect.objectContaining({ modelId: user.id, actorId: user.id }),
])
);
if (!document.state) {
throw new Error("Expected collaborative state to be persisted");
}
const ydoc = new Y.Doc();
Y.applyUpdate(ydoc, document.state);
expect(yDocToProsemirrorJSON(ydoc, "default")).toEqual(document.content);
}
);
it("should leave retained mentions without attribution unchanged", async () => {
const user = await buildUser();
const mention = `@[Writer](mention://${randomUUID()}/user/${user.id})`;
let document = await buildDocument({
teamId: user.teamId,
content: parser.parse(mention).toJSON(),
});
const originalMentions = DocumentHelper.parseMentions(document);
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, { document, text: `${mention} updated` })
);
await document.reload();
expect(DocumentHelper.parseMentions(document)).toEqual(originalMentions);
});
it("should change lastModifiedById", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Changed",
document,
})
);
const event = await Event.findLatest({
teamId: user.teamId,
});
expect(document.lastModifiedById).toEqual(user.id);
expect(event!.name).toEqual("documents.update");
expect(event!.documentId).toEqual(document.id);
});
it("should change lastModifiedById when republishing an already published document", async () => {
const user = await buildUser();
const creator = await buildUser({ teamId: user.teamId });
let document = await buildDocument({
teamId: user.teamId,
userId: creator.id,
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Changed",
publish: true,
document,
})
);
expect(document.createdById).toEqual(creator.id);
expect(document.lastModifiedById).toEqual(user.id);
});
it("should not change lastModifiedById or generate event if nothing changed", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
title: document.title,
document,
})
);
expect(document.lastModifiedById).not.toEqual(user.id);
});
it("should notify collaboration server when text changes", async () => {
const notifyUpdateSpy = vi
.spyOn(APIUpdateExtension, "notifyUpdate")
.mockResolvedValue(undefined);
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Initial text",
});
// Create initial collaborative state (simulating an active collaboration session)
const ydoc = ProsemirrorHelper.toYDoc("Initial text");
document.state = Buffer.from(Y.encodeStateAsUpdate(ydoc));
await document.save();
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Changed content",
document,
})
);
expect(notifyUpdateSpy).toHaveBeenCalledWith(document.id, user.id);
notifyUpdateSpy.mockRestore();
});
it("should not notify collaboration server when only title changes", async () => {
const notifyUpdateSpy = vi
.spyOn(APIUpdateExtension, "notifyUpdate")
.mockResolvedValue(undefined);
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
title: "New Title",
document,
})
);
expect(notifyUpdateSpy).not.toHaveBeenCalled();
notifyUpdateSpy.mockRestore();
});
it("should keep the loaded collection when the title changes", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const { id } = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const document = await Document.findByPk(id, {
userId: user.id,
rejectOnEmpty: true,
});
const loadedCollection = document.collection;
const result = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
title: "New Title",
document,
})
);
expect(result).toBe(document);
expect(result.collection).toBe(loadedCollection);
expect(result.collection?.documentStructure?.[0].title).toEqual(
"New Title"
);
});
describe("replace", () => {
it("should update document content when changing text", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Changed",
document,
})
);
expect(document.text).toEqual("Changed");
expect(document.content).toEqual({
type: "doc",
content: [
{
type: "paragraph",
content: [
{
type: "text",
text: "Changed",
},
],
},
],
});
});
});
describe("append", () => {
it("should append document content when requested", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Initial",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Appended",
document,
editMode: TextEditMode.Append,
})
);
expect(document.text).toEqual("InitialAppended");
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "InitialAppended" }],
},
],
});
});
it("should preserve rich content when appending", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "**Bold**",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Appended",
document,
editMode: TextEditMode.Append,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [{ type: "strong" }],
text: "Bold",
},
{
type: "text",
text: "Appended",
},
],
},
],
});
});
it("should preserve rich content from JSON when appending", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const id = randomUUID();
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [{ type: "comment", attrs: { id, userId: id } }],
text: "Italic",
},
],
},
],
};
await document.save();
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Appended",
document,
editMode: TextEditMode.Append,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [{ type: "comment", attrs: { id, userId: id } }],
text: "Italic",
},
{
type: "text",
text: "Appended",
},
],
},
],
});
});
it("should create new paragraph when appending with newline", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Initial",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "\n\nAppended",
document,
editMode: TextEditMode.Append,
})
);
expect(document.text).toEqual("Initial\n\nAppended");
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Initial" }],
},
{
type: "paragraph",
content: [{ type: "text", text: "Appended" }],
},
],
});
});
});
describe("prepend", () => {
it("should prepend document content when requested", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Existing",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Prepended",
document,
editMode: TextEditMode.Prepend,
})
);
expect(document.text).toEqual("PrependedExisting");
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "PrependedExisting" }],
},
],
});
});
it("should preserve rich content when prepending", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "**Bold**",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Prepended",
document,
editMode: TextEditMode.Prepend,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [
{
type: "text",
text: "Prepended",
},
{
type: "text",
marks: [{ type: "strong" }],
text: "Bold",
},
],
},
],
});
});
it("should create new paragraph when prepending with newline", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Existing",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Prepended\n\n",
document,
editMode: TextEditMode.Prepend,
})
);
expect(document.text).toEqual("Prepended\n\nExisting");
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Prepended" }],
},
{
type: "paragraph",
content: [{ type: "text", text: "Existing" }],
},
],
});
});
});
describe("patch", () => {
const listItem = (text: string, marks?: ProsemirrorMark[]) => ({
type: "list_item",
content: [
{
type: "paragraph",
content: [{ type: "text", text, ...(marks && { marks }) }],
},
],
});
/** The serialized markdown line of a document that contains the needle. */
const lineContaining = async (doc: Document, needle: string) =>
(await DocumentHelper.toMarkdown(doc, { includeTitle: false }))
.split("\n")
.find((line) => line.includes(needle))!;
it("should patch specific text in document content", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Hello world\n\nThis is a test",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Hello earth",
TextEditMode.Patch,
"Hello world"
);
const content = result.content!.content!;
expect(content).toHaveLength(2);
expect(content[0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Hello earth" }],
});
expect(content[1]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "This is a test" }],
});
});
it("should patch text retrieved via toMarkdown containing smart quotes and brackets", async () => {
const user = await buildUser();
const document = await buildDocument({
teamId: user.teamId,
content: {
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "the cat’s “meow” [loud]" }],
},
],
},
});
// findText is the exact text a client receives from retrieval.
const findText = await DocumentHelper.toMarkdown(document, {
includeTitle: false,
});
expect(findText).toBe("the cat’s “meow” [loud]");
const result = DocumentHelper.applyMarkdownToDocument(
document,
"quiet",
TextEditMode.Patch,
findText
);
expect(result.content!.content![0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "quiet" }],
});
});
it("should throw when findText is not found in document", async () => {
const user = await buildUser();
const document = await buildDocument({
teamId: user.teamId,
text: "Hello world",
});
await expect(
withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "replacement",
findText: "nonexistent text",
document,
editMode: TextEditMode.Patch,
})
)
).rejects.toThrow("The specified text was not found in the document");
});
it("should handle dollar signs in replacement text literally", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "The price is TBD",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"$100 & $200",
TextEditMode.Patch,
"TBD"
);
const content = result.content!.content!;
expect(content).toHaveLength(1);
expect(content[0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "The price is $100 & $200" }],
});
});
it("should delete matched text when replacement is empty string", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "Hello beautiful world",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"",
TextEditMode.Patch,
"beautiful "
);
const content = result.content!.content!;
expect(content).toHaveLength(1);
expect(content[0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Hello world" }],
});
});
it("should handle multi-block replacement in a single paragraph", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Replace this text here" }],
},
],
};
await document.save();
// Replace with content that parses to multiple blocks
const result = DocumentHelper.applyMarkdownToDocument(
document,
"First paragraph\n\nSecond paragraph",
TextEditMode.Patch,
"Replace this text here"
);
const content = result.content!.content!;
// Should produce two paragraphs, not silently drop the second
expect(content.length).toBeGreaterThanOrEqual(2);
expect(content[0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "First paragraph" }],
});
expect(content[1]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Second paragraph" }],
});
});
it("should patch multi-block content", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "# Heading\n\nOld content\n\nKeep this",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"# New Heading\n\nNew content",
TextEditMode.Patch,
"# Heading\n\nOld content"
);
const content = result.content!.content!;
expect(content).toHaveLength(3);
expect(content[0]).toMatchObject({
type: "heading",
content: [{ type: "text", text: "New Heading" }],
});
expect(content[1]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "New content" }],
});
expect(content[2]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Keep this" }],
});
});
it("should patch the middle item in a list", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "- First item\n- Second item\n- Third item",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "* Updated item",
findText: "* Second item",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "bullet_list",
content: [
listItem("First item"),
listItem("Updated item"),
listItem("Third item"),
],
},
{ type: "paragraph" },
],
});
});
it("should keep a notice nested in its list item when patching another item", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "1. Alpha one.\n2. Bravo two:\n\n :::info\n A note inside item two.\n :::\n3. Charlie three.",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "Amber",
findText: "Alpha",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "ordered_list",
content: [
listItem("Amber one."),
{
type: "list_item",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Bravo two:" }],
},
{
type: "container_notice",
content: [
{
type: "paragraph",
content: [
{ type: "text", text: "A note inside item two." },
],
},
],
},
],
},
listItem("Charlie three."),
],
},
{ type: "paragraph" },
],
});
});
it("should append new blocks after a table when patching the last row", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "## Sizes\n\n| Quantity | Value |\n|---|---|\n| alpha | 1 |\n| beta | 2 |\n| gamma | 3 |\n",
});
const lastRow = await lineContaining(document, "gamma");
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: `${lastRow}\n\n## New\n\nbody text`,
findText: lastRow,
document,
editMode: TextEditMode.Patch,
})
);
const content = document.content as ProsemirrorData;
expect(content.content?.map((n) => n.type)).toEqual([
"heading",
"table",
"heading",
"paragraph",
]);
expect(content.content?.[1].content).toHaveLength(4);
expect(document.text).toContain("gamma");
expect(document.text).toContain("## New");
expect(document.text).toContain("body text");
});
it("should not drop later rows when patching a middle table row with new blocks", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "| Quantity | Value |\n|---|---|\n| alpha | 1 |\n| beta | 2 |\n| gamma | 3 |\n",
});
const middleRow = await lineContaining(document, "beta");
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: `${middleRow}\n\n## New`,
findText: middleRow,
document,
editMode: TextEditMode.Patch,
})
);
expect(document.text).toContain("beta");
expect(document.text).toContain("## New");
expect(document.text).toContain("gamma");
});
it("should keep list items when the replacement uses a different bullet marker", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "* alpha\n* beta\n* gamma",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "- beta EDITED",
findText: "* beta",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "bullet_list",
content: [
listItem("alpha"),
listItem("beta EDITED"),
listItem("gamma"),
],
},
{ type: "paragraph" },
],
});
});
it("should keep later blockquote paragraphs when one is replaced with plain text", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "> alpha\n>\n> beta\n>\n> gamma\n\n## Notes",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "beta EDITED",
findText: "> beta",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.text).toContain("alpha");
expect(document.text).toContain("beta EDITED");
expect(document.text).toContain("gamma");
expect(document.text).toContain("## Notes");
});
it("should preserve comment marks on earlier rows when appending a row", async () => {
const user = await buildUser();
const commentId = randomUUID();
let document = await buildDocument({
teamId: user.teamId,
text: "| A | B |\n|---|---|\n| one | 1 |\n| two | 2 |",
});
// Attach a comment mark to the first body row cell text
const content = document.content as ProsemirrorData;
const table = content.content![0];
const firstRow = table.content![1];
const cellPara = firstRow.content![0].content![0];
cellPara.content![0].marks = [
{ type: "comment", attrs: { id: commentId, userId: user.id } },
];
document.content = content;
document.changed("content", true);
await document.save();
const lastRow = await lineContaining(document, "two");
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: `${lastRow}\n${lastRow.replace("two", "three").replace("2", "3")}`,
findText: lastRow,
document,
editMode: TextEditMode.Patch,
})
);
const result = document.content as ProsemirrorData;
const resultTable = result.content![0];
expect(resultTable.type).toBe("table");
expect(resultTable.content).toHaveLength(4);
const resultCellPara = resultTable.content![1].content![0].content![0];
expect(resultCellPara.content![0].marks).toMatchObject([
{ type: "comment", attrs: { id: commentId, userId: user.id } },
]);
expect(document.text).toContain("three");
});
it("should preserve comment marks on both neighbours when editing a middle item and adding another", async () => {
const user = await buildUser();
const commentId = randomUUID();
const commentMark = {
type: "comment",
attrs: { id: commentId, userId: user.id },
};
let document = await buildDocument({
teamId: user.teamId,
content: {
type: "doc",
content: [
{
type: "bullet_list",
content: [
listItem("alpha", [commentMark]),
listItem("beta"),
listItem("gamma", [commentMark]),
],
},
],
},
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "* beta EDITED\n* delta",
findText: "* beta",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "bullet_list",
content: [
listItem("alpha", [commentMark]),
listItem("beta EDITED"),
listItem("delta"),
listItem("gamma", [commentMark]),
],
},
{ type: "paragraph" },
],
});
});
it("should preserve comment marks on later items when removing an earlier item", async () => {
const user = await buildUser();
const commentId = randomUUID();
const commentMark = {
type: "comment",
attrs: { id: commentId, userId: user.id },
};
let document = await buildDocument({
teamId: user.teamId,
content: {
type: "doc",
content: [
{
type: "bullet_list",
content: [
listItem("alpha"),
listItem("beta"),
listItem("gamma", [commentMark]),
],
},
],
},
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "",
findText: "* alpha\n",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "bullet_list",
content: [listItem("beta"), listItem("gamma", [commentMark])],
},
{ type: "paragraph" },
],
});
});
it("should replace a whole list with a paragraph", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "# Title\n\n* only item\n\nafter",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "plain text now",
findText: "* only item",
document,
editMode: TextEditMode.Patch,
})
);
const content = document.content as ProsemirrorData;
expect(content.content?.map((n) => n.type)).toEqual([
"heading",
"paragraph",
"paragraph",
]);
expect(document.text).toContain("plain text now");
expect(document.text).not.toContain("only item");
expect(document.text).toContain("after");
});
it("should keep all items when a bullet item is changed to an ordered item", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "* alpha\n* beta\n* gamma",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "1. beta EDITED",
findText: "* beta",
document,
editMode: TextEditMode.Patch,
})
);
const content = document.content as ProsemirrorData;
expect(content.content?.map((n) => n.type)).toEqual([
"bullet_list",
"ordered_list",
"bullet_list",
"paragraph",
]);
expect(document.text).toContain("alpha");
expect(document.text).toContain("beta EDITED");
expect(document.text).toContain("gamma");
});
it("should keep one ordered list when the replacement uses a different delimiter", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "1. one\n2. two\n3. three",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "2) two EDITED",
findText: "2. two",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "ordered_list",
attrs: { order: 1 },
content: [
listItem("one"),
listItem("two EDITED"),
listItem("three"),
],
},
{ type: "paragraph" },
],
});
});
it("should not join adjacent ordered lists with different list styles", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "a. alpha",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "a. alpha\n1) numeric",
findText: "a. alpha",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "ordered_list",
attrs: { listStyle: "lower-alpha" },
content: [listItem("alpha")],
},
{
type: "ordered_list",
attrs: { listStyle: "number" },
content: [listItem("numeric")],
},
{ type: "paragraph" },
],
});
});
it("should keep nested items when a nested bullet marker changes", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "* alpha\n * one\n * two\n * three\n* beta",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: " - two EDITED",
findText: " * two",
document,
editMode: TextEditMode.Patch,
})
);
expect(document.content).toMatchObject({
type: "doc",
content: [
{
type: "bullet_list",
content: [
{
type: "list_item",
content: [
{ type: "paragraph" },
{
type: "bullet_list",
content: [
listItem("one"),
listItem("two EDITED"),
listItem("three"),
],
},
],
},
listItem("beta"),
],
},
{ type: "paragraph" },
],
});
});
it("should append a new section after a blockquote that ends the document", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "> alpha\n>\n> beta",
});
document = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
text: "> beta\n\n## New\n\nbody",
findText: "> beta",
document,
editMode: TextEditMode.Patch,
})
);
const content = document.content as ProsemirrorData;
expect(content.content?.map((n) => n.type)).toEqual([
"blockquote",
"heading",
"paragraph",
]);
expect(content.content?.[0].content).toHaveLength(2);
expect(document.text).toContain("## New");
expect(document.text).toContain("body");
});
it("should preserve comment marks on untouched blocks when patching", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// Build content with a comment mark (not representable in markdown)
// on the LAST paragraph, then patch the FIRST paragraph.
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "First paragraph" }],
},
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "Commented text",
},
],
},
{
type: "paragraph",
content: [{ type: "text", text: "Third paragraph" }],
},
],
};
await document.save();
// Capture the ProseMirror JSON of untouched blocks BEFORE patching
// (with schema defaults already applied via toProsemirror → toJSON)
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const secondParaBefore = beforeDoc.content[1];
const thirdParaBefore = beforeDoc.content[2];
// Call DocumentHelper directly to inspect the ProseMirror result
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Updated first",
TextEditMode.Patch,
"First paragraph"
);
const content = result.content!.content!;
// Verify untouched blocks are byte-for-byte identical
expect(content[1]).toEqual(secondParaBefore);
expect(content[2]).toEqual(thirdParaBefore);
// Verify the patched block was actually updated
expect(content[0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Updated first" }],
});
// Verify we still have exactly 3 blocks
expect(content).toHaveLength(3);
});
it("should preserve comment marks when patching a later block", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// Comment mark on the FIRST paragraph, patch the THIRD.
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "Commented text",
},
],
},
{
type: "paragraph",
content: [{ type: "text", text: "Middle paragraph" }],
},
{
type: "paragraph",
content: [{ type: "text", text: "Last paragraph" }],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const firstParaBefore = beforeDoc.content[0];
const secondParaBefore = beforeDoc.content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Updated last",
TextEditMode.Patch,
"Last paragraph"
);
const content = result.content!.content!;
// Both untouched blocks must be identical
expect(content[0]).toEqual(firstParaBefore);
expect(content[1]).toEqual(secondParaBefore);
// Patched block updated
expect(content[2]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Updated last" }],
});
expect(content).toHaveLength(3);
});
it("should preserve comment marks in complex document when patching middle content", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// Complex document: heading, paragraph with comment, bullet list, paragraph to patch
document.content = {
type: "doc",
content: [
{
type: "heading",
attrs: { level: 2 },
content: [{ type: "text", text: "Section Title" }],
},
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "This has a comment",
},
],
},
{
type: "bullet_list",
content: [
{
type: "list_item",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Item one" }],
},
],
},
{
type: "list_item",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Item two" }],
},
],
},
],
},
{
type: "paragraph",
content: [{ type: "text", text: "Final paragraph to edit" }],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Edited final paragraph",
TextEditMode.Patch,
"Final paragraph to edit"
);
const content = result.content!.content!;
// All three untouched blocks must be byte-for-byte identical
expect(content[0]).toEqual(beforeDoc.content[0]);
expect(content[1]).toEqual(beforeDoc.content[1]);
expect(content[2]).toEqual(beforeDoc.content[2]);
// Patched block updated
expect(content[3]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Edited final paragraph" }],
});
expect(content).toHaveLength(4);
});
it("should preserve comment mark when patching adjacent text in the same paragraph", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// Paragraph: "Hello world " + "commented"(with comment mark) + " end"
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [
{ type: "text", text: "Hello world " },
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "commented",
},
{ type: "text", text: " end" },
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const commentNode = beforeDoc.content[0].content[1];
const endNode = beforeDoc.content[0].content[2];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Goodbye world ",
TextEditMode.Patch,
"Hello world "
);
const content = result.content!.content!;
expect(content).toHaveLength(1);
// Comment mark and trailing text must be preserved exactly
expect(content[0]).toMatchObject({
type: "paragraph",
content: [
{ type: "text", text: "Goodbye world " },
commentNode,
endNode,
],
});
});
it("should preserve rich content in other checklist items when patching one item", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// Checklist with 3 items; second item has a comment mark
document.content = {
type: "doc",
content: [
{
type: "checkbox_list",
content: [
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [{ type: "text", text: "First task" }],
},
],
},
{
type: "checkbox_item",
attrs: { checked: true },
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "Commented task",
},
],
},
],
},
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Third task" }],
},
],
},
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const secondItem = beforeDoc.content[0].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Updated task",
TextEditMode.Patch,
"First task"
);
const list = result.content!.content![0];
// The second checklist item with its comment mark must be preserved
expect(list.content![1]).toEqual(secondItem);
// The first item should be updated
expect(list.content![0].content![0].content![0].text).toEqual(
"Updated task"
);
// All three items should still exist
expect(list.content).toHaveLength(3);
});
it("should patch checklist item checked state while preserving rich content in siblings", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
document.content = {
type: "doc",
content: [
{
type: "checkbox_list",
content: [
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Buy groceries" }],
},
],
},
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "Review PR",
},
],
},
],
},
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const secondItem = beforeDoc.content[0].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"- [x] Buy groceries",
TextEditMode.Patch,
"- [ ] Buy groceries"
);
const list = result.content!.content![0];
// Checked state should be updated
expect(list.content![0].attrs!.checked).toBe(true);
// Text should remain the same
expect(list.content![0].content![0].content![0].text).toEqual(
"Buy groceries"
);
// Second item with comment mark must be preserved exactly
expect(list.content![1]).toEqual(secondItem);
});
it("should uncheck a checkbox item while preserving rich content in siblings", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// First item is checked, second has a comment mark
document.content = {
type: "doc",
content: [
{
type: "checkbox_list",
content: [
{
type: "checkbox_item",
attrs: { checked: true },
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Buy groceries" }],
},
],
},
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "Review PR",
},
],
},
],
},
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const secondItem = beforeDoc.content[0].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"- [ ] Buy groceries",
TextEditMode.Patch,
"- [x] Buy groceries"
);
const list = result.content!.content![0];
// Checked state should be updated to false
expect(list.content![0].attrs!.checked).toBe(false);
// Text should remain the same
expect(list.content![0].content![0].content![0].text).toEqual(
"Buy groceries"
);
// Second item with comment mark must be preserved exactly
expect(list.content![1]).toEqual(secondItem);
});
it("should preserve mention node when patching adjacent text in the same paragraph", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const mentionId = randomUUID();
// Paragraph: "Hello " + @mention + " please review this"
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [
{ type: "text", text: "Hello " },
{
type: "mention",
attrs: {
type: "user",
label: "Tom",
modelId: mentionId,
actorId: null,
id: mentionId,
},
},
{ type: "text", text: " please review this" },
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const mentionNode = beforeDoc.content[0].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"please approve this",
TextEditMode.Patch,
"please review this"
);
const content = result.content!.content!;
expect(content).toHaveLength(1);
expect(content[0].type).toEqual("paragraph");
// The mention node must be preserved
expect(content[0].content![1]).toEqual(mentionNode);
});
it("should preserve table colwidth when patching a different cell", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
// Table with colwidth set on cells (not representable in markdown)
document.content = {
type: "doc",
content: [
{
type: "table",
content: [
{
type: "tr",
content: [
{
type: "th",
attrs: {
colspan: 1,
rowspan: 1,
colwidth: [150],
alignment: null,
},
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Header A" }],
},
],
},
{
type: "th",
attrs: {
colspan: 1,
rowspan: 1,
colwidth: [250],
alignment: null,
},
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Header B" }],
},
],
},
],
},
{
type: "tr",
content: [
{
type: "td",
attrs: {
colspan: 1,
rowspan: 1,
colwidth: [150],
alignment: null,
},
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Cell to edit" }],
},
],
},
{
type: "td",
attrs: {
colspan: 1,
rowspan: 1,
colwidth: [250],
alignment: null,
},
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Keep this" }],
},
],
},
],
},
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
// Second cell in second row should retain colwidth
const unchangedCell = beforeDoc.content[0].content[1].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Updated cell",
TextEditMode.Patch,
"Cell to edit"
);
const table = result.content!.content![0];
const secondRow = table.content![1];
// The unchanged cell must preserve its colwidth attr
expect(secondRow.content![1]).toEqual(unchangedCell);
expect(secondRow.content![1].attrs!.colwidth).toEqual([250]);
});
it("should preserve trailing whitespace in checklist items when patching", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
// Checklist where an item ends with a hard break (trailing spaces matter)
document.content = {
type: "doc",
content: [
{
type: "checkbox_list",
content: [
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Edit me" }],
},
],
},
{
type: "checkbox_item",
attrs: { checked: false },
content: [
{
type: "paragraph",
content: [
{ type: "text", text: "Line one" },
{ type: "br" },
{ type: "text", text: "Line two" },
],
},
],
},
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const secondItem = beforeDoc.content[0].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Edited",
TextEditMode.Patch,
"Edit me"
);
const list = result.content!.content![0];
// The second item with its hard break must be preserved exactly
expect(list.content![1]).toEqual(secondItem);
});
it("should preserve rich content in blockquote when patching", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
const commentId = randomUUID();
// Blockquote with two paragraphs; second has a comment mark
document.content = {
type: "doc",
content: [
{
type: "blockquote",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Edit this line" }],
},
{
type: "paragraph",
content: [
{
type: "text",
marks: [
{
type: "comment",
attrs: { id: commentId, userId: commentId },
},
],
text: "Keep this comment",
},
],
},
],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const secondPara = beforeDoc.content[0].content[1];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Edited line",
TextEditMode.Patch,
"Edit this line"
);
const blockquote = result.content!.content![0];
// Patched paragraph updated
expect(blockquote.content![0].content![0].text).toEqual("Edited line");
// Second paragraph with comment mark preserved exactly
expect(blockquote.content![1]).toEqual(secondPara);
});
it("should preserve a blockquote containing a table when patching a later link", async () => {
const user = await buildUser();
const document = await buildDocument({ teamId: user.teamId });
const fillerParagraphs: ProsemirrorData[] = Array.from(
{ length: 242 },
(_, index) => ({
type: "paragraph",
content: [{ type: "text", text: `Quoted paragraph ${index + 1}` }],
})
);
document.content = {
type: "doc",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Before quote" }],
},
{
type: "blockquote",
content: [
{
type: "heading",
attrs: { level: 1 },
content: [{ type: "text", text: "Quoted source" }],
},
{
type: "table",
content: [
{
type: "tr",
content: [
{
type: "th",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Key" }],
},
],
},
{
type: "th",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Value" }],
},
],
},
],
},
{
type: "tr",
content: [
{
type: "td",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Alpha" }],
},
],
},
{
type: "td",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Keep this row" }],
},
],
},
],
},
],
},
...fillerParagraphs,
{
type: "paragraph",
content: [
{ type: "text", text: "See " },
{
type: "text",
marks: [
{
type: "link",
attrs: { href: "https://example.com/reference" },
},
],
text: "Reference",
},
{ type: "text", text: "." },
],
},
{
type: "paragraph",
content: [{ type: "text", text: "Tail sentinel." }],
},
],
},
{
type: "paragraph",
content: [{ type: "text", text: "After quote" }],
},
],
};
await document.save();
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const expected = structuredClone(beforeDoc);
expected.content[1].content[244].content[1].marks[0].attrs.href =
"https://example.com/reference#h-target";
const result = DocumentHelper.applyMarkdownToDocument(
document,
"> See [Reference](https://example.com/reference#h-target).",
TextEditMode.Patch,
"> See [Reference](https://example.com/reference)."
);
expect(result.content).toEqual(expected);
});
it("should always patch the first occurrence when findText appears multiple times", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "TODO item\n\nSome details\n\nTODO item",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"DONE item",
TextEditMode.Patch,
"TODO item"
);
const content = result.content!.content!;
expect(content).toHaveLength(3);
// First occurrence replaced
expect(content[0]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "DONE item" }],
});
// Middle paragraph unchanged
expect(content[1]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "Some details" }],
});
// Second occurrence untouched
expect(content[2]).toMatchObject({
type: "paragraph",
content: [{ type: "text", text: "TODO item" }],
});
});
it("should patch text containing inline formatting", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
text: "This is **bold** text",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"This is **strong** text",
TextEditMode.Patch,
"This is **bold** text"
);
const content = result.content!.content!;
expect(content).toHaveLength(1);
expect(content[0]).toMatchObject({
type: "paragraph",
content: [
{ type: "text", text: "This is " },
{
type: "text",
marks: [{ type: "strong" }],
text: "strong",
},
{ type: "text", text: " text" },
],
});
});
it("should insert replacement text verbatim inside a code block", async () => {
const user = await buildUser();
const document = await buildDocument({
teamId: user.teamId,
text: "```bash\nfirst line\necho start\n echo indented\nlast line\n```",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"echo `date`\n echo indented",
TextEditMode.Patch,
"echo start\n echo indented"
);
const content = result.content!.content!;
expect(content).toHaveLength(2);
expect(content[1].type).toBe("paragraph");
expect(content[0]).toMatchObject({
type: "code_block",
content: [
{
type: "text",
text: "first line\necho `date`\n echo indented\nlast line",
},
],
});
expect(content[0].content![0].marks).toBeUndefined();
expect(() => schema.nodeFromJSON(result.content!).check()).not.toThrow();
});
it("should not apply marks when patching a single line in a code block", async () => {
const user = await buildUser();
const document = await buildDocument({
teamId: user.teamId,
text: "```python\nclass A:\n def init(self):\n pass\n```",
});
const result = DocumentHelper.applyMarkdownToDocument(
document,
"def __init__(self):",
TextEditMode.Patch,
"def init(self):"
);
const content = result.content!.content!;
expect(content).toHaveLength(2);
expect(content[1].type).toBe("paragraph");
expect(content[0]).toMatchObject({
type: "code_block",
content: [
{
type: "text",
text: "class A:\n def __init__(self):\n pass",
},
],
});
expect(content[0].content![0].marks).toBeUndefined();
});
it("should preserve ordered list container attrs when patching an item", async () => {
const user = await buildUser();
let document = await buildDocument({
teamId: user.teamId,
});
// Ordered list starting at 3 with lower-alpha style
document.content = {
type: "doc",
content: [
{
type: "ordered_list",
attrs: { order: 3, listStyle: "lower-alpha" },
content: [
{
type: "list_item",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "First item" }],
},
],
},
{
type: "list_item",
content: [
{
type: "paragraph",
content: [{ type: "text", text: "Second item" }],
},
],
},
],
},
],
};
await document.save();
const result = DocumentHelper.applyMarkdownToDocument(
document,
"Updated item",
TextEditMode.Patch,
"First item"
);
const list = result.content!.content![0];
// Container attrs must be preserved
expect(list.attrs!.order).toEqual(3);
expect(list.attrs!.listStyle).toEqual("lower-alpha");
// Patched item updated
expect(list.content![0].content![0].content![0].text).toEqual(
"Updated item"
);
// Unchanged item preserved
expect(list.content![1].content![0].content![0].text).toEqual(
"Second item"
);
});
it("should apply a link when wrapping existing table cell text", async () => {
const user = await buildUser();
const document = await buildDocument({ teamId: user.teamId });
document.content = parser
.parse("| Name | Notes |\n|------|-------|\n| Alpha | see |\n")
.toJSON();
await document.save();
const result = DocumentHelper.applyMarkdownToDocument(
document,
"[see](https://example.com/docs)",
TextEditMode.Patch,
"see"
);
// The cell text is unchanged but should now carry a link mark — it must
// not be silently dropped during the merge.
const cellText =
result.content!.content![0].content![1].content![1].content![0]
.content![0];
expect(cellText.text).toEqual("see");
expect(cellText.marks).toEqual([
expect.objectContaining({
type: "link",
attrs: expect.objectContaining({ href: "https://example.com/docs" }),
}),
]);
});
it("should preserve other table cells when adding a link to one cell", async () => {
const user = await buildUser();
const document = await buildDocument({ teamId: user.teamId });
document.content = parser
.parse(
"| Name | Notes |\n|------|-------|\n| Alpha | see |\n| Beta | other |\n"
)
.toJSON();
await document.save();
// Capture the untouched (Beta) row BEFORE patching so we can assert its
// structure and attrs are preserved exactly, not just its text.
const beforeDoc = DocumentHelper.toProsemirror(document).toJSON();
const untouchedRow = beforeDoc.content[0].content[2];
const result = DocumentHelper.applyMarkdownToDocument(
document,
"see [docs](https://example.com/d)",
TextEditMode.Patch,
"see"
);
// The patched cell gained the link
expect(result.text).toContain("[docs](https://example.com/d)");
// The untouched row node must remain identical
expect(result.content!.content![0].content![2]).toEqual(untouchedRow);
});
it("should apply a mark when wrapping existing list item text", async () => {
const user = await buildUser();
const document = await buildDocument({ teamId: user.teamId });
document.content = parser.parse("- clickme\n- other\n").toJSON();
await document.save();
const result = DocumentHelper.applyMarkdownToDocument(
document,
"[clickme](https://example.com)",
TextEditMode.Patch,
"clickme"
);
expect(result.text).toContain("[clickme](https://example.com)");
expect(result.text).toContain("other");
});
});
describe("block ids", () => {
const paragraph = (text: string) => ({
type: "paragraph",
content: [{ type: "text", text }],
});
const listId = randomUUID();
const toggleId = randomUUID();
const content: ProsemirrorData = {
type: "doc",
content: [
{
type: "checkbox_list",
attrs: { id: listId },
content: ["one", "two"].map((text) => ({
type: "checkbox_item",
attrs: { checked: false },
content: [paragraph(text)],
})),
},
{
type: "container_toggle",
attrs: { id: toggleId },
content: [paragraph("Title"), paragraph("Body")],
},
],
};
const blockIds = (document: Document) =>
(document.content?.content ?? [])
.filter((node) => node.type !== "paragraph")
.map((node) => node.attrs?.id);
it("assigns ids and a trailing paragraph to markdown written through the API", async () => {
const user = await buildUser();
const document = await buildDocument({ teamId: user.teamId });
const result = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
document,
text: "- [ ] one\n\n+++ Title\nBody\n+++",
})
);
const [checklist, toggle] = blockIds(result);
expect(checklist).toEqual(expect.any(String));
expect(toggle).toEqual(expect.any(String));
expect(result.content?.content?.at(-1)?.type).toBe("paragraph");
expect(result.text.trim().endsWith("+++")).toBe(true);
});
it.each([
["checkbox list", "two", "three"],
["toggle block", "Body", "Changed body"],
])("keeps the id of a patched %s", async (_name, findText, replacement) => {
const user = await buildUser();
const document = await buildDocument({
teamId: user.teamId,
content,
});
const result = await withAPIContext(user, (ctx) =>
documentUpdater(ctx, {
document,
text: replacement,
editMode: TextEditMode.Patch,
findText,
})
);
expect(result.text).toContain(replacement);
expect(blockIds(result)).toEqual([listId, toggleId]);
});
});
});