Files
CoHaiSe-CLOUD/backend/src/services/chatService.ts
T
Gitea ActionsandEsiah f689ab4d57
CD — Deployment / deploy (push) Successful in 34s
refactor: restructure frontend and backend by domain services (#26)
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]>
2026-11-13 09:13:27 +00:00

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],
);
};