CD — Deployment / deploy (push) Successful in 34s
Split the monolithic backend (lib/, routes/, access.ts, storage.ts, media.ts) into a layered structure inspired by JeanXXIII-CRM: - config/: appConfig, db - middleware/: auth (session, roles, cookies) - models/: shared types - routes/: *Routes.ts (thin HTTP handlers) - services/: *Service.ts (business logic, one per domain) - utils/: errors, http, migrate, ratelimit, validators, service bootstrap Frontend likewise: services/*Service.ts + apiClient, contexts/, types/, utils/format. Route files now carry the "Routes" suffix; service files are named authService.ts, ratelimit.ts, etc. and live in their own files, frontend and backend separated. Updated docs and READMEs to reflect the new layout. Typecheck and builds pass. --------- Co-authored-by: xEsiah <[email protected]> Reviewed-on: #26 Reviewed-by: Esiah <[email protected]> Co-authored-by: Gitea Actions <-[email protected]>
279 lines
8.6 KiB
TypeScript
279 lines
8.6 KiB
TypeScript
import type { Db } from "../config/db.js";
|
|
import type { SessionUser } from "../models/types.js";
|
|
import { AppError } from "../utils/errors.js";
|
|
import { canManageFolder, canRead, READ_SQL } from "./auditService.js";
|
|
|
|
const DATETIME_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,6})?$/;
|
|
|
|
export 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`;
|
|
|
|
export 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,
|
|
});
|
|
|
|
const assertFolder = async (
|
|
db: Db,
|
|
folderId: string,
|
|
): Promise<{ id: string; owner_id: string | null; access_type: string }> => {
|
|
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 assertReadableFolder = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
): Promise<{ id: string; owner_id: string | null; access_type: string }> => {
|
|
const folder = await assertFolder(db, folderId);
|
|
if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable.");
|
|
return folder;
|
|
};
|
|
|
|
const markRead = async (db: Db, 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);
|
|
};
|
|
|
|
/** Nombre de messages non lus par dossier. */
|
|
export const unreadCounts = async (db: Db, user: SessionUser): Promise<Record<string, number>> => {
|
|
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 unread;
|
|
};
|
|
|
|
export interface ChatMember {
|
|
id: string;
|
|
first_name: string;
|
|
last_name: string;
|
|
role_slug: string;
|
|
avatar_updated_at: Date | null;
|
|
last_login_at: string | null;
|
|
is_self: boolean;
|
|
}
|
|
|
|
export const members = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
): Promise<ChatMember[]> => {
|
|
const folder = await assertReadableFolder(db, user, folderId);
|
|
|
|
const rows = await db.query<Omit<ChatMember, "is_self">>(
|
|
`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 rows.map((row) => ({ ...row, is_self: row.id === user.id }));
|
|
};
|
|
|
|
export const messages = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
options: { after?: number; limit?: number; editedAfter?: string | null },
|
|
): Promise<{ messages: MessageRow[]; cursor: string }> => {
|
|
await assertReadableFolder(db, user, folderId);
|
|
|
|
const limit = Math.min(200, Math.max(1, options.limit ?? 50));
|
|
const after = Math.max(0, options.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 = options.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(db, folderId, user.id, newest);
|
|
|
|
return { messages: rows, cursor: serverCursor };
|
|
};
|
|
|
|
export const sendMessage = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
body: string,
|
|
): Promise<MessageRow> => {
|
|
await assertReadableFolder(db, user, folderId);
|
|
|
|
const result = await db.exec(
|
|
"INSERT INTO chat_messages (folder_id, user_id, body) VALUES (?, ?, ?)",
|
|
[folderId, user.id, body],
|
|
);
|
|
return db.required<MessageRow>(`${SELECT_MESSAGE} WHERE m.id = ?`, [result.insertId]);
|
|
};
|
|
|
|
export const editMessage = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
id: number,
|
|
body: string,
|
|
): Promise<MessageRow> => {
|
|
await assertReadableFolder(db, user, folderId);
|
|
|
|
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`,
|
|
[body, id, folderId, user.id],
|
|
);
|
|
if (result.affectedRows === 0) throw AppError.notFound("Message introuvable.");
|
|
|
|
return db.required<MessageRow>(`${SELECT_MESSAGE} WHERE m.id = ?`, [id]);
|
|
};
|
|
|
|
export const togglePin = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
id: number,
|
|
): Promise<boolean> => {
|
|
await assertReadableFolder(db, user, folderId);
|
|
|
|
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],
|
|
);
|
|
return row.is_pinned === 1;
|
|
};
|
|
|
|
export const pins = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
): Promise<MessageRow[]> => {
|
|
await assertReadableFolder(db, user, folderId);
|
|
|
|
return 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],
|
|
);
|
|
};
|
|
|
|
export const deleteMessage = async (
|
|
db: Db,
|
|
user: SessionUser,
|
|
folderId: string,
|
|
id: number,
|
|
): Promise<void> => {
|
|
await assertReadableFolder(db, user, folderId);
|
|
|
|
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],
|
|
);
|
|
};
|