fix(files): allow uploading to root when another user has same name (#15)
CD — Deployment / deploy (push) Successful in 43s

Root is a personal namespace per user, so duplicate checks must scope to the
current owner when uploading at root level. Subfolders keep their existing
uniqueness rules.

Also fixed folder creation at root with the same owner scope.

---------

Co-authored-by: xEsiah <[email protected]>
Reviewed-on: #15
Reviewed-by: Esiah <[email protected]>
Co-authored-by: Gitea Actions <-[email protected]>
This commit was merged in pull request #15.
This commit is contained in:
Gitea Actions
2026-10-22 10:52:23 +00:00
committed by Esiah
co-authored by Esiah
parent cbe33bf563
commit 699c523caa
11 changed files with 713 additions and 37 deletions
@@ -0,0 +1,25 @@
-- 009_chat_edits_and_pins.sql
--
-- 1. Edition des messages : `edited_at` enregistre l'instant de la derniere
-- modification. NULL signifie que le message n'a jamais ete edite, donc
-- l'interface n'affiche aucune mention. La colonne est posee par le
-- serveur, jamais par le client.
--
-- `edited_at` suit exactement la convention de `created_at` (meme horloge
-- de la base, meme cadran) : les deux colonnes doivent afficher la meme
-- heure relative l'une a l'autre, sinon la mention « (modifié) » paraitrait
-- anterieure au message qu'elle annote.
--
-- 2. Epinglage : `is_pinned` marque les messages mis de cote dans le salon.
-- Plusieurs messages peuvent etre epingles en meme temps. L'index sert a
-- retrouver les epingles d'un dossier sans parcourir tout le salon.
--
-- L'index sur `edited_at` sert au curseur `editedAfter` de la lecture
-- incrementale : il rattrape les messages reecrits dont le curseur
-- d'identifiant ne peut pas dire grand-chose.
ALTER TABLE chat_messages
ADD COLUMN edited_at DATETIME(3) NULL AFTER created_at,
ADD COLUMN is_pinned TINYINT(1) NOT NULL DEFAULT 0 AFTER edited_at,
ADD KEY idx_chat_messages_pinned (folder_id, is_pinned, id),
ADD KEY idx_chat_messages_edited (folder_id, edited_at);
+165 -5
View File
@@ -30,11 +30,21 @@ const sendInput = z.object({
body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."),
});
/** Meme borne que l'envoi : un message edite ne peut pas devenir plus long. */
const editInput = z.object({
body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."),
});
/** Horodatage renvoye tel quel par le serveur : `AAAA-MM-JJTHH:MM:SS.ffffff`. */
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;
@@ -42,7 +52,7 @@ interface MessageRow {
/** Auteur joint a la ligne : meme jointure que la lecture, pour la reponse du POST. */
const SELECT_MESSAGE = `
SELECT m.id, m.user_id, m.body, m.created_at,
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
@@ -55,6 +65,8 @@ const publicMessage = (row: MessageRow) => ({
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,
});
@@ -181,6 +193,30 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
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);
/**
* Curseur d'edition. Le curseur `after` ne voit que les messages plus
* recents : une reecriture d'un ancien message y resterait invisible.
*
* Le curseur est un horodatage de la base, dans le meme cadran que la
* colonne `edited_at` : le client le renvoie tel quel, sans conversion.
* Comparer une chaine ISO (UTC) a un DATETIME stocke en heure locale
* decalerait la fenetre de la difference de fuseau.
*
* Il est calcule AVANT la requete : une edition survenue entre les deux
* porte un horodatage posterieur au curseur, elle sera donc vue au tour
* suivant plutot que perdue.
*/
// `cursor` est un mot reserve en MariaDB : l'alias est renomme.
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;
// `after` sert a la synchronisation incrementale (polling) : on ne remonte
// que les messages posterieurs au dernier connu, dans l'ordre du temps.
// Sans `after` : les `limit` derniers, remis dans l'ordre croissant.
@@ -188,10 +224,12 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
after > 0
? await db.query<MessageRow>(
`${SELECT_MESSAGE}
WHERE m.folder_id = ? AND m.deleted_at IS NULL AND m.id > ?
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],
[folderId, after, editedSince],
)
: (
await db.query<MessageRow>(
@@ -206,7 +244,7 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
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) });
return context.json({ messages: rows.map(publicMessage), cursor: serverCursor });
});
app.post("/api/cloud/folders/:folderId/chat/messages", requireAuth, async (context) => {
@@ -233,6 +271,122 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
return context.json({ message: publicMessage(row) }, 201);
});
/**
* Edition d'un message. Seul l'auteur peut modifier ce qu'il a ecrit : le
* filtre `user_id = ?` est porte par la requete SQL, donc un message d'autrui
* est indistinguishable d'un message inexistant. Le gestionnaire du dossier
* peut supprimer un message, mais pas le reecrire a la place de son auteur.
*/
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 context.req.json().catch(() => null));
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) });
},
);
/**
* Epinglage d'un message. Bascule atomique en base : le salon compte
* plusieurs participants, deux clics croises ne doivent pas laisser le
* message dans un etat incoherent. Tout membre du salon peut epingler.
*/
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 });
},
);
/**
* Messages epingles du salon. Relu a chaque tour de synchronisation : le
* curseur `after` ne remonte que les messages plus recents, donc un
* epinglage pose sur un ancien message resterait invisible sans cette lecture
* dediee.
*/
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,
@@ -254,7 +408,13 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => {
throw AppError.notFound("Message introuvable.");
}
await db.exec("UPDATE chat_messages SET deleted_at = UTC_TIMESTAMP(3) WHERE id = ?", [id]);
// Un message retire quitte aussi les epingles : le laisser marque ferait
// apparaitre un epingle fantome dans le bandeau. `deleted_at` suit la
// meme horloge que `created_at`.
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 });
},
+9 -2
View File
@@ -267,10 +267,17 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => {
throw AppError.payloadTooLarge("Votre quota de stockage est depasse.");
}
// Un nom est unique dans un dossier, mais la racine est un espace
// personnel : chaque utilisateur y depose ses propres fichiers, et la
// liste n'en montre que les siens. Le controle de doublon doit donc
// suivre la meme regle, sinon le fichier d'un autre compte a la racine
// bloquerait un depot qui n'a rien a voir avec lui.
const duplicate = await db.one(
`SELECT 1 AS taken FROM files
WHERE folder_id <=> ? AND active_name = ? AND deleted_at IS NULL LIMIT 1`,
[folderId, name],
WHERE folder_id <=> ? AND active_name = ? AND deleted_at IS NULL
AND ( folder_id IS NOT NULL OR owner_id = ? )
LIMIT 1`,
[folderId, name, user.id],
);
if (duplicate) throw AppError.conflict("Ce nom existe deja ici.");
+7 -2
View File
@@ -159,10 +159,15 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void =>
}
}
// La racine est l'espace personnel de chaque compte : un dossier du meme
// nom cree par quelqu'un d'autre ne doit pas bloquer celui-ci. Dans un
// dossier, le nom reste unique pour tous ses participants.
const duplicate = await db.one(
`SELECT 1 AS taken FROM folders
WHERE parent_id <=> ? AND active_name = ? AND deleted_at IS NULL LIMIT 1`,
[parentId ?? null, name],
WHERE parent_id <=> ? AND active_name = ? AND deleted_at IS NULL
AND ( parent_id IS NOT NULL OR owner_id = ? )
LIMIT 1`,
[parentId ?? null, name, user.id],
);
if (duplicate) throw AppError.conflict("Ce nom existe deja ici.");