Files

2320 lines
62 KiB
TypeScript

import path from "node:path";
import fractionalIndex from "fractional-index";
import fs from "fs-extra";
import invariant from "invariant";
import contentDisposition from "content-disposition";
import Router from "@koa/router";
import { escapeRegExp, has, remove, uniq } from "es-toolkit/compat";
import mime from "mime-types";
import type { Order, ScopeOptions, WhereOptions } from "sequelize";
import type { Filter } from "@shared/helpers/FilterHelper";
import { Op, Sequelize } from "sequelize";
import { randomUUID } from "node:crypto";
import type { DirectionFilter, SortFilter } from "@shared/types";
import { type NavigationNode } from "@shared/types";
import {
DocumentPermission,
ExportContentType,
FileOperationFormat,
StatusFilter,
UserRole,
} from "@shared/types";
import { subtractDate } from "@shared/utils/date";
import slugify from "@server/utils/slugify";
import { Day } from "@shared/utils/time";
import documentCreator, {
authorizeDocumentCreate,
authorizeDocumentPublish,
} from "@server/commands/documentCreator";
import documentDuplicator from "@server/commands/documentDuplicator";
import documentLoader from "@server/commands/documentLoader";
import documentMover from "@server/commands/documentMover";
import documentPermanentDeleter from "@server/commands/documentPermanentDeleter";
import documentRestorer from "@server/commands/documentRestorer";
import documentUpdater from "@server/commands/documentUpdater";
import env from "@server/env";
import {
InvalidRequestError,
AuthenticationError,
ValidationError,
IncorrectEditionError,
NotFoundError,
} from "@server/errors";
import auth from "@server/middlewares/authentication";
import multipart from "@server/middlewares/multipart";
import { rateLimiter } from "@server/middlewares/rateLimiter";
import { transaction } from "@server/middlewares/transaction";
import validate from "@server/middlewares/validate";
import {
Attachment,
Relationship,
Collection,
Document,
DocumentInsight,
Event,
SearchQuery,
Template,
User,
View,
UserMembership,
Group,
GroupUser,
GroupMembership,
FileOperation,
} from "@server/models";
import { SearchQuerySource } from "@server/models/SearchQuery";
import AttachmentHelper from "@server/models/helpers/AttachmentHelper";
import { DocumentHelper } from "@server/models/helpers/DocumentHelper";
import {
authorizeFilterFields,
buildWhere,
collectEqValues,
combineFilters,
expandDocumentIdInFilter,
extractTopLevelEqValue,
hasFieldInFilter,
legacyParamsToFilter,
mapFilterFields,
} from "@server/models/helpers/Filters";
import HTMLHelper from "@server/models/helpers/HTMLHelper";
import { ProsemirrorHelper } from "@server/models/helpers/ProsemirrorHelper";
import TextBundleHelper from "@server/models/helpers/TextBundleHelper";
import SearchProviderManager from "@server/utils/SearchProviderManager";
import { TextHelper } from "@server/models/helpers/TextHelper";
import { authorize, cannot } from "@server/policies";
import {
presentDocument,
presentDocumentInsight,
presentDocuments,
presentPolicies,
presentTemplate,
presentMembership,
presentUser,
presentGroupMembership,
presentGroup,
presentFileOperation,
} from "@server/presenters";
import DocumentImportTask from "@server/queues/tasks/DocumentImportTask";
import EmptyTrashTask from "@server/queues/tasks/EmptyTrashTask";
import FileStorage from "@server/storage/files";
import type { APIContext } from "@server/types";
import { RateLimiterStrategy } from "@server/utils/RateLimiter";
import { convertBareUrlsToEmbedMarkdown } from "@server/utils/embeds";
import { streamZipResponse } from "@server/utils/koa";
import { QueryHelper } from "@server/storage/QueryHelper";
import { getTeamFromContext } from "@server/utils/passport";
import pagination, { paginateQuery } from "../middlewares/pagination";
import * as T from "./schema";
import {
loadPublicShare,
getAllIdsInSharedTree,
} from "@server/commands/shareLoader";
const router = new Router();
/**
* Resolve every `documentId` leaf in a search filter to an `id in [...]` leaf
* containing the document and all of its descendants. When a user is given,
* each referenced document is authorized for read access. In share contexts
* the expansion is only scoped to the share's team — results are constrained
* to the share's own document subtree by the provider, so no per-document
* authorization is needed.
*
* @param filter the search filter to transform.
* @param context the user performing the search, or the share's team scope.
* @returns the filter with documentId leaves expanded, or the original filter
* if none are present.
*/
async function expandDocumentIdLeaves(
filter: Filter,
context: { user: User } | { teamId: string }
): Promise<Filter> {
const documentIds = uniq(collectEqValues(filter, "documentId"));
if (documentIds.length === 0) {
return filter;
}
const expandedIds = new Map<string, string[]>();
await Promise.all(
documentIds.map(async (documentId) => {
if ("user" in context) {
const document = await Document.findByPk(documentId, {
userId: context.user.id,
});
authorize(context.user, "read", document);
expandedIds.set(documentId, [
documentId,
...(await document.findAllChildDocumentIds()),
]);
} else {
const document = await Document.unscoped().findOne({
where: { id: documentId, teamId: context.teamId },
});
expandedIds.set(
documentId,
document
? [documentId, ...(await document.findAllChildDocumentIds())]
: [documentId]
);
}
})
);
return expandDocumentIdInFilter(filter, expandedIds);
}
/**
* Build the visibility clauses for drafts: a draft is only ever visible to its
* creator or to a user with a user or group membership on it. List endpoints
* that can return drafts route through this so the invariant lives in one place.
*
* @param user the user the drafts must be visible to.
* @returns an array of OR-able Sequelize conditions.
*/
async function draftVisibilityClauses(user: User): Promise<WhereOptions[]> {
return [
{ createdById: user.id },
{ id: await Document.membershipDocumentIds(user.id) },
];
}
router.post(
"documents.list",
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
auth(),
pagination(),
validate(T.DocumentsListSchema),
async (ctx: APIContext<T.DocumentsListReq>) => {
const {
sort,
direction,
backlinkDocumentId,
parentDocumentId: legacyParentDocumentId,
userId: legacyUserId,
statusFilter,
filters: rawFilters,
} = ctx.input.body;
let { collectionId: legacyCollectionId } = ctx.input.body;
const { offset, limit } = ctx.state.pagination;
// always filter by the current team
const { user } = ctx.state.auth;
const where: WhereOptions<Document> & {
[Op.and]: WhereOptions<Document>[];
} = {
teamId: user.teamId,
[Op.and]: [
{
deletedAt: {
[Op.eq]: null,
},
},
],
};
// Resolve the parent document being targeted from either the legacy
// top-level param or the filters DSL, so the membership escape below
// applies in both cases. `isNull` leaves resolve to undefined here
// (no specific parent to authorize against).
const normalizedFilter = combineFilters(rawFilters);
const parentDocumentId =
legacyParentDocumentId ??
(normalizedFilter
? extractTopLevelEqValue(normalizedFilter, "parentDocumentId")
: undefined);
// Membership escape: if the caller is filtering by a parent document they
// are a direct member of (or have group membership to), bypass the default
// collection access check. Mirrors the prior behavior of pushing then
// removing the legacy collectionId predicate.
let collectionScopeDropped = false;
if (parentDocumentId) {
const [groupMembership, membership] = await Promise.all([
GroupMembership.findOne({
where: { documentId: parentDocumentId },
include: [
{
model: Group,
required: true,
include: [
{
model: GroupUser,
required: true,
where: { userId: user.id },
},
],
},
],
}),
UserMembership.findOne({
where: { userId: user.id, documentId: parentDocumentId },
}),
]);
if (groupMembership || membership) {
collectionScopeDropped = true;
legacyCollectionId = undefined;
}
}
// The schema rejects callers that combine `filters` with the deprecated
// top-level params, so exactly one of these is set.
const filter =
normalizedFilter ??
legacyParamsToFilter({
userId: legacyUserId,
collectionId: legacyCollectionId,
parentDocumentId: legacyParentDocumentId,
});
// Exclude archived docs by default. Suppressed when the caller targets a
// specific status, or when their filter already references archivedAt.
const filterIncludesArchivedAt =
filter !== undefined && hasFieldInFilter(filter, "archivedAt");
if (!statusFilter && !filterIncludesArchivedAt) {
where[Op.and].push({ archivedAt: { [Op.eq]: null } });
}
// Sort=index needs the collection's documentStructure for ordering and
// pagination. Only meaningful when the filter targets a single collection.
let documentIds: string[] = [];
let collection: Collection | null | undefined;
const explicitCollectionId =
filter !== undefined
? extractTopLevelEqValue(filter, "collectionId")
: undefined;
if (explicitCollectionId && sort === "index") {
collection = await Collection.findByPk(explicitCollectionId, {
userId: user.id,
includeDocumentStructure: true,
});
authorize(user, "readDocument", collection);
documentIds = (collection.documentStructure || [])
.slice(offset, offset + limit)
.map((node) => node.id);
where[Op.and].push({ id: documentIds });
}
// Apply filter and re-run authorize() for any auth-bearing fields. The
// public-API `documentId` field is renamed to the underlying `id` column;
// `userId` is handled inside `buildWhere` (maps to `collaboratorIds`).
if (filter) {
await authorizeFilterFields(user, filter, {
collections: collection ? [collection] : undefined,
});
const mapped = mapFilterFields(filter, { documentId: "id" });
where[Op.and].push(buildWhere<Document>(mapped));
}
if (!backlinkDocumentId && !collectionScopeDropped) {
const collectionIds = await user.collectionIds();
where[Op.and].push({
[Op.or]: [
{ collectionId: collectionIds },
{ collectionId: null, createdById: user.id },
],
});
}
if (backlinkDocumentId) {
const sourceDocumentIds = await Relationship.findSourceDocumentIdsForUser(
backlinkDocumentId,
user
);
where[Op.and].push({ id: sourceDocumentIds });
// For safety, ensure the collectionId is not set in the query.
remove(where[Op.and], (cond) => has(cond, "collectionId"));
}
// A filter referencing publishedAt can surface drafts (the replacement
// for the deprecated statusFilter=draft). Drafts are only ever visible to
// their creator or users with a direct membership — enforce that here,
// mirroring the legacy statusFilter path below.
const filterIncludesDrafts =
!statusFilter &&
filter !== undefined &&
hasFieldInFilter(filter, "publishedAt");
if (filterIncludesDrafts) {
where[Op.and].push({
[Op.or]: [
{ publishedAt: { [Op.ne]: null } },
...(await draftVisibilityClauses(user)),
],
});
}
const statusQuery = [];
if (statusFilter?.includes(StatusFilter.Published)) {
statusQuery.push({
[Op.and]: [
{
publishedAt: {
[Op.ne]: null,
},
archivedAt: {
[Op.eq]: null,
},
},
],
});
}
if (statusFilter?.includes(StatusFilter.Draft)) {
statusQuery.push({
[Op.and]: [
{
publishedAt: {
[Op.eq]: null,
},
archivedAt: {
[Op.eq]: null,
},
[Op.or]: await draftVisibilityClauses(user),
},
],
});
}
if (statusFilter?.includes(StatusFilter.Archived)) {
statusQuery.push({
archivedAt: {
[Op.ne]: null,
},
});
}
if (statusQuery.length) {
where[Op.and].push({
[Op.or]: statusQuery,
});
}
// When sorting by index, use array_position to sort by the document order
// in the collection structure directly in SQL, enabling correct pagination
const orderClause =
sort === "index"
? documentIds.length > 0
? [
[
Sequelize.literal(
`array_position(ARRAY[:documentIds]::uuid[], "document"."id")`
),
direction,
],
]
: undefined
: [[sort, direction]];
const includeDrafts =
!!statusFilter?.includes(StatusFilter.Draft) || filterIncludesDrafts;
// The withDrafts scope drops the defaultScope filters, so re-apply the
// ones we still want — templates and trial-import documents should never
// appear in this listing.
if (includeDrafts) {
where[Op.and].push({
template: false,
sourceMetadata: { trial: { [Op.is]: null } },
});
}
// When sorting by index, pagination is already handled by slicing documentIds,
// so we skip the SQL-level offset to avoid double-pagination
const { results: documents, pagination } = await paginateQuery(
ctx,
({ offset: queryOffset, limit: queryLimit }) =>
Document.withMembershipScope(user.id, { includeDrafts }).findAll({
where,
order: orderClause as Order,
offset: sort === "index" ? 0 : queryOffset,
limit: queryLimit,
replacements: {
documentIds,
},
}),
// The membership includes are LEFT JOINs that never filter rows, so
// the total can be counted without them.
() =>
(includeDrafts
? Document.unscoped()
: Document.scope("defaultScope")
).count({ where })
);
const data = await presentDocuments(ctx, documents);
const policies = presentPolicies(user, documents);
ctx.body = {
pagination,
data,
policies,
};
}
);
router.post(
"documents.archived",
auth({ role: UserRole.Member }),
pagination(),
validate(T.DocumentsArchivedSchema),
async (ctx: APIContext<T.DocumentsArchivedReq>) => {
const { sort, direction, collectionId } = ctx.input.body;
const { user } = ctx.state.auth;
if (sort === "index") {
throw ValidationError(
"Sorting archived documents by index is not supported"
);
}
let where: WhereOptions<Document> = {
teamId: user.teamId,
archivedAt: {
[Op.ne]: null,
},
};
// if a specific collection is passed then we need to check auth to view it
if (collectionId) {
where = { ...where, collectionId };
const collection = await Collection.findByPk(collectionId, {
userId: user.id,
});
authorize(user, "readDocument", collection);
// otherwise, filter by all collections the user has access to
} else {
const collectionIds = await user.collectionIds();
where = {
...where,
collectionId: collectionIds,
};
}
const documents = await Document.withMembershipScope(user.id).findAll({
where,
order: [[sort, direction]],
offset: ctx.state.pagination.offset,
limit: ctx.state.pagination.limit,
});
const data = await presentDocuments(ctx, documents);
const policies = presentPolicies(user, documents);
ctx.body = {
pagination: ctx.state.pagination,
data,
policies,
};
}
);
router.post(
"documents.deleted",
auth({ role: UserRole.Member }),
pagination(),
validate(T.DocumentsDeletedSchema),
async (ctx: APIContext<T.DocumentsDeletedReq>) => {
const { sort, direction, filters: rawFilters } = ctx.input.body;
const { user } = ctx.state.auth;
const collectionIds = await user.collectionIds({
paranoid: false,
});
const membershipScope: Readonly<ScopeOptions> = {
method: ["withMembership", user.id],
};
const viewScope: Readonly<ScopeOptions> = {
method: ["withViews", user.id],
};
const where: WhereOptions<Document> & {
[Op.and]: WhereOptions<Document>[];
} = {
teamId: user.teamId,
deletedAt: {
[Op.ne]: null,
},
[Op.and]: [
{
[Op.or]: [
{
collectionId: {
[Op.in]: collectionIds,
},
},
{
createdById: user.id,
collectionId: {
[Op.is]: null,
},
},
],
},
{
[Op.or]: [
{ publishedAt: { [Op.ne]: null } },
...(await draftVisibilityClauses(user)),
],
},
],
};
const filter = combineFilters(rawFilters);
if (filter) {
await authorizeFilterFields(user, filter);
where[Op.and].push(buildWhere<Document>(filter));
}
const documents = await Document.scope([
membershipScope,
viewScope,
"withDrafts",
]).findAll({
where,
paranoid: false,
order: [[sort, direction]],
offset: ctx.state.pagination.offset,
limit: ctx.state.pagination.limit,
});
const data = await presentDocuments(ctx, documents);
const policies = presentPolicies(user, documents);
ctx.body = {
pagination: ctx.state.pagination,
data,
policies,
};
}
);
router.post(
"documents.viewed",
auth(),
pagination(),
validate(T.DocumentsViewedSchema),
async (ctx: APIContext<T.DocumentsViewedReq>) => {
const { sort, direction } = ctx.input.body;
const { user } = ctx.state.auth;
const viewIds = await View.findAccessibleIds(user, {
sort,
direction,
offset: ctx.state.pagination.offset,
limit: ctx.state.pagination.limit,
});
const views = viewIds.length
? await View.findAll({
where: {
id: viewIds,
},
order: [[sort, direction]],
include: [
{
model: Document.scope([
"withDrafts",
"withoutStateOrText",
{ method: ["withMembership", user.id] },
]),
required: true,
},
],
})
: [];
const documents = views.map((view) => {
const document = view.document;
document.views = [view];
return document;
});
const data = await presentDocuments(ctx, documents);
const policies = presentPolicies(user, documents);
ctx.body = {
pagination: ctx.state.pagination,
data,
policies,
};
}
);
router.post(
"documents.drafts",
auth(),
pagination(),
validate(T.DocumentsDraftsSchema),
async (ctx: APIContext<T.DocumentsDraftsReq>) => {
const { collectionId, dateFilter, direction, sort } = ctx.input.body;
const { user } = ctx.state.auth;
if (collectionId) {
const collection = await Collection.findByPk(collectionId, {
userId: user.id,
});
authorize(user, "readDocument", collection);
}
const collectionIds = collectionId
? [collectionId]
: await user.collectionIds();
const where: WhereOptions = {
teamId: user.teamId,
createdById: user.id,
collectionId: {
[Op.or]: [{ [Op.in]: collectionIds }, { [Op.is]: null }],
},
publishedAt: {
[Op.is]: null,
},
};
if (dateFilter) {
where.updatedAt = {
[Op.gte]: subtractDate(new Date(), dateFilter),
};
} else {
delete where.updatedAt;
}
const documents = await Document.withMembershipScope(user.id, {
includeDrafts: true,
}).findAll({
where,
order: [[sort, direction]],
offset: ctx.state.pagination.offset,
limit: ctx.state.pagination.limit,
});
const data = await presentDocuments(ctx, documents);
const policies = presentPolicies(user, documents);
ctx.body = {
pagination: ctx.state.pagination,
data,
policies,
};
}
);
router.post(
"documents.info",
auth({ optional: true }),
validate(T.DocumentsInfoSchema),
async (ctx: APIContext<T.DocumentsInfoReq>) => {
const { id, shareId } = ctx.input.body;
const { user } = ctx.state.auth;
const apiVersion = getAPIVersion(ctx);
let document: Document | null;
let serializedDocument: Record<string, unknown> | undefined;
let isPublic = false;
if (shareId) {
const teamFromCtx = await getTeamFromContext(ctx, {
includeOAuthState: false,
});
const result = await loadPublicShare({
id: shareId,
documentId: id,
teamId: teamFromCtx?.id,
});
document = result.document;
if (!document) {
throw NotFoundError("Document could not be found for shareId");
}
const { sharedTree } = result;
const [scopedDocument, backlinkIds] = await Promise.all([
// reload with membership scope if user is authenticated
user
? Document.findByPk(document.id, {
userId: user.id,
rejectOnEmpty: true,
})
: document,
// Get backlinks that are within the shared tree
sharedTree
? Relationship.findSourceDocumentIdsInSharedTree(
document.id,
getAllIdsInSharedTree(sharedTree)
)
: undefined,
]);
document = scopedDocument;
isPublic = cannot(user, "read", document);
serializedDocument = await presentDocument(ctx, document, {
isPublic,
shareId,
includeUpdatedAt: result.share.showLastUpdated,
backlinkIds,
});
} else {
if (!user) {
throw AuthenticationError("Authentication required");
}
document = await documentLoader({
id: id!, // validation ensures id will be present here
user,
});
serializedDocument = await presentDocument(ctx, document);
}
ctx.body = {
// Passing apiVersion=2 has a single effect, to change the response payload to
// include top level keys for document.
data:
apiVersion >= 2
? {
document: serializedDocument,
}
: serializedDocument,
policies: isPublic ? undefined : presentPolicies(user, [document]),
};
}
);
router.post(
"documents.insights",
auth(),
validate(T.DocumentsInsightsSchema),
async (ctx: APIContext<T.DocumentsInsightsReq>) => {
const { id, startDate, endDate } = ctx.input.body;
const { user } = ctx.state.auth;
const document = await Document.findByPk(id, {
userId: user.id,
includeContent: false,
});
authorize(user, "listViews", document);
if (!document.insightsEnabled) {
throw ValidationError("Insights are not enabled for this document");
}
const end = endDate ?? new Date();
const start = startDate ?? new Date(end.getTime() - 30 * Day.ms);
const insights = await DocumentInsight.findAll({
where: {
documentId: document.id,
date: {
[Op.gte]: start.toISOString().slice(0, 10),
[Op.lte]: end.toISOString().slice(0, 10),
},
},
order: [["date", "ASC"]],
});
ctx.body = {
data: insights.map(presentDocumentInsight),
};
}
);
router.post(
"documents.users",
auth(),
pagination(),
validate(T.DocumentsUsersSchema),
async (ctx: APIContext<T.DocumentsUsersReq>) => {
const { id, userId, query } = ctx.input.body;
const actor = ctx.state.auth.user;
const document = await Document.findByPk(id, {
userId: actor.id,
includeContent: false,
});
authorize(actor, "read", document);
authorize(actor, "listUsers", actor.team);
let where: WhereOptions<User> = {
teamId: document.teamId,
suspendedAt: {
[Op.is]: null,
},
};
const [collection, memberIds, collectionMemberIds] = await Promise.all([
document.$get("collection"),
Document.membershipUserIds(document.id),
document.collectionId
? Collection.membershipUserIds(document.collectionId)
: [],
]);
where = {
...where,
[Op.or]: [
{
id: {
[Op.in]: uniq([...memberIds, ...collectionMemberIds]),
},
},
collection?.permission
? {
role: {
[Op.ne]: UserRole.Guest,
},
}
: {},
],
};
if (query) {
where = {
...where,
[Op.and]: [
Sequelize.literal(
`unaccent(LOWER(name)) like unaccent(LOWER(:query))`
),
],
};
}
if (userId) {
where = {
...where,
id: userId,
};
}
const replacements = { query: QueryHelper.likeContains(query ?? "") };
const { results: users, pagination } = await paginateQuery<User>(
ctx,
(opts) => User.findAll({ where, replacements, ...opts }),
() =>
User.count({
where,
replacements,
}) as unknown as Promise<number>
);
ctx.body = {
pagination,
data: users.map((user) => presentUser(user)),
policies: presentPolicies(actor, users),
};
}
);
router.post(
"documents.documents",
auth(),
validate(T.DocumentsChildrenSchema),
async (ctx: APIContext<T.DocumentsChildrenReq>) => {
const { id } = ctx.input.body;
const { user } = ctx.state.auth;
const document = await Document.findByPk(id, {
userId: user.id,
includeContent: false,
});
authorize(user, "read", document);
let documentTree: NavigationNode | undefined;
if (document.collectionId) {
const collection = await Collection.findByPk(document.collectionId, {
includeDocumentStructure: true,
});
documentTree = collection?.getDocumentTree(document.id) ?? undefined;
}
ctx.body = {
data: documentTree,
};
}
);
router.post(
"documents.export",
rateLimiter(RateLimiterStrategy.TwentyFivePerMinute),
auth(),
validate(T.DocumentsExportSchema),
async (ctx: APIContext<T.DocumentsExportReq>) => {
const { id, signedUrls, includeChildDocuments } = ctx.input.body;
const { user } = ctx.state.auth;
const accept = ctx.request.headers["accept"];
const document = await documentLoader({
id,
user,
// We need the collaborative state to generate HTML, but not for the
// formats that are written from markdown.
includeState: !(
accept?.includes("text/markdown") ||
accept?.includes(ExportContentType.TextBundle)
),
});
authorize(user, "download", document);
const format = accept?.includes("text/html")
? FileOperationFormat.HTMLZip
: accept?.includes("text/markdown")
? FileOperationFormat.MarkdownZip
: accept?.includes(ExportContentType.TextBundle)
? FileOperationFormat.TextBundleZip
: accept?.includes("application/pdf")
? FileOperationFormat.PDF
: null;
if (format === FileOperationFormat.PDF) {
throw IncorrectEditionError(
"PDF export is not available in the community edition"
);
}
if (includeChildDocuments) {
if (!format) {
throw InvalidRequestError(
"format needed for exporting nested documents"
);
}
const fileOperation = await FileOperation.createExport(ctx, {
document,
format,
});
ctx.body = {
success: true,
data: {
fileOperation: presentFileOperation(fileOperation),
},
};
return;
}
let contentType: string;
let content: string;
const toMarkdown = async () =>
DocumentHelper.toMarkdown(document, {
signedUrls,
teamId: user.teamId,
commonMark: true,
});
// A TextBundle is a directory of files, so unlike the other formats it has
// no self-contained single-file form to fall back to.
const isTextBundle = format === FileOperationFormat.TextBundleZip;
if (format === FileOperationFormat.HTMLZip) {
contentType = "text/html";
content = await DocumentHelper.toHTML(document, {
centered: true,
includeMermaid: true,
});
} else if (isTextBundle || format === FileOperationFormat.MarkdownZip) {
contentType = "text/markdown";
content = await toMarkdown();
} else {
ctx.body = {
data: await toMarkdown(),
};
return;
}
// Override the extension for Markdown as it's incorrect in the mime-types
// library until a new release > 2.1.35
const extension =
contentType === "text/markdown" ? "md" : mime.extension(contentType);
const fileName = slugify(document.displayTitle);
const attachmentIds = ProsemirrorHelper.parseAttachmentIds(
DocumentHelper.toProsemirror(document)
);
const attachments = attachmentIds.length
? await Attachment.findAll({
where: {
teamId: document.teamId,
id: attachmentIds,
},
})
: [];
// Read attachments and, when exporting HTML, inline small images that are
// referenced a single time as base64 data URIs. Any remaining attachments
// are bundled alongside the document in a zip.
const externalAttachments: { attachment: Attachment; buffer: Buffer }[] =
[];
for (const attachment of attachments) {
const buffer = await AttachmentHelper.readBuffer(attachment);
if (contentType === "text/html") {
const inlined = HTMLHelper.inlineImage(
content,
attachment.redirectUrl,
attachment.contentType,
buffer
);
if (inlined !== null) {
content = inlined;
continue;
}
}
externalAttachments.push({ attachment, buffer });
}
if (isTextBundle) {
const root = `${fileName}.${TextBundleHelper.bundleExtension}`;
const usedAssetNames = new Set<string>();
streamZipResponse(
ctx,
`${fileName}.${TextBundleHelper.packExtension}`,
(zip) => {
for (const { attachment, buffer } of externalAttachments) {
const reference = TextBundleHelper.assetPath(
attachment.name,
usedAssetNames
);
zip.addBuffer(buffer, path.join(root, reference), {
mtime: attachment.updatedAt,
});
content = content.replace(
new RegExp(escapeRegExp(attachment.redirectUrl), "g"),
encodeURI(reference)
);
}
zip.addBuffer(
Buffer.from(TextBundleHelper.info(document)),
path.join(root, TextBundleHelper.infoFileName),
{ mtime: document.updatedAt }
);
zip.addBuffer(
Buffer.from(content),
path.join(root, TextBundleHelper.textFileName),
{ mtime: document.updatedAt }
);
}
);
return;
}
// When there are no external attachments the document is self-contained and
// can be served directly rather than bundled in a zip.
if (externalAttachments.length === 0) {
ctx.set("Content-Type", contentType);
ctx.set(
"Content-Disposition",
contentDisposition(`${fileName}.${extension}`, {
type: "attachment",
})
);
ctx.body = content;
return;
}
streamZipResponse(ctx, `${fileName}.zip`, (zip) => {
for (const { attachment, buffer } of externalAttachments) {
const location = path.join(
"attachments",
`${attachment.id}.${mime.extension(attachment.contentType)}`
);
zip.addBuffer(buffer, location, { mtime: attachment.updatedAt });
content = content.replace(
new RegExp(escapeRegExp(attachment.redirectUrl), "g"),
location
);
}
zip.addBuffer(Buffer.from(content), `${fileName}.${extension}`, {
mtime: document.updatedAt,
});
});
}
);
router.post(
"documents.restore",
auth({ role: UserRole.Member }),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsRestoreSchema),
transaction(),
async (ctx: APIContext<T.DocumentsRestoreReq>) => {
const { id, collectionId, revisionId } = ctx.input.body;
const { user } = ctx.state.auth;
const { transaction } = ctx.state;
const document = await Document.findByPk(id, {
userId: user.id,
paranoid: false,
transaction,
});
authorize(user, "read", document);
await documentRestorer(ctx, { document, collectionId, revisionId });
ctx.body = {
data: await presentDocument(ctx, document),
policies: presentPolicies(user, [document]),
};
}
);
router.post(
"documents.search_titles",
auth(),
pagination(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsSearchTitlesSchema),
async (ctx: APIContext<T.DocumentsSearchTitlesReq>) => {
const { query, sort, direction, filters: rawFilters } = ctx.input.body;
const { collectionId, userId, documentId, statusFilter, dateFilter } =
ctx.input.body;
const { offset, limit } = ctx.state.pagination;
const { user } = ctx.state.auth;
const filter =
combineFilters(rawFilters) ??
legacyParamsToFilter({
collectionId,
userId,
documentId,
statusFilter,
dateFilter,
});
if (filter) {
await authorizeFilterFields(user, filter);
}
const resolvedFilter = filter
? await expandDocumentIdLeaves(filter, { user })
: undefined;
const documents =
await SearchProviderManager.getProvider().searchTitlesForUser(user, {
query,
filter: resolvedFilter,
offset,
limit,
sort: sort as SortFilter,
direction: direction as DirectionFilter,
});
const policies = presentPolicies(user, documents);
const data = await presentDocuments(ctx, documents);
ctx.body = {
pagination: ctx.state.pagination,
data,
policies,
};
}
);
router.post(
"documents.search",
auth({ optional: true }),
pagination(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsSearchSchema),
async (ctx: APIContext<T.DocumentsSearchReq>) => {
const {
query,
shareId,
snippetMinWords,
snippetMaxWords,
sort,
direction,
filters: rawFilters,
} = ctx.input.body;
const { collectionId, documentId, userId, dateFilter, statusFilter } =
ctx.input.body;
const filter =
combineFilters(rawFilters) ??
legacyParamsToFilter({
collectionId,
userId,
documentId,
statusFilter,
dateFilter,
});
const { offset, limit } = ctx.state.pagination;
const { user } = ctx.state.auth;
let teamId;
let response;
let share;
let isPublic = false;
const searchStartedAt = Date.now();
if (shareId) {
const teamFromCtx = await getTeamFromContext(ctx, {
includeOAuthState: false,
});
const result = await loadPublicShare({
id: shareId,
teamId: teamFromCtx?.id,
});
share = result.share;
const { collection, document } = result; // One of collection or document should be available
if (share.documentId && !share?.includeChildDocuments) {
throw InvalidRequestError("Child documents cannot be searched");
}
teamId = share.teamId;
const team = share.team;
invariant(team, "Share must belong to a team");
const shareScopeId = collection?.id || document?.collectionId;
const shareFilter = combineFilters([
...(filter ? [filter] : []),
...(shareScopeId
? [
{
field: "collectionId",
operator: "eq" as const,
value: shareScopeId,
},
]
: []),
]);
const [resolvedShareFilter, scopedCollection, scopedDocument] =
await Promise.all([
shareFilter
? expandDocumentIdLeaves(shareFilter, { teamId: share.teamId })
: undefined,
// reload with membership scope if user is authenticated
user && collection
? Collection.findByPk(collection.id, { userId: user.id })
: collection,
user && document
? Document.findByPk(document.id, { userId: user.id })
: document,
]);
isPublic = scopedCollection
? cannot(user, "read", scopedCollection)
: cannot(user, "read", scopedDocument);
response = await SearchProviderManager.getProvider().searchForTeam(team, {
query,
filter: resolvedShareFilter,
share,
offset,
limit,
snippetMinWords,
snippetMaxWords,
sort: sort as SortFilter,
direction: direction as DirectionFilter,
usePopularityBoost: false,
});
} else {
if (!user) {
throw AuthenticationError("Authentication error");
}
teamId = user.teamId;
if (filter) {
await authorizeFilterFields(user, filter);
}
const resolvedFilter = filter
? await expandDocumentIdLeaves(filter, { user })
: undefined;
response = await SearchProviderManager.getProvider().searchForUser(user, {
query,
filter: resolvedFilter,
offset,
limit,
snippetMinWords,
snippetMaxWords,
sort: sort as SortFilter,
direction: direction as DirectionFilter,
});
}
const { results, total } = response;
const documents = results.map((result) => result.document);
const [data] = await Promise.all([
Promise.all(
results.map(async (result) => {
const document = await presentDocument(ctx, result.document, {
isPublic,
shareId,
});
return { ...result, document };
})
),
// When requesting subsequent pages of search results we don't want to record
// duplicate search query records
query && offset === 0
? SearchQuery.record({
userId: user?.id,
teamId,
shareId: share?.id,
// auth.type values are a subset of search sources; unauthenticated share searches default to "app"
source:
(ctx.state.auth.type as unknown as SearchQuerySource) ||
SearchQuerySource.App,
query,
results: total,
duration: Date.now() - searchStartedAt,
})
: undefined,
]);
ctx.body = {
pagination: { ...ctx.state.pagination, total },
data,
policies: user ? presentPolicies(user, documents) : null,
};
}
);
router.post(
"documents.templatize",
auth({ role: UserRole.Member }),
rateLimiter(RateLimiterStrategy.TwentyFivePerMinute),
validate(T.DocumentsTemplatizeSchema),
transaction(),
async (ctx: APIContext<T.DocumentsTemplatizeReq>) => {
const { id, collectionId, publish } = ctx.input.body;
const { user } = ctx.state.auth;
const { transaction } = ctx.state;
const original = await Document.findByPk(id, {
userId: user.id,
transaction,
});
authorize(user, "update", original);
if (collectionId) {
const collection = await Collection.findByPk(collectionId, {
userId: user.id,
transaction,
});
authorize(user, "createTemplate", collection);
} else {
authorize(user, "createTemplate", user.team);
}
const template = await Template.createWithCtx(ctx, {
editorVersion: original.editorVersion,
collectionId,
teamId: user.teamId,
publishedAt: publish ? new Date() : null,
lastModifiedById: user.id,
createdById: user.id,
icon: original.icon,
color: original.color,
title: original.title,
content: original.content,
});
// reload to get all of the data needed to present (user, collection etc)
const reloaded = await Template.findByPk(template.id, {
userId: user.id,
transaction,
});
invariant(reloaded, "template not found");
ctx.body = {
data: presentTemplate(reloaded),
policies: presentPolicies(user, [reloaded]),
};
}
);
router.post(
"documents.update",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsUpdateSchema),
transaction(),
async (ctx: APIContext<T.DocumentsUpdateReq>) => {
const { transaction } = ctx.state;
const { id, insightsEnabled, publish, collectionId, ...input } =
ctx.input.body;
const updatingDeprecatedReason =
input.deprecatedReason !== undefined &&
Object.keys(ctx.input.body).every(
(key) => key === "id" || key === "deprecatedReason"
);
const editorVersion = ctx.headers["x-editor-version"] as string | undefined;
const { user } = ctx.state.auth;
let collection: Collection | null | undefined;
let document = await Document.findByPk(id, {
userId: user.id,
includeState: true,
paranoid: !updatingDeprecatedReason,
transaction,
});
collection = document?.collection;
authorize(
user,
updatingDeprecatedReason ? "updateDeprecatedReason" : "update",
document
);
if (!updatingDeprecatedReason && input.deprecatedReason !== undefined) {
authorize(user, "updateDeprecatedReason", document);
}
if (collection && insightsEnabled !== undefined) {
authorize(user, "updateInsights", document);
}
if (publish) {
await authorizeDocumentPublish(ctx, document, collectionId);
}
if (input.templateId && input.templateId !== document.templateId) {
const template = await Template.findByPk(input.templateId, {
userId: user.id,
transaction,
});
authorize(user, "read", template);
}
document = await documentUpdater(ctx, {
document,
...input,
publish,
collectionId,
insightsEnabled,
editorVersion,
});
ctx.body = {
data: await presentDocument(ctx, document),
policies: presentPolicies(user, [document]),
};
}
);
router.post(
"documents.duplicate",
auth(),
rateLimiter(RateLimiterStrategy.TwentyFivePerMinute),
validate(T.DocumentsDuplicateSchema),
transaction(),
async (ctx: APIContext<T.DocumentsDuplicateReq>) => {
const { transaction } = ctx.state;
const { id, title, publish, recursive, collectionId, parentDocumentId } =
ctx.input.body;
const { user } = ctx.state.auth;
const document = await Document.findByPk(id, {
userId: user.id,
transaction,
});
authorize(user, "duplicate", document);
let collection: Collection | null | undefined;
if (parentDocumentId) {
const parent = await Document.findByPk(parentDocumentId, {
userId: user.id,
transaction,
});
authorize(user, "update", parent);
if (!parent.publishedAt) {
throw InvalidRequestError("Cannot duplicate document inside a draft");
}
if (collectionId && collectionId !== parent.collectionId) {
throw InvalidRequestError(
"collectionId must match the collection of the parent document"
);
}
// The copy is nested under the parent, so it belongs to the parent's
// collection.
collection = parent.collectionId
? await Collection.findByPk(parent.collectionId, {
userId: user.id,
transaction,
})
: undefined;
} else {
collection = collectionId
? await Collection.findByPk(collectionId, {
userId: user.id,
transaction,
})
: document?.collection;
// The copy is created in the destination collection, so create permission
// is required there rather than on the source.
if (collection) {
authorize(user, "createDocument", collection);
}
}
const response = await documentDuplicator(ctx, {
collection,
document,
title,
publish,
recursive,
parentDocumentId,
});
ctx.body = {
data: {
documents: await presentDocuments(ctx, response),
},
policies: presentPolicies(user, response),
};
}
);
router.post(
"documents.move",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsMoveSchema),
transaction(),
async (ctx: APIContext<T.DocumentsMoveReq>) => {
const { transaction } = ctx.state;
const { id, parentDocumentId, index } = ctx.input.body;
let collectionId = ctx.input.body.collectionId;
const { user } = ctx.state.auth;
const document = await Document.findByPk(id, {
userId: user.id,
transaction,
});
authorize(user, "move", document);
if (parentDocumentId) {
const parent = await Document.findByPk(parentDocumentId, {
userId: user.id,
transaction,
});
authorize(user, "update", parent);
collectionId = parent.collectionId;
if (!parent.publishedAt) {
throw InvalidRequestError("Cannot move document inside a draft");
}
} else if (collectionId) {
const collection = await Collection.findByPk(collectionId, {
userId: user.id,
transaction,
});
authorize(user, "updateDocument", collection);
} else {
throw InvalidRequestError("collectionId is required to move a document");
}
const { documents, collectionChanged } = await documentMover(ctx, {
document,
collectionId: collectionId ?? null,
parentDocumentId,
index,
});
ctx.body = {
data: {
documents: await presentDocuments(ctx, documents),
// Included for backwards compatibility
collections: [],
},
policies: collectionChanged ? presentPolicies(user, documents) : [],
};
}
);
router.post(
"documents.archive",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsArchiveSchema),
transaction(),
async (ctx: APIContext<T.DocumentsArchiveReq>) => {
const { id, reason } = ctx.input.body;
const { user } = ctx.state.auth;
const { transaction } = ctx.state;
const document = await Document.findByPk(id, {
userId: user.id,
rejectOnEmpty: true,
transaction,
});
authorize(user, "archive", document);
if (reason !== undefined) {
document.deprecatedReason = reason || null;
}
await document.archiveWithCtx(ctx);
ctx.body = {
data: await presentDocument(ctx, document),
policies: presentPolicies(user, [document]),
};
}
);
router.post(
"documents.delete",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsDeleteSchema),
transaction(),
async (ctx: APIContext<T.DocumentsDeleteReq>) => {
const { transaction } = ctx.state;
const { id, permanent, reason } = ctx.input.body;
const { user } = ctx.state.auth;
if (permanent) {
const document = await Document.findByPk(id, {
userId: user.id,
paranoid: false,
transaction,
});
authorize(user, "permanentDelete", document);
await documentPermanentDeleter([document]);
await Event.createFromContext(ctx, {
name: "documents.permanent_delete",
documentId: document.id,
collectionId: document.collectionId,
data: {
title: document.title,
},
});
} else {
const document = await Document.findByPk(id, {
userId: user.id,
transaction,
});
authorize(user, "delete", document);
if (reason !== undefined) {
document.deprecatedReason = reason || null;
}
await document.destroyWithCtx(ctx);
}
ctx.body = {
success: true,
};
}
);
router.post(
"documents.unpublish",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerMinute),
validate(T.DocumentsUnpublishSchema),
transaction(),
async (ctx: APIContext<T.DocumentsUnpublishReq>) => {
const { id, detach } = ctx.input.body;
const { user } = ctx.state.auth;
const document = await Document.findByPk(id, {
userId: user.id,
});
authorize(user, "unpublish", document);
await document.unpublishWithCtx(ctx, { detach });
ctx.body = {
data: await presentDocument(ctx, document),
policies: presentPolicies(user, [document]),
};
}
);
router.post(
"documents.import",
auth(),
rateLimiter(RateLimiterStrategy.TwentyFivePerMinute),
multipart({
maximumFileSize: env.FILE_STORAGE_IMPORT_MAX_SIZE,
optional: true,
}),
validate(T.DocumentsImportSchema),
async (ctx: APIContext<T.DocumentsImportReq>) => {
const { collectionId, parentDocumentId, publish, attachmentId } =
ctx.input.body;
const { user } = ctx.state.auth;
if (!attachmentId && !ctx.input.file) {
throw ValidationError("one of attachmentId or file is required");
}
const { collection } = await authorizeDocumentCreate(ctx, {
collectionId,
parentDocumentId,
});
let key: string;
let fileName: string;
let mimeType: string;
if (attachmentId) {
const attachment = await Attachment.findByPk(attachmentId);
authorize(user, "read", attachment);
key = attachment.key;
fileName = attachment.name;
mimeType = attachment.contentType;
} else {
const file = ctx.input.file!;
const buffer = await fs.readFile(file.filepath);
fileName = file.originalFilename ?? file.newFilename;
mimeType = file.mimetype ?? "";
key = AttachmentHelper.getKey({
id: randomUUID(),
name: fileName,
userId: user.id,
});
await FileStorage.store({
body: buffer,
contentType: mimeType,
contentLength: buffer.length,
key,
acl: "private",
});
}
const document = await DocumentImportTask.scheduleAndWait({
key,
sourceMetadata: {
fileName,
mimeType,
},
userId: user.id,
collectionId: collection?.id,
parentDocumentId,
publish,
authType: ctx.state.auth.type,
ip: ctx.request.ip,
});
ctx.body = {
data: await presentDocument(ctx, document),
policies: presentPolicies(user, [document]),
};
}
);
router.post(
"documents.create",
auth(),
rateLimiter(RateLimiterStrategy.TwentyFivePerMinute),
validate(T.DocumentsCreateSchema),
transaction(),
async (ctx: APIContext<T.DocumentsCreateReq>) => {
const {
id,
title,
text,
icon,
color,
publish,
index,
collectionId,
parentDocumentId,
fullWidth,
preferences,
templateId,
createdAt,
} = ctx.input.body;
const editorVersion = ctx.headers["x-editor-version"] as string | undefined;
const { transaction } = ctx.state;
const { user } = ctx.state.auth;
const { collection } = await authorizeDocumentCreate(ctx, {
collectionId,
parentDocumentId,
});
let template: Template | null | undefined;
if (templateId) {
template = await Template.findByPk(templateId, {
userId: user.id,
transaction,
});
authorize(user, "read", template);
}
// Pre-process text to convert bare embed URLs to markdown link format
const processedText = text ? convertBareUrlsToEmbedMarkdown(text) : text;
const document = await documentCreator(ctx, {
id,
title,
text: processedText
? await TextHelper.replaceImagesWithAttachments(
ctx,
processedText,
user
)
: processedText,
icon,
color,
createdAt,
publish,
index,
collectionId: collection?.id,
parentDocumentId,
template,
fullWidth,
preferences,
editorVersion,
});
if (collection) {
document.collection = collection;
}
ctx.body = {
data: await presentDocument(ctx, document),
policies: presentPolicies(user, [document]),
};
}
);
router.post(
"documents.add_user",
auth(),
validate(T.DocumentsAddUserSchema),
rateLimiter(RateLimiterStrategy.OneHundredPerHour),
transaction(),
async (ctx: APIContext<T.DocumentsAddUserReq>) => {
const { transaction } = ctx.state;
const { user: actor } = ctx.state.auth;
const { id, userId, permission } = ctx.input.body;
if (userId === actor.id) {
throw ValidationError("You cannot invite yourself");
}
const [document, user] = await Promise.all([
Document.findByPk(id, {
userId: actor.id,
rejectOnEmpty: true,
transaction,
}),
User.findByPk(userId, {
rejectOnEmpty: true,
transaction,
}),
]);
authorize(actor, "manageUsers", document);
authorize(actor, "read", user);
const UserMemberships = await UserMembership.findAll({
where: {
userId,
},
attributes: ["id", "index", "updatedAt"],
limit: 1,
order: [
// using LC_COLLATE:"C" because we need byte order to drive the sorting
// find only the first star so we can create an index before it
Sequelize.literal('"user_permission"."index" collate "C"'),
["updatedAt", "DESC"],
],
transaction,
});
// create membership at the beginning of their "Shared with me" section
const index = fractionalIndex(
null,
UserMemberships.length ? UserMemberships[0].index : null
);
let membership = await UserMembership.findOneForUpdate(
{ documentId: id, userId },
{ transaction }
);
if (membership) {
if (permission) {
membership.permission = permission;
// disconnect from the source if the permission is manually updated
membership.sourceId = null;
await membership.save(ctx.context);
}
} else {
membership = await UserMembership.create(
{
documentId: id,
userId,
index,
permission: permission || user.defaultDocumentPermission,
createdById: actor.id,
},
ctx.context
);
}
ctx.body = {
data: {
users: [presentUser(user)],
memberships: [presentMembership(membership)],
},
};
}
);
router.post(
"documents.remove_user",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerHour),
validate(T.DocumentsRemoveUserSchema),
transaction(),
async (ctx: APIContext<T.DocumentsRemoveUserReq>) => {
const { transaction } = ctx.state;
const { user: actor } = ctx.state.auth;
const { id, userId } = ctx.input.body;
const [document, user] = await Promise.all([
Document.findByPk(id, {
userId: actor.id,
rejectOnEmpty: true,
transaction,
}),
User.findByPk(userId, {
rejectOnEmpty: true,
transaction,
}),
]);
if (actor.id !== userId) {
authorize(actor, "manageUsers", document);
authorize(actor, "read", user);
}
const membership = await UserMembership.findOne({
where: {
documentId: id,
userId,
},
transaction,
lock: transaction.LOCK.UPDATE,
rejectOnEmpty: true,
});
if (membership.sourceId) {
throw ValidationError(
"Cannot remove access that is inherited from a parent document"
);
}
await membership.destroy(ctx.context);
ctx.body = {
success: true,
};
}
);
router.post(
"documents.add_group",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerHour),
validate(T.DocumentsAddGroupSchema),
transaction(),
async (ctx: APIContext<T.DocumentsAddGroupsReq>) => {
const { id, groupId, permission } = ctx.input.body;
const { transaction } = ctx.state;
const { user } = ctx.state.auth;
const [document, group] = await Promise.all([
Document.findByPk(id, {
userId: user.id,
rejectOnEmpty: true,
transaction,
}),
Group.findByPk(groupId, {
rejectOnEmpty: true,
transaction,
}),
]);
authorize(user, "manageUsers", document);
authorize(user, "read", group);
let membership = await GroupMembership.findOneForUpdate(
{ documentId: id, groupId },
{ transaction }
);
if (membership) {
if (permission) {
membership.permission = permission;
// disconnect from the source if the permission is manually updated
membership.sourceId = null;
await membership.save(ctx.context);
}
} else {
membership = await GroupMembership.create(
{
documentId: id,
groupId,
permission: permission ?? DocumentPermission.ReadWrite,
createdById: user.id,
},
ctx.context
);
}
ctx.body = {
data: {
groupMemberships: [presentGroupMembership(membership)],
},
};
}
);
router.post(
"documents.remove_group",
auth(),
rateLimiter(RateLimiterStrategy.OneHundredPerHour),
validate(T.DocumentsRemoveGroupSchema),
transaction(),
async (ctx: APIContext<T.DocumentsRemoveGroupReq>) => {
const { transaction } = ctx.state;
const { user } = ctx.state.auth;
const { id, groupId } = ctx.input.body;
const [document, group] = await Promise.all([
Document.findByPk(id, {
userId: user.id,
rejectOnEmpty: true,
transaction,
}),
Group.findByPk(groupId, {
rejectOnEmpty: true,
transaction,
}),
]);
authorize(user, "manageUsers", document);
authorize(user, "read", group);
const membership = await GroupMembership.findOne({
where: {
documentId: id,
groupId,
},
transaction,
lock: transaction.LOCK.NO_KEY_UPDATE,
rejectOnEmpty: true,
});
await membership.destroy(ctx.context);
ctx.body = {
success: true,
};
}
);
router.post(
"documents.memberships",
auth(),
pagination(),
validate(T.DocumentsMembershipsSchema),
async (ctx: APIContext<T.DocumentsMembershipsReq>) => {
const { id, query, permission } = ctx.input.body;
const { user: actor } = ctx.state.auth;
const document = await Document.findByPk(id, { userId: actor.id });
authorize(actor, "update", document);
let where: WhereOptions<UserMembership> = {
documentId: id,
};
let userWhere;
if (query) {
userWhere = {
name: { [Op.iLike]: QueryHelper.likeContains(query) },
};
}
if (permission) {
where = { ...where, permission };
}
const options = {
where,
include: [
{
model: User,
as: "user",
where: userWhere,
required: true,
},
],
};
const { results: memberships, pagination } = await paginateQuery(
ctx,
(opts) =>
UserMembership.findAll({
...options,
order: [["createdAt", "DESC"]],
...opts,
}),
() => UserMembership.count(options)
);
ctx.body = {
pagination,
data: {
memberships: memberships.map(presentMembership),
users: memberships.map((membership) => presentUser(membership.user)),
},
};
}
);
router.post(
"documents.group_memberships",
auth(),
pagination(),
validate(T.DocumentsMembershipsSchema),
async (ctx: APIContext<T.DocumentsMembershipsReq>) => {
const { id, query, permission } = ctx.input.body;
const { user } = ctx.state.auth;
const document = await Document.findByPk(id, { userId: user.id });
authorize(user, "update", document);
let where: WhereOptions<GroupMembership> = {
documentId: id,
};
let groupWhere;
if (query) {
groupWhere = {
name: { [Op.iLike]: QueryHelper.likeContains(query) },
};
}
if (permission) {
where = { ...where, permission };
}
const options = {
where,
include: [
{
model: Group,
as: "group",
where: groupWhere,
required: true,
},
],
};
const { results: memberships, pagination } = await paginateQuery(
ctx,
(opts) =>
GroupMembership.findAll({
...options,
order: [["createdAt", "DESC"]],
...opts,
}),
() => GroupMembership.count(options)
);
const groupMemberships = memberships.map(presentGroupMembership);
ctx.body = {
pagination,
data: {
groupMemberships,
groups: await Promise.all(
memberships.map((membership) => presentGroup(membership.group))
),
},
};
}
);
router.post(
"documents.empty_trash",
auth({ role: UserRole.Admin }),
rateLimiter(RateLimiterStrategy.TenPerHour),
async (ctx: APIContext) => {
const { user } = ctx.state.auth;
const collectionIds = await user.collectionIds({
paranoid: false,
});
const documents = await Document.scope("withDrafts").findAll({
attributes: ["id"],
where: {
deletedAt: {
[Op.ne]: null,
},
[Op.or]: [
{
collectionId: {
[Op.in]: collectionIds,
},
},
{
createdById: user.id,
collectionId: {
[Op.is]: null,
},
},
],
},
paranoid: false,
});
if (documents.length) {
await new EmptyTrashTask().schedule({
documentIds: documents.map((doc) => doc.id),
});
}
await Event.createFromContext(ctx, {
name: "documents.empty_trash",
});
ctx.body = {
success: true,
};
}
);
// Remove this helper once apiVersion is removed (#6175)
function getAPIVersion(ctx: APIContext) {
return Number(
ctx.headers["x-api-version"] ??
(typeof ctx.input.body === "object" &&
ctx.input.body &&
"apiVersion" in ctx.input.body &&
ctx.input.body.apiVersion) ??
0
);
}
export default router;