356 lines
12 KiB
TypeScript
356 lines
12 KiB
TypeScript
import { z } from "zod";
|
|
import {
|
|
AppError,
|
|
createRateLimiter,
|
|
currentUser,
|
|
readJson,
|
|
requireAuth,
|
|
type App,
|
|
type Config,
|
|
type Db,
|
|
} from "../lib/index.js";
|
|
import { audit, canManageFolder, canRead, READ_SQL } from "../access.js";
|
|
|
|
const uuid = z
|
|
.string()
|
|
.regex(
|
|
/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
|
|
"Identifiant invalide.",
|
|
);
|
|
|
|
const sendInput = z.object({
|
|
body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."),
|
|
});
|
|
|
|
const editInput = z.object({
|
|
body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."),
|
|
});
|
|
|
|
const DATETIME_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,6})?$/;
|
|
|
|
interface MessageRow {
|
|
id: number;
|
|
user_id: string | null;
|
|
body: string;
|
|
created_at: string;
|
|
edited_at: string | null;
|
|
is_pinned: number;
|
|
first_name: string | null;
|
|
last_name: string | null;
|
|
avatar_updated_at: Date | null;
|
|
}
|
|
|
|
const SELECT_MESSAGE = `
|
|
SELECT m.id, m.user_id, m.body, m.created_at, m.edited_at, m.is_pinned,
|
|
u.first_name, u.last_name, ua.updated_at AS avatar_updated_at
|
|
FROM chat_messages m
|
|
LEFT JOIN users u ON u.id = m.user_id
|
|
LEFT JOIN user_avatars ua ON ua.user_id = m.user_id`;
|
|
|
|
const publicMessage = (row: MessageRow) => ({
|
|
id: row.id,
|
|
user_id: row.user_id,
|
|
first_name: row.first_name,
|
|
last_name: row.last_name,
|
|
body: row.body,
|
|
created_at: row.created_at,
|
|
edited_at: row.edited_at,
|
|
is_pinned: row.is_pinned === 1,
|
|
has_avatar: row.user_id !== null && row.avatar_updated_at !== null,
|
|
avatar_updated_at: row.avatar_updated_at,
|
|
});
|
|
|
|
export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
|
|
const limiter = createRateLimiter(20, 10_000);
|
|
|
|
const assertFolder = async (
|
|
folderId: string,
|
|
): Promise<{ id: string; owner_id: string | null; access_type: string }> => {
|
|
if (!uuid.safeParse(folderId).success) throw AppError.notFound("Dossier introuvable.");
|
|
const folder = await db.one<{ id: string; owner_id: string | null; access_type: string }>(
|
|
"SELECT id, owner_id, access_type FROM folders WHERE id = ? AND deleted_at IS NULL",
|
|
[folderId],
|
|
);
|
|
if (!folder) throw AppError.notFound("Dossier introuvable.");
|
|
return folder;
|
|
};
|
|
|
|
const markRead = async (folderId: string, userId: string, messageId: number): Promise<void> => {
|
|
if (messageId <= 0) return;
|
|
await db
|
|
.exec(
|
|
`INSERT INTO chat_reads (folder_id, user_id, last_read_message_id)
|
|
VALUES (?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
last_read_message_id = GREATEST(last_read_message_id, ?),
|
|
updated_at = UTC_TIMESTAMP(3)`,
|
|
[folderId, userId, messageId, messageId],
|
|
)
|
|
.catch(() => undefined);
|
|
};
|
|
|
|
app.get("/api/cloud/chat/unread", requireAuth, async (context) => {
|
|
const user = currentUser(context);
|
|
const rows = await db.query<{ folder_id: string; unread: number }>(
|
|
`SELECT f.id AS folder_id, COUNT(m.id) AS unread
|
|
FROM folders f
|
|
JOIN chat_messages m
|
|
ON m.folder_id = f.id
|
|
AND m.deleted_at IS NULL
|
|
AND m.user_id <> ?
|
|
WHERE f.deleted_at IS NULL
|
|
AND m.id > COALESCE (
|
|
( SELECT cr.last_read_message_id
|
|
FROM chat_reads cr
|
|
WHERE cr.folder_id = f.id AND cr.user_id = ? ), 0 )
|
|
AND ${READ_SQL}
|
|
GROUP BY f.id
|
|
HAVING unread > 0`,
|
|
[user.id, user.id, user.id, user.id],
|
|
);
|
|
|
|
const unread: Record<string, number> = {};
|
|
for (const row of rows) unread[row.folder_id] = Number(row.unread);
|
|
return context.json({ unread });
|
|
});
|
|
|
|
app.get("/api/cloud/folders/:folderId/chat/members", requireAuth, async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
const folder = await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
|
|
const rows = await db.query<{
|
|
id: string;
|
|
first_name: string;
|
|
last_name: string;
|
|
role_slug: string;
|
|
avatar_updated_at: Date | null;
|
|
last_login_at: string | null;
|
|
}>(
|
|
`SELECT u.id, u.first_name, u.last_name, r.slug AS role_slug,
|
|
ua.updated_at AS avatar_updated_at, u.last_login_at
|
|
FROM users u
|
|
JOIN roles r ON r.id = u.role_id
|
|
LEFT JOIN user_avatars ua ON ua.user_id = u.id
|
|
WHERE u.deleted_at IS NULL AND u.is_active = 1
|
|
AND ( u.id = ?
|
|
OR ? = 1
|
|
OR EXISTS ( SELECT 1 FROM folder_permissions fp
|
|
WHERE fp.folder_id = ? AND fp.user_id = u.id
|
|
AND fp.level IN ('read', 'write', 'admin')
|
|
AND ( fp.expires_at IS NULL OR fp.expires_at > UTC_TIMESTAMP() ) ) )
|
|
ORDER BY u.first_name ASC, u.last_name ASC`,
|
|
[folder.owner_id, folder.access_type === "public" ? 1 : 0, folderId],
|
|
);
|
|
|
|
return context.json({
|
|
members: rows.map((row) => ({
|
|
id: row.id,
|
|
first_name: row.first_name,
|
|
last_name: row.last_name,
|
|
role_slug: row.role_slug,
|
|
has_avatar: row.avatar_updated_at !== null,
|
|
avatar_updated_at: row.avatar_updated_at,
|
|
last_login_at: row.last_login_at,
|
|
is_self: row.id === user.id,
|
|
})),
|
|
});
|
|
});
|
|
|
|
app.get("/api/cloud/folders/:folderId/chat/messages", requireAuth, async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
|
|
const limit = Math.min(200, Math.max(1, Number(context.req.query("limit")) || 50));
|
|
const after = Math.max(0, Number(context.req.query("after")) || 0);
|
|
|
|
const cursorRow = await db.one<{ chat_cursor: string }>(
|
|
"SELECT DATE_FORMAT(CURRENT_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f') AS chat_cursor",
|
|
);
|
|
const serverCursor = cursorRow?.chat_cursor ?? "1970-01-01T00:00:00.000000";
|
|
const editedAfterRaw = context.req.query("editedAfter");
|
|
const editedSince =
|
|
typeof editedAfterRaw === "string" && DATETIME_CURSOR.test(editedAfterRaw)
|
|
? editedAfterRaw
|
|
: serverCursor;
|
|
|
|
const rows =
|
|
after > 0
|
|
? await db.query<MessageRow>(
|
|
`${SELECT_MESSAGE}
|
|
WHERE m.folder_id = ? AND m.deleted_at IS NULL
|
|
AND ( m.id > ?
|
|
OR ( m.edited_at IS NOT NULL AND m.edited_at >= ? ) )
|
|
ORDER BY m.id ASC
|
|
LIMIT ${limit}`,
|
|
[folderId, after, editedSince],
|
|
)
|
|
: (
|
|
await db.query<MessageRow>(
|
|
`${SELECT_MESSAGE}
|
|
WHERE m.folder_id = ? AND m.deleted_at IS NULL
|
|
ORDER BY m.id DESC
|
|
LIMIT ${limit}`,
|
|
[folderId],
|
|
)
|
|
).reverse();
|
|
|
|
const newest = rows.reduce((max, row) => Math.max(max, row.id), 0);
|
|
await markRead(folderId, user.id, newest);
|
|
|
|
return context.json({ messages: rows.map(publicMessage), cursor: serverCursor });
|
|
});
|
|
|
|
app.post("/api/cloud/folders/:folderId/chat/messages", requireAuth, async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
|
|
if (!limiter.allow(user.id)) {
|
|
throw AppError.unprocessable("Vous envoyez des messages trop rapidement.");
|
|
}
|
|
const parsed = sendInput.safeParse(await readJson(context));
|
|
if (!parsed.success) {
|
|
throw AppError.badRequest(parsed.error.issues[0]?.message ?? "Message invalide.");
|
|
}
|
|
|
|
const result = await db.exec(
|
|
"INSERT INTO chat_messages (folder_id, user_id, body) VALUES (?, ?, ?)",
|
|
[folderId, user.id, parsed.data.body],
|
|
);
|
|
const row = await db.required<MessageRow>(`${SELECT_MESSAGE} WHERE m.id = ?`, [result.insertId]);
|
|
return context.json({ message: publicMessage(row) }, 201);
|
|
});
|
|
|
|
app.patch(
|
|
"/api/cloud/folders/:folderId/chat/messages/:id",
|
|
requireAuth,
|
|
async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
const id = Number(context.req.param("id"));
|
|
await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
if (!Number.isSafeInteger(id) || id <= 0) throw AppError.notFound("Message introuvable.");
|
|
|
|
if (!limiter.allow(user.id)) {
|
|
throw AppError.unprocessable("Vous envoyez des messages trop rapidement.");
|
|
}
|
|
|
|
const parsed = editInput.safeParse(await readJson(context));
|
|
if (!parsed.success) {
|
|
throw AppError.badRequest(parsed.error.issues[0]?.message ?? "Message invalide.");
|
|
}
|
|
|
|
const result = await db.exec(
|
|
`UPDATE chat_messages
|
|
SET body = ?, edited_at = CURRENT_TIMESTAMP(3)
|
|
WHERE id = ? AND folder_id = ? AND user_id = ? AND deleted_at IS NULL`,
|
|
[parsed.data.body, id, folderId, user.id],
|
|
);
|
|
if (result.affectedRows === 0) throw AppError.notFound("Message introuvable.");
|
|
|
|
await audit(
|
|
db,
|
|
context,
|
|
user,
|
|
"chat.edit",
|
|
"message",
|
|
String(id),
|
|
{ folderId },
|
|
config.TRUST_PROXY,
|
|
);
|
|
const row = await db.required<MessageRow>(`${SELECT_MESSAGE} WHERE m.id = ?`, [id]);
|
|
return context.json({ message: publicMessage(row) });
|
|
},
|
|
);
|
|
|
|
app.put(
|
|
"/api/cloud/folders/:folderId/chat/messages/:id/pin",
|
|
requireAuth,
|
|
async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
const id = Number(context.req.param("id"));
|
|
await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
if (!Number.isSafeInteger(id) || id <= 0) throw AppError.notFound("Message introuvable.");
|
|
|
|
if (!limiter.allow(user.id)) {
|
|
throw AppError.unprocessable("Vous envoyez des messages trop rapidement.");
|
|
}
|
|
|
|
const result = await db.exec(
|
|
"UPDATE chat_messages SET is_pinned = 1 - is_pinned WHERE id = ? AND folder_id = ? AND deleted_at IS NULL",
|
|
[id, folderId],
|
|
);
|
|
if (result.affectedRows === 0) throw AppError.notFound("Message introuvable.");
|
|
|
|
const row = await db.required<{ is_pinned: number }>(
|
|
"SELECT is_pinned FROM chat_messages WHERE id = ?",
|
|
[id],
|
|
);
|
|
const pinned = row.is_pinned === 1;
|
|
await audit(
|
|
db,
|
|
context,
|
|
user,
|
|
pinned ? "chat.pin" : "chat.unpin",
|
|
"message",
|
|
String(id),
|
|
{ folderId },
|
|
config.TRUST_PROXY,
|
|
);
|
|
return context.json({ pinned });
|
|
},
|
|
);
|
|
|
|
app.get("/api/cloud/folders/:folderId/chat/pins", requireAuth, async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
|
|
const rows = await db.query<MessageRow>(
|
|
`${SELECT_MESSAGE}
|
|
WHERE m.folder_id = ? AND m.is_pinned = 1 AND m.deleted_at IS NULL
|
|
ORDER BY m.id DESC
|
|
LIMIT 50`,
|
|
[folderId],
|
|
);
|
|
return context.json({ messages: rows.map(publicMessage) });
|
|
});
|
|
|
|
app.delete(
|
|
"/api/cloud/folders/:folderId/chat/messages/:id",
|
|
requireAuth,
|
|
async (context) => {
|
|
const user = currentUser(context);
|
|
const folderId = context.req.param("folderId") ?? "";
|
|
const id = Number(context.req.param("id"));
|
|
await assertFolder(folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
if (!Number.isSafeInteger(id) || id <= 0) throw AppError.notFound("Message introuvable.");
|
|
|
|
const row = await db.one<{ user_id: string | null }>(
|
|
"SELECT user_id FROM chat_messages WHERE id = ? AND folder_id = ? AND deleted_at IS NULL",
|
|
[id, folderId],
|
|
);
|
|
if (!row || (row.user_id !== user.id && !(await canManageFolder(db, user, folderId)))) {
|
|
throw AppError.notFound("Message introuvable.");
|
|
}
|
|
|
|
await db.exec(
|
|
"UPDATE chat_messages SET deleted_at = CURRENT_TIMESTAMP(3), is_pinned = 0 WHERE id = ?",
|
|
[id],
|
|
);
|
|
await audit(db, context, user, "chat.delete", "message", String(id), { folderId }, config.TRUST_PROXY);
|
|
return context.json({ ok: true });
|
|
},
|
|
);
|
|
};
|