mirror of
https://github.com/outline/outline.git
synced 2026-11-22 05:51:43 +03:00
* perf: Use FOR NO KEY UPDATE where locked rows are only updated Rows that other tables reference by foreign key are now locked with FOR NO KEY UPDATE when the transaction only updates or soft-deletes them, so concurrent inserts that reference the row are not blocked. * test: Collaborative save does not wait for foreign key inserts
152 lines
4.0 KiB
TypeScript
152 lines
4.0 KiB
TypeScript
import Router from "@koa/router";
|
|
import { Op, type WhereOptions } from "sequelize";
|
|
import { UserRole } from "@shared/types";
|
|
import { ValidationError } from "@server/errors";
|
|
import auth from "@server/middlewares/authentication";
|
|
import { transaction } from "@server/middlewares/transaction";
|
|
import validate from "@server/middlewares/validate";
|
|
import { FileOperation, Team } from "@server/models";
|
|
import { authorize } from "@server/policies";
|
|
import { presentFileOperation, presentPolicies } from "@server/presenters";
|
|
import FileStorage from "@server/storage/files";
|
|
import type { APIContext } from "@server/types";
|
|
import pagination from "../middlewares/pagination";
|
|
import * as T from "./schema";
|
|
|
|
const router = new Router();
|
|
|
|
router.post(
|
|
"fileOperations.info",
|
|
auth(),
|
|
validate(T.FileOperationsInfoSchema),
|
|
async (ctx: APIContext<T.FileOperationsInfoReq>) => {
|
|
const { id } = ctx.input.body;
|
|
const { user } = ctx.state.auth;
|
|
|
|
const fileOperation = await FileOperation.findByPk(id, {
|
|
userId: user.id,
|
|
rejectOnEmpty: true,
|
|
});
|
|
|
|
authorize(user, "read", fileOperation);
|
|
|
|
ctx.body = {
|
|
data: presentFileOperation(fileOperation),
|
|
};
|
|
}
|
|
);
|
|
|
|
router.post(
|
|
"fileOperations.list",
|
|
auth({ role: UserRole.Admin }),
|
|
pagination(),
|
|
validate(T.FileOperationsListSchema),
|
|
async (ctx: APIContext<T.FileOperationsListReq>) => {
|
|
const { direction, sort, type } = ctx.input.body;
|
|
const { user } = ctx.state.auth;
|
|
|
|
const where: WhereOptions<FileOperation> = {
|
|
teamId: user.teamId,
|
|
type,
|
|
// Exclude operations on the personal collections of other users.
|
|
[Op.and]: [
|
|
{
|
|
[Op.or]: [
|
|
{ "$collection.ownerId$": null },
|
|
{ "$collection.ownerId$": user.id },
|
|
],
|
|
},
|
|
{
|
|
[Op.or]: [
|
|
{ "$document.collection.ownerId$": null },
|
|
{ "$document.collection.ownerId$": user.id },
|
|
],
|
|
},
|
|
{
|
|
[Op.or]: [
|
|
{ "options.personalOwnerId": null },
|
|
{ "options.personalOwnerId": user.id },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
const team = await Team.findByPk(user.teamId);
|
|
authorize(user, "update", team);
|
|
|
|
const [fileOperations, total] = await Promise.all([
|
|
FileOperation.findAll({
|
|
where,
|
|
order: [[sort, direction]],
|
|
offset: ctx.state.pagination.offset,
|
|
limit: ctx.state.pagination.limit,
|
|
}),
|
|
FileOperation.count({
|
|
where,
|
|
}),
|
|
]);
|
|
|
|
ctx.body = {
|
|
pagination: { ...ctx.state.pagination, total },
|
|
data: fileOperations.map(presentFileOperation),
|
|
policies: presentPolicies(user, fileOperations),
|
|
};
|
|
}
|
|
);
|
|
|
|
const handleFileOperationsRedirect = async (
|
|
ctx: APIContext<T.FileOperationsRedirectReq>
|
|
) => {
|
|
const id = (ctx.input.body.id ?? ctx.input.query.id) as string;
|
|
const { user } = ctx.state.auth;
|
|
|
|
const fileOperation = await FileOperation.findByPk(id, {
|
|
userId: user.id,
|
|
rejectOnEmpty: true,
|
|
});
|
|
authorize(user, "read", fileOperation);
|
|
|
|
if (fileOperation.state !== "complete") {
|
|
throw ValidationError(`${fileOperation.type} is not complete yet`);
|
|
}
|
|
|
|
const accessUrl = await FileStorage.getSignedUrl(fileOperation.key);
|
|
ctx.redirect(accessUrl);
|
|
};
|
|
|
|
router.register(
|
|
"fileOperations.redirect",
|
|
["get", "post"],
|
|
[
|
|
auth(),
|
|
validate(T.FileOperationsRedirectSchema),
|
|
handleFileOperationsRedirect,
|
|
]
|
|
);
|
|
|
|
router.post(
|
|
"fileOperations.delete",
|
|
auth({ role: UserRole.Admin }),
|
|
validate(T.FileOperationsDeleteSchema),
|
|
transaction(),
|
|
async (ctx: APIContext<T.FileOperationsDeleteReq>) => {
|
|
const { id } = ctx.input.body;
|
|
const { user } = ctx.state.auth;
|
|
const { transaction } = ctx.state;
|
|
|
|
const fileOperation = await FileOperation.unscoped().findByPk(id, {
|
|
rejectOnEmpty: true,
|
|
transaction,
|
|
lock: transaction.LOCK.NO_KEY_UPDATE,
|
|
});
|
|
authorize(user, "delete", fileOperation);
|
|
|
|
await fileOperation.destroyWithCtx(ctx);
|
|
|
|
ctx.body = {
|
|
success: true,
|
|
};
|
|
}
|
|
);
|
|
|
|
export default router;
|