Files

9883 lines
296 KiB
TypeScript

import { readFile } from "node:fs/promises";
import path from "node:path";
import { faker } from "@faker-js/faker";
import { addMinutes, subDays } from "date-fns";
import FormData from "form-data";
import {
CollectionPermission,
DocumentPermission,
ExportContentType,
FileOperationFormat,
HeadingPrefixStyle,
StatusFilter,
TeamPreference,
UserRole,
} from "@shared/types";
import { TextHelper } from "@shared/utils/TextHelper";
import { DeprecationValidation, DocumentValidation } from "@shared/validations";
import { createContext } from "@server/context";
import { parser } from "@server/editor";
import type { Group, User } from "@server/models";
import {
Collection,
Document,
View,
Revision,
UserMembership,
SearchQuery,
Event,
FileOperation,
GroupMembership,
Relationship,
Share,
} from "@server/models";
import { RelationshipType } from "@server/models/Relationship";
import { DocumentHelper } from "@server/models/helpers/DocumentHelper";
import DocumentImportTask from "@server/queues/tasks/DocumentImportTask";
import FileStorage from "@server/storage/files";
import {
buildShare,
buildCollection,
buildUser,
buildDocument,
buildDraftDocument,
buildViewer,
buildTeam,
buildGroup,
buildAdmin,
buildTemplate,
buildAttachment,
buildSubdomain,
buildGuestUser,
} from "@server/test/factories";
import {
getTestServer,
readZipResponse,
withAPIContext,
} from "@server/test/support";
const server = getTestServer();
beforeEach(async () => {
await buildDocument();
});
type PermissionManagementSubject = {
actor: User;
document: Document;
member: User;
group: Group;
};
async function expectCanManageDocumentPermissions({
actor,
document,
member,
group,
}: PermissionManagementSubject) {
const addUser = await server.post("/api/documents.add_user", actor, {
body: {
id: document.id,
userId: member.id,
},
});
expect(addUser.status).toEqual(200);
const removeUser = await server.post("/api/documents.remove_user", actor, {
body: {
id: document.id,
userId: member.id,
},
});
expect(removeUser.status).toEqual(200);
const addGroup = await server.post("/api/documents.add_group", actor, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(addGroup.status).toEqual(200);
const removeGroup = await server.post("/api/documents.remove_group", actor, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(removeGroup.status).toEqual(200);
}
async function expectCannotManageDocumentPermissions({
actor,
document,
member,
group,
}: PermissionManagementSubject) {
await UserMembership.create({
userId: member.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: actor.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: actor.id,
});
const addUser = await server.post("/api/documents.add_user", actor, {
body: {
id: document.id,
userId: member.id,
permission: DocumentPermission.ReadWrite,
},
});
expect(addUser.status).toEqual(403);
const removeUser = await server.post("/api/documents.remove_user", actor, {
body: {
id: document.id,
userId: member.id,
},
});
expect(removeUser.status).toEqual(403);
const addGroup = await server.post("/api/documents.add_group", actor, {
body: {
id: document.id,
groupId: group.id,
permission: DocumentPermission.ReadWrite,
},
});
expect(addGroup.status).toEqual(403);
const removeGroup = await server.post("/api/documents.remove_group", actor, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(removeGroup.status).toEqual(403);
}
describe("#documents.info", () => {
it("should fail if both id and shareId are absent", async () => {
const res = await server.post("/api/documents.info", {
body: {},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("one of id or shareId is required");
});
it("should return published document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.info", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
});
it("should return published document for urlId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.info", user, {
body: {
id: document.urlId,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
});
it("should return archived document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.info", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
});
it("should not return published document in collection not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
permission: null,
teamId: user.teamId,
});
const document = await buildDocument({
collectionId: collection.id,
});
const res = await server.post("/api/documents.info", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should return drafts", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.info", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
});
it("should return document from shareId without token", async () => {
const user = await buildUser();
const document = await buildDocument({ userId: user.id });
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
expect(body.data.createdBy).toEqual(undefined);
expect(body.data.updatedBy).toEqual(undefined);
});
it("should not return document of a deleted collection, when the user was absent in the collection", async () => {
const user = await buildUser();
const user2 = await buildUser({
teamId: user.teamId,
});
const collection = await buildCollection({
permission: null,
teamId: user.teamId,
createdById: user.id,
});
const doc = await buildDocument({
collectionId: collection.id,
teamId: user.teamId,
userId: user.id,
});
await server.post("/api/collections.delete", user, {
body: {
id: collection.id,
},
});
const res = await server.post("/api/documents.info", user2, {
body: {
id: doc.id,
},
});
expect(res.status).toEqual(403);
});
it("should return document of a deleted collection, when the user was present in the collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
permission: null,
teamId: user.teamId,
createdById: user.id,
});
const doc = await buildDocument({
collectionId: collection.id,
teamId: user.teamId,
userId: user.id,
});
await server.post("/api/collections.delete", user, {
body: {
id: collection.id,
},
});
const res = await server.post("/api/documents.info", user, {
body: {
id: doc.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(doc.id);
});
describe("apiVersion=2", () => {
it("should return document associated with shareId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
includeChildDocuments: true,
});
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
id: document.id,
apiVersion: 2,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.document.id).toEqual(document.id);
expect(body.data.document.createdBy).toEqual(undefined);
expect(body.data.document.updatedBy).toEqual(undefined);
});
it("should return document available in shareId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const childDocument = await buildDocument({
parentDocumentId: document.id,
collectionId: document.collectionId,
userId: user.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
includeChildDocuments: true,
});
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
id: childDocument.id,
apiVersion: 2,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.document.id).toEqual(childDocument.id);
expect(body.data.document.createdBy).toEqual(undefined);
expect(body.data.document.updatedBy).toEqual(undefined);
});
it("should throw error when requested document is not associated with shareId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const anotherDocument = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
includeChildDocuments: true,
});
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
id: anotherDocument.id,
apiVersion: 2,
},
});
expect(res.status).toEqual(403);
});
it("should not return document from shareId if sharing is disabled for team", async () => {
const team = await buildTeam({ sharing: false });
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
apiVersion: 2,
},
});
expect(res.status).toEqual(403);
});
});
it("should not return document from shareId if sharing is disabled for collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
sharing: false,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
},
});
expect(res.status).toEqual(403);
});
it("should not return document from revoked shareId", async () => {
const user = await buildUser();
const document = await buildDocument({ userId: user.id });
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
await share.revoke(createContext({ user }));
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
},
});
expect(res.status).toEqual(404);
});
it("should not return document from archived shareId", async () => {
const user = await buildUser();
const document = await buildDocument({ userId: user.id });
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.info", {
body: {
shareId: share.id,
},
});
expect(res.status).toEqual(404);
});
it("should return document from shareId with token", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.info", user, {
body: {
shareId: share.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
expect(body.data.createdBy.id).toEqual(user.id);
expect(body.data.updatedBy.id).toEqual(user.id);
expect(body.policies[0].abilities.update).toBeTruthy();
});
it("should return draft document from shareId with token", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.info", user, {
body: {
shareId: share.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
expect(body.data.createdBy.id).toEqual(user.id);
expect(body.data.updatedBy.id).toEqual(user.id);
});
it("should return document from shareId in collection not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
permission: null,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: document.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.info", user, {
body: {
shareId: share.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
});
it("should not error if document doesn't exist", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.info", user, {
body: {
id: "9bcbf864-1090-4eb6-ba05-4da0c3a5c58e",
},
});
expect(res.status).toEqual(404);
});
it("should require authorization without token", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.info", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
it("should require authorization with incorrect token", async () => {
const document = await buildDocument();
const user = await buildUser();
const res = await server.post("/api/documents.info", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should require a valid shareId", async () => {
const res = await server.post("/api/documents.info", {
body: {
shareId: "share_id",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("shareId: Must be a valid UUID or share slug");
});
});
describe("#documents.export", () => {
afterEach(() => {
vi.restoreAllMocks();
});
it("should create a file operation for a document export with children", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "Nested Export",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.export", user, {
body: { id: document.id, includeChildDocuments: true },
headers: { accept: "text/markdown" },
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.fileOperation.name).toBe(document.title);
expect(body.data.fileOperation.state).toBe("creating");
const fileOperation = await FileOperation.findByPk(
body.data.fileOperation.id,
{ rejectOnEmpty: true }
);
expect(fileOperation.documentId).toBe(document.id);
expect(fileOperation.teamId).toBe(document.teamId);
expect(fileOperation.format).toBe(FileOperationFormat.MarkdownZip);
expect(fileOperation.options).toBeNull();
});
it("should return published document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toEqual(await DocumentHelper.toMarkdown(document));
});
it("should return document text with accept=text/markdown", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
headers: {
accept: "text/markdown",
},
});
const body = await res.text();
expect(body).toEqual(await DocumentHelper.toMarkdown(document));
});
it("should return archived document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toEqual(await DocumentHelper.toMarkdown(document));
});
it("should not return published document in collection not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
permission: null,
teamId: user.teamId,
});
const document = await buildDocument({
collectionId: collection.id,
});
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should return drafts", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toEqual(await DocumentHelper.toMarkdown(document));
});
it("should stream a zip when the document has attachments", async () => {
const user = await buildUser();
const attachment = await buildAttachment({
teamId: user.teamId,
userId: user.id,
});
const document = await buildDocument({
title: "Export Test",
userId: user.id,
teamId: user.teamId,
text: `![image](${attachment.redirectUrl})`,
});
vi.spyOn(FileStorage, "getFileBuffer").mockResolvedValue(
Buffer.from("image-data")
);
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
headers: {
accept: "text/markdown",
},
});
expect(res.status).toEqual(200);
expect(res.headers.get("content-type")).toEqual("application/zip");
expect(res.headers.get("content-disposition")).toContain(
`filename="export-test.zip"`
);
const location = `attachments/${attachment.id}.png`;
const entries = await readZipResponse(res);
expect(Object.keys(entries).sort()).toEqual([location, "export-test.md"]);
expect(entries[location]).toEqual("image-data");
expect(entries["export-test.md"]).toContain(location);
expect(entries["export-test.md"]).not.toContain(attachment.redirectUrl);
});
it("should stream a textpack when TextBundle is requested", async () => {
const user = await buildUser();
const attachment = await buildAttachment(
{ teamId: user.teamId, userId: user.id, contentType: "image/png" },
"photo.png"
);
const document = await buildDocument({
title: "Export Test",
userId: user.id,
teamId: user.teamId,
text: `![image](${attachment.redirectUrl})`,
});
vi.spyOn(FileStorage, "getFileBuffer").mockResolvedValue(
Buffer.from("image-data")
);
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
headers: {
accept: ExportContentType.TextBundle,
},
});
expect(res.status).toEqual(200);
expect(res.headers.get("content-disposition")).toContain(
`filename="export-test.textpack"`
);
const bundle = "export-test.textbundle";
const entries = await readZipResponse(res);
expect(Object.keys(entries).sort()).toEqual([
`${bundle}/assets/photo.png`,
`${bundle}/info.json`,
`${bundle}/text.markdown`,
]);
expect(entries[`${bundle}/assets/photo.png`]).toEqual("image-data");
expect(entries[`${bundle}/text.markdown`]).toContain("assets/photo.png");
expect(JSON.parse(entries[`${bundle}/info.json`]).type).toEqual(
"net.daringfireball.markdown"
);
});
it("should stream a textpack when TextBundle is requested for a document with no attachments", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "Plain Export",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
headers: {
accept: ExportContentType.TextBundle,
},
});
expect(res.status).toEqual(200);
// A bundle is a directory, so there is no self-contained single file form
// to fall back to when nothing is referenced.
const entries = await readZipResponse(res);
expect(Object.keys(entries).sort()).toEqual([
"plain-export.textbundle/info.json",
"plain-export.textbundle/text.markdown",
]);
});
it("should require authorization without token", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.export", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
it("should require authorization with incorrect token", async () => {
const document = await buildDocument();
const user = await buildUser();
const res = await server.post("/api/documents.export", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
});
describe("#documents.list", () => {
it("should fail for invalid userId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
userId: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("userId: Invalid UUID");
});
it("should fail for invalid collectionId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
collectionId: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("collectionId: Invalid UUID");
});
it("should fail for invalid parentDocumentId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
parentDocumentId: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("parentDocumentId: Invalid UUID");
});
it("should fail for invalid backlinkDocumentId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
backlinkDocumentId: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("backlinkDocumentId: Invalid UUID");
});
it("should return documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should allow filtering documents with no parent", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await buildDocument({
title: "child document",
text: "random text",
parentDocumentId: document.id,
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
parentDocumentId: null,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should not return draft documents", async () => {
const user = await buildUser();
await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should return draft documents when filtering with statusFilter", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
expect(body.pagination.total).toEqual(1);
});
it("should return drafts shared directly with the user", async () => {
const user = await buildUser();
const author = await buildUser({ teamId: user.teamId });
const document = await buildDraftDocument({
userId: author.id,
teamId: user.teamId,
});
await UserMembership.create({
documentId: document.id,
userId: user.id,
createdById: author.id,
permission: DocumentPermission.Read,
});
const res = await server.post("/api/documents.list", user, {
body: {
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
expect(body.pagination.total).toEqual(1);
});
it("should not return archived documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
document.archivedAt = new Date();
await document.save();
const res = await server.post("/api/documents.list", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should return only archived documents in a collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
});
const docs = await Promise.all([
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
}),
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
}),
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
}),
]);
await withAPIContext(user, (ctx) => docs[0].archiveWithCtx(ctx));
const res = await server.post("/api/documents.list", user, {
body: {
statusFilter: [StatusFilter.Archived],
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(1);
expect(body.data[0].id).toEqual(docs[0].id);
});
it("should return archived documents across all collections user has access to", async () => {
const user = await buildUser();
const collections = await Promise.all([
buildCollection({
teamId: user.teamId,
}),
buildCollection({
teamId: user.teamId,
}),
]);
const docs = await Promise.all([
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collections[0].id,
}),
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collections[1].id,
}),
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collections[1].id,
}),
]);
await Promise.all([
withAPIContext(user, (ctx) => docs[0].archiveWithCtx(ctx)),
withAPIContext(user, (ctx) => docs[1].archiveWithCtx(ctx)),
]);
const res = await server.post("/api/documents.list", user, {
body: {
statusFilter: [StatusFilter.Archived],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(2);
const docIds = body.data.map((doc: { id: string }) => doc.id);
expect(docIds).toContain(docs[0].id);
expect(docIds).toContain(docs[1].id);
expect(docIds).not.toContain(docs[2].id);
});
it("should not return documents in private collections not a member of", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
teamId: team.id,
permission: null,
});
await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const res = await server.post("/api/documents.list", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should allow changing sort direction", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const anotherDoc = await buildDocument({
title: "another document",
text: "random text",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
direction: "ASC",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data[0].id).toEqual(document.id);
expect(body.data[1].id).toEqual(anotherDoc.id);
});
it("should allow sorting by collection index", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const anotherDoc = await buildDocument({
title: "another document",
text: "random text",
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
await collection.reload();
await collection.addDocumentToStructure(anotherDoc, 0);
const res = await server.post("/api/documents.list", user, {
body: {
collectionId: collection.id,
sort: "index",
direction: "ASC",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data[0].id).toEqual(anotherDoc.id);
expect(body.data[1].id).toEqual(document.id);
});
it("should allow pagination with collection index sort", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
// Create 25 documents for pagination testing
// Note: buildDocument adds each doc to position 0, so they'll be in reverse order
const documents = [];
for (let i = 0; i < 25; i++) {
const doc = await buildDocument({
title: `document ${i}`,
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
documents.push(doc);
}
// Documents are added at position 0, so the order in documentStructure is reversed
// documents[24] is first, documents[0] is last
const expectedOrder = documents.slice().reverse();
// First page (offset=0, limit=10)
const res1 = await server.post("/api/documents.list", user, {
body: {
collectionId: collection.id,
sort: "index",
direction: "ASC",
offset: 0,
limit: 10,
},
});
const body1 = await res1.json();
expect(res1.status).toEqual(200);
expect(body1.data).toHaveLength(10);
expect(body1.data[0].id).toEqual(expectedOrder[0].id);
expect(body1.data[9].id).toEqual(expectedOrder[9].id);
// Second page (offset=10, limit=10) - this tests the bug fix
const res2 = await server.post("/api/documents.list", user, {
body: {
collectionId: collection.id,
sort: "index",
direction: "ASC",
offset: 10,
limit: 10,
},
});
const body2 = await res2.json();
expect(res2.status).toEqual(200);
expect(body2.data).toHaveLength(10);
expect(body2.data[0].id).toEqual(expectedOrder[10].id);
expect(body2.data[9].id).toEqual(expectedOrder[19].id);
// Third page (offset=20, limit=10)
const res3 = await server.post("/api/documents.list", user, {
body: {
collectionId: collection.id,
sort: "index",
direction: "ASC",
offset: 20,
limit: 10,
},
});
const body3 = await res3.json();
expect(res3.status).toEqual(200);
expect(body3.data).toHaveLength(5);
expect(body3.data[0].id).toEqual(expectedOrder[20].id);
expect(body3.data[4].id).toEqual(expectedOrder[24].id);
});
it("should allow filtering by collection", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
collectionId: document.collectionId,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
});
it("should allow filtering to private collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
permission: null,
});
await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
await UserMembership.update(
{
userId: user.id,
permission: CollectionPermission.Read,
},
{
where: {
createdById: user.id,
collectionId: collection.id,
},
}
);
const res = await server.post("/api/documents.list", user, {
body: {
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
});
it("should return backlinks", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const anotherDoc = await buildDocument({
title: "another document",
text: "random text",
userId: user.id,
teamId: user.teamId,
});
await Relationship.create({
reverseDocumentId: anotherDoc.id,
type: RelationshipType.Backlink,
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.list", user, {
body: {
backlinkDocumentId: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(anotherDoc.id);
});
describe("filter DSL", () => {
it("should match a simple contains leaf case-insensitively", async () => {
const user = await buildUser();
await buildDocument({
title: "First document",
userId: user.id,
teamId: user.teamId,
});
await buildDocument({
title: "Second document",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "title", operator: "contains", value: "first" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(1);
expect(body.data[0].title).toEqual("First document");
});
it("should match an OR group", async () => {
const user = await buildUser();
await buildDocument({
title: "First document",
userId: user.id,
teamId: user.teamId,
});
await buildDocument({
title: "Second document",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [
{
operator: "OR",
filters: [
{ field: "title", operator: "eq", value: "First document" },
{ field: "title", operator: "eq", value: "Second document" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(2);
});
it("should match documents created by a user, excluding collaborations", async () => {
const user = await buildUser();
const otherUser = await buildUser({ teamId: user.teamId });
const created = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const collaborated = await buildDocument({
userId: otherUser.id,
teamId: user.teamId,
});
collaborated.lastModifiedById = user.id;
await collaborated.save();
expect(collaborated.collaboratorIds).toContain(user.id);
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "createdById", operator: "eq", value: user.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).toEqual([created.id]);
});
it("should reject unsupported operators for createdById", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "createdById", operator: "isNotNull" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject an unknown field", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "nope", operator: "eq", value: "x" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject a value provided with isNull", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "publishedAt", operator: "isNull", value: "x" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject a scalar value for the in operator", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "title", operator: "in", value: "x" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject filter nesting beyond the depth limit", async () => {
const user = await buildUser();
const leaf = { field: "title", operator: "eq", value: "x" };
let nested: Record<string, unknown> = leaf;
for (let i = 0; i < 6; i++) {
nested = { operator: "AND", filters: [nested] };
}
const res = await server.post("/api/documents.list", user, {
body: { filters: [nested] },
});
expect(res.status).toEqual(400);
});
it("should not leak documents across teams", async () => {
const userA = await buildUser();
const userB = await buildUser();
await buildDocument({
title: "Cross team",
userId: userB.id,
teamId: userB.teamId,
});
const res = await server.post("/api/documents.list", userA, {
body: {
filters: [{ field: "title", operator: "eq", value: "Cross team" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(0);
});
it("should re-run authorize for collectionId in filter", async () => {
const user = await buildUser();
const otherUser = await buildUser();
const privateCollection = await buildCollection({
teamId: otherUser.teamId,
userId: otherUser.id,
permission: null,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [
{
field: "collectionId",
operator: "eq",
value: privateCollection.id,
},
],
},
});
expect(res.status).toEqual(403);
});
it("should include archived documents when filter references archivedAt", async () => {
const user = await buildUser();
const archived = await buildDocument({
title: "Old doc",
userId: user.id,
teamId: user.teamId,
archivedAt: new Date(),
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "archivedAt", operator: "isNotNull" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.map((d: { id: string }) => d.id)).toContain(archived.id);
});
it("should escape LIKE wildcards in contains values", async () => {
const user = await buildUser();
await buildDocument({
title: "5050",
userId: user.id,
teamId: user.teamId,
});
const literal = await buildDocument({
title: "50% off",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "title", operator: "contains", value: "50%" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(1);
expect(body.data[0].id).toEqual(literal.id);
});
it("should produce equivalent results for legacy collectionId and filter", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const legacyRes = await server.post("/api/documents.list", user, {
body: {
collectionId: document.collectionId,
},
});
const filterRes = await server.post("/api/documents.list", user, {
body: {
filters: [
{
field: "collectionId",
operator: "eq",
value: document.collectionId,
},
],
},
});
const legacyBody = await legacyRes.json();
const filterBody = await filterRes.json();
expect(legacyRes.status).toEqual(200);
expect(filterRes.status).toEqual(200);
expect(filterBody.data.map((d: { id: string }) => d.id).sort()).toEqual(
legacyBody.data.map((d: { id: string }) => d.id).sort()
);
});
it("should reject filters combined with legacy userId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
userId: user.id,
filters: [{ field: "title", operator: "eq", value: "Match" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject filters combined with legacy collectionId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.list", user, {
body: {
collectionId: document.collectionId,
filters: [{ field: "title", operator: "eq", value: "x" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject filters combined with statusFilter", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
statusFilter: [StatusFilter.Archived],
filters: [{ field: "title", operator: "eq", value: "x" }],
},
});
expect(res.status).toEqual(400);
});
it("should apply parent-doc membership escape for parentDocumentId in filters", async () => {
const user = await buildUser();
const otherUser = await buildUser({ teamId: user.teamId });
const privateCollection = await buildCollection({
teamId: user.teamId,
userId: otherUser.id,
permission: null,
});
const parent = await buildDocument({
teamId: user.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const child = await buildDocument({
teamId: user.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
parentDocumentId: parent.id,
});
await UserMembership.create({
createdById: otherUser.id,
documentId: parent.id,
userId: user.id,
permission: DocumentPermission.Read,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [
{ field: "parentDocumentId", operator: "eq", value: parent.id },
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.map((d: { id: string }) => d.id)).toEqual([child.id]);
});
/**
* Helper: builds a viewing user plus a teammate-owned private collection
* containing one secret document. The viewing user has zero access to the
* collection. Tests below assert that no filter shape can surface the
* secret document to the viewing user.
*/
const setupVictim = async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const secretDoc = await buildDocument({
title: "TOP SECRET PAYROLL",
text: "salaries everywhere",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const ownCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const ownDoc = await buildDocument({
title: "Mundane",
teamId: viewer.teamId,
userId: viewer.id,
collectionId: ownCollection.id,
});
return {
viewer,
otherUser,
privateCollection,
secretDoc,
ownCollection,
ownDoc,
};
};
it("must not leak docs across collections via OR with collectionId+title", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "secret" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs across collections via OR with collectionId+empty contains", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs across collections via OR with collectionId+userId of teammate", async () => {
const { viewer, otherUser, ownCollection, secretDoc } =
await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "userId", operator: "eq", value: otherUser.id },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs across collections via OR using collectionId in[]", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "in",
value: [ownCollection.id],
},
{ field: "title", operator: "contains", value: "" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs across collections via OR with collectionId nested in AND", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
operator: "AND",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "x" },
],
},
{ field: "title", operator: "contains", value: "" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs via OR with collectionId+documentId of secret doc", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{
field: "documentId",
operator: "eq",
value: secretDoc.id,
},
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs via deeply nested AND-of-OR with collectionId", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "AND",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "" },
],
},
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs via top-level array implicit-AND with sibling OR group", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{
operator: "OR",
filters: [
{ field: "title", operator: "contains", value: "" },
{ field: "title", operator: "contains", value: "secret" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
// The collectionId leaf is at top level (AND), so semantically results
// must be limited to ownCollection. Secret doc lives in a different
// collection and must not appear.
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must reject OR with one authorized collectionId and one unauthorized collectionId", async () => {
const { viewer, ownCollection, privateCollection } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{
field: "collectionId",
operator: "eq",
value: privateCollection.id,
},
],
},
],
},
});
// Authorize must run for every collectionId eq value referenced
// anywhere in the tree. The unauthorized one must trigger 403.
expect(res.status).toEqual(403);
});
it("must reject in[] containing both an authorized and unauthorized collection", async () => {
const { viewer, ownCollection, privateCollection } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
field: "collectionId",
operator: "in",
value: [ownCollection.id, privateCollection.id],
},
],
},
});
expect(res.status).toEqual(403);
});
it("must not leak docs from a private collection via filtering by teammate userId", async () => {
// No collectionId in filter at all — just createdById of a teammate.
// The default collection scope must still apply, restricting results to
// the viewer's accessible collections.
const { viewer, otherUser, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [{ field: "userId", operator: "eq", value: otherUser.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak a secret doc by direct documentId lookup", async () => {
const { viewer, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{ field: "documentId", operator: "eq", value: secretDoc.id },
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak secret docs via documentId in[]", async () => {
const { viewer, secretDoc, ownDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
field: "documentId",
operator: "in",
value: [secretDoc.id, ownDoc.id],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
expect(ids).toContain(ownDoc.id);
});
it("must not leak archived docs in private collections via archivedAt filter", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const archivedSecret = await buildDocument({
title: "Archived secret",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
archivedAt: new Date(),
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [{ field: "archivedAt", operator: "isNotNull" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(archivedSecret.id);
});
it("must not bypass collection scope via templateId filter", async () => {
const { viewer, otherUser, privateCollection, secretDoc } =
await setupVictim();
const template = await buildTemplate({
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
// Make the secret doc reference the template
await secretDoc.update({ templateId: template.id });
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{ field: "templateId", operator: "eq", value: template.id },
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs across teams via cross-team collectionId in OR", async () => {
const viewer = await buildUser();
const otherTeamUser = await buildUser();
const otherTeamCollection = await buildCollection({
teamId: otherTeamUser.teamId,
userId: otherTeamUser.id,
});
const otherTeamDoc = await buildDocument({
title: "Other team secret",
teamId: otherTeamUser.teamId,
userId: otherTeamUser.id,
collectionId: otherTeamCollection.id,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{ field: "title", operator: "contains", value: "secret" },
{
field: "collectionId",
operator: "eq",
value: otherTeamCollection.id,
},
],
},
],
},
});
// Either the cross-team collection auth fails (403), or the doc is
// simply not returned because the team filter filters it out. Both
// outcomes are acceptable; what is NOT acceptable is leaking the doc.
if (res.status === 200) {
const body = await res.json();
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(otherTeamDoc.id);
} else {
expect(res.status).toEqual(403);
}
});
it("must not leak docs via parentDocumentId membership escape combined with sibling collectionId access", async () => {
// Membership escape on parentDocumentId drops the default collection
// scope. If the schema then ANDs the parentDocumentId leaf with the
// rest of the filter, results must still be restricted to actual
// children of the parent doc.
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const parent = await buildDocument({
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const sibling = await buildDocument({
title: "Sibling not a child",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
await UserMembership.create({
createdById: otherUser.id,
documentId: parent.id,
userId: viewer.id,
permission: DocumentPermission.Read,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{ field: "parentDocumentId", operator: "eq", value: parent.id },
{ field: "title", operator: "contains", value: "" },
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
// The viewer has membership on `parent`, so its children would be
// returned. But `sibling` is not a child of `parent`, so it must not
// appear despite living in the same private collection.
expect(ids).not.toContain(sibling.id);
});
it("must not leak docs via parentDocumentId in OR with collectionId", async () => {
// Even if the filter mentions parentDocumentId in an OR, the membership
// escape must not engage (it requires a single, top-level eq). And the
// OR with collectionId must not drop the default collection scope.
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const parent = await buildDocument({
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const child = await buildDocument({
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
parentDocumentId: parent.id,
});
await UserMembership.create({
createdById: otherUser.id,
documentId: parent.id,
userId: viewer.id,
permission: DocumentPermission.Read,
});
const ownCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{ field: "parentDocumentId", operator: "eq", value: parent.id },
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
],
},
],
},
});
const body = await res.json();
// Inside an OR group, the membership escape on parentDocumentId is not
// triggered. The default collection scope must therefore still apply,
// and the child of `parent` (which lives in a private collection the
// viewer cannot access) must not appear.
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(child.id);
});
it("must not return drafts of other users via filter", async () => {
// Draft visibility is enforced by statusFilter handling for the
// legacy path; with filters it must still hold.
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const sharedCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const otherDraft = await buildDraftDocument({
title: "Other user draft",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: sharedCollection.id,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [{ field: "publishedAt", operator: "isNull" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(otherDraft.id);
});
it("should return own drafts via publishedAt isNull filter", async () => {
const viewer = await buildUser();
const collection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const collectionlessDraft = await buildDraftDocument({
title: "My unplaced draft",
teamId: viewer.teamId,
userId: viewer.id,
});
const collectionDraft = await buildDraftDocument({
title: "My collection draft",
teamId: viewer.teamId,
userId: viewer.id,
collectionId: collection.id,
});
const published = await buildDocument({
title: "Published",
teamId: viewer.teamId,
userId: viewer.id,
collectionId: collection.id,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [{ field: "publishedAt", operator: "isNull" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).toContain(collectionlessDraft.id);
expect(ids).toContain(collectionDraft.id);
expect(ids).not.toContain(published.id);
});
it("should return drafts shared via direct membership when filtering publishedAt", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const sharedCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const sharedDraft = await buildDraftDocument({
title: "Shared draft",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: sharedCollection.id,
});
await UserMembership.create({
userId: viewer.id,
documentId: sharedDraft.id,
permission: DocumentPermission.Read,
createdById: otherUser.id,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [{ field: "publishedAt", operator: "isNull" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).toContain(sharedDraft.id);
});
it("must not bypass collection scope via collectionId neq", async () => {
// `neq` must not be considered an explicit collection target. The
// default collection scope must still apply.
const { viewer, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
field: "collectionId",
operator: "neq",
value: "00000000-0000-0000-0000-000000000000",
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not bypass collection scope via collectionId notIn", async () => {
// `notIn` must not be considered an explicit collection target.
const { viewer, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
field: "collectionId",
operator: "notIn",
value: ["00000000-0000-0000-0000-000000000000"],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not bypass collection scope via collectionId isNotNull", async () => {
const { viewer, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [{ field: "collectionId", operator: "isNotNull" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not bypass auth via collectionId pattern matching", async () => {
// contains/startsWith/endsWith on collectionId must not be treated as
// an explicit collection target. Postgres may also error out applying
// iLike to a UUID column — that's a separate availability concern,
// but either way no data must leak.
const { viewer, secretDoc, privateCollection } = await setupVictim();
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
field: "collectionId",
operator: "startsWith",
value: privateCollection.id.substring(0, 8),
},
],
},
});
// Acceptable: 200 with empty/scoped data, 400 (validation), or 500
// (SQL type mismatch). Unacceptable: 200 with the secret doc visible.
if (res.status === 200) {
const body = await res.json();
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
} else {
expect([400, 500]).toContain(res.status);
}
});
it("must not allow contains-injected SQL wildcards to broaden matches", async () => {
// The `%` and `_` characters in user-supplied contains values must be
// escaped so they cannot match unrelated rows.
const user = await buildUser();
const decoy = await buildDocument({
title: "abxc",
teamId: user.teamId,
userId: user.id,
});
const target = await buildDocument({
title: "ab_c",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "title", operator: "contains", value: "ab_c" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).toContain(target.id);
expect(ids).not.toContain(decoy.id);
});
it("must reject NOT-style operators that are not in the comparison allowlist", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [
{ field: "title", operator: "regexp", value: ".*" } as never,
],
},
});
expect(res.status).toEqual(400);
});
it("must reject filters when an empty array is passed", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: { filters: [] },
});
expect(res.status).toEqual(400);
});
it("must reject filters when in[] is empty", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "title", operator: "in", value: [] }],
},
});
expect(res.status).toEqual(400);
});
it("must not allow exceeding the top-level filter count limit", async () => {
const user = await buildUser();
const filters = Array.from({ length: 51 }).map(() => ({
field: "title",
operator: "eq",
value: "x",
}));
const res = await server.post("/api/documents.list", user, {
body: { filters },
});
expect(res.status).toEqual(400);
});
it("must not allow exceeding maxInValues limit on in[]", async () => {
const user = await buildUser();
const value = Array.from({ length: 101 }).map(
(_, i) => `00000000-0000-0000-0000-${String(i).padStart(12, "0")}`
);
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "documentId", operator: "in", value }],
},
});
expect(res.status).toEqual(400);
});
it("must reject unsupported operators for userId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "userId", operator: "isNotNull" }],
},
});
expect(res.status).toEqual(400);
});
it("must reject SQL-injection attempts in ISO 8601 duration values", async () => {
// dateFromDuration interpolates the duration into a Sequelize literal.
// The validation regex must reject anything containing quote
// characters or other SQL metacharacters.
const user = await buildUser();
const res = await server.post("/api/documents.list", user, {
body: {
filters: [
{
field: "updatedAt",
operator: "gte",
value: "P1D'; DROP TABLE documents; --",
},
],
},
});
// The value isn't a valid duration so it falls through as a literal
// string compared via Op.gte. That comparison will either return zero
// rows or fail at the type-cast level; what matters is no SQL error
// and no leaked rows. Acceptable: 200 with empty data, or 400.
expect([200, 400]).toContain(res.status);
if (res.status === 200) {
const body = await res.json();
// No rows should leak.
expect(Array.isArray(body.data)).toBe(true);
}
});
it("must compare duration-shaped values on non-date fields as strings", async () => {
// A duration-shaped value must only be converted to a date literal for
// date fields; on a text field it is a plain string comparison.
const user = await buildUser();
const document = await buildDocument({
title: "Zebra",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [{ field: "title", operator: "gte", value: "P1D" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).toContain(document.id);
});
it("must reject an out-of-range duration rather than fail at the database", async () => {
const user = await buildUser();
for (const value of [
"-P999999999Y",
"P999999999Y",
"-PT99999999999999999S",
]) {
const filters = [{ field: "createdAt", operator: "gte", value }];
for (const endpoint of [
"/api/documents.list",
"/api/documents.search",
"/api/documents.search_titles",
]) {
const res = await server.post(endpoint, user, {
body: { query: "test", filters },
});
expect(res.status).toEqual(400);
}
}
});
it("must reject an out-of-range duration on an unauthenticated share search", async () => {
const team = await buildTeam();
const author = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
userId: author.id,
});
const share = await buildShare({
teamId: team.id,
userId: author.id,
documentId: document.id,
includeChildDocuments: true,
published: true,
});
const res = await server.post("/api/documents.search", {
body: {
shareId: share.id,
query: "test",
filters: [
{ field: "createdAt", operator: "gte", value: "-P999999999Y" },
],
},
});
expect(res.status).toEqual(400);
});
it("must reject a filter expression over the node limit", async () => {
const user = await buildUser();
const leaf = { field: "title", operator: "eq", value: "x" };
// Depth 3 with 7 filters per group is inside both shape limits, but
// holds 57 nodes.
const wide = {
operator: "OR",
filters: Array.from({ length: 7 }, () => ({
operator: "OR",
filters: Array.from({ length: 7 }, () => leaf),
})),
};
for (const endpoint of [
"/api/documents.list",
"/api/documents.search",
"/api/documents.search_titles",
]) {
const res = await server.post(endpoint, user, {
body: { query: "test", filters: [wide] },
});
expect(res.status).toEqual(400);
}
});
it("must reject a filter list whose entries total over the node limit", async () => {
const user = await buildUser();
// Each entry is inside the per-expression limit; the sum is not.
const filters = Array.from({ length: 5 }, () => ({
operator: "OR",
filters: Array.from({ length: 10 }, () => ({
field: "title",
operator: "eq",
value: "x",
})),
}));
const res = await server.post("/api/documents.list", user, {
body: { filters },
});
expect(res.status).toEqual(400);
});
it("must accept the widest filter expression the app builds", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.list", user, {
body: {
filters: [
{ field: "collectionId", operator: "eq", value: collection.id },
{ field: "userId", operator: "eq", value: user.id },
{ field: "updatedAt", operator: "gte", value: "-P1Y" },
{
operator: "OR",
filters: [
{ field: "archivedAt", operator: "isNotNull" },
{
operator: "AND",
filters: [
{ field: "archivedAt", operator: "isNull" },
{ field: "publishedAt", operator: "isNotNull" },
],
},
{
operator: "AND",
filters: [
{ field: "archivedAt", operator: "isNull" },
{ field: "publishedAt", operator: "isNull" },
],
},
],
},
],
},
});
expect(res.status).toEqual(200);
});
it("must not leak draft drafts via OR with createdById self + collectionId of teammate's collection", async () => {
// Drafts are restricted to creator + members. Filter DSL must not
// provide a path to bypass that.
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const sharedCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const otherDraft = await buildDraftDocument({
title: "Other user secret draft",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: sharedCollection.id,
});
const res = await server.post("/api/documents.list", viewer, {
body: {
filters: [
{
operator: "OR",
filters: [
{ field: "userId", operator: "eq", value: viewer.id },
{
field: "collectionId",
operator: "eq",
value: sharedCollection.id,
},
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
// statusFilter is not set in this request, so drafts shouldn't be
// included by default — but verify either way that the other user's
// draft is not exposed.
expect(ids).not.toContain(otherDraft.id);
});
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.list");
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
});
describe("#documents.drafts", () => {
it("should fail for invalid collectionId", async () => {
const user = await buildUser();
await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.drafts", user, {
body: {
collectionId: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("collectionId: Invalid UUID");
});
it("should fail for invalid dateFilter", async () => {
const user = await buildUser();
await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.drafts", user, {
body: {
dateFilter: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("dateFilter: Invalid input");
});
it("should return unpublished documents", async () => {
const user = await buildUser();
await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.drafts", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
});
it("should return drafts, including ones without collectionIds", async () => {
const drafts = [];
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
drafts.push(document);
const draftDocument = await buildDraftDocument({
title: "draft title",
text: "draft text",
createdById: user.id,
teamId: user.teamId,
});
drafts.push(draftDocument);
const res = await server.post("/api/documents.drafts", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(drafts.length);
});
it("should not return drafts in private collections not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
permission: null,
});
await buildDraftDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.drafts", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
});
describe("#documents.search_titles", () => {
it("should include individually shared drafts with a user in search results", async () => {
const user = await buildUser();
// create a private collection
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
permission: null,
});
// create a draft in collection
const document = await buildDocument({
collectionId: collection.id,
teamId: user.teamId,
createdById: user.id,
title: "Some title",
});
document.publishedAt = null;
await document.save();
const member = await buildUser({
teamId: user.teamId,
});
// add member to the document
await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
const res = await server.post("/api/documents.search_titles", member, {
body: {
query: "title",
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(body.data).toHaveLength(1);
expect(body.data[0].id).toEqual(document.id);
expect(res.status).toEqual(200);
});
it("should include individually shared docs with a user in search results", async () => {
const user = await buildUser();
// create a private collection
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
permission: null,
});
// create document in that private collection
const document = await buildDocument({
collectionId: collection.id,
teamId: user.teamId,
createdById: user.id,
title: "Some title",
});
const member = await buildUser({
teamId: user.teamId,
});
// add member to the document
await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
const res = await server.post("/api/documents.search_titles", member, {
body: {
query: "title",
},
});
const body = await res.json();
expect(body.data).toHaveLength(1);
expect(body.data[0].id).toEqual(document.id);
expect(res.status).toEqual(200);
});
it("should fail without query", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.search_titles", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"query: Invalid input: expected string, received undefined"
);
});
it("should return case insensitive results for partial query", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "SECRET",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should allow filtering of results by date", async () => {
const user = await buildUser();
await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
createdAt: subDays(new Date(), 365),
updatedAt: subDays(new Date(), 365),
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "SECRET",
dateFilter: "day",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should allow filtering to include archived", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
archivedAt: new Date(),
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "SECRET",
statusFilter: [StatusFilter.Archived],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should allow filtering to include drafts", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "SECRET",
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should allow filtering to include a user", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "SECRET",
userId: user.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should not include archived or deleted documents", async () => {
const user = await buildUser();
await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
archivedAt: new Date(),
});
await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Super secret",
deletedAt: new Date(),
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "SECRET",
statusFilter: [StatusFilter.Published, StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.search_titles");
expect(res.status).toEqual(401);
});
describe("filter DSL", () => {
it("should filter by userId via collaboratorIds", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "match title",
teamId: user.teamId,
userId: user.id,
});
await buildDocument({
title: "match title",
teamId: user.teamId,
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "match",
filters: [{ field: "userId", operator: "eq", value: user.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should filter by documentId scope", async () => {
const user = await buildUser();
const parent = await buildDocument({
title: "parent match",
teamId: user.teamId,
userId: user.id,
});
const child = await buildDocument({
title: "child match",
teamId: user.teamId,
userId: user.id,
parentDocumentId: parent.id,
collectionId: parent.collectionId,
});
await buildDocument({
title: "unrelated match",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "match",
filters: [{ field: "documentId", operator: "eq", value: parent.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const returnedIds = body.data.map((d: { id: string }) => d.id).sort();
expect(returnedIds).toEqual([parent.id, child.id].sort());
});
it("should reject filters combined with legacy userId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.search_titles", user, {
body: {
query: "match",
userId: user.id,
filters: [{ field: "userId", operator: "eq", value: user.id }],
},
});
expect(res.status).toEqual(400);
});
it("must not leak titles via OR with collectionId+title", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const secretDoc = await buildDocument({
title: "TOP SECRET match",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const ownCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const res = await server.post("/api/documents.search_titles", viewer, {
body: {
query: "match",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "match" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak titles via collectionId in[] sibling to a permissive leaf", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const secretDoc = await buildDocument({
title: "TOP SECRET match",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const ownCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const res = await server.post("/api/documents.search_titles", viewer, {
body: {
query: "match",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "in",
value: [ownCollection.id],
},
{ field: "title", operator: "contains", value: "" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map((d: { id: string }) => d.id);
expect(ids).not.toContain(secretDoc.id);
});
it("must 403 when a private collection is targeted via filter", async () => {
const viewer = await buildUser();
const otherUser = await buildUser();
const privateCollection = await buildCollection({
teamId: otherUser.teamId,
userId: otherUser.id,
permission: null,
});
const res = await server.post("/api/documents.search_titles", viewer, {
body: {
query: "secret",
filters: [
{
field: "collectionId",
operator: "eq",
value: privateCollection.id,
},
],
},
});
expect(res.status).toEqual(403);
});
it("must 403 on documentId scope to a doc the user cannot read", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const secretParent = await buildDocument({
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const res = await server.post("/api/documents.search_titles", viewer, {
body: {
query: "x",
filters: [
{
field: "documentId",
operator: "eq",
value: secretParent.id,
},
],
},
});
expect(res.status).toEqual(403);
});
});
});
describe("#documents.search", () => {
it("should return results", async () => {
const user = await buildUser();
await buildDocument({
userId: user.id,
teamId: user.teamId,
title: "Much test support",
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "much",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.title).toEqual("Much test support");
});
it("should return results using shareId", async () => {
const subdomain = buildSubdomain();
const team = await buildTeam({ subdomain });
const findableDocument = await buildDocument({
title: "search term",
text: "random text",
teamId: team.id,
});
await buildDocument({
title: "search term",
text: "should not be found",
userId: findableDocument.createdById,
teamId: team.id,
});
const share = await buildShare({
includeChildDocuments: true,
documentId: findableDocument.id,
teamId: team.id,
urlId: "abc123",
});
const res = await server.post("/api/documents.search", {
body: {
query: "search term",
shareId: "abc123",
},
headers: {
host: `${subdomain}.outline.dev`,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(share.documentId);
});
it("should not return drafts using shareId", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
title: "test",
});
const share = await buildShare({
documentId: document.id,
includeChildDocuments: true,
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
shareId: share.id,
statusFilter: [StatusFilter.Draft],
query: "test",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not allow search if child documents are not included", async () => {
const findableDocument = await buildDocument({
title: "search term",
text: "random text",
});
const share = await buildShare({
includeChildDocuments: false,
document: findableDocument,
});
const res = await server.post("/api/documents.search", {
body: {
query: "search term",
shareId: share.id,
},
});
expect(res.status).toEqual(400);
});
it("should return results in ranked order", async () => {
const user = await buildUser();
await buildDocument({
title: "search term",
text: "random text",
userId: user.id,
teamId: user.teamId,
});
const renamedDoc = await buildDocument({
title: "search term",
text: "random text",
userId: user.id,
teamId: user.teamId,
});
renamedDoc.title = "change";
await renamedDoc.save();
await buildDocument({
title: "random text",
text: "search term",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(3);
// Results should be ordered by descending search ranking
const rankings = body.data.map(
(result: { ranking: number }) => result.ranking
);
expect(rankings[0]).toBeGreaterThanOrEqual(rankings[1]);
expect(rankings[1]).toBeGreaterThanOrEqual(rankings[2]);
});
describe("search operators", () => {
it("negative search operator", async () => {
const user = await buildUser();
await buildDocument({
title: "search term",
text: "random text",
userId: user.id,
teamId: user.teamId,
});
const firstResult = await buildDocument({
title: "title text",
text: "search term",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: `search -random`,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(firstResult.id);
});
it("quoted search operator", async () => {
const user = await buildUser();
await buildDocument({
title: "document one",
text: "term search",
userId: user.id,
teamId: user.teamId,
});
const firstResult = await buildDocument({
title: "search term",
text: "content",
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: `"search term"`,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(firstResult.id);
});
});
it("should not return draft documents", async () => {
const user = await buildUser();
await buildDocument({
title: "search term",
text: "search term",
publishedAt: null,
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
statusFilter: [StatusFilter.Published, StatusFilter.Archived],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not error when search term is very long", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.search", user, {
body: {
query:
"much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much much longer search term",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should return draft documents created by user if chosen", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "search term",
text: "search term",
publishedAt: null,
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(document.id);
});
it("should return drafts without collection too", async () => {
const user = await buildUser();
await buildDraftDocument({
title: "some title",
text: "some text",
createdById: user.id,
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
statusFilter: [StatusFilter.Draft],
query: "text",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
});
it("should not return draft documents created by other users", async () => {
const user = await buildUser();
await buildDocument({
title: "search term",
text: "search term",
publishedAt: null,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not return archived documents", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
statusFilter: [StatusFilter.Published, StatusFilter.Draft],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should return archived documents if chosen", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
statusFilter: [StatusFilter.Archived],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(document.id);
});
it("should return documents for a specific user", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
// This one will be filtered out
await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
userId: user.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(document.id);
});
it("should return documents for a specific private collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
permission: null,
});
await UserMembership.create({
createdById: user.id,
collectionId: collection.id,
userId: user.id,
permission: CollectionPermission.Read,
});
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(document.id);
});
it("should return documents for a specific collection", async () => {
const user = await buildUser();
const collection = await buildCollection();
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
});
// This one will be filtered out
await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
collectionId: document.collectionId,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(document.id);
});
it("should not return documents in private collections not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
permission: null,
});
await buildDocument({
title: "search term",
text: "search term",
publishedAt: null,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not allow unknown dateFilter values", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
dateFilter: "DROP TABLE students;",
},
});
expect(res.status).toEqual(400);
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.search", {
body: {
query: "search term",
},
});
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
it("should save search term, hits and source", async () => {
const user = await buildUser();
await server.post("/api/documents.search", user, {
body: {
query: "my term",
},
});
const searchQuery = await SearchQuery.findAll({
where: {
teamId: user.teamId,
query: "my term",
},
});
expect(searchQuery.length).toBe(1);
expect(searchQuery[0].results).toBe(0);
expect(searchQuery[0].source).toBe("app");
expect(Number.isInteger(searchQuery[0].duration)).toBe(true);
expect(searchQuery[0].duration).toBeGreaterThanOrEqual(0);
});
it("should include individually shared docs with a user in search results", async () => {
const user = await buildUser();
// create a private collection
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
permission: null,
});
// create document in that private collection
const document = await buildDocument({
collectionId: collection.id,
teamId: user.teamId,
createdById: user.id,
title: "Some title",
});
const member = await buildUser({
teamId: user.teamId,
});
// add member to the document
await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
const res = await server.post("/api/documents.search", member, {
body: {
query: "title",
},
});
const body = await res.json();
expect(body.data).toHaveLength(1);
expect(body.data[0].document.id).toEqual(document.id);
expect(res.status).toEqual(200);
});
it("should include individually shared drafts with a user in search results", async () => {
const user = await buildUser();
// create a private collection
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
permission: null,
});
// create a draft in collection
const document = await buildDocument({
collectionId: collection.id,
teamId: user.teamId,
createdById: user.id,
title: "Some title",
});
document.publishedAt = null;
await document.save();
const member = await buildUser({
teamId: user.teamId,
});
// add member to the document
await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
const res = await server.post("/api/documents.search", member, {
body: {
query: "title",
statusFilter: [StatusFilter.Draft],
},
});
const body = await res.json();
expect(body.data).toHaveLength(1);
expect(body.data[0].document.id).toEqual(document.id);
expect(res.status).toEqual(200);
});
it("should not return documents from other collections when filtering by specific collection without search term", async () => {
const user = await buildUser();
const collection1 = await buildCollection({
teamId: user.teamId,
userId: user.id,
});
const collection2 = await buildCollection({
teamId: user.teamId,
userId: user.id,
});
const docsInCollection1 = await Promise.all([
buildDocument({
teamId: user.teamId,
userId: user.id,
collectionId: collection1.id,
title: "document 1 in collection 1",
}),
buildDocument({
teamId: user.teamId,
userId: user.id,
collectionId: collection1.id,
title: "document 2 in collection 1",
}),
]);
await Promise.all([
buildDocument({
teamId: user.teamId,
userId: user.id,
collectionId: collection2.id,
title: "document 1 in collection 2",
}),
buildDocument({
teamId: user.teamId,
userId: user.id,
collectionId: collection2.id,
title: "document 2 in collection 2",
}),
]);
const res = await server.post("/api/documents.search", user, {
body: {
collectionId: collection1.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(2);
const returnedIds = body.data
.map((d: { document: { id: string } }) => d.document.id)
.sort();
const expectedIds = docsInCollection1.map((d) => d.id).sort();
expect(returnedIds).toEqual(expectedIds);
});
describe("filter DSL", () => {
it("should produce equivalent results for legacy collectionId and filter", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const legacyRes = await server.post("/api/documents.search", user, {
body: {
query: "search term",
collectionId: document.collectionId,
},
});
const filterRes = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [
{
field: "collectionId",
operator: "eq",
value: document.collectionId,
},
],
},
});
const legacyBody = await legacyRes.json();
const filterBody = await filterRes.json();
expect(legacyRes.status).toEqual(200);
expect(filterRes.status).toEqual(200);
expect(
filterBody.data
.map((r: { document: { id: string } }) => r.document.id)
.sort()
).toEqual(
legacyBody.data
.map((r: { document: { id: string } }) => r.document.id)
.sort()
);
});
it("should filter by userId via collaboratorIds", async () => {
const user = await buildUser();
const document = await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
await buildDocument({
title: "search term",
text: "search term",
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [{ field: "userId", operator: "eq", value: user.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(1);
expect(body.data[0].document.id).toEqual(document.id);
});
it("should filter by documentId scope", async () => {
const user = await buildUser();
const parent = await buildDocument({
title: "parent",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const child = await buildDocument({
title: "child",
text: "search term",
teamId: user.teamId,
userId: user.id,
parentDocumentId: parent.id,
collectionId: parent.collectionId,
});
await buildDocument({
title: "unrelated",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [{ field: "documentId", operator: "eq", value: parent.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const returnedIds = body.data
.map((r: { document: { id: string } }) => r.document.id)
.sort();
expect(returnedIds).toEqual([parent.id, child.id].sort());
});
it("should filter by documentId in[] scope", async () => {
const user = await buildUser();
const parentA = await buildDocument({
title: "parentA",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const childA = await buildDocument({
title: "childA",
text: "search term",
teamId: user.teamId,
userId: user.id,
parentDocumentId: parentA.id,
collectionId: parentA.collectionId,
});
const parentB = await buildDocument({
title: "parentB",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
await buildDocument({
title: "unrelated",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [
{
field: "documentId",
operator: "in",
value: [parentA.id, parentB.id],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const returnedIds = body.data
.map((r: { document: { id: string } }) => r.document.id)
.sort();
expect(returnedIds).toEqual([parentA.id, childA.id, parentB.id].sort());
});
it("should expand documentId leaves nested inside groups", async () => {
const user = await buildUser();
const parentA = await buildDocument({
title: "parentA",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const parentB = await buildDocument({
title: "parentB",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
await buildDocument({
title: "unrelated",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [
{
operator: "OR",
filters: [
{ field: "documentId", operator: "eq", value: parentA.id },
{ field: "documentId", operator: "eq", value: parentB.id },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const returnedIds = body.data
.map((r: { document: { id: string } }) => r.document.id)
.sort();
expect(returnedIds).toEqual([parentA.id, parentB.id].sort());
});
it("should reject unsupported operators for documentId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [{ field: "documentId", operator: "isNotNull" }],
},
});
expect(res.status).toEqual(400);
});
it("should reject unsupported operators for userId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [{ field: "userId", operator: "neq", value: user.id }],
},
});
expect(res.status).toEqual(400);
});
it("should scope results to a documentId filter combined with shareId", async () => {
const subdomain = buildSubdomain();
const team = await buildTeam({ subdomain });
const parent = await buildDocument({
title: "search term",
text: "parent",
teamId: team.id,
});
const childA = await buildDocument({
title: "search term",
text: "childA",
teamId: team.id,
userId: parent.createdById,
parentDocumentId: parent.id,
collectionId: parent.collectionId,
});
await buildDocument({
title: "search term",
text: "childB",
teamId: team.id,
userId: parent.createdById,
parentDocumentId: parent.id,
collectionId: parent.collectionId,
});
await buildShare({
includeChildDocuments: true,
documentId: parent.id,
teamId: team.id,
urlId: "abc456",
});
const res = await server.post("/api/documents.search", {
body: {
query: "search term",
shareId: "abc456",
filters: [{ field: "documentId", operator: "eq", value: childA.id }],
},
headers: {
host: `${subdomain}.outline.dev`,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(childA.id);
});
it("should scope results to the legacy documentId param combined with shareId", async () => {
const subdomain = buildSubdomain();
const team = await buildTeam({ subdomain });
const parent = await buildDocument({
title: "search term",
text: "parent",
teamId: team.id,
});
const childA = await buildDocument({
title: "search term",
text: "childA",
teamId: team.id,
userId: parent.createdById,
parentDocumentId: parent.id,
collectionId: parent.collectionId,
});
await buildDocument({
title: "search term",
text: "childB",
teamId: team.id,
userId: parent.createdById,
parentDocumentId: parent.id,
collectionId: parent.collectionId,
});
await buildShare({
includeChildDocuments: true,
documentId: parent.id,
teamId: team.id,
urlId: "abc789",
});
const res = await server.post("/api/documents.search", {
body: {
query: "search term",
shareId: "abc789",
documentId: childA.id,
},
headers: {
host: `${subdomain}.outline.dev`,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].document.id).toEqual(childA.id);
});
it("should re-run authorize for collectionId in filter", async () => {
const user = await buildUser();
const otherUser = await buildUser();
const privateCollection = await buildCollection({
teamId: otherUser.teamId,
userId: otherUser.id,
permission: null,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [
{
field: "collectionId",
operator: "eq",
value: privateCollection.id,
},
],
},
});
expect(res.status).toEqual(403);
});
it("should reject filters combined with legacy collectionId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.search", user, {
body: {
collectionId: document.collectionId,
filters: [
{
field: "collectionId",
operator: "eq",
value: document.collectionId,
},
],
},
});
expect(res.status).toEqual(400);
});
it("supports title contains as an additional filter alongside the FTS query", async () => {
const user = await buildUser();
const match = await buildDocument({
title: "match needle",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
await buildDocument({
title: "no needle here",
text: "search term",
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.search", user, {
body: {
query: "search term",
filters: [{ field: "title", operator: "contains", value: "match" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map(
(r: { document: { id: string } }) => r.document.id
);
expect(ids).toContain(match.id);
});
it("supports an OR group at top level without bypassing visibility", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const ownCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
const ownDoc = await buildDocument({
title: "search term in own",
text: "search term",
teamId: viewer.teamId,
userId: viewer.id,
collectionId: ownCollection.id,
});
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "search term",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "userId", operator: "eq", value: otherUser.id },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map(
(r: { document: { id: string } }) => r.document.id
);
expect(ids).toContain(ownDoc.id);
});
/**
* Helper: builds a viewer plus a teammate-owned private collection
* containing one secret document. The viewer has zero access to the
* collection. Tests below assert that no search-filter shape can
* surface the secret document to the viewer.
*/
const setupVictim = async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const secretDoc = await buildDocument({
title: "TOP SECRET PAYROLL",
text: "secret material body",
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const ownCollection = await buildCollection({
teamId: viewer.teamId,
userId: viewer.id,
});
return {
viewer,
otherUser,
privateCollection,
secretDoc,
ownCollection,
};
};
it("must not leak docs across collections via OR with collectionId+title", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "secret material",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "secret" },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map(
(r: { document: { id: string } }) => r.document.id
);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs via OR with collectionId+userId of teammate", async () => {
const { viewer, otherUser, ownCollection, secretDoc } =
await setupVictim();
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "secret material",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "userId", operator: "eq", value: otherUser.id },
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map(
(r: { document: { id: string } }) => r.document.id
);
expect(ids).not.toContain(secretDoc.id);
});
it("must not leak docs via deeply nested AND-of-OR with collectionId", async () => {
const { viewer, ownCollection, secretDoc } = await setupVictim();
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "secret material",
filters: [
{
operator: "AND",
filters: [
{
operator: "OR",
filters: [
{
field: "collectionId",
operator: "eq",
value: ownCollection.id,
},
{ field: "title", operator: "contains", value: "" },
],
},
],
},
],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
const ids = body.data.map(
(r: { document: { id: string } }) => r.document.id
);
expect(ids).not.toContain(secretDoc.id);
});
it("must 403 when filter targets a private collection", async () => {
const viewer = await buildUser();
const otherUser = await buildUser();
const privateCollection = await buildCollection({
teamId: otherUser.teamId,
userId: otherUser.id,
permission: null,
});
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "x",
filters: [
{
field: "collectionId",
operator: "eq",
value: privateCollection.id,
},
],
},
});
expect(res.status).toEqual(403);
});
it("must 403 when filter targets a documentId in a private collection", async () => {
const viewer = await buildUser();
const otherUser = await buildUser({ teamId: viewer.teamId });
const privateCollection = await buildCollection({
teamId: viewer.teamId,
userId: otherUser.id,
permission: null,
});
const secret = await buildDocument({
teamId: viewer.teamId,
userId: otherUser.id,
collectionId: privateCollection.id,
});
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "x",
filters: [{ field: "documentId", operator: "eq", value: secret.id }],
},
});
expect(res.status).toEqual(403);
});
it("must 403 when in[] contains both an authorized and unauthorized collection", async () => {
const { viewer, ownCollection, privateCollection } = await setupVictim();
const res = await server.post("/api/documents.search", viewer, {
body: {
query: "x",
filters: [
{
field: "collectionId",
operator: "in",
value: [ownCollection.id, privateCollection.id],
},
],
},
});
expect(res.status).toEqual(403);
});
});
});
describe("#documents.templatize", () => {
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.templatize", user);
const body = await res.json();
expect(res.status).toBe(400);
expect(body.message).toBe("id: Must be a valid UUID or slug");
});
it("should require publish", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.templatize", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toBe(400);
expect(body.message).toBe(
"publish: Invalid input: expected boolean, received undefined"
);
});
it("should create a published non-workspace template", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", user, {
body: {
id: document.id,
collectionId: collection.id,
publish: true,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.publishedAt).toBeTruthy();
expect(body.data.collectionId).toEqual(collection.id);
});
it("should create a published workspace template", async () => {
const admin = await buildAdmin();
const collection = await buildCollection({
createdById: admin.id,
teamId: admin.teamId,
});
const document = await buildDocument({
userId: admin.id,
teamId: admin.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", admin, {
body: {
id: document.id,
publish: true,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.publishedAt).toBeTruthy();
expect(body.data.collectionId).toBeNull();
});
it("should create a draft non-workspace template", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", user, {
body: {
id: document.id,
collectionId: collection.id,
publish: false,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.publishedAt).toBeNull();
expect(body.data.collectionId).toEqual(collection.id);
});
it("should create a draft workspace template", async () => {
const admin = await buildAdmin();
const collection = await buildCollection({
createdById: admin.id,
teamId: admin.teamId,
});
const document = await buildDocument({
userId: admin.id,
teamId: admin.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", admin, {
body: {
id: document.id,
publish: false,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.publishedAt).toBeNull();
expect(body.data.collectionId).toBeNull();
});
it("should create a template in a different collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const anotherCollection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", user, {
body: {
id: document.id,
collectionId: anotherCollection.id,
publish: true,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.publishedAt).toBeTruthy();
expect(body.data.collectionId).toEqual(anotherCollection.id);
});
it("should not allow non-admin to create workspace template", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", user, {
body: {
id: document.id,
publish: true,
},
});
expect(res.status).toBe(403);
});
it("should not allow editor without collection admin to templatize", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
permission: null,
});
// Downgrade user from Admin (default for creator) to ReadWrite
await UserMembership.update(
{ permission: CollectionPermission.ReadWrite },
{ where: { userId: user.id, collectionId: collection.id } }
);
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.templatize", user, {
body: {
id: document.id,
collectionId: collection.id,
publish: true,
},
});
expect(res.status).toBe(403);
});
});
describe("#documents.archived", () => {
it("should return archived documents in a given collection", async () => {
const user = await buildUser();
const [firstCollection, secondCollection] = await Promise.all([
buildCollection({ teamId: user.teamId }),
buildCollection({ teamId: user.teamId }),
]);
const [documentInFirstCollection, documentInSecondCollection] =
await Promise.all([
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: firstCollection.id,
}),
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: secondCollection.id,
}),
]);
await Promise.all([
withAPIContext(user, (ctx) =>
documentInFirstCollection.archiveWithCtx(ctx)
),
withAPIContext(user, (ctx) =>
documentInSecondCollection.archiveWithCtx(ctx)
),
]);
const res = await server.post("/api/documents.archived", user, {
body: {
collectionId: firstCollection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(1);
expect(body.data[0].id).toEqual(documentInFirstCollection.id);
expect(body.data[0].archivedAt).toBeTruthy();
});
it("should return archived documents in all user collections", async () => {
const user = await buildUser();
const [firstCollection, secondCollection] = await Promise.all([
buildCollection({ teamId: user.teamId }),
buildCollection({ teamId: user.teamId }),
]);
const [documentInFirstCollection, documentInSecondCollection] =
await Promise.all([
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: firstCollection.id,
}),
buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: secondCollection.id,
}),
]);
await Promise.all([
withAPIContext(user, (ctx) =>
documentInFirstCollection.archiveWithCtx(ctx)
),
withAPIContext(user, (ctx) =>
documentInSecondCollection.archiveWithCtx(ctx)
),
]);
const res = await server.post("/api/documents.archived", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).toHaveLength(2);
});
it("should return archived documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.archived", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
});
it("should not return deleted documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
const res = await server.post("/api/documents.archived", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not return documents in private collections not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
permission: null,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: collection.id,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.archived", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should require member", async () => {
const viewer = await buildViewer();
const res = await server.post("/api/documents.archived", viewer);
expect(res.status).toEqual(403);
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.archived");
expect(res.status).toEqual(401);
});
});
describe("#documents.deleted", () => {
it("should return deleted documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.policies[0].abilities.delete).toEqual(false);
expect(body.policies[0].abilities.restore).toBeTruthy();
expect(body.policies[0].abilities.permanentDelete).toEqual(false);
});
it("should return deleted documents, including users drafts without collection", async () => {
const user = await buildUser();
const user2 = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const draftDocument = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
collectionId: null,
});
const otherUserDraft = await buildDraftDocument({
userId: user2.id,
teamId: user.teamId,
collectionId: null,
});
await Promise.all([
withAPIContext(user, (ctx) => document.destroyWithCtx(ctx)),
withAPIContext(user, (ctx) => draftDocument.destroyWithCtx(ctx)),
withAPIContext(user2, (ctx) => otherUserDraft.destroyWithCtx(ctx)),
]);
const res = await server.post("/api/documents.deleted", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(2);
expect(body.policies[0].abilities.delete).toEqual(false);
expect(body.policies[0].abilities.restore).toBeTruthy();
expect(body.policies[0].abilities.permanentDelete).toEqual(false);
});
it("should return deleted documents with permanent delete abilities for admin users", async () => {
const admin = await buildAdmin();
const document = await buildDocument({
userId: admin.id,
teamId: admin.teamId,
});
await withAPIContext(admin, (ctx) => document.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", admin);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.policies[0].abilities.delete).toEqual(false);
expect(body.policies[0].abilities.restore).toBeTruthy();
expect(body.policies[0].abilities.permanentDelete).toBeTruthy();
});
it("should not return documents in private collections not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
permission: null,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: collection.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should filter documents by the user that deleted them", async () => {
const user = await buildUser();
const collection = await buildCollection({ teamId: user.teamId });
const other = await buildUser({ teamId: user.teamId });
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const otherDocument = await buildDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
await withAPIContext(other, (ctx) => otherDocument.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", user, {
body: {
filters: [{ field: "deletedById", operator: "eq", value: user.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
expect(body.data[0].updatedBy.id).toEqual(user.id);
const otherRes = await server.post("/api/documents.deleted", user, {
body: {
filters: [{ field: "deletedById", operator: "eq", value: other.id }],
},
});
const otherBody = await otherRes.json();
expect(otherRes.status).toEqual(200);
expect(otherBody.data.length).toEqual(1);
expect(otherBody.data[0].id).toEqual(otherDocument.id);
});
it("should record the deleting user on nested documents", async () => {
const user = await buildUser();
const collection = await buildCollection({ teamId: user.teamId });
const other = await buildUser({ teamId: user.teamId });
const document = await buildDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
});
const childDocument = await buildDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
parentDocumentId: document.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
await childDocument.reload({ paranoid: false });
expect(childDocument.deletedById).toEqual(user.id);
expect(childDocument.lastModifiedById).toEqual(other.id);
const res = await server.post("/api/documents.deleted", user, {
body: {
filters: [{ field: "deletedById", operator: "eq", value: user.id }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(2);
expect(body.data[0].deletedBy.id).toEqual(user.id);
expect(body.data[0].deletedBy.name).toEqual(user.name);
});
it("should present the deleting user on a single document", async () => {
const user = await buildUser();
const collection = await buildCollection({ teamId: user.teamId });
const document = await buildDocument({
teamId: user.teamId,
collectionId: collection.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
const res = await server.post("/api/documents.info", user, {
body: { id: document.id },
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedBy.id).toEqual(user.id);
expect(body.data.deletedBy.name).toEqual(user.name);
});
it("should not present a deleting user on an active document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.info", user, {
body: { id: document.id },
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedBy).toBeUndefined();
});
it("should reject filters on fields outside the allowlist", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.deleted", user, {
body: {
filters: [{ field: "title", operator: "eq", value: "secret" }],
},
});
expect(res.status).toEqual(400);
});
it("should filter documents by date deleted", async () => {
const user = await buildUser();
const collection = await buildCollection({ teamId: user.teamId });
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
await Document.update(
{ deletedAt: subDays(new Date(), 10) },
{
where: { id: document.id },
paranoid: false,
silent: true,
hooks: false,
}
);
const res = await server.post("/api/documents.deleted", user, {
body: {
filters: [{ field: "deletedAt", operator: "gte", value: "-P1D" }],
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
const monthRes = await server.post("/api/documents.deleted", user, {
body: {
filters: [{ field: "deletedAt", operator: "gte", value: "-P1M" }],
},
});
const monthBody = await monthRes.json();
expect(monthRes.status).toEqual(200);
expect(monthBody.data.length).toEqual(1);
});
it("should not return deleted drafts created by other collection members", async () => {
const user = await buildUser();
const other = await buildUser({ teamId: user.teamId });
const collection = await buildCollection({ teamId: user.teamId });
const ownDraft = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const otherDraft = await buildDraftDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
});
const otherDocument = await buildDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
});
await withAPIContext(user, (ctx) => ownDraft.destroyWithCtx(ctx));
await withAPIContext(other, (ctx) => otherDraft.destroyWithCtx(ctx));
await withAPIContext(other, (ctx) => otherDocument.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", user);
const body = await res.json();
const ids = body.data.map((d: { id: string }) => d.id);
expect(res.status).toEqual(200);
expect(ids).toHaveLength(2);
expect(ids).toContain(ownDraft.id);
expect(ids).toContain(otherDocument.id);
expect(ids).not.toContain(otherDraft.id);
});
it("should return deleted drafts the user has a direct membership on", async () => {
const user = await buildUser();
const other = await buildUser({ teamId: user.teamId });
const collection = await buildCollection({ teamId: user.teamId });
const sharedDraft = await buildDraftDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
});
await UserMembership.create({
createdById: other.id,
documentId: sharedDraft.id,
userId: user.id,
permission: DocumentPermission.ReadWrite,
});
await withAPIContext(other, (ctx) => sharedDraft.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(sharedDraft.id);
});
it("should return deleted drafts shared with a group of the user", async () => {
const user = await buildUser();
const other = await buildUser({ teamId: user.teamId });
const group = await buildGroup({ teamId: user.teamId });
await group.$add("user", user, {
through: { createdById: other.id },
});
const collection = await buildCollection({ teamId: user.teamId });
const sharedDraft = await buildDraftDocument({
userId: other.id,
teamId: user.teamId,
collectionId: collection.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: sharedDraft.id,
permission: DocumentPermission.ReadWrite,
createdById: other.id,
});
await withAPIContext(other, (ctx) => sharedDraft.destroyWithCtx(ctx));
const res = await server.post("/api/documents.deleted", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(sharedDraft.id);
});
it("should require member", async () => {
const viewer = await buildViewer();
const res = await server.post("/api/documents.deleted", viewer);
expect(res.status).toEqual(403);
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.deleted");
expect(res.status).toEqual(401);
});
});
describe("#documents.viewed", () => {
it("should reject sorting by a document column", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.viewed", user, {
body: { sort: "title" },
});
expect(res.status).toEqual(400);
});
it("should return empty result if no views", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should return recently viewed documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
expect(body.policies[0].abilities.update).toBeTruthy();
});
it("should paginate in view order and skip deleted documents", async () => {
const user = await buildUser();
const documents = await Promise.all(
[0, 1, 2, 3].map(() =>
buildDocument({
userId: user.id,
teamId: user.teamId,
})
)
);
for (const [index, document] of documents.entries()) {
await View.create(
{
documentId: document.id,
userId: user.id,
updatedAt: new Date(Date.now() - index * 1000),
},
{ silent: true }
);
}
await documents[1].destroy();
const res = await server.post("/api/documents.viewed", user, {
body: { limit: 2 },
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.map((doc: { id: string }) => doc.id)).toEqual([
documents[0].id,
documents[2].id,
]);
const nextRes = await server.post("/api/documents.viewed", user, {
body: { limit: 2, offset: 2 },
});
const nextBody = await nextRes.json();
expect(nextRes.status).toEqual(200);
expect(nextBody.data.map((doc: { id: string }) => doc.id)).toEqual([
documents[3].id,
]);
});
it("should not return recently viewed but deleted documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
await document.destroy();
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not return recently viewed documents in collection not a member of", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
permission: null,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
await UserMembership.destroy({
where: {
userId: user.id,
collectionId: collection.id,
},
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should not return viewed drafts created by other collection members", async () => {
const owner = await buildUser();
const user = await buildUser({ teamId: owner.teamId });
const document = await buildDocument({
userId: owner.id,
teamId: owner.teamId,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
await document.update({ publishedAt: null });
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should return viewed drafts created by the user", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should return viewed documents shared directly with the user", async () => {
const owner = await buildUser();
const user = await buildUser({ teamId: owner.teamId });
const collection = await buildCollection({
userId: owner.id,
teamId: owner.teamId,
permission: null,
});
const document = await buildDocument({
userId: owner.id,
collectionId: collection.id,
teamId: owner.teamId,
});
await UserMembership.create({
userId: user.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: owner.id,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should return viewed documents shared with a group of the user", async () => {
const owner = await buildUser();
const user = await buildUser({ teamId: owner.teamId });
const group = await buildGroup({ teamId: owner.teamId });
await group.$add("user", user, {
through: { createdById: owner.id },
});
const collection = await buildCollection({
userId: owner.id,
teamId: owner.teamId,
permission: null,
});
const document = await buildDocument({
userId: owner.id,
collectionId: collection.id,
teamId: owner.teamId,
});
await GroupMembership.create({
groupId: group.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: owner.id,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should return viewed drafts shared with a group of the user", async () => {
const owner = await buildUser();
const user = await buildUser({ teamId: owner.teamId });
const group = await buildGroup({ teamId: owner.teamId });
await group.$add("user", user, {
through: { createdById: owner.id },
});
const document = await buildDraftDocument({
userId: owner.id,
teamId: owner.teamId,
});
await GroupMembership.create({
groupId: group.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: owner.id,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should return viewed documents shared with a guest", async () => {
const owner = await buildUser();
const guest = await buildGuestUser({ teamId: owner.teamId });
const document = await buildDocument({
userId: owner.id,
teamId: owner.teamId,
});
await UserMembership.create({
userId: guest.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: owner.id,
});
await View.incrementOrCreate(createContext({ user: guest }), {
documentId: document.id,
userId: guest.id,
});
const res = await server.post("/api/documents.viewed", guest);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should return viewed drafts with no collection", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
collectionId: null,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(1);
expect(body.data[0].id).toEqual(document.id);
});
it("should not return drafts with no collection created by another user", async () => {
const owner = await buildUser();
const user = await buildUser({ teamId: owner.teamId });
const document = await buildDraftDocument({
userId: owner.id,
teamId: owner.teamId,
collectionId: null,
});
await View.incrementOrCreate(createContext({ user }), {
documentId: document.id,
userId: user.id,
});
const res = await server.post("/api/documents.viewed", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.length).toEqual(0);
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.viewed");
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
});
describe("#documents.move", () => {
it("should fail if attempting to nest doc within itself", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: document.collectionId,
parentDocumentId: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"infinite loop detected, cannot nest a document inside itself"
);
});
it("should fail if attempting to nest doc within a child of itself", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const childDocument = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: document.collectionId,
parentDocumentId: document.id,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: document.collectionId,
parentDocumentId: childDocument.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"infinite loop detected, cannot nest a document inside itself"
);
});
it("should fail if attempting to nest doc within a draft", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const draft = await buildDraftDocument({
userId: user.id,
teamId: document.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: collection.id,
parentDocumentId: draft.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("Cannot move document inside a draft");
});
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.move", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should fail for invalid index", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: collection.id,
index: -1,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("index: Too small: expected number to be >=0");
});
it("should move doc to the top of collection as its first child", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: collection.id,
index: 0,
},
});
expect(res.status).toEqual(200);
});
it("should move the document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.documents[0].collectionId).toEqual(collection.id);
expect(body.policies[0].abilities.move).toBeTruthy();
});
it("should not allow moving the document to a collection the user cannot access", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const collection = await buildCollection();
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
expect(res.status).toEqual(403);
});
it("should require authentication", async () => {
const res = await server.post("/api/documents.move");
expect(res.status).toEqual(401);
});
it("should require authorization", async () => {
const team = await buildTeam();
const collection = await buildCollection({
teamId: team.id,
});
const document = await buildDocument({
teamId: team.id,
collectionId: collection.id,
});
const user = await buildUser();
const res = await server.post("/api/documents.move", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
expect(res.status).toEqual(403);
});
it("should allow reordering subdocuments with document-only admin access", async () => {
const owner = await buildUser();
const collection = await buildCollection({
teamId: owner.teamId,
userId: owner.id,
permission: null,
});
const parent = await buildDocument({
teamId: owner.teamId,
userId: owner.id,
collectionId: collection.id,
});
const childA = await buildDocument({
teamId: owner.teamId,
userId: owner.id,
collectionId: collection.id,
parentDocumentId: parent.id,
});
const childB = await buildDocument({
teamId: owner.teamId,
userId: owner.id,
collectionId: collection.id,
parentDocumentId: parent.id,
});
const user = await buildUser({ teamId: owner.teamId });
await UserMembership.create({
documentId: parent.id,
userId: user.id,
createdById: owner.id,
permission: DocumentPermission.Admin,
});
const res = await server.post("/api/documents.move", user, {
body: {
id: childB.id,
parentDocumentId: parent.id,
index: 0,
},
});
expect(res.status).toEqual(200);
expect(childA).toBeTruthy();
});
});
describe("#documents.restore", () => {
it("should fail if attempting to restore document to an archived collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const archiveRes = await server.post("/api/collections.archive", user, {
body: {
id: collection.id,
},
});
expect(archiveRes.status).toEqual(200);
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"Unable to restore, the collection may have been deleted or archived"
);
});
it("should fail if attempting to restore to a collection for which the user does not have access", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const archiveRes = await server.post("/api/collections.archive", user, {
body: {
id: collection.id,
},
});
expect(archiveRes.status).toEqual(200);
const anotherCollection = await buildCollection();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: anotherCollection.id,
},
});
expect(res.status).toEqual(403);
});
it("should fail with not found for a revision that does not exist", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
revisionId: faker.string.uuid(),
},
});
expect(res.status).toEqual(404);
});
it("should require id", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should fail for invalid collectionId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: "invalid",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("collectionId: Invalid UUID");
});
it("should allow restore of trashed drafts of a collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedAt).toEqual(null);
expect(body.data.collectionId).toEqual(collection.id);
});
it("should allow restore of trashed drafts with collectionId", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
collectionId: null,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedAt).toEqual(null);
expect(body.data.collectionId).toEqual(collection.id);
});
it("should not allow restore of another user's trashed draft", async () => {
const user = await buildUser();
const anotherUser = await buildUser({ teamId: user.teamId });
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDraftDocument({
userId: anotherUser.id,
teamId: user.teamId,
collectionId: null,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
expect(res.status).toEqual(403);
});
it("should allow restore of trashed documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
deprecatedReason: "Outdated",
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedAt).toEqual(null);
expect(body.data.deprecatedReason).toBeNull();
await document.reload();
expect(document.deprecatedReason).toBeNull();
});
it("should allow restore of trashed documents with collectionId", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedAt).toEqual(null);
expect(body.data.collectionId).toEqual(collection.id);
});
it("should allow restore of documents from a deleted collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const anotherCollection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
await collection.destroy({ hooks: false });
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: anotherCollection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.deletedAt).toEqual(null);
expect(body.data.archivedAt).toEqual(null);
expect(body.data.collectionId).toEqual(anotherCollection.id);
});
it("should not allow restore of documents to a deleted collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
await collection.destroy({ hooks: false });
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"Unable to restore, the collection may have been deleted or archived"
);
});
it("should not allow restore of documents to an archived collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
await document.destroy();
collection.archivedAt = new Date();
await collection.save();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"Unable to restore, the collection may have been deleted or archived"
);
});
it("should not allow restore of trashed documents to collection user cannot access", async () => {
const user = await buildUser();
const collection = await buildCollection();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
await document.destroy();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
expect(res.status).toEqual(403);
});
it("should allow restore of archived documents", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
deprecatedReason: "Outdated",
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.archivedAt).toEqual(null);
expect(body.data.deprecatedReason).toBeNull();
await document.reload();
expect(document.deprecatedReason).toBeNull();
});
it("should clear reasons from archived descendants when restoring", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const child = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: document.collectionId,
parentDocumentId: document.id,
deprecatedReason: "Child is outdated",
});
const grandchild = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: document.collectionId,
parentDocumentId: child.id,
deprecatedReason: "Grandchild is outdated",
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.restore", user, {
body: { id: document.id },
});
expect(res.status).toBe(200);
await Promise.all([child.reload(), grandchild.reload()]);
for (const descendant of [child, grandchild]) {
expect(descendant.archivedAt).toBeNull();
expect(descendant.deprecatedReason).toBeNull();
}
});
it("should restore archived when previous parent is archived", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const childDocument = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: document.collectionId,
parentDocumentId: document.id,
});
await withAPIContext(user, (ctx) => childDocument.archiveWithCtx(ctx));
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.restore", user, {
body: {
id: childDocument.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.parentDocumentId).toEqual(null);
expect(body.data.archivedAt).toEqual(null);
});
it("should restore the document to a previous version", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const revision = await Revision.createFromDocument(
createContext({ user }),
document
);
const previous = revision.content;
const revisionId = revision.id;
// update the document contents
document.content = parser.parse("updated")?.toJSON();
await document.save();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
revisionId,
},
headers: {
"x-api-version": "3",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.data).toEqual(previous);
});
it("should not allow restoring a revision in another document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const anotherDoc = await buildDocument();
const revision = await Revision.createFromDocument(
createContext({ user }),
anotherDoc
);
const revisionId = revision.id;
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
revisionId,
},
});
expect(res.status).toEqual(403);
});
it("should not change the collection when restoring a revision", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const anotherCollection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
const revision = await Revision.createFromDocument(
createContext({ user }),
document
);
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: anotherCollection.id,
revisionId: revision.id,
},
});
expect(res.status).toEqual(200);
await document.reload();
expect(document.collectionId).toEqual(collection.id);
const reloaded = await Collection.findByPk(collection.id, {
includeDocumentStructure: true,
});
expect(reloaded?.documentStructure?.map((node) => node.id)).toContain(
document.id
);
});
it("should return the same error for an unknown document", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.restore", user, {
body: {
id: faker.string.uuid(),
},
});
expect(res.status).toEqual(403);
});
it.each(["active", "archived", "deleted"])(
"should return the same error for a %s document in another team",
async (state) => {
const user = await buildUser();
const collection = await buildCollection();
const document = await buildDocument({
teamId: collection.teamId,
collectionId: collection.id,
archivedAt: state === "archived" ? new Date() : undefined,
});
if (state === "deleted") {
await document.destroy();
}
const { documentStructure } = await Collection.findByPk(collection.id, {
includeDocumentStructure: true,
rejectOnEmpty: true,
});
for (const destId of [undefined, faker.string.uuid()]) {
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: destId,
},
});
expect(res.status).toEqual(403);
}
const revision = await Revision.createFromDocument(
createContext({ user }),
document
);
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
collectionId: faker.string.uuid(),
revisionId: revision.id,
},
});
expect(res.status).toEqual(403);
await document.reload({ paranoid: false });
expect(!!document.archivedAt).toEqual(state === "archived");
expect(!!document.deletedAt).toEqual(state === "deleted");
const reloaded = await Collection.findByPk(collection.id, {
includeDocumentStructure: true,
rejectOnEmpty: true,
});
expect(reloaded.documentStructure).toEqual(documentStructure);
}
);
it("should require authentication", async () => {
const res = await server.post("/api/documents.restore");
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
it("should require authorization", async () => {
const admin = await buildAdmin();
const document = await buildDocument({
teamId: admin.teamId,
userId: admin.id,
});
const revision = await Revision.createFromDocument(
createContext({ user: admin }),
document
);
const revisionId = revision.id;
const user = await buildUser();
const res = await server.post("/api/documents.restore", user, {
body: {
id: document.id,
revisionId,
},
});
expect(res.status).toEqual(403);
});
});
describe("#documents.import", () => {
it("should require collectionId or parentDocumentId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.import", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"body: one of collectionId or parentDocumentId is required"
);
});
it("should error if no file or attachmentId is passed", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.import", user, {
body: {
collectionId: collection.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("one of attachmentId or file is required");
});
it("should import a document from a direct file upload", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
});
vi.spyOn(FileStorage, "store").mockResolvedValue(
undefined as unknown as string
);
vi.spyOn(DocumentImportTask.prototype, "schedule").mockResolvedValue({
finished: vi.fn().mockResolvedValue({ documentId: document.id }),
} as unknown as Awaited<ReturnType<DocumentImportTask["schedule"]>>);
const content = await readFile(
path.resolve(
__dirname,
"..",
"..",
"..",
"test",
"fixtures",
"markdown.md"
)
);
const form = new FormData();
form.append("file", content, "markdown.md");
form.append("collectionId", collection.id);
const res = await server.post("/api/documents.import", user, {
headers: form.getHeaders(),
body: form,
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
vi.restoreAllMocks();
});
it("should import a child document with parent document permission only", async () => {
const team = await buildTeam();
const author = await buildUser({ teamId: team.id });
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: author.id,
teamId: team.id,
permission: null,
});
const parentDocument = await buildDocument({
userId: author.id,
teamId: team.id,
collectionId: collection.id,
});
await UserMembership.create({
documentId: parentDocument.id,
userId: user.id,
createdById: author.id,
permission: DocumentPermission.ReadWrite,
});
const childDocument = await buildDocument({
userId: user.id,
teamId: team.id,
collectionId: collection.id,
parentDocumentId: parentDocument.id,
});
vi.spyOn(FileStorage, "store").mockResolvedValue(
undefined as unknown as string
);
const schedule = vi
.spyOn(DocumentImportTask.prototype, "schedule")
.mockResolvedValue({
finished: vi.fn().mockResolvedValue({ documentId: childDocument.id }),
} as unknown as Awaited<ReturnType<DocumentImportTask["schedule"]>>);
const content = await readFile(
path.resolve(
__dirname,
"..",
"..",
"..",
"test",
"fixtures",
"markdown.md"
)
);
const form = new FormData();
form.append("file", content, "markdown.md");
form.append("collectionId", collection.id);
form.append("parentDocumentId", parentDocument.id);
const res = await server.post("/api/documents.import", user, {
headers: form.getHeaders(),
body: form,
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(childDocument.id);
expect(schedule).toHaveBeenCalledWith(
expect.objectContaining({ collectionId: collection.id })
);
vi.restoreAllMocks();
});
it("should ignore a collectionId the user cannot write when a parent document is given", async () => {
const team = await buildTeam();
const author = await buildUser({ teamId: team.id });
const user = await buildUser({ teamId: team.id });
const ownCollection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const privateCollection = await buildCollection({
userId: author.id,
teamId: team.id,
permission: null,
});
const parentDocument = await buildDocument({
userId: user.id,
teamId: team.id,
collectionId: ownCollection.id,
});
const childDocument = await buildDocument({
userId: user.id,
teamId: team.id,
collectionId: ownCollection.id,
parentDocumentId: parentDocument.id,
});
vi.spyOn(FileStorage, "store").mockResolvedValue(
undefined as unknown as string
);
const schedule = vi
.spyOn(DocumentImportTask.prototype, "schedule")
.mockResolvedValue({
finished: vi.fn().mockResolvedValue({ documentId: childDocument.id }),
} as unknown as Awaited<ReturnType<DocumentImportTask["schedule"]>>);
const content = await readFile(
path.resolve(
__dirname,
"..",
"..",
"..",
"test",
"fixtures",
"markdown.md"
)
);
const form = new FormData();
form.append("file", content, "markdown.md");
form.append("collectionId", privateCollection.id);
form.append("parentDocumentId", parentDocument.id);
form.append("publish", "true");
const res = await server.post("/api/documents.import", user, {
headers: form.getHeaders(),
body: form,
});
expect(res.status).toEqual(200);
expect(schedule).toHaveBeenCalledWith(
expect.objectContaining({ collectionId: ownCollection.id })
);
vi.restoreAllMocks();
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.import", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
});
describe("#documents.create", () => {
it("should create the personal collection for the personal collectionId", async () => {
const team = await buildTeam();
team.setPreference(TeamPreference.PersonalDocs, true);
await team.save();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: { collectionId: "personal", title: "First", publish: true },
});
const body = await res.json();
expect(res.status).toEqual(200);
const collection = await Collection.findOne({
where: { teamId: team.id, ownerId: user.id },
rejectOnEmpty: true,
});
expect(body.data.collectionId).toEqual(collection.id);
expect(body.data.ownerId).toEqual(user.id);
const res2 = await server.post("/api/documents.create", user, {
body: { collectionId: "personal", title: "Second", publish: true },
});
const body2 = await res2.json();
expect(res2.status).toEqual(200);
expect(body2.data.collectionId).toEqual(collection.id);
});
it("should not create the personal collection when turned off", async () => {
const team = await buildTeam();
team.setPreference(TeamPreference.PersonalDocs, false);
await team.save();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: { collectionId: "personal", title: "First", publish: true },
});
expect(res.status).toEqual(403);
expect(await Collection.count({ where: { ownerId: user.id } })).toEqual(0);
});
it("should replace template variables when a doc is created from a template", async () => {
const user = await buildUser();
const text = `This document was created by {author} on {date}`;
const template = await buildTemplate({
userId: user.id,
teamId: user.teamId,
title: "template title",
text,
});
const res = await server.post("/api/documents.create", user, {
body: {
templateId: template.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toEqual(
TextHelper.replaceTemplateVariables(template.title, user)
);
expect(body.data.text).toEqual(
TextHelper.replaceTemplateVariables(text, user)
);
});
it("should create a document with empty title if no title is explicitly passed", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.create", user, {
body: {
text: "hello",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toEqual("");
});
it("should not create a document with text over the maximum length", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.create", user, {
body: {
title: "title",
text: "a".repeat(DocumentValidation.maxLength + 1),
},
});
expect(res.status).toEqual(400);
});
it("should use template title when doc is created using a template and title is not explicitly passed", async () => {
const user = await buildUser();
const template = await buildTemplate({
userId: user.id,
teamId: user.teamId,
title: "template title",
});
const res = await server.post("/api/documents.create", user, {
body: {
templateId: template.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toEqual(template.title);
});
it("should override template title when doc title is explicitly passed", async () => {
const user = await buildUser();
const template = await buildTemplate({
userId: user.id,
teamId: user.teamId,
title: "template title",
});
const res = await server.post("/api/documents.create", user, {
body: {
templateId: template.id,
title: "doc title",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toEqual("doc title");
});
it("should override template text when doc text is explicitly passed", async () => {
const user = await buildUser();
const template = await buildTemplate({
userId: user.id,
teamId: user.teamId,
text: "template text",
});
const res = await server.post("/api/documents.create", user, {
body: {
templateId: template.id,
text: "doc text",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.text).toEqual("doc text");
});
it("should fail for invalid collectionId", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: "invalid",
title: "new document",
text: "hello",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("collectionId: Invalid UUID");
});
it("should succeed if collectionId is null", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: null,
title: "new document",
text: "hello",
},
});
expect(res.status).toEqual(200);
});
it("should succeed with specific createdAt date in the past", async () => {
const user = await buildUser();
const createdAt = new Date().toISOString();
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: null,
title: "new document",
createdAt,
text: "hello",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.createdAt).toEqual(createdAt);
expect(body.data.updatedAt).toEqual(createdAt);
});
it("should fail with createdAt date in the future", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: null,
title: "new document",
createdAt: addMinutes(new Date(), 1).toISOString(),
text: "hello",
},
});
expect(res.status).toEqual(400);
});
it("should fail for invalid parentDocumentId", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: {
parentDocumentId: "invalid",
title: "new document",
text: "hello",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("parentDocumentId: Invalid UUID");
});
it("should create as a new document with icon", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: collection.id,
icon: "🚢",
title: "new document",
text: "hello",
publish: true,
},
});
const body = await res.json();
const newDocument = await Document.findByPk(body.data.id);
expect(res.status).toEqual(200);
expect(newDocument!.parentDocumentId).toBe(null);
expect(newDocument!.collectionId).toBe(collection.id);
expect(newDocument!.icon).toBe("🚢");
expect(body.policies[0].abilities.update).toBeTruthy();
});
it("should create a draft document not belonging to any collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: {
title: "draft document",
text: "draft document without collection",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("draft document");
expect(body.data.text).toBe("draft document without collection");
expect(body.data.collectionId).toBeNull();
});
it("should allow creating a draft template without a collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: {
template: true,
title: "template",
text: "template without collection",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.publishedAt).toBeNull();
expect(body.data.collectionId).toBeNull();
});
it("should not allow publishing without specifying the collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: {
title: "title",
text: "text",
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toBe(
"collectionId or parentDocumentId is required to publish"
);
});
it("should not allow very long titles", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: collection.id,
title:
"This is a really long title that is not acceptable to Outline because it is so ridiculously long that we need to have a limit somewhere",
text: " ",
},
});
expect(res.status).toEqual(400);
});
// The length of UTF-8 "🛡" is 2 according to "🛡".length in node,
// so the length of the title totals to be 101.
// This test should not pass but does because length of the character
// calculated by lodash's size function is _.size('🛡') == 1.
// So the sentence's length comes out to be exactly 100.
it("should count variable length unicode character using lodash's size function", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const res = await server.post("/api/documents.create", user, {
body: {
collectionId: collection.id,
title:
"This text would be exactly 100 chars long if the following unicode character was counted as 1 char 🛡",
text: " ",
},
});
expect(res.status).toEqual(200);
});
it("should create as a child and add to collection if published", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
const res = await server.post("/api/documents.create", user, {
body: {
parentDocumentId: document.id,
title: "new document",
text: "hello",
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("new document");
expect(body.policies[0].abilities.update).toBeTruthy();
});
it("should error with invalid parentDocument", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const res = await server.post("/api/documents.create", user, {
body: {
parentDocumentId: "d7a4eb73-fac1-4028-af45-d7e34d54db8e",
title: "new document",
text: "hello",
},
});
const body = await res.json();
expect(res.status).toEqual(403);
expect(body).toMatchSnapshot();
});
it("should create as a child and not add to collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
const res = await server.post("/api/documents.create", user, {
body: {
parentDocumentId: document.id,
title: "new document",
text: "hello",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("new document");
expect(body.policies[0].abilities.update).toBeTruthy();
});
});
describe("#documents.update", () => {
describe("deprecatedReason", () => {
it.each(["archived", "deleted"])(
"should update the reason for an %s document without changing attribution",
async (status) => {
const user = await buildUser();
const editor = await buildUser({ teamId: user.teamId });
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
archivedAt: status === "archived" ? new Date() : null,
deletedAt: status === "deleted" ? new Date() : null,
});
const updatedAt = document.updatedAt.toISOString();
const res = await server.post("/api/documents.update", editor, {
body: {
id: document.id,
deprecatedReason: " Replaced by the new guide. ",
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.deprecatedReason).toBe("Replaced by the new guide.");
expect(body.data.updatedBy.id).toBe(user.id);
expect(body.data.updatedAt).toBe(updatedAt);
await document.reload({ paranoid: false });
expect(document.deprecatedReason).toBe("Replaced by the new guide.");
expect(document.isActive).toBe(false);
}
);
it.each([null, "", " "])(
"should clear the reason with %j",
async (value) => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
archivedAt: new Date(),
deprecatedReason: "Outdated",
});
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, deprecatedReason: value },
});
expect(res.status).toBe(200);
await document.reload();
expect(document.deprecatedReason).toBeNull();
}
);
it.each(["archived", "deleted"])(
"should reject changes to other fields on an %s document",
async (status) => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
archivedAt: status === "archived" ? new Date() : null,
deletedAt: status === "deleted" ? new Date() : null,
});
for (const fields of [
{ title: "Changed" },
{ text: "Changed" },
{ publish: true },
{ fullWidth: true },
]) {
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
deprecatedReason: "Outdated",
...fields,
},
});
expect([403, 404]).toContain(res.status);
}
await document.reload({ paranoid: false });
expect(document.deprecatedReason).toBeNull();
}
);
it.each(["viewer", "other team", "private collection"])(
"should deny a user with no edit access: %s",
async (access) => {
const owner = await buildUser();
const user =
access === "viewer"
? await buildViewer({ teamId: owner.teamId })
: await buildUser(
access === "other team" ? {} : { teamId: owner.teamId }
);
const collection = await buildCollection({
userId: owner.id,
teamId: owner.teamId,
permission:
access === "private collection"
? null
: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
userId: owner.id,
teamId: owner.teamId,
collectionId: collection.id,
archivedAt: new Date(),
});
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, deprecatedReason: "Outdated" },
});
expect(res.status).toBe(403);
await document.reload();
expect(document.deprecatedReason).toBeNull();
}
);
it("should reject a reason on an active document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, deprecatedReason: "Outdated" },
});
expect(res.status).toBe(403);
});
it("should validate the reason length", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
archivedAt: new Date(),
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
deprecatedReason: "x".repeat(
DeprecationValidation.maxReasonLength + 1
),
},
});
expect(res.status).toBe(400);
});
});
describe("templateId", () => {
it("should set a template the user can read", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const template = await buildTemplate({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, templateId: template.id },
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.templateId).toBe(template.id);
});
it("should not set a template from another team", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const template = await buildTemplate();
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, templateId: template.id },
});
expect(res.status).toBe(403);
await document.reload();
expect(document.templateId).toBeNull();
});
it("should not set a template in a collection the user cannot read", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const collection = await buildCollection({
teamId: user.teamId,
permission: null,
});
const template = await buildTemplate({
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, templateId: template.id },
});
expect(res.status).toBe(403);
});
it("should allow saving with an unchanged template that was deleted", async () => {
const user = await buildUser();
const template = await buildTemplate({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
templateId: template.id,
});
await template.destroy();
const res = await server.post("/api/documents.update", user, {
body: { id: document.id, title: "Updated", templateId: template.id },
});
expect(res.status).toBe(200);
});
});
it("should update document details in the root", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
icon: "library",
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
text: "Updated text",
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("Updated title");
expect(body.data.text).toBe("Updated text");
expect(body.data.icon).toBe("library");
const events = await Event.findAll({
where: {
teamId: document.teamId,
},
});
expect(events.length).toEqual(1);
});
it("should update document with a null preferences value", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
preferences: null,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("Updated title");
expect(body.data.preferences).toBe(null);
});
it("should update document preferences", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
preferences: { headingPrefix: HeadingPrefixStyle.Numeric },
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.preferences).toEqual({
headingPrefix: HeadingPrefixStyle.Numeric,
});
});
it("should update document when lastRevision matches", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Updated text",
lastRevision: document.revisionCount,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.text).toBe("Updated text");
expect(body.data.revision).toBe(document.revisionCount + 1);
});
it("should return conflict when lastRevision does not match", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Updated text",
lastRevision: document.revisionCount - 1,
},
});
const body = await res.json();
expect(res.status).toEqual(409);
expect(body.error).toBe("document_conflict");
const previousRevision = document.revisionCount;
await document.reload();
expect(document.revisionCount).toBe(previousRevision);
});
it("should not update a document with text over the maximum length", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "a".repeat(DocumentValidation.maxLength + 1),
},
});
expect(res.status).toEqual(400);
});
it("should not allow publishing a draft without specifying the collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDraftDocument({
teamId: team.id,
userId: user.id,
collectionId: null,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
text: "Updated text",
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toBe(
"collectionId is required to publish a draft without collection"
);
});
it("should successfully publish a draft", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDraftDocument({
title: "title",
text: "text",
teamId: team.id,
userId: user.id,
collectionId: null,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
text: "Updated text",
collectionId: collection.id,
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.collectionId).toBe(collection.id);
expect(body.data.title).toBe("Updated title");
expect(body.data.text).toBe("Updated text");
});
it("should not allow publishing by another collection's user", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
const anotherTeam = await buildTeam();
user.teamId = anotherTeam.id;
await user.save();
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
text: "Updated text",
collectionId: collection.id,
publish: true,
},
});
expect(res.status).toEqual(403);
});
it("should not allow publishing a child draft into an inaccessible collection", async () => {
const team = await buildTeam();
const admin = await buildAdmin({ teamId: team.id });
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const privateCollection = await buildCollection({
userId: admin.id,
teamId: team.id,
permission: null,
});
const parentDocument = await buildDocument({
userId: user.id,
teamId: team.id,
collectionId: collection.id,
});
const document = await buildDraftDocument({
userId: user.id,
teamId: team.id,
collectionId: null,
parentDocumentId: parentDocument.id,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
collectionId: privateCollection.id,
publish: true,
},
});
expect(res.status).toEqual(403);
const reloaded = await Document.unscoped().findByPk(document.id);
expect(reloaded?.publishedAt).toBeNull();
expect(reloaded?.collectionId).toBeNull();
});
it("should allow publishing a child draft into the parent collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const parentDocument = await buildDocument({
userId: user.id,
teamId: team.id,
collectionId: collection.id,
});
const document = await buildDraftDocument({
userId: user.id,
teamId: team.id,
collectionId: null,
parentDocumentId: parentDocument.id,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
collectionId: collection.id,
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.collectionId).toBe(collection.id);
expect(body.data.parentDocumentId).toBe(parentDocument.id);
});
it("should publish a child draft at the root of another collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const member = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const otherCollection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const parentDocument = await buildDocument({
userId: user.id,
teamId: team.id,
collectionId: collection.id,
});
await UserMembership.create({
userId: member.id,
documentId: parentDocument.id,
permission: DocumentPermission.Read,
createdById: user.id,
});
const document = await buildDraftDocument({
userId: user.id,
teamId: team.id,
collectionId: null,
parentDocumentId: parentDocument.id,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
collectionId: otherCollection.id,
publish: true,
},
});
expect(res.status).toEqual(200);
await document.reload();
expect(document.collectionId).toBe(otherCollection.id);
expect(document.parentDocumentId).toBeNull();
await otherCollection.reload();
expect(otherCollection.documentStructure?.map((node) => node.id)).toContain(
document.id
);
const membership = await UserMembership.findOne({
where: { userId: member.id, documentId: document.id },
});
expect(membership).toBeNull();
});
it("should fail to update an invalid icon value", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
icon: ":)",
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toBe("icon: Invalid input");
});
it("should successfully update the icon", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
icon: "beaker",
color: "#FFDDEE",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.icon).toBe("beaker");
expect(body.data.color).toBe("#FFDDEE");
});
it("should successfully remove the icon", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
icon: "beaker",
color: "#FFDDEE",
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
icon: null,
color: null,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.icon).toBeNull();
expect(body.data.color).toBeNull();
});
it("should allow publishing document in private collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
permission: null,
});
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
await UserMembership.update(
{
userId: user.id,
permission: CollectionPermission.ReadWrite,
},
{
where: {
createdById: user.id,
collectionId: collection.id,
},
}
);
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
collectionId: collection.id,
title: "Updated title",
text: "Updated text",
publish: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.publishedAt).toBeTruthy();
expect(body.policies[0].abilities.update).toBeTruthy();
const events = await Event.findAll({
where: {
teamId: document.teamId,
},
});
expect(events.length).toEqual(1);
});
it("should not edit archived document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
text: "Updated text",
},
});
expect(res.status).toEqual(403);
});
it("should update document details for children", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
collection.documentStructure = [
{
id: "af1da94b-9591-4bab-897c-11774b804b77",
url: "/d/some-beef-RSZwQDsfpc",
title: "some beef",
children: [
{
id: "ab1da94b-9591-4bab-897c-11774b804b66",
url: "/d/another-doc-RSZwQDsfpc",
title: "Another doc",
children: [],
},
{ ...(await document.toNavigationNode()), children: [] },
],
},
];
await collection.save();
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated title",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("Updated title");
});
it("allows editing by read-write collection user", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
permission: null,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
await UserMembership.update(
{
createdById: user.id,
permission: CollectionPermission.ReadWrite,
},
{
where: {
collectionId: collection.id,
userId: user.id,
},
}
);
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Changed text",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.title).toBe("Changed text");
expect(body.data.updatedBy.id).toBe(user.id);
expect(body.policies[0].abilities.update).toBeTruthy();
});
it("does not allow editing by read-only collection user", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
permission: null,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
await UserMembership.update(
{
createdById: user.id,
permission: CollectionPermission.Read,
},
{
where: {
collectionId: collection.id,
userId: user.id,
},
}
);
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Changed text",
},
});
expect(res.status).toEqual(403);
});
it("does not allow editing in read-only collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
collection.permission = CollectionPermission.Read;
await collection.save();
await UserMembership.destroy({
where: {
userId: user.id,
collectionId: collection.id,
},
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Changed text",
},
});
expect(res.status).toEqual(403);
});
it("should append document with text", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Additional text",
append: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.text).toBe(document.text + "Additional text");
expect(body.data.updatedBy.id).toBe(user.id);
});
it("should require text while appending", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated Title",
append: true,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body).toMatchSnapshot();
});
it("should allow setting empty text", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: "Updated Title",
text: "",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.text).toBe("");
});
it("should not produce event if nothing changes", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
title: document.title,
},
});
expect(res.status).toEqual(200);
const events = await Event.findAll({
where: {
teamId: document.teamId,
},
});
expect(events.length).toEqual(0);
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.update", {
body: {
id: document.id,
text: "Updated",
},
});
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
it("should require authorization", async () => {
const document = await buildDocument();
const user = await buildUser();
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Updated",
},
});
expect(res.status).toEqual(403);
});
it("should fail for invalid collectionId", async () => {
const document = await buildDocument();
const user = await buildUser();
const res = await server.post("/api/documents.update", user, {
body: {
id: document.id,
text: "Updated",
collectionId: "invalid",
},
});
const body = await res.json();
expect(res.status).toBe(400);
expect(body.message).toBe("collectionId: Invalid UUID");
});
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.update", user, {
body: {
text: "Updated",
},
});
const body = await res.json();
expect(res.status).toBe(400);
expect(body.message).toBe("id: Must be a valid UUID or slug");
});
});
describe("#documents.archive", () => {
it.each([undefined, " Replaced by a new guide. ", null, " "])(
"should archive with reason %j",
async (reason) => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.archive", user, {
body: { id: document.id, reason },
});
expect(res.status).toBe(200);
await document.reload({ paranoid: false });
expect(document.archivedAt).not.toBeNull();
const expectedReason =
reason === undefined ? null : reason?.trim() || null;
expect(document.deprecatedReason).toBe(expectedReason);
const body = await res.json();
expect(body.data.deprecatedReason).toBe(expectedReason);
}
);
it("should reject an oversized reason before archive", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.archive", user, {
body: {
id: document.id,
reason: "x".repeat(DeprecationValidation.maxReasonLength + 1),
},
});
expect(res.status).toBe(400);
await document.reload();
expect(document.isActive).toBe(true);
expect(document.deprecatedReason).toBeNull();
});
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.archive", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should allow archiving document", async () => {
const admin = await buildAdmin();
const user = await buildUser({ teamId: admin.teamId });
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: admin.id,
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.archive", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.updatedBy.id).toEqual(user.id);
expect(body.data.archivedAt).toBeTruthy();
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.archive", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
});
describe("#documents.delete", () => {
it.each([undefined, " Replaced by a new guide. ", null, " "])(
"should delete with reason %j",
async (reason) => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
archivedAt: new Date(),
deprecatedReason: "Archived reason",
});
const res = await server.post("/api/documents.delete", user, {
body: { id: document.id, reason },
});
expect(res.status).toBe(200);
await document.reload({ paranoid: false });
expect(document.deletedAt).not.toBeNull();
const expectedReason =
reason === undefined ? "Archived reason" : reason?.trim() || null;
expect(document.deprecatedReason).toBe(expectedReason);
}
);
it("should reject an oversized reason before delete", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
reason: "x".repeat(DeprecationValidation.maxReasonLength + 1),
},
});
expect(res.status).toBe(400);
await document.reload();
expect(document.isActive).toBe(true);
expect(document.deprecatedReason).toBeNull();
});
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.delete", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should allow deleting document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
reason: "No longer needed",
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.success).toEqual(true);
await document.reload({ paranoid: false });
expect(document.deprecatedReason).toBe("No longer needed");
});
it("should delete a draft without collection", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
teamId: user.teamId,
userId: user.id,
deletedAt: null,
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.success).toEqual(true);
const deletedDoc = await Document.findByPk(document.id, {
paranoid: false,
});
expect(deletedDoc).toBeDefined();
expect(deletedDoc).not.toBeNull();
expect(deletedDoc?.deletedAt).toBeTruthy();
});
it("should not allow deleting another user's draft without collection", async () => {
const user = await buildUser();
const anotherUser = await buildUser({ teamId: user.teamId });
const document = await buildDraftDocument({
teamId: user.teamId,
userId: anotherUser.id,
collectionId: null,
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should delete a draft under deleted collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
createdById: user.id,
teamId: user.teamId,
deletedAt: new Date(),
});
const document = await buildDocument({
createdById: user.id,
teamId: user.teamId,
collectionId: collection.id,
publishedAt: null,
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
},
});
expect(res.status).toBe(200);
const deletedDoc = await Document.findByPk(document.id, {
paranoid: false,
});
expect(deletedDoc).not.toBe(null);
expect(deletedDoc?.deletedAt).not.toBe(null);
});
it("should allow permanently deleting a document as admin", async () => {
const user = await buildAdmin();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await server.post("/api/documents.delete", user, {
body: {
id: document.id,
},
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
permanent: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.success).toEqual(true);
});
it("should not allow permanently deleting a document as non-admin", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDocument({
userId: user.id,
teamId: team.id,
});
await server.post("/api/documents.delete", user, {
body: {
id: document.id,
},
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
permanent: true,
},
});
const body = await res.json();
expect(res.status).toEqual(403);
expect(body.message).toEqual("Authorization error");
});
it("should allow deleting document without collection", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: team.id,
});
// delete collection without hooks to trigger document deletion
await collection.destroy({
hooks: false,
});
const res = await server.post("/api/documents.delete", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.success).toEqual(true);
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.delete", {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
});
describe("#documents.unpublish", () => {
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.unpublish", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should unpublish a document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
expect(body.data.publishedAt).toBeNull();
expect(body.data.createdBy.id).toEqual(user.id);
expect(body.data.updatedBy.id).toEqual(user.id);
expect(body.policies[0].abilities.createChildDocument).toEqual(false);
expect(body.policies[0].abilities.update).toBeTruthy();
const reloaded = await Document.unscoped().findByPk(document.id);
expect(reloaded!.createdById).toEqual(user.id);
});
it("should remove the collection and parent when detaching", async () => {
const user = await buildUser();
const parentDocument = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: parentDocument.collectionId,
parentDocumentId: parentDocument.id,
});
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
detach: true,
},
});
expect(res.status).toEqual(200);
const reloaded = await Document.unscoped().findByPk(document.id);
expect(reloaded?.publishedAt).toBeNull();
expect(reloaded?.collectionId).toBeNull();
expect(reloaded?.parentDocumentId).toBeNull();
});
it("should disable public shares when unpublishing a document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const share = await buildShare({
documentId: document.id,
teamId: user.teamId,
userId: user.id,
});
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(200);
const reloaded = await Share.unscoped().findByPk(share.id);
expect(reloaded!.published).toEqual(false);
const infoRes = await server.post("/api/shares.info", {
body: {
id: share.id,
},
});
expect(infoRes.status).toEqual(404);
});
it("should unpublish a document with archived children", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
const child = await buildDocument({
userId: user.id,
teamId: user.teamId,
parentDocumentId: document.id,
});
await withAPIContext(user, (ctx) => child.archiveWithCtx(ctx));
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
expect(body.data.publishedAt).toBeNull();
expect(body.data.updatedBy.id).toEqual(user.id);
});
it("should unpublish another users document", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.id).toEqual(document.id);
expect(body.data.publishedAt).toBeNull();
expect(body.data.updatedBy.id).toEqual(user.id);
const reloaded = await Document.unscoped().findByPk(document.id);
expect(reloaded!.createdById).toEqual(user.id);
});
it("should fail to unpublish a draft document", async () => {
const user = await buildUser();
const document = await buildDraftDocument({
userId: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should fail to unpublish a deleted document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.destroyWithCtx(ctx));
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should fail to unpublish an archived document", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
});
await withAPIContext(user, (ctx) => document.archiveWithCtx(ctx));
const res = await server.post("/api/documents.unpublish", user, {
body: {
id: document.id,
},
});
expect(res.status).toEqual(403);
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.unpublish", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
});
describe("#documents.users", () => {
it("should return all users when collection is not private", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
});
const document = await buildDocument({
collectionId: collection.id,
userId: user.id,
teamId: user.teamId,
});
const [alan, bret, ken] = await Promise.all([
buildUser({
name: "Alan Kay",
teamId: user.teamId,
}),
buildUser({
name: "Bret Victor",
teamId: user.teamId,
}),
buildUser({
name: "Ken Thompson",
teamId: user.teamId,
}),
]);
const res = await server.post("/api/documents.users", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.length).toBe(4);
const memberIds = body.data.map((u: User) => u.id);
expect(memberIds).toContain(alan.id);
expect(memberIds).toContain(bret.id);
expect(memberIds).toContain(ken.id);
expect(memberIds).toContain(user.id);
});
it("should return collection users when collection is private", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
userId: user.id,
teamId: user.teamId,
});
const [alan, ken] = await Promise.all([
buildUser({
name: "Alan Kay",
teamId: user.teamId,
}),
buildUser({
name: "Ken",
teamId: user.teamId,
}),
buildUser({
name: "Bret Victor",
teamId: user.teamId,
}),
]);
await UserMembership.create({
createdById: alan.id,
collectionId: collection.id,
userId: alan.id,
permission: CollectionPermission.ReadWrite,
});
await UserMembership.create({
createdById: ken.id,
documentId: document.id,
userId: ken.id,
permission: DocumentPermission.ReadWrite,
});
const res = await server.post("/api/documents.users", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.length).toBe(3);
const memberIds = body.data.map((u: User) => u.id);
expect(memberIds).toContain(user.id);
expect(memberIds).toContain(alan.id);
expect(memberIds).toContain(ken.id);
});
it("should return document users with names matching the search query", async () => {
const user = await buildUser({
// Ensure the generated name doesn't match
name: "zzz",
});
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
userId: user.id,
teamId: user.teamId,
});
const [alan, bret, ken, jamie] = await Promise.all([
buildUser({
name: "Alan Kay",
teamId: user.teamId,
}),
buildUser({
name: "Brët Victor",
teamId: user.teamId,
}),
buildUser({
name: "Ken Thompsoń",
teamId: user.teamId,
}),
buildUser({
name: "Jámie Zawinsky",
teamId: user.teamId,
}),
]);
const group = await buildGroup({
name: "Hackers",
createdById: user.id,
teamId: user.teamId,
});
// add people to group
await Promise.all([
group.$add("user", ken, {
through: {
createdById: user.id,
},
}),
group.$add("user", jamie, {
through: {
createdById: user.id,
},
}),
]);
// add people and groups to collection
await Promise.all([
UserMembership.create({
collectionId: collection.id,
userId: alan.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
UserMembership.create({
collectionId: collection.id,
userId: bret.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
UserMembership.create({
collectionId: collection.id,
userId: ken.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
GroupMembership.create({
collectionId: collection.id,
groupId: group.id,
permission: CollectionPermission.ReadWrite,
createdById: user.id,
}),
]);
const res = await server.post("/api/documents.users", user, {
body: {
id: document.id,
query: "Al",
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.length).toBe(1);
expect(body.data[0].id).toContain(alan.id);
expect(body.data[0].name).toBe(alan.name);
const anotherRes = await server.post("/api/documents.users", user, {
body: {
id: document.id,
query: "e",
},
});
const anotherBody = await anotherRes.json();
expect(anotherRes.status).toBe(200);
expect(anotherBody.data.length).toBe(3);
const memberIds = anotherBody.data.map((u: User) => u.id);
const memberNames = anotherBody.data.map((u: User) => u.name);
expect(memberIds).toContain(bret.id);
expect(memberIds).toContain(ken.id);
expect(memberIds).toContain(jamie.id);
expect(memberNames).toContain(bret.name);
expect(memberNames).toContain(ken.name);
expect(memberNames).toContain(jamie.name);
});
it("should return document users with id matching userId", async () => {
const user = await buildUser({
// Ensure the generated name doesn't match
name: "zzz",
});
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
userId: user.id,
teamId: user.teamId,
});
const [alan, bret, ken, jamie] = await Promise.all([
buildUser({
name: "Alan Kay",
teamId: user.teamId,
}),
buildUser({
name: "Brët Victor",
teamId: user.teamId,
}),
buildUser({
name: "Ken Thompsoń",
teamId: user.teamId,
}),
buildUser({
name: "Jámie Zawinsky",
teamId: user.teamId,
}),
]);
const group = await buildGroup({
name: "Hackers",
createdById: user.id,
teamId: user.teamId,
});
// add people to group
await group.$add("user", ken, {
through: {
createdById: user.id,
},
});
// add people and groups to collection
await Promise.all([
UserMembership.create({
collectionId: collection.id,
userId: alan.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
UserMembership.create({
collectionId: collection.id,
userId: bret.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
UserMembership.create({
collectionId: collection.id,
userId: ken.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
GroupMembership.create({
collectionId: collection.id,
groupId: group.id,
permission: CollectionPermission.ReadWrite,
createdById: user.id,
}),
]);
const res = await server.post("/api/documents.users", user, {
body: {
id: document.id,
userId: alan.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.length).toBe(1);
expect(body.data[0].id).toContain(alan.id);
expect(body.data[0].name).toBe(alan.name);
const anotherRes = await server.post("/api/documents.users", user, {
body: {
id: document.id,
userId: jamie.id,
},
});
const anotherBody = await anotherRes.json();
expect(anotherRes.status).toBe(200);
expect(anotherBody.data.length).toBe(0);
});
it("should not return suspended or guest users", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
userId: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
userId: user.id,
teamId: user.teamId,
});
const [alan, bret, ken] = await Promise.all([
buildUser({
name: "Alan Kay",
teamId: user.teamId,
}),
buildUser({
name: "Bret Victor",
teamId: user.teamId,
}),
buildUser({
name: "Ken Thompson",
teamId: user.teamId,
}),
buildUser({
name: "Guest",
teamId: user.teamId,
role: UserRole.Guest,
}),
]);
// add people to collection
await Promise.all([
UserMembership.create({
collectionId: collection.id,
userId: alan.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
UserMembership.create({
collectionId: collection.id,
userId: bret.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
UserMembership.create({
collectionId: collection.id,
userId: ken.id,
permission: CollectionPermission.Read,
createdById: user.id,
}),
]);
// suspend Alan
alan.suspendedAt = new Date();
await alan.save();
const res = await server.post("/api/documents.users", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.length).toBe(3);
const memberIds = body.data.map((u: User) => u.id);
expect(memberIds).not.toContain(alan.id);
expect(memberIds).toContain(bret.id);
expect(memberIds).toContain(ken.id);
});
it("should not allow guests to list users", async () => {
const owner = await buildUser();
const guest = await buildGuestUser({ teamId: owner.teamId });
const collection = await buildCollection({
teamId: owner.teamId,
userId: owner.id,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
collectionId: collection.id,
userId: owner.id,
teamId: owner.teamId,
});
await UserMembership.create({
userId: guest.id,
documentId: document.id,
permission: DocumentPermission.Read,
createdById: owner.id,
});
const res = await server.post("/api/documents.users", guest, {
body: {
id: document.id,
},
});
expect(res.status).toBe(403);
});
});
describe("document permission management authorization", () => {
it("should prevent collection read_write members from managing document users and groups", async () => {
const team = await buildTeam();
const actor = await buildUser({ teamId: team.id });
const collection = await buildCollection({
teamId: team.id,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
teamId: team.id,
collectionId: collection.id,
});
const member = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
await expectCannotManageDocumentPermissions({
actor,
document,
member,
group,
});
});
it("should allow collection admins to manage document users and groups", async () => {
const team = await buildTeam();
const admin = await buildAdmin({ teamId: team.id });
const actor = await buildUser({ teamId: team.id });
const collection = await buildCollection({
teamId: team.id,
userId: admin.id,
permission: null,
});
const document = await buildDocument({
teamId: team.id,
collectionId: collection.id,
});
const member = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
await collection.$add("user", actor, {
through: {
permission: CollectionPermission.Admin,
createdById: admin.id,
},
});
await expectCanManageDocumentPermissions({
actor,
document,
member,
group,
});
});
it("should allow workspace admins with read access to manage document users and groups", async () => {
const team = await buildTeam();
const actor = await buildAdmin({ teamId: team.id });
const collection = await buildCollection({
teamId: team.id,
permission: CollectionPermission.Read,
});
const document = await buildDocument({
teamId: team.id,
collectionId: collection.id,
});
const member = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
await expectCanManageDocumentPermissions({
actor,
document,
member,
group,
});
});
it("should allow direct document admins to manage users and groups", async () => {
const team = await buildTeam();
const actor = await buildUser({ teamId: team.id });
const collection = await buildCollection({
teamId: team.id,
permission: null,
});
const document = await buildDocument({
teamId: team.id,
collectionId: collection.id,
});
const member = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
await UserMembership.create({
userId: actor.id,
documentId: document.id,
permission: DocumentPermission.Admin,
createdById: actor.id,
});
await expectCanManageDocumentPermissions({
actor,
document,
member,
group,
});
});
it("should prevent direct document read_write members from managing users and groups", async () => {
const team = await buildTeam();
const actor = await buildUser({ teamId: team.id });
const collection = await buildCollection({
teamId: team.id,
permission: null,
});
const document = await buildDocument({
teamId: team.id,
collectionId: collection.id,
});
const member = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
await UserMembership.create({
userId: actor.id,
documentId: document.id,
permission: DocumentPermission.ReadWrite,
createdById: actor.id,
});
await expectCannotManageDocumentPermissions({
actor,
document,
member,
group,
});
});
});
describe("#documents.add_user", () => {
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.add_user", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.add_user", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
it("should fail with status 400 bad request if user attempts to invite themself", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: user.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("You cannot invite yourself");
});
it("should succeed with status 200 ok", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const member = await buildUser({ teamId: user.teamId });
const res = await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data).not.toBeFalsy();
expect(body.data.users).not.toBeFalsy();
expect(body.data.users).toHaveLength(1);
expect(body.data.users[0].id).toEqual(member.id);
expect(body.data.memberships).not.toBeFalsy();
expect(body.data.memberships[0].userId).toEqual(member.id);
expect(body.data.memberships[0].documentId).toEqual(document.id);
expect(body.data.memberships[0].permission).toEqual(
DocumentPermission.ReadWrite
);
});
});
describe("#documents.remove_user", () => {
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.remove_user", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should require authentication", async () => {
const document = await buildDocument();
const res = await server.post("/api/documents.remove_user", {
body: {
id: document.id,
},
});
expect(res.status).toEqual(401);
});
it("should require authorization", async () => {
const document = await buildDocument();
const user = await buildUser();
const anotherUser = await buildUser({
teamId: user.teamId,
});
const res = await server.post("/api/documents.remove_user", user, {
body: {
id: document.id,
userId: anotherUser.id,
},
});
expect(res.status).toEqual(403);
});
it("should remove user from document", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const member = await buildUser({
teamId: user.teamId,
});
await server.post("/api/documents.add_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
let users = await document.$get("users");
expect(users.length).toEqual(1);
const res = await server.post("/api/documents.remove_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
users = await document.$get("users");
expect(res.status).toEqual(200);
expect(users.length).toEqual(0);
});
it("should not remove user with access inherited from a parent", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const parentDocument = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const document = await buildDocument({
collectionId: collection.id,
parentDocumentId: parentDocument.id,
createdById: user.id,
teamId: user.teamId,
});
const member = await buildUser({
teamId: user.teamId,
});
const sourceMembership = await UserMembership.create({
createdById: user.id,
documentId: parentDocument.id,
userId: member.id,
permission: DocumentPermission.ReadWrite,
});
await UserMembership.create({
createdById: user.id,
documentId: document.id,
userId: member.id,
permission: DocumentPermission.ReadWrite,
sourceId: sourceMembership.id,
});
const res = await server.post("/api/documents.remove_user", user, {
body: {
id: document.id,
userId: member.id,
},
});
expect(res.status).toEqual(400);
expect(
await UserMembership.count({
where: { documentId: document.id, userId: member.id },
})
).not.toEqual(0);
});
});
describe("#documents.add_group", () => {
it("should preserve existing permission when permission is omitted", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup({ teamId: user.teamId });
const membership = await GroupMembership.create({
createdById: user.id,
documentId: document.id,
groupId: group.id,
permission: DocumentPermission.Admin,
});
const res = await server.post("/api/documents.add_group", user, {
body: { id: document.id, groupId: group.id },
});
expect(res.status).toEqual(200);
await membership.reload();
expect(membership.permission).toEqual(DocumentPermission.Admin);
});
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.add_group", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should require authentication", async () => {
const document = await buildDocument();
const group = await buildGroup();
const res = await server.post("/api/documents.add_group", {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(401);
});
it("should require authorization", async () => {
const document = await buildDocument();
const user = await buildUser();
const group = await buildGroup({
teamId: user.teamId,
});
const res = await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(403);
});
it("should require group in team", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup();
const res = await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(403);
});
it("should add group to document", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup({
teamId: user.teamId,
});
const res = await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
const body = await res.json();
const groupMemberships = await GroupMembership.findAll({
where: { documentId: document.id },
});
expect(res.status).toEqual(200);
expect(groupMemberships.length).toEqual(1);
expect(body.data).not.toBeFalsy();
expect(body.data.groupMemberships).not.toBeFalsy();
expect(body.data.groupMemberships).toHaveLength(1);
expect(body.data.groupMemberships[0].groupId).toEqual(group.id);
expect(body.data.groupMemberships[0].documentId).toEqual(document.id);
expect(body.data.groupMemberships[0].permission).toEqual(
DocumentPermission.ReadWrite
);
});
it("should add group to document with custom permission", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup({
teamId: user.teamId,
});
const res = await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
permission: DocumentPermission.Read,
},
});
const body = await res.json();
const groupMemberships = await GroupMembership.findAll({
where: { documentId: document.id },
});
expect(res.status).toEqual(200);
expect(groupMemberships.length).toEqual(1);
expect(body.data.groupMemberships[0].permission).toEqual(
DocumentPermission.Read
);
});
it("should update existing group membership permission", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup({
teamId: user.teamId,
});
// First add with Read permission
await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
permission: DocumentPermission.Read,
},
});
// Then update to ReadWrite permission
const res = await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
permission: DocumentPermission.ReadWrite,
},
});
const body = await res.json();
const groupMemberships = await GroupMembership.findAll({
where: { documentId: document.id },
});
expect(res.status).toEqual(200);
expect(groupMemberships.length).toEqual(1);
expect(body.data.groupMemberships[0].permission).toEqual(
DocumentPermission.ReadWrite
);
// Verify only one membership exists
const memberships = await GroupMembership.findAll({
where: {
documentId: document.id,
groupId: group.id,
},
});
expect(memberships.length).toEqual(1);
});
});
describe("#documents.remove_group", () => {
it("should require id", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.remove_group", user);
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual("id: Must be a valid UUID or slug");
});
it("should require authentication", async () => {
const document = await buildDocument();
const group = await buildGroup();
const res = await server.post("/api/documents.remove_group", {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(401);
});
it("should require authorization", async () => {
const document = await buildDocument();
const user = await buildUser();
const group = await buildGroup({
teamId: user.teamId,
});
const res = await server.post("/api/documents.remove_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(403);
});
it("should require group in team", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup();
const res = await server.post("/api/documents.remove_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(403);
});
it("should remove group from document", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup({
teamId: user.teamId,
});
// First add the group
await server.post("/api/documents.add_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
let groupMemberships = await GroupMembership.findAll({
where: { documentId: document.id },
});
expect(groupMemberships.length).toEqual(1);
// Then remove the group
const res = await server.post("/api/documents.remove_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
groupMemberships = await GroupMembership.findAll({
where: { documentId: document.id },
});
expect(res.status).toEqual(200);
expect(groupMemberships.length).toEqual(0);
});
it("should fail when group membership does not exist", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
createdById: user.id,
permission: null,
});
const document = await buildDocument({
collectionId: collection.id,
createdById: user.id,
teamId: user.teamId,
});
const group = await buildGroup({
teamId: user.teamId,
});
// Try to remove group that was never added
const res = await server.post("/api/documents.remove_group", user, {
body: {
id: document.id,
groupId: group.id,
},
});
expect(res.status).toEqual(404);
});
});
describe("#documents.memberships", () => {
let actor: User, document: Document;
beforeEach(async () => {
actor = await buildUser();
const collection = await buildCollection({
teamId: actor.teamId,
createdById: actor.id,
permission: null,
});
document = await buildDocument({
collectionId: collection.id,
createdById: actor.id,
teamId: actor.teamId,
});
});
it("should return members in document", async () => {
const members = await Promise.all([
buildUser({ teamId: actor.teamId }),
buildUser({ teamId: actor.teamId }),
]);
await Promise.all([
server.post("/api/documents.add_user", actor, {
body: {
id: document.id,
userId: members[0].id,
},
}),
server.post("/api/documents.add_user", actor, {
body: {
id: document.id,
userId: members[1].id,
},
}),
]);
const res = await server.post("/api/documents.memberships", actor, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.users.length).toEqual(2);
expect(body.data.users.map((u: User) => u.id).includes(members[0].id)).toBe(
true
);
expect(body.data.users.map((u: User) => u.id).includes(members[1].id)).toBe(
true
);
});
it("should allow filtering members in document by permission", async () => {
const members = await Promise.all([
buildUser({ teamId: actor.teamId }),
buildUser({ teamId: actor.teamId }),
]);
await Promise.all([
server.post("/api/documents.add_user", actor, {
body: {
id: document.id,
userId: members[0].id,
permission: DocumentPermission.ReadWrite,
},
}),
server.post("/api/documents.add_user", actor, {
body: {
id: document.id,
userId: members[1].id,
permission: DocumentPermission.Read,
},
}),
]);
const res = await server.post("/api/documents.memberships", actor, {
body: {
id: document.id,
permission: DocumentPermission.Read,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.users.length).toEqual(1);
expect(body.data.users[0].id).toEqual(members[1].id);
});
});
describe("#documents.duplicate", () => {
it("should require authentication", async () => {
const res = await server.post("/api/documents.duplicate");
expect(res.status).toEqual(401);
});
it("should duplicate a document with fullWidth property", async () => {
const user = await buildUser();
const document = await buildDocument({
userId: user.id,
teamId: user.teamId,
fullWidth: true,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.documents).toHaveLength(1);
expect(body.data.documents[0].fullWidth).toBe(true);
});
it("should duplicate child documents with fullWidth property when recursive=true", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const parent = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
fullWidth: true,
});
await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: collection.id,
parentDocumentId: parent.id,
fullWidth: true,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: parent.id,
recursive: true,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.documents).toHaveLength(2);
expect(body.data.documents[0].fullWidth).toBe(true);
expect(body.data.documents[1].fullWidth).toBe(true);
});
it("should allow duplicating from a read-only collection into a writable one", async () => {
const user = await buildUser();
const source = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.Read,
});
const destination = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: source.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
collectionId: destination.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.documents).toHaveLength(1);
expect(body.data.documents[0].collectionId).toEqual(destination.id);
});
it("should allow duplicating from a read-only collection under a writable parent", async () => {
const user = await buildUser();
const source = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.Read,
});
const destination = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: source.id,
});
const parent = await buildDocument({
teamId: user.teamId,
collectionId: destination.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
collectionId: destination.id,
parentDocumentId: parent.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.documents).toHaveLength(1);
expect(body.data.documents[0].parentDocumentId).toEqual(parent.id);
expect(body.data.documents[0].collectionId).toEqual(destination.id);
});
it("should not allow a collectionId that disagrees with the parent document", async () => {
const user = await buildUser();
const source = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.Read,
});
const destination = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: source.id,
});
const parent = await buildDocument({
teamId: user.teamId,
collectionId: destination.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
// deliberately mismatched with the parent's collection
collectionId: source.id,
parentDocumentId: parent.id,
},
});
const body = await res.json();
expect(res.status).toEqual(400);
expect(body.message).toEqual(
"collectionId must match the collection of the parent document"
);
});
it("should place the copy in the parent's collection when no collectionId is given", async () => {
const user = await buildUser();
const source = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.Read,
});
const destination = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: source.id,
});
const parent = await buildDocument({
teamId: user.teamId,
collectionId: destination.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
parentDocumentId: parent.id,
},
});
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.data.documents).toHaveLength(1);
expect(body.data.documents[0].collectionId).toEqual(destination.id);
expect(body.data.documents[0].parentDocumentId).toEqual(parent.id);
});
it("should not allow duplicating under a parent in a read-only collection", async () => {
const user = await buildUser();
const source = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.ReadWrite,
});
const destination = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.Read,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: source.id,
});
const parent = await buildDocument({
teamId: user.teamId,
collectionId: destination.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
parentDocumentId: parent.id,
},
});
expect(res.status).toEqual(403);
});
it("should not allow duplicating into a read-only collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.Read,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
expect(res.status).toEqual(403);
});
it("should not allow a viewer to duplicate", async () => {
const user = await buildViewer();
const collection = await buildCollection({
teamId: user.teamId,
permission: CollectionPermission.ReadWrite,
});
const document = await buildDocument({
teamId: user.teamId,
collectionId: collection.id,
});
const res = await server.post("/api/documents.duplicate", user, {
body: {
id: document.id,
collectionId: collection.id,
},
});
expect(res.status).toEqual(403);
});
});
describe("#documents.empty_trash", () => {
it("should require authentication", async () => {
const res = await server.post("/api/documents.empty_trash");
const body = await res.json();
expect(res.status).toEqual(401);
expect(body).toMatchSnapshot();
});
it("should allow admin users", async () => {
const user = await buildAdmin();
const res = await server.post("/api/documents.empty_trash", user);
const body = await res.json();
expect(res.status).toEqual(200);
expect(body.success).toEqual(true);
});
it("should not allow non-admin users", async () => {
const user = await buildUser();
const res = await server.post("/api/documents.empty_trash", user);
const body = await res.json();
expect(res.status).toEqual(403);
expect(body).toMatchSnapshot();
});
});
describe("#documents.documents", () => {
it("should return document tree for a document in a collection", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const parent = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const child1 = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
parentDocumentId: parent.id,
title: "Child 1",
});
const child2 = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
parentDocumentId: parent.id,
title: "Child 2",
});
const res = await server.post("/api/documents.documents", user, {
body: {
id: parent.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.id).toBe(parent.id);
const childIds = body.data.children.map((node: { id: string }) => node.id);
expect(childIds).toContain(child1.id);
expect(childIds).toContain(child2.id);
});
it("should have empty children nodes if document has no children", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const parent = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.documents", user, {
body: {
id: parent.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data.id).toBe(parent.id);
expect(body.data.children.length).toBe(0);
});
it("should return undefined if document is not part of a collection", async () => {
const user = await buildUser();
const doc = await buildDocument({
userId: user.id,
teamId: user.teamId,
collectionId: null,
});
const res = await server.post("/api/documents.documents", user, {
body: {
id: doc.id,
},
});
const body = await res.json();
expect(res.status).toBe(200);
expect(body.data).toBeUndefined();
});
it("should require authentication", async () => {
const user = await buildUser();
const collection = await buildCollection({
userId: user.id,
teamId: user.teamId,
});
const parent = await buildDocument({
userId: user.id,
collectionId: collection.id,
teamId: user.teamId,
});
const res = await server.post("/api/documents.documents", {
body: {
id: parent.id,
},
});
const body = await res.json();
expect(res.status).toBe(401);
expect(body).toMatchSnapshot();
});
it("should return 403 if user does not have access to the document", async () => {
const user = await buildUser();
const otherUser = await buildUser();
const collection = await buildCollection({
userId: otherUser.id,
teamId: otherUser.teamId,
permission: null,
});
const parent = await buildDocument({
userId: otherUser.id,
collectionId: collection.id,
teamId: otherUser.teamId,
});
const res = await server.post("/api/documents.documents", user, {
body: {
id: parent.id,
},
});
const body = await res.json();
expect(res.status).toBe(403);
expect(body).toMatchSnapshot();
});
});