Déclarer et appliquer les durées de conservation
La table RetentionPolicy existait et cinq durées y étaient semées depuis la matrice ; rien ne les appliquait. Une durée déclarée que personne n'exécute est une conformité de papier. Aucune durée par défaut n'est appliquée, et c'est le point central : la matrice interdit explicitement d'aligner tout sur cinq ans. Un objet sans politique déclarée se conserve, et l'écran le signale plutôt que de le taire. Symétrie inverse, tout aussi importante : effacer faute de règle serait aussi fautif que garder indéfiniment. La justification est obligatoire au niveau du serveur. Une durée sans motif est une durée qu'on ne saura pas défendre le jour d'un contrôle. Les politiques sont effectif-datées comme le reste de l'application : une pièce déposée en mars relève de la règle en vigueur en mars. Sans cela, un durcissement rétroactif purgerait ce que la règle du moment autorisait à garder. La résolution va du précis au général — Document:SICK_NOTE avant Document — car un arrêt de travail et un contrat n'ont aucune raison de se conserver aussi longtemps. Trois refus distincts plutôt qu'un seul : absence de politique, conservation suspendue à titre probatoire, échéance non atteinte. Les confondre sous « rien à purger » empêcherait de vérifier que la conservation est réellement tenue. Un quatrième existe : employee_departure est déclaré mais non calculable, PlanFlow ne modélisant pas de date de départ — purger sur une date inventée serait pire que ne pas purger, et l'écran l'affiche comme tel. La purge s'exécute en ligne de commande pour une tâche planifiée, la matrice demandant des purges automatiques ; un bouton qu'il faut penser à presser n'en est pas une. Elle passe par le client scopé et la RLS, compte par compte. Les tables append-only en sont exclues par construction : le journal d'audit doit survivre aux données qu'il décrit, sans quoi on ne pourrait plus démontrer que la purge a eu lieu. L'échéance affichée est dérivée de la politique, jamais stockée — même discipline que la péremption d'un export. Deux pièges rencontrés : un objet de composants exporté depuis un module client ne survit pas au passage par un composant serveur, React n'en recevant qu'un undefined ; et le minLength du navigateur masquait le contrôle serveur de la justification, que des espaces suffisent à contourner. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Cr9dkEHwbDgkWPnyGj1Rjv
This commit is contained in:
13 files changed
+1371
-6
No files matched your search
@@ -0,0 +1,170 @@
|
||||
import {
|
||||
LegalHoldForm,
|
||||
PurgeForm,
|
||||
RetentionPolicyForm,
|
||||
} from '@/components/settings/RetentionForms';
|
||||
import { PageBody, PageHeader } from '@/components/shell/PageHeader';
|
||||
import { Badge } from '@/components/ui/Badge';
|
||||
import { Card, CardHeader } from '@/components/ui/Card';
|
||||
import {
|
||||
isComputable,
|
||||
START_POINT_LABELS,
|
||||
VERDICT_LABELS,
|
||||
type StartPoint,
|
||||
} from '@/domain/retention/policy';
|
||||
import { query } from '@/server/context';
|
||||
import { inspectRetention } from '@/server/retention/purge';
|
||||
|
||||
export const metadata = { title: 'Conservation · PlanFlow' };
|
||||
export const dynamic = 'force-dynamic';
|
||||
|
||||
const dateFormat = new Intl.DateTimeFormat('fr-FR', { dateStyle: 'medium' });
|
||||
|
||||
export default async function RetentionPage() {
|
||||
const { policies, candidates } = await query(
|
||||
'settings.access',
|
||||
async (db) => ({
|
||||
policies: await db.retentionPolicy.findMany({
|
||||
orderBy: [{ objectType: 'asc' }, { effectiveFrom: 'desc' }],
|
||||
}),
|
||||
candidates: await inspectRetention(db),
|
||||
}),
|
||||
);
|
||||
|
||||
const due = candidates.filter((entry) => entry.verdict === 'DUE');
|
||||
const unpolicied = candidates.filter((entry) => entry.verdict === 'NO_POLICY');
|
||||
|
||||
return (
|
||||
<PageBody>
|
||||
<PageHeader
|
||||
title="Durées de conservation"
|
||||
subtitle="Chaque durée porte sa justification : elle devra être défendue lors d’un contrôle."
|
||||
actions={
|
||||
due.length > 0 ? (
|
||||
<Badge tone="warn">{due.length} pièce(s) échue(s)</Badge>
|
||||
) : (
|
||||
<Badge tone="ok">Rien d’échu</Badge>
|
||||
)
|
||||
}
|
||||
/>
|
||||
|
||||
<section className="rounded-3 border border-line-1 bg-surface-2 p-4 text-sm text-ink-2">
|
||||
<p>
|
||||
Les minima légaux ne sont ni universels ni une autorisation de tout
|
||||
garder. PlanFlow n’applique <strong>aucune durée par défaut</strong> :
|
||||
un objet sans politique déclarée se conserve, et cet écran le signale.
|
||||
</p>
|
||||
<p className="mt-2">
|
||||
Les journaux d’audit échappent à la purge : ils doivent survivre aux
|
||||
données qu’ils décrivent, sans quoi il deviendrait impossible de
|
||||
démontrer que la purge a bien eu lieu.
|
||||
</p>
|
||||
</section>
|
||||
|
||||
<Card>
|
||||
<CardHeader
|
||||
title="Politiques déclarées"
|
||||
badge={<Badge tone="neutral">{policies.length}</Badge>}
|
||||
/>
|
||||
<div className="overflow-x-auto">
|
||||
<table className="w-full min-w-[880px] border-collapse text-sm">
|
||||
<thead>
|
||||
<tr className="border-b border-line-2 bg-surface-2 text-left text-micro font-semibold tracking-[0.06em] text-ink-3 uppercase">
|
||||
<th className="px-4 py-2.5">Objet</th>
|
||||
<th className="px-4 py-2.5">Durée</th>
|
||||
<th className="px-4 py-2.5">Point de départ</th>
|
||||
<th className="px-4 py-2.5">Justification</th>
|
||||
<th className="px-4 py-2.5">En vigueur le</th>
|
||||
<th className="px-4 py-2.5">Conservation probatoire</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{policies.map((policy) => (
|
||||
<tr
|
||||
key={policy.id}
|
||||
className="border-b border-line-1 last:border-b-0"
|
||||
>
|
||||
<td className="px-4 py-2.5 font-medium">{policy.objectType}</td>
|
||||
<td className="tnum px-4 py-2.5">
|
||||
{policy.durationMonths} mois
|
||||
</td>
|
||||
<td className="px-4 py-2.5 text-ink-2">
|
||||
{START_POINT_LABELS[policy.startPoint as StartPoint] ??
|
||||
policy.startPoint}
|
||||
{!isComputable(policy.startPoint) ? (
|
||||
// Le dire plutôt que de laisser croire que la politique
|
||||
// s'applique : PlanFlow ne modèle pas encore cette date.
|
||||
<Badge tone="warn">non calculable</Badge>
|
||||
) : null}
|
||||
</td>
|
||||
<td className="px-4 py-2.5 text-ink-2">
|
||||
{policy.justification}
|
||||
</td>
|
||||
<td className="tnum px-4 py-2.5 text-ink-2">
|
||||
{dateFormat.format(policy.effectiveFrom)}
|
||||
</td>
|
||||
<td className="px-4 py-2.5">
|
||||
<LegalHoldForm policyId={policy.id} held={policy.legalHold} />
|
||||
</td>
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</Card>
|
||||
|
||||
<Card>
|
||||
<CardHeader title="Déclarer une durée" />
|
||||
<div className="p-4">
|
||||
<RetentionPolicyForm />
|
||||
</div>
|
||||
</Card>
|
||||
|
||||
<Card>
|
||||
<CardHeader
|
||||
title="Pièces du dossier salarié"
|
||||
badge={<Badge tone="neutral">{candidates.length}</Badge>}
|
||||
/>
|
||||
<div className="flex flex-col gap-3 p-4">
|
||||
{candidates.length === 0 ? (
|
||||
<p className="text-sm text-ink-3">Aucune pièce déposée.</p>
|
||||
) : (
|
||||
<ul className="flex flex-col gap-1 text-sm">
|
||||
{candidates.slice(0, 40).map((candidate) => (
|
||||
<li key={candidate.id} className="flex flex-wrap items-center gap-2">
|
||||
<Badge
|
||||
tone={
|
||||
candidate.verdict === 'DUE'
|
||||
? 'warn'
|
||||
: candidate.verdict === 'HELD'
|
||||
? 'info'
|
||||
: 'neutral'
|
||||
}
|
||||
>
|
||||
{VERDICT_LABELS[candidate.verdict]}
|
||||
</Badge>
|
||||
<span className="text-ink-1">{candidate.name}</span>
|
||||
<span className="text-micro text-ink-3">
|
||||
{candidate.category}
|
||||
</span>
|
||||
<span className="tnum text-micro text-ink-3">
|
||||
déposée le {dateFormat.format(candidate.uploadedAt)}
|
||||
</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
|
||||
{unpolicied.length > 0 ? (
|
||||
<p className="text-micro text-ink-3">
|
||||
{unpolicied.length} pièce(s) sans politique déclarée : elles ne
|
||||
seront pas purgées tant qu’aucune durée ne les vise.
|
||||
</p>
|
||||
) : null}
|
||||
|
||||
<PurgeForm due={due.length} />
|
||||
</div>
|
||||
</Card>
|
||||
</PageBody>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
'use client';
|
||||
|
||||
import { useActionState } from 'react';
|
||||
|
||||
import { Button } from '@/components/ui/Button';
|
||||
import {
|
||||
START_POINT_LABELS,
|
||||
START_POINTS,
|
||||
} from '@/domain/retention/policy';
|
||||
import {
|
||||
runPurgeAction,
|
||||
saveRetentionPolicyAction,
|
||||
toggleLegalHoldAction,
|
||||
type RetentionState,
|
||||
} from '@/server/retention/actions';
|
||||
|
||||
const empty: RetentionState = {};
|
||||
|
||||
export function RetentionPolicyForm() {
|
||||
const [state, action, pending] = useActionState(
|
||||
saveRetentionPolicyAction,
|
||||
empty,
|
||||
);
|
||||
|
||||
return (
|
||||
<form action={action} className="grid gap-3 sm:grid-cols-2">
|
||||
<Field
|
||||
label="Objet"
|
||||
name="objectType"
|
||||
placeholder="Document:SICK_NOTE"
|
||||
required
|
||||
hint="Un objet précis l’emporte sur le général : « Document:SICK_NOTE » avant « Document »."
|
||||
/>
|
||||
<Field
|
||||
label="Durée en mois"
|
||||
name="durationMonths"
|
||||
type="number"
|
||||
min={1}
|
||||
required
|
||||
hint="De date à date. 60 pour cinq ans."
|
||||
/>
|
||||
|
||||
<label className="flex flex-col gap-1">
|
||||
<span className="text-micro font-medium tracking-[0.04em] text-ink-3 uppercase">
|
||||
Point de départ
|
||||
</span>
|
||||
<select
|
||||
name="startPoint"
|
||||
defaultValue="creation"
|
||||
className="h-8 rounded-2 border border-line-2 bg-surface px-2 text-sm text-ink-1"
|
||||
>
|
||||
{START_POINTS.map((point) => (
|
||||
<option key={point} value={point}>
|
||||
{START_POINT_LABELS[point]}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</label>
|
||||
|
||||
<Field
|
||||
label="En vigueur à partir du"
|
||||
name="effectiveFrom"
|
||||
type="date"
|
||||
required
|
||||
hint="Effectif-daté : une pièce relève de la politique en vigueur au jour de son dépôt."
|
||||
/>
|
||||
|
||||
<label className="flex flex-col gap-1 sm:col-span-2">
|
||||
<span className="text-micro font-medium tracking-[0.04em] text-ink-3 uppercase">
|
||||
Justification
|
||||
</span>
|
||||
<textarea
|
||||
name="justification"
|
||||
rows={2}
|
||||
required
|
||||
minLength={10}
|
||||
className="rounded-2 border border-line-2 bg-surface px-2 py-1 text-sm text-ink-1"
|
||||
/>
|
||||
<span className="text-micro text-ink-3">
|
||||
Obligatoire. Une durée sans motif est une durée qu’on ne saura pas
|
||||
défendre le jour d’un contrôle.
|
||||
</span>
|
||||
</label>
|
||||
|
||||
<div className="flex items-center gap-3 sm:col-span-2">
|
||||
<Button type="submit" variant="primary" disabled={pending}>
|
||||
Enregistrer
|
||||
</Button>
|
||||
<Messages state={state} />
|
||||
</div>
|
||||
</form>
|
||||
);
|
||||
}
|
||||
|
||||
export function LegalHoldForm({
|
||||
policyId,
|
||||
held,
|
||||
}: {
|
||||
policyId: string;
|
||||
held: boolean;
|
||||
}) {
|
||||
const [state, action, pending] = useActionState(toggleLegalHoldAction, empty);
|
||||
|
||||
return (
|
||||
<form action={action} className="flex items-center gap-2">
|
||||
<input type="hidden" name="policyId" value={policyId} />
|
||||
<Button type="submit" disabled={pending}>
|
||||
{held ? 'Lever la suspension' : 'Suspendre'}
|
||||
</Button>
|
||||
{held ? (
|
||||
<span className="text-micro text-info-soft-ink">Suspendue</span>
|
||||
) : null}
|
||||
{state.error ? (
|
||||
<span role="alert" className="text-micro text-danger">
|
||||
{state.error}
|
||||
</span>
|
||||
) : null}
|
||||
</form>
|
||||
);
|
||||
}
|
||||
|
||||
export function PurgeForm({ due }: { due: number }) {
|
||||
const [state, action, pending] = useActionState(runPurgeAction, empty);
|
||||
|
||||
return (
|
||||
<form action={action} className="flex flex-wrap items-center gap-3 border-t border-line-1 pt-3">
|
||||
<Button type="submit" variant="primary" disabled={pending || due === 0}>
|
||||
Purger les pièces échues
|
||||
</Button>
|
||||
<span className="text-micro text-ink-3">
|
||||
{/* Le bouton est un dépannage : la matrice demande des purges
|
||||
automatiques, et `pnpm retention:purge` sert à les planifier. */}
|
||||
Aussi disponible en ligne de commande, pour une exécution périodique.
|
||||
</span>
|
||||
<Messages state={state} />
|
||||
</form>
|
||||
);
|
||||
}
|
||||
|
||||
function Messages({ state }: { state: RetentionState }) {
|
||||
return (
|
||||
<>
|
||||
{state.error ? (
|
||||
<span role="alert" className="text-xs text-danger">
|
||||
{state.error}
|
||||
</span>
|
||||
) : null}
|
||||
{state.message ? (
|
||||
<span className="text-xs text-ok-soft-ink">{state.message}</span>
|
||||
) : null}
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
function Field({
|
||||
label,
|
||||
name,
|
||||
hint,
|
||||
...rest
|
||||
}: {
|
||||
label: string;
|
||||
name: string;
|
||||
hint?: string;
|
||||
} & React.InputHTMLAttributes<HTMLInputElement>) {
|
||||
const id = `retention-${name}`;
|
||||
return (
|
||||
<div className="flex flex-col gap-1">
|
||||
<label
|
||||
htmlFor={id}
|
||||
className="text-micro font-medium tracking-[0.04em] text-ink-3 uppercase"
|
||||
>
|
||||
{label}
|
||||
</label>
|
||||
<input
|
||||
id={id}
|
||||
name={name}
|
||||
className="h-8 rounded-2 border border-line-2 bg-surface px-2 text-sm text-ink-1"
|
||||
{...rest}
|
||||
/>
|
||||
{hint ? <p className="text-micro text-ink-3">{hint}</p> : null}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
// Exports nommés et non un objet de composants : une référence client passée
|
||||
// depuis un composant serveur ne survit pas à l'indirection d'un namespace —
|
||||
// React ne reçoit alors qu'un `undefined` et rend une page d'erreur.
|
||||
@@ -85,6 +85,11 @@ export const NAVIGATION: NavSection[] = [
|
||||
{ id: 'registre', label: 'Registre de paramétrage', href: '/reglages/registre' },
|
||||
{ id: 'email', label: 'Envoi de courrier', href: '/reglages/email' },
|
||||
{ id: 'securite', label: 'Sécurité', href: '/reglages/securite' },
|
||||
{
|
||||
id: 'conservation',
|
||||
label: 'Durées de conservation',
|
||||
href: '/reglages/conservation',
|
||||
},
|
||||
{ id: 'convention', label: 'Convention collective' },
|
||||
{ id: 'postes', label: 'Postes et étiquettes' },
|
||||
{ id: 'roles', label: 'Rôles et permissions' },
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* Durées de conservation — PLAN.md §12.5, matrice n° 21.
|
||||
*
|
||||
* La matrice est explicite : les minima légaux ne sont ni universels ni une
|
||||
* autorisation de tout garder. **Aucune durée par défaut n'est appliquée ici.**
|
||||
* Un objet sans politique déclarée se conserve, et l'écran le dit — inventer
|
||||
* « cinq ans partout » serait précisément la faute que le plan interdit.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Points de départ du décompte.
|
||||
*
|
||||
* `employee_departure` est **déclaré mais pas calculable** : PlanFlow ne modèle
|
||||
* pas encore de date de départ. Une politique qui s'y adosse est conservée et
|
||||
* affichée, jamais appliquée — la déclarer applicable reviendrait à purger sur
|
||||
* une date inventée.
|
||||
*/
|
||||
export const START_POINTS = [
|
||||
'creation',
|
||||
'contract_end',
|
||||
'period_end',
|
||||
'employee_departure',
|
||||
] as const;
|
||||
|
||||
export type StartPoint = (typeof START_POINTS)[number];
|
||||
|
||||
export const START_POINT_LABELS: Record<StartPoint, string> = {
|
||||
creation: 'Création de l’objet',
|
||||
contract_end: 'Fin du contrat',
|
||||
period_end: 'Fin de la période de paie',
|
||||
employee_departure: 'Départ du salarié',
|
||||
};
|
||||
|
||||
/** Points de départ que le code sait situer dans le temps aujourd'hui. */
|
||||
export const COMPUTABLE_START_POINTS = new Set<StartPoint>([
|
||||
'creation',
|
||||
'contract_end',
|
||||
'period_end',
|
||||
]);
|
||||
|
||||
export function isComputable(startPoint: string): boolean {
|
||||
return COMPUTABLE_START_POINTS.has(startPoint as StartPoint);
|
||||
}
|
||||
|
||||
export interface RetentionPolicyLike {
|
||||
objectType: string;
|
||||
durationMonths: number;
|
||||
startPoint: string;
|
||||
legalHold: boolean;
|
||||
effectiveFrom: Date;
|
||||
}
|
||||
|
||||
/**
|
||||
* Politique applicable à une date donnée.
|
||||
*
|
||||
* Effectif-daté comme le reste : une pièce déposée en mars relève de la
|
||||
* politique en vigueur en mars, même si elle a changé depuis. Sans cela, un
|
||||
* durcissement rétroactif purgerait des pièces que la règle du moment
|
||||
* autorisait à garder.
|
||||
*/
|
||||
export function applicablePolicy<T extends RetentionPolicyLike>(
|
||||
policies: readonly T[],
|
||||
objectType: string,
|
||||
at: Date,
|
||||
): T | null {
|
||||
const candidates = policies
|
||||
.filter(
|
||||
(policy) =>
|
||||
policy.objectType === objectType && policy.effectiveFrom <= at,
|
||||
)
|
||||
.sort(
|
||||
(a, b) => b.effectiveFrom.getTime() - a.effectiveFrom.getTime(),
|
||||
);
|
||||
|
||||
return candidates[0] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Politique applicable, en remontant du plus précis au plus général.
|
||||
*
|
||||
* `Document:SICK_NOTE` avant `Document` : un arrêt de travail et un contrat
|
||||
* n'ont aucune raison de se conserver aussi longtemps, et la matrice demande
|
||||
* justement de trancher par objet.
|
||||
*/
|
||||
export function resolvePolicy<T extends RetentionPolicyLike>(
|
||||
policies: readonly T[],
|
||||
objectTypes: readonly string[],
|
||||
at: Date,
|
||||
): T | null {
|
||||
for (const objectType of objectTypes) {
|
||||
const found = applicablePolicy(policies, objectType, at);
|
||||
if (found) return found;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Échéance de conservation.
|
||||
*
|
||||
* Un décalage en mois, pas en jours : « cinq ans » se compte de date à date.
|
||||
* `setUTCMonth` ramène le 31 mars + 1 mois au 31 avril, donc au 1er mai ; on
|
||||
* borne au dernier jour du mois visé pour que l'échéance reste dans le mois
|
||||
* attendu.
|
||||
*/
|
||||
export function dueAt(anchor: Date, durationMonths: number): Date {
|
||||
const target = new Date(anchor.getTime());
|
||||
const day = target.getUTCDate();
|
||||
|
||||
target.setUTCDate(1);
|
||||
target.setUTCMonth(target.getUTCMonth() + durationMonths);
|
||||
|
||||
const lastDay = new Date(
|
||||
Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0),
|
||||
).getUTCDate();
|
||||
target.setUTCDate(Math.min(day, lastDay));
|
||||
|
||||
return target;
|
||||
}
|
||||
|
||||
export type PurgeVerdict =
|
||||
| 'NO_POLICY'
|
||||
| 'NOT_DUE'
|
||||
| 'HELD'
|
||||
| 'NOT_COMPUTABLE'
|
||||
| 'DUE';
|
||||
|
||||
export interface PurgeInput {
|
||||
policy: RetentionPolicyLike | null;
|
||||
anchor: Date | null;
|
||||
now: Date;
|
||||
}
|
||||
|
||||
/**
|
||||
* Faut-il purger ?
|
||||
*
|
||||
* Chaque refus porte son motif : « rien à purger » sans distinguer l'absence de
|
||||
* politique, la suspension pour contentieux et l'échéance non atteinte
|
||||
* empêcherait de vérifier que la conservation est tenue.
|
||||
*/
|
||||
export function purgeVerdict({ policy, anchor, now }: PurgeInput): PurgeVerdict {
|
||||
if (!policy) return 'NO_POLICY';
|
||||
// Le legal hold prime sur tout : une pièce sous séquestre ne se purge pas,
|
||||
// même largement échue.
|
||||
if (policy.legalHold) return 'HELD';
|
||||
if (!isComputable(policy.startPoint)) return 'NOT_COMPUTABLE';
|
||||
if (!anchor) return 'NOT_COMPUTABLE';
|
||||
|
||||
return dueAt(anchor, policy.durationMonths) <= now ? 'DUE' : 'NOT_DUE';
|
||||
}
|
||||
|
||||
export const VERDICT_LABELS: Record<PurgeVerdict, string> = {
|
||||
NO_POLICY: 'Aucune politique déclarée',
|
||||
NOT_DUE: 'Échéance non atteinte',
|
||||
HELD: 'Suspendue — conservation à titre probatoire',
|
||||
NOT_COMPUTABLE: 'Point de départ non calculable',
|
||||
DUE: 'À purger',
|
||||
};
|
||||
@@ -1,5 +1,11 @@
|
||||
import { can } from '@/domain/access/authorize';
|
||||
import type { DocumentCategory } from '@/domain/documents/rules';
|
||||
import {
|
||||
dueAt,
|
||||
isComputable,
|
||||
resolvePolicy,
|
||||
type RetentionPolicyLike,
|
||||
} from '@/domain/retention/policy';
|
||||
import { query } from '@/server/context';
|
||||
import { signedDocumentUrl } from '@/server/documents/links';
|
||||
|
||||
@@ -10,6 +16,12 @@ export interface DocumentRow {
|
||||
mimeType: string;
|
||||
sizeBytes: number;
|
||||
isSensitive: boolean;
|
||||
/**
|
||||
* Échéance **dérivée** de la politique en vigueur au dépôt, jamais stockée.
|
||||
* La colonne existe au schéma pour une échéance fixée à la main ; tant
|
||||
* qu'elle ne sert pas, deux sources de vérité vaudraient mieux qu'une seule
|
||||
* uniquement dans les rapports de bogue.
|
||||
*/
|
||||
retentionUntil: Date | null;
|
||||
uploadedAt: Date;
|
||||
/** Lien signé, valable quelques minutes seulement. */
|
||||
@@ -42,17 +54,31 @@ export async function listDocuments(
|
||||
mimeType: true,
|
||||
sizeBytes: true,
|
||||
isSensitive: true,
|
||||
retentionUntil: true,
|
||||
uploadedAt: true,
|
||||
},
|
||||
});
|
||||
|
||||
const policies =
|
||||
(await db.retentionPolicy.findMany()) as RetentionPolicyLike[];
|
||||
|
||||
return {
|
||||
documents: rows.map((row) => ({
|
||||
...row,
|
||||
category: row.category as DocumentCategory,
|
||||
href: signedDocumentUrl(row.id),
|
||||
})),
|
||||
documents: rows.map((row) => {
|
||||
const policy = resolvePolicy(
|
||||
policies,
|
||||
[`Document:${row.category}`, 'Document'],
|
||||
row.uploadedAt,
|
||||
);
|
||||
|
||||
return {
|
||||
...row,
|
||||
category: row.category as DocumentCategory,
|
||||
retentionUntil:
|
||||
policy && isComputable(policy.startPoint)
|
||||
? dueAt(row.uploadedAt, policy.durationMonths)
|
||||
: null,
|
||||
href: signedDocumentUrl(row.id),
|
||||
};
|
||||
}),
|
||||
canManage: can(actor, 'members.documents.manage'),
|
||||
};
|
||||
});
|
||||
|
||||
@@ -0,0 +1,186 @@
|
||||
'use server';
|
||||
|
||||
import { revalidatePath } from 'next/cache';
|
||||
import { z } from 'zod';
|
||||
|
||||
import { AuthorizationError } from '@/domain/access/authorize';
|
||||
import { START_POINTS } from '@/domain/retention/policy';
|
||||
import { recordAudit } from '@/server/audit';
|
||||
import { mutate } from '@/server/context';
|
||||
import { runRetentionPurge } from '@/server/retention/purge';
|
||||
|
||||
export interface RetentionState {
|
||||
error?: string;
|
||||
ok?: boolean;
|
||||
message?: string;
|
||||
}
|
||||
|
||||
const policyInput = z.object({
|
||||
objectType: z.string().trim().min(1, 'Objet requis').max(80),
|
||||
durationMonths: z.coerce
|
||||
.number()
|
||||
.int()
|
||||
.min(1, 'La durée doit valoir au moins un mois')
|
||||
.max(1200),
|
||||
startPoint: z.enum(START_POINTS),
|
||||
/**
|
||||
* Obligatoire, et c'est le point : la matrice exige que chaque durée porte sa
|
||||
* justification. Une durée sans motif est une durée qu'on ne saura pas
|
||||
* défendre le jour d'un contrôle.
|
||||
*/
|
||||
justification: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(10, 'Justifiez la durée : elle devra être défendue lors d’un contrôle')
|
||||
.max(500),
|
||||
effectiveFrom: z.coerce.date(),
|
||||
});
|
||||
|
||||
export async function saveRetentionPolicyAction(
|
||||
_previous: RetentionState,
|
||||
formData: FormData,
|
||||
): Promise<RetentionState> {
|
||||
const parsed = policyInput.safeParse({
|
||||
objectType: formData.get('objectType'),
|
||||
durationMonths: formData.get('durationMonths'),
|
||||
startPoint: formData.get('startPoint'),
|
||||
justification: formData.get('justification'),
|
||||
effectiveFrom: formData.get('effectiveFrom'),
|
||||
});
|
||||
|
||||
if (!parsed.success) {
|
||||
return { error: parsed.error.issues[0]?.message ?? 'Formulaire invalide' };
|
||||
}
|
||||
|
||||
try {
|
||||
await mutate('settings.access', async (db, actor) => {
|
||||
const { objectType, effectiveFrom } = parsed.data;
|
||||
|
||||
const existing = await db.retentionPolicy.findFirst({
|
||||
where: { objectType, effectiveFrom },
|
||||
});
|
||||
|
||||
if (existing) {
|
||||
await db.retentionPolicy.update({
|
||||
where: { id: existing.id },
|
||||
data: {
|
||||
durationMonths: parsed.data.durationMonths,
|
||||
startPoint: parsed.data.startPoint,
|
||||
justification: parsed.data.justification,
|
||||
} as never,
|
||||
});
|
||||
} else {
|
||||
await db.retentionPolicy.create({ data: parsed.data as never });
|
||||
}
|
||||
|
||||
await recordAudit(db, {
|
||||
actorMembershipId: actor.membershipId,
|
||||
action: 'retention.policy.save',
|
||||
entityType: 'RetentionPolicy',
|
||||
entityId: existing?.id ?? objectType,
|
||||
before: existing
|
||||
? {
|
||||
durationMonths: existing.durationMonths,
|
||||
startPoint: existing.startPoint,
|
||||
}
|
||||
: null,
|
||||
after: {
|
||||
objectType,
|
||||
durationMonths: parsed.data.durationMonths,
|
||||
startPoint: parsed.data.startPoint,
|
||||
},
|
||||
});
|
||||
});
|
||||
} catch (error) {
|
||||
return toState(error, "Vous n'avez pas le droit de modifier les durées.");
|
||||
}
|
||||
|
||||
revalidatePath('/reglages/conservation');
|
||||
return { ok: true, message: 'Durée enregistrée.' };
|
||||
}
|
||||
|
||||
/**
|
||||
* Suspend ou lève une conservation à titre probatoire.
|
||||
*
|
||||
* Un contentieux impose de garder des pièces au-delà de leur échéance. La
|
||||
* suspension prime sur la durée, et son basculement est tracé : lever un
|
||||
* séquestre est une décision, pas un réglage.
|
||||
*/
|
||||
export async function toggleLegalHoldAction(
|
||||
_previous: RetentionState,
|
||||
formData: FormData,
|
||||
): Promise<RetentionState> {
|
||||
const id = String(formData.get('policyId') ?? '');
|
||||
if (!id) return { error: 'Politique introuvable.' };
|
||||
|
||||
let held = false;
|
||||
|
||||
try {
|
||||
await mutate('settings.access', async (db, actor) => {
|
||||
const policy = await db.retentionPolicy.findUnique({ where: { id } });
|
||||
if (!policy) return;
|
||||
|
||||
held = !policy.legalHold;
|
||||
await db.retentionPolicy.update({
|
||||
where: { id },
|
||||
data: { legalHold: held } as never,
|
||||
});
|
||||
|
||||
await recordAudit(db, {
|
||||
actorMembershipId: actor.membershipId,
|
||||
action: held ? 'retention.hold.set' : 'retention.hold.release',
|
||||
entityType: 'RetentionPolicy',
|
||||
entityId: id,
|
||||
before: { legalHold: policy.legalHold },
|
||||
after: { legalHold: held },
|
||||
});
|
||||
});
|
||||
} catch (error) {
|
||||
return toState(error, "Vous n'avez pas le droit de modifier les durées.");
|
||||
}
|
||||
|
||||
revalidatePath('/reglages/conservation');
|
||||
return {
|
||||
ok: true,
|
||||
message: held
|
||||
? 'Conservation suspendue : les pièces concernées ne seront pas purgées.'
|
||||
: 'Suspension levée.',
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Lance la purge.
|
||||
*
|
||||
* Exposée à l'écran **et** disponible en ligne de commande pour une exécution
|
||||
* périodique : la matrice demande des purges automatiques, et un bouton qu'il
|
||||
* faut penser à presser n'en est pas une.
|
||||
*/
|
||||
export async function runPurgeAction(
|
||||
_previous: RetentionState,
|
||||
_formData: FormData,
|
||||
): Promise<RetentionState> {
|
||||
let purged = 0;
|
||||
|
||||
try {
|
||||
await mutate('settings.access', async (db, actor) => {
|
||||
const report = await runRetentionPurge(db, actor.membershipId);
|
||||
purged = report.purged;
|
||||
});
|
||||
} catch (error) {
|
||||
return toState(error, "Vous n'avez pas le droit de lancer une purge.");
|
||||
}
|
||||
|
||||
revalidatePath('/reglages/conservation');
|
||||
return {
|
||||
ok: true,
|
||||
message:
|
||||
purged === 0
|
||||
? 'Aucune pièce échue : rien n’a été effacé.'
|
||||
: `${purged} pièce${purged > 1 ? 's' : ''} effacée${purged > 1 ? 's' : ''}.`,
|
||||
};
|
||||
}
|
||||
|
||||
function toState(error: unknown, denied: string): RetentionState {
|
||||
if (error instanceof AuthorizationError) return { error: denied };
|
||||
throw error;
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
import 'server-only';
|
||||
|
||||
import {
|
||||
purgeVerdict,
|
||||
resolvePolicy,
|
||||
type PurgeVerdict,
|
||||
type RetentionPolicyLike,
|
||||
} from '@/domain/retention/policy';
|
||||
import { recordAudit } from '@/server/audit';
|
||||
import { removeFile } from '@/server/documents/storage';
|
||||
import type { ScopedClient } from '@/server/tenant';
|
||||
|
||||
/**
|
||||
* Purge des pièces échues — PLAN.md §12.5.
|
||||
*
|
||||
* La purge ne s'applique qu'aux objets pour lesquels une politique a été
|
||||
* **déclarée**. Le reste se conserve, et l'écran l'annonce : effacer faute de
|
||||
* règle serait aussi fautif que garder indéfiniment.
|
||||
*
|
||||
* Les tables append-only en sont exclues par construction — un déclencheur
|
||||
* PostgreSQL refuse d'y supprimer. C'est voulu : le journal d'audit doit
|
||||
* survivre à la purge des données qu'il décrit, sans quoi on ne pourrait plus
|
||||
* démontrer que la purge a eu lieu.
|
||||
*/
|
||||
|
||||
export interface PurgeCandidate {
|
||||
id: string;
|
||||
name: string;
|
||||
category: string;
|
||||
uploadedAt: Date;
|
||||
verdict: PurgeVerdict;
|
||||
dueVia: string | null;
|
||||
}
|
||||
|
||||
export interface PurgeReport {
|
||||
candidates: PurgeCandidate[];
|
||||
purged: number;
|
||||
}
|
||||
|
||||
function policiesFor(category: string): string[] {
|
||||
return [`Document:${category}`, 'Document'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Inventaire, sans rien effacer.
|
||||
*
|
||||
* Un état des lieux consultable est ce qui rend la purge vérifiable plutôt que
|
||||
* confiante : on doit pouvoir dire, avant de l'exécuter, ce qu'elle emportera.
|
||||
*/
|
||||
export async function inspectRetention(
|
||||
db: ScopedClient,
|
||||
now = new Date(),
|
||||
): Promise<PurgeCandidate[]> {
|
||||
const policies = (await db.retentionPolicy.findMany()) as RetentionPolicyLike[];
|
||||
const documents = await db.document.findMany({
|
||||
where: { deletedAt: null },
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
category: true,
|
||||
uploadedAt: true,
|
||||
retentionUntil: true,
|
||||
},
|
||||
orderBy: { uploadedAt: 'asc' },
|
||||
});
|
||||
|
||||
return documents.map((document) => {
|
||||
const policy = resolvePolicy(
|
||||
policies,
|
||||
policiesFor(document.category),
|
||||
document.uploadedAt,
|
||||
);
|
||||
|
||||
return {
|
||||
id: document.id,
|
||||
name: document.name,
|
||||
category: document.category,
|
||||
uploadedAt: document.uploadedAt,
|
||||
verdict: purgeVerdict({
|
||||
policy,
|
||||
anchor: document.uploadedAt,
|
||||
now,
|
||||
}),
|
||||
dueVia: policy?.objectType ?? null,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Exécute la purge.
|
||||
*
|
||||
* Le contenu disparaît ; la ligne reste, marquée supprimée, et une entrée
|
||||
* d'audit dit pourquoi. Une purge silencieuse serait indistinguable d'une
|
||||
* perte de données.
|
||||
*/
|
||||
export async function runRetentionPurge(
|
||||
db: ScopedClient,
|
||||
actorMembershipId: string,
|
||||
now = new Date(),
|
||||
): Promise<PurgeReport> {
|
||||
const candidates = await inspectRetention(db, now);
|
||||
const due = candidates.filter((candidate) => candidate.verdict === 'DUE');
|
||||
|
||||
for (const candidate of due) {
|
||||
const document = await db.document.findUnique({
|
||||
where: { id: candidate.id },
|
||||
select: { fileKey: true, name: true, category: true },
|
||||
});
|
||||
if (!document) continue;
|
||||
|
||||
await db.document.update({
|
||||
where: { id: candidate.id },
|
||||
data: { deletedAt: now, deletedBy: 'retention' } as never,
|
||||
});
|
||||
|
||||
await recordAudit(db, {
|
||||
actorMembershipId,
|
||||
action: 'document.purge',
|
||||
entityType: 'Document',
|
||||
entityId: candidate.id,
|
||||
before: { name: document.name, category: document.category },
|
||||
after: { purgedBy: 'retention', policy: candidate.dueVia },
|
||||
});
|
||||
|
||||
await removeFile(document.fileKey);
|
||||
}
|
||||
|
||||
return { candidates, purged: due.length };
|
||||
}
|
||||
Reference in new issue
Block a user