Files
parenthese/backend/src/lib/entity-deletion.ts
T
IliesAllaliandClaude Opus 5.5 291dde8073 Aperçus flous (BlurHash) pendant le chargement des photos et des portraits
Les photos partent en taille réelle, sans miniature : sur un réseau lent, une vignette restait un carré
vide et un portrait montrait ses initiales. Chaque photo et chaque portrait a maintenant un aperçu flou
aux bonnes couleurs (une chaîne de 28 caractères), affiché jusqu'à l'arrivée de l'image, sans fondu.

- Base : media_items.blurhash et persons.avatarBlurhash (migration additive 20261027_001).
- API : calculé à l'envoi d'une photo et d'un portrait (sharp, 32 px), publié dans le graphe ; les autres
  chemins (Immich, import GEDCOM, propositions acceptées) et les photos d'avant sont rattrapés en tâche de
  fond (lots de 25, puis une passe par minute). Un fichier illisible reçoit un aperçu vide.
- Navigateur : vignettes de la fiche, de la frise et du gestionnaire de souvenirs, portrait de la fiche,
  portraits et souvenirs dessinés sur l'arbre.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 16:17:58 +01:00

132 lines
4.2 KiB
TypeScript

import { Prisma, type PrismaClient } from '../generated/prisma/client.js'
type Db = PrismaClient | Prisma.TransactionClient
// Suppression d'une personne ou d'une union, avec tout ce qui en dépend. Un seul chemin pour la route du
// propriétaire et pour une contribution approuvée : la voie contribution ne marquait que la personne, et ses
// photos, unions et liens restaient servis à toute la famille.
//
// Les fichiers ne sont pas effacés ici (on est souvent dans une transaction qui peut encore échouer) : la
// fonction renvoie leurs chemins, à passer à removeStoredFile une fois la transaction validée. Les garder sur
// le disque laissait aussi contourner le quota, qui ne compte que les médias non supprimés.
export type DeletionResult = {
unions: number
links: number
medias: number
filePaths: string[]
}
export async function softDeletePersonCascade(
db: Db,
treeId: string,
personId: string,
actorUserId: string | null,
now = new Date(),
): Promise<DeletionResult | null> {
const person = await db.person.findFirst({
where: { id: personId, treeId, deletedAt: null },
select: { avatarPath: true },
})
if (!person) return null
await db.person.updateMany({
where: { id: personId, treeId, deletedAt: null },
data: { deletedAt: now, updatedBy: actorUserId, avatarPath: null, avatarMimeType: null, avatarCrop: Prisma.DbNull, avatarBlurhash: null, immichPersonId: null },
})
const unions = await db.union.findMany({
where: {
treeId,
deletedAt: null,
OR: [{ partner1PersonId: personId }, { partner2PersonId: personId }],
},
select: { id: true },
})
const unionIds = unions.map((union) => union.id)
const medias = await db.mediaItem.findMany({
where: { treeId, personId, deletedAt: null },
select: { id: true, filePath: true, thumbPath: true },
})
// Identifications : la personne disparaît des photos des autres, et ses souvenirs n'ont plus personne
await db.mediaPersonTag.deleteMany({
where: {
treeId,
OR: [{ personId }, ...(medias.length > 0 ? [{ mediaId: { in: medias.map((media) => media.id) } }] : [])],
},
})
const [deletedUnions, deletedLinks, deletedMedia] = await Promise.all([
db.union.updateMany({
where: { treeId, id: { in: unionIds }, deletedAt: null },
data: { deletedAt: now },
}),
// Liens de la personne, et liens qui passaient par une de ses unions
db.parentChildLink.updateMany({
where: {
treeId,
deletedAt: null,
OR: [
{ parentPersonId: personId },
{ childPersonId: personId },
...(unionIds.length > 0 ? [{ viaUnionId: { in: unionIds } }] : []),
],
},
data: { deletedAt: now },
}),
db.mediaItem.updateMany({
where: { treeId, personId, deletedAt: null },
data: { deletedAt: now },
}),
// Événements de vie de la personne et de ses unions
db.lifeEvent.updateMany({
where: {
treeId,
deletedAt: null,
OR: [{ personId }, ...(unionIds.length > 0 ? [{ unionId: { in: unionIds } }] : [])],
},
data: { deletedAt: now },
}),
])
// Racine de l'arbre supprimée : le graphe repart sans racine plutôt que sur une personne effacée
await db.tree.updateMany({
where: { id: treeId, rootPersonId: personId },
data: { rootPersonId: null },
})
const filePaths = [
person.avatarPath,
...medias.flatMap((media) => [media.filePath, media.thumbPath]),
].filter((value): value is string => Boolean(value) && !/^https?:\/\//.test(value as string))
return {
unions: deletedUnions.count,
links: deletedLinks.count,
medias: deletedMedia.count,
filePaths,
}
}
export async function softDeleteUnionCascade(
db: Db,
treeId: string,
unionId: string,
now = new Date(),
): Promise<{ links: number } | null> {
const deletedUnion = await db.union.updateMany({
where: { id: unionId, treeId, deletedAt: null },
data: { deletedAt: now },
})
if (deletedUnion.count === 0) return null
const deletedLinks = await db.parentChildLink.updateMany({
where: { treeId, viaUnionId: unionId, deletedAt: null },
data: { deletedAt: now },
})
return { links: deletedLinks.count }
}