Écran de première installation
Les migrations posent le schéma et rien d'autre : une instance neuve n'a aucun compte et aucun utilisateur, donc personne ne peut se connecter. Le seed n'y remédie pas — il installe une démonstration et refuse de tourner en production, à raison. La première visite est désormais redirigée vers `/installation` : nom de l'entreprise, premier établissement avec son fuseau, et compte administrateur. L'écran crée le compte, le catalogue des capacités, les cinq rôles fournis, le propriétaire et son périmètre, puis ouvre la session par le chemin ordinaire — le rôle propriétaire exige aussitôt un second facteur, comme il se doit. Il ne se rouvre pas. Une table `Installation` d'une seule ligne, contrainte en base et protégée par un trigger append-only, marque l'instance. Elle est délibérément hors RLS, et c'est sa raison d'être : la politique d'`Account` ne laisse voir que le compte courant, si bien qu'une instance installée paraîtrait vierge à qui n'a pas de session — et la création d'un propriétaire se rouvrirait à tout venant. Le recensement des politiques porte l'exception, affirmée dans les deux sens. Deux défauts trouvés en éprouvant l'écran sur une base réellement vierge : `INSERT ... RETURNING` sur `Account` était refusé. L'insertion est permise, mais la relecture de la ligne écrite passe par la politique de lecture, qui exige un compte courant. L'identifiant est donc tiré côté application et annoncé avant la création — la règle de partout, appliquée à la transaction qui crée le compte. Et un défaut qui dépassait cet écran : React 19 vide les champs non contrôlés dès qu'une action se termine, refus compris. Les champs vidés portant `required`, le clic suivant était arrêté par la validation du navigateur avant d'émettre un `submit` — le formulaire paraissait mort. Le formulaire de connexion en souffrait aussi ; la suite l'avait manqué parce qu'aucun test ne soumettait deux fois de suite. `PersistentForm` photographie la saisie à l'envoi et la rétablit, mots de passe exclus. Au passage, `Field` rattache son indication par `aria-describedby` : placée dans le `<label>`, elle entrait dans le nom accessible du champ. Éprouvé sur une base vierge, image de production, rôle NOSUPERUSER NOBYPASSRLS : redirection, trois refus motivés, installation, second facteur exigé, écran refermé pour le propriétaire comme pour un visiteur. 450 tests unitaires et d'intégration, 77 tests de bout en bout. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Cr9dkEHwbDgkWPnyGj1Rjv
This commit is contained in:
21 files changed
+1367
-11
No files matched your search
@@ -7,6 +7,7 @@ import { PageBody, PageHeader } from '@/components/shell/PageHeader';
|
||||
import { Card, CardHeader } from '@/components/ui/Card';
|
||||
import { mfaRequired } from '@/domain/access/mfa-policy';
|
||||
import { currentSession } from '@/server/auth/session';
|
||||
import { isInstalled } from '@/server/install/state';
|
||||
|
||||
/**
|
||||
* Toutes les routes applicatives passent par ici.
|
||||
@@ -17,6 +18,11 @@ import { currentSession } from '@/server/auth/session';
|
||||
* sessions en base (matrice n° 23).
|
||||
*/
|
||||
export default async function AppLayout({ children }: { children: ReactNode }) {
|
||||
// Avant même la session : sur une instance vierge, il n'y a pas de compte à
|
||||
// qui appartenir, et renvoyer vers la connexion ferait rebondir d'un écran à
|
||||
// l'autre sans jamais dire ce qui manque.
|
||||
if (!(await isInstalled())) redirect('/installation');
|
||||
|
||||
const session = await currentSession();
|
||||
if (!session) redirect('/connexion');
|
||||
|
||||
|
||||
@@ -4,6 +4,7 @@ import { useActionState } from 'react';
|
||||
import { useFormStatus } from 'react-dom';
|
||||
|
||||
import { Button } from '@/components/ui/Button';
|
||||
import { PersistentForm } from '@/components/ui/PersistentForm';
|
||||
import { signInAction, type SignInState } from '@/server/auth/actions';
|
||||
|
||||
function SubmitButton() {
|
||||
@@ -27,7 +28,10 @@ export function SignInForm() {
|
||||
);
|
||||
|
||||
return (
|
||||
<form action={formAction} className="flex flex-col gap-4">
|
||||
<PersistentForm
|
||||
action={formAction}
|
||||
className="flex flex-col gap-4"
|
||||
>
|
||||
<label className="flex flex-col gap-1.5">
|
||||
<span className="text-sm font-medium">Adresse électronique</span>
|
||||
<input
|
||||
@@ -61,6 +65,6 @@ export function SignInForm() {
|
||||
) : null}
|
||||
|
||||
<SubmitButton />
|
||||
</form>
|
||||
</PersistentForm>
|
||||
);
|
||||
}
|
||||
@@ -2,11 +2,16 @@ import { redirect } from 'next/navigation';
|
||||
|
||||
import { SignInForm } from '@/app/(auth)/connexion/SignInForm';
|
||||
import { currentSession } from '@/server/auth/session';
|
||||
import { isInstalled } from '@/server/install/state';
|
||||
|
||||
export const metadata = { title: 'Connexion · PlanFlow' };
|
||||
export const dynamic = 'force-dynamic';
|
||||
|
||||
export default async function ConnexionPage() {
|
||||
// Une instance vierge n'a aucun compte : proposer de se connecter y serait
|
||||
// une impasse, et l'échec ne dirait pas qu'il manque une installation.
|
||||
if (!(await isInstalled())) redirect('/installation');
|
||||
|
||||
if (await currentSession()) redirect('/');
|
||||
|
||||
return (
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
'use client';
|
||||
|
||||
import { useActionState } from 'react';
|
||||
import { useFormStatus } from 'react-dom';
|
||||
|
||||
import { Button } from '@/components/ui/Button';
|
||||
import { Field, FormError } from '@/components/ui/Form';
|
||||
import { PersistentForm } from '@/components/ui/PersistentForm';
|
||||
import { MIN_PASSWORD_LENGTH } from '@/domain/access/invitation';
|
||||
import { DEFAULT_TIMEZONE } from '@/domain/install/rules';
|
||||
import { installAction, type InstallState } from '@/server/install/actions';
|
||||
|
||||
function SubmitButton() {
|
||||
const { pending } = useFormStatus();
|
||||
return (
|
||||
<Button type="submit" variant="primary" className="w-full" disabled={pending}>
|
||||
{pending ? 'Installation…' : 'Installer PlanFlow'}
|
||||
</Button>
|
||||
);
|
||||
}
|
||||
|
||||
export function InstallForm() {
|
||||
const [state, formAction] = useActionState<InstallState, FormData>(
|
||||
installAction,
|
||||
{},
|
||||
);
|
||||
|
||||
return (
|
||||
<PersistentForm
|
||||
action={formAction}
|
||||
className="flex flex-col gap-6"
|
||||
>
|
||||
<fieldset className="flex flex-col gap-4 border-0 p-0">
|
||||
<legend className="mb-1 text-sm font-semibold">Votre entreprise</legend>
|
||||
|
||||
<Field
|
||||
label="Nom de l’entreprise"
|
||||
name="companyName"
|
||||
required
|
||||
autoComplete="organization"
|
||||
/>
|
||||
|
||||
<div className="flex flex-col gap-4 sm:flex-row">
|
||||
<Field
|
||||
label="Premier établissement"
|
||||
name="locationName"
|
||||
required
|
||||
hint="Vous pourrez en ajouter d’autres ensuite."
|
||||
/>
|
||||
<Field
|
||||
label="Fuseau horaire"
|
||||
name="timezone"
|
||||
required
|
||||
defaultValue={DEFAULT_TIMEZONE}
|
||||
hint="Il décide des durées travaillées, changement d’heure compris."
|
||||
/>
|
||||
</div>
|
||||
</fieldset>
|
||||
|
||||
<fieldset className="flex flex-col gap-4 border-0 p-0">
|
||||
<legend className="mb-1 text-sm font-semibold">
|
||||
Votre compte administrateur
|
||||
</legend>
|
||||
|
||||
<div className="flex flex-col gap-4 sm:flex-row">
|
||||
<Field label="Prénom" name="firstName" required autoComplete="given-name" />
|
||||
<Field label="Nom" name="lastName" required autoComplete="family-name" />
|
||||
</div>
|
||||
|
||||
<Field
|
||||
label="Adresse électronique"
|
||||
name="email"
|
||||
type="email"
|
||||
required
|
||||
autoComplete="username"
|
||||
/>
|
||||
|
||||
<Field
|
||||
label="Mot de passe"
|
||||
name="password"
|
||||
type="password"
|
||||
required
|
||||
autoComplete="new-password"
|
||||
hint={`${MIN_PASSWORD_LENGTH} caractères au moins, sans votre nom ni votre adresse.`}
|
||||
/>
|
||||
<Field
|
||||
label="Confirmez le mot de passe"
|
||||
name="passwordConfirmation"
|
||||
type="password"
|
||||
required
|
||||
autoComplete="new-password"
|
||||
/>
|
||||
</fieldset>
|
||||
|
||||
<FormError>{state.error}</FormError>
|
||||
|
||||
<SubmitButton />
|
||||
</PersistentForm>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
import { redirect } from 'next/navigation';
|
||||
|
||||
import { InstallForm } from '@/app/installation/InstallForm';
|
||||
import { isInstalled } from '@/server/install/state';
|
||||
|
||||
export const metadata = { title: 'Installation · PlanFlow' };
|
||||
export const dynamic = 'force-dynamic';
|
||||
|
||||
/**
|
||||
* Première installation — PLAN.md §5.
|
||||
*
|
||||
* Après `prisma migrate deploy`, une instance neuve a le schéma et rien
|
||||
* d'autre : aucun compte, aucun utilisateur, personne pour se connecter. Le
|
||||
* seed ne comble pas ce trou — il installe une démonstration et refuse de
|
||||
* tourner en production, à raison.
|
||||
*
|
||||
* Cet écran est donc le seul de l'application à s'ouvrir sans session. Il se
|
||||
* referme définitivement dès qu'il a servi.
|
||||
*/
|
||||
export default async function InstallationPage() {
|
||||
if (await isInstalled()) redirect('/connexion');
|
||||
|
||||
return (
|
||||
<main className="flex min-h-dvh items-center justify-center bg-canvas p-6">
|
||||
<div className="w-full max-w-xl">
|
||||
<div className="mb-6 flex items-center gap-2.5">
|
||||
<span aria-hidden className="size-6 rounded-2 bg-accent" />
|
||||
<span className="text-xl font-semibold tracking-[-0.015em]">
|
||||
PlanFlow
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<div className="rounded-3 border border-line-1 bg-surface p-6 shadow-e1">
|
||||
<h1 className="text-lg font-semibold">Première installation</h1>
|
||||
<p className="mt-1 mb-5 text-sm text-ink-2">
|
||||
Cette instance est vierge. Créez votre entreprise et le compte qui
|
||||
l’administrera — cet écran ne se rouvrira pas.
|
||||
</p>
|
||||
|
||||
<InstallForm />
|
||||
</div>
|
||||
|
||||
<p className="mt-4 text-center text-micro text-ink-3">
|
||||
Le compte créé ici détient tous les droits. Un second facteur vous sera
|
||||
demandé dès la première connexion.
|
||||
</p>
|
||||
</div>
|
||||
</main>
|
||||
);
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
'use client';
|
||||
|
||||
import type { InputHTMLAttributes, ReactNode } from 'react';
|
||||
import { useId, type InputHTMLAttributes, type ReactNode } from 'react';
|
||||
import { useFormStatus } from 'react-dom';
|
||||
|
||||
import { Button, type ButtonProps } from '@/components/ui/Button';
|
||||
@@ -11,20 +11,37 @@ export interface FieldProps extends InputHTMLAttributes<HTMLInputElement> {
|
||||
hint?: string;
|
||||
}
|
||||
|
||||
export function Field({ label, hint, className, ...rest }: FieldProps) {
|
||||
export function Field({ label, hint, className, id, ...rest }: FieldProps) {
|
||||
// L'indication est rattachée par `aria-describedby` et non laissée dans le
|
||||
// `<label>`. Placée dedans, elle entre dans le **nom accessible** du champ :
|
||||
// une aide à la saisie devient alors une partie de son intitulé, annoncée
|
||||
// comme telle par un lecteur d'écran, et deux champs voisins cessent d'être
|
||||
// distinguables par leur nom.
|
||||
const generated = useId();
|
||||
const fieldId = id ?? generated;
|
||||
const hintId = `${fieldId}-hint`;
|
||||
|
||||
return (
|
||||
<label className="flex min-w-0 flex-1 flex-col gap-1.5">
|
||||
<span className="text-sm font-medium">{label}</span>
|
||||
<div className="flex min-w-0 flex-1 flex-col gap-1.5">
|
||||
<label htmlFor={fieldId} className="text-sm font-medium">
|
||||
{label}
|
||||
</label>
|
||||
<input
|
||||
{...rest}
|
||||
id={fieldId}
|
||||
{...(hint ? { 'aria-describedby': hintId } : {})}
|
||||
className={cx(
|
||||
'h-9 rounded-2 border border-line-2 bg-surface px-3 text-sm text-ink-1',
|
||||
'outline-none placeholder:text-ink-3 focus-visible:border-focus',
|
||||
className,
|
||||
)}
|
||||
/>
|
||||
{hint ? <span className="text-micro text-ink-3">{hint}</span> : null}
|
||||
</label>
|
||||
{hint ? (
|
||||
<span id={hintId} className="text-micro text-ink-3">
|
||||
{hint}
|
||||
</span>
|
||||
) : null}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
'use client';
|
||||
|
||||
import { useEffect, useRef, type FormHTMLAttributes, type ReactNode } from 'react';
|
||||
|
||||
/**
|
||||
* Un formulaire qui ne perd pas la saisie quand le serveur refuse.
|
||||
*
|
||||
* React 19 **vide les champs non contrôlés dès que l'action se termine**, sans
|
||||
* distinguer le succès de l'échec. Sur un refus, l'utilisateur retrouve donc un
|
||||
* formulaire vierge et doit tout ressaisir — sur l'écran de première
|
||||
* installation, huit champs pour un mot de passe trop court.
|
||||
*
|
||||
* Pire que l'agacement : les champs vidés portent `required`, si bien que le
|
||||
* clic suivant est arrêté par la validation du navigateur **avant** d'émettre
|
||||
* un `submit`. Le formulaire paraît alors mort — le bouton répond, et rien ne
|
||||
* part.
|
||||
*
|
||||
* Le remède : photographier la saisie à l'envoi, et la rétablir quand React
|
||||
* remet le formulaire à zéro. Les mots de passe sont exclus de la photo — les
|
||||
* réécrire dans le document les exposerait au cache de la page et à toute
|
||||
* extension qui la lit.
|
||||
*/
|
||||
|
||||
export interface PersistentFormProps
|
||||
extends Omit<FormHTMLAttributes<HTMLFormElement>, 'action'> {
|
||||
action: (formData: FormData) => void | Promise<void>;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Le rétablissement est **inconditionnel**, et ce n'est pas un raccourci.
|
||||
*
|
||||
* Le distinguer selon l'issue supposerait de lire l'état de l'action au moment
|
||||
* de la remise à zéro. Or React remet le formulaire à zéro pendant la
|
||||
* validation du rendu, tandis qu'un `useEffect` s'exécute après : le drapeau lu
|
||||
* serait celui de l'envoi précédent, et le premier refus perdrait la saisie —
|
||||
* exactement le défaut qu'on corrige. Mieux vaut ne pas dépendre de cet ordre.
|
||||
*
|
||||
* Un formulaire qui doit se vider après un envoi réussi le fait donc lui-même.
|
||||
* La règle par défaut est la bonne : ne jamais perdre ce que l'utilisateur a
|
||||
* tapé.
|
||||
*/
|
||||
export function PersistentForm({
|
||||
action,
|
||||
children,
|
||||
...rest
|
||||
}: PersistentFormProps) {
|
||||
const formRef = useRef<HTMLFormElement>(null);
|
||||
const snapshot = useRef<Array<[string, string]> | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
const form = formRef.current;
|
||||
if (!form) return;
|
||||
|
||||
const restorable = (element: Element): element is HTMLInputElement =>
|
||||
element instanceof HTMLInputElement &&
|
||||
Boolean(element.name) &&
|
||||
// Un mot de passe ne se réécrit pas dans le document.
|
||||
element.type !== 'password' &&
|
||||
// Cases et boutons radio : leur état vit dans `checked`, pas dans
|
||||
// `value`, et le rétablir demanderait de photographier autre chose.
|
||||
element.type !== 'checkbox' &&
|
||||
element.type !== 'radio' &&
|
||||
// Les champs internes des actions serveur portent un nom en `$ACTION_`.
|
||||
// Les toucher défairait le câblage de l'action elle-même.
|
||||
!element.name.startsWith('$');
|
||||
|
||||
const capture = () => {
|
||||
snapshot.current = [...form.elements]
|
||||
.filter(restorable)
|
||||
.map((field) => [field.name, field.value]);
|
||||
};
|
||||
|
||||
const rewrite = () => {
|
||||
const captured = snapshot.current;
|
||||
if (!captured) return;
|
||||
|
||||
// Après la remise à zéro, pas pendant : l'événement `reset` précède
|
||||
// l'effacement, et écrire ici serait aussitôt défait.
|
||||
queueMicrotask(() => {
|
||||
for (const [name, value] of captured) {
|
||||
const field = form.elements.namedItem(name);
|
||||
if (field instanceof Element && restorable(field)) {
|
||||
field.value = value;
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
form.addEventListener('submit', capture);
|
||||
form.addEventListener('reset', rewrite);
|
||||
return () => {
|
||||
form.removeEventListener('submit', capture);
|
||||
form.removeEventListener('reset', rewrite);
|
||||
};
|
||||
}, []);
|
||||
|
||||
return (
|
||||
<form ref={formRef} action={action} {...rest}>
|
||||
{children}
|
||||
</form>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
import { passwordProblem } from '@/domain/access/invitation';
|
||||
|
||||
/**
|
||||
* Règles de la première installation — PLAN.md §5.
|
||||
*
|
||||
* L'écran qui s'appuie dessus est le seul de l'application à s'ouvrir sans
|
||||
* session : il crée le compte, le premier établissement et le propriétaire.
|
||||
* Ses refus sont donc énoncés ici, en fonctions pures, pour être éprouvés sans
|
||||
* base ni navigateur.
|
||||
*/
|
||||
|
||||
export interface InstallationForm {
|
||||
companyName: string;
|
||||
locationName: string;
|
||||
timezone: string;
|
||||
firstName: string;
|
||||
lastName: string;
|
||||
email: string;
|
||||
password: string;
|
||||
passwordConfirmation: string;
|
||||
}
|
||||
|
||||
/** Matricule du premier salarié. Le registre du personnel les veut ordonnés. */
|
||||
export const FIRST_EMPLOYEE_NUMBER = 'E0001';
|
||||
|
||||
/**
|
||||
* Fuseau par défaut. La convention collective et les durées légales portées par
|
||||
* l'application sont françaises ; proposer autre chose par défaut serait un
|
||||
* piège plutôt qu'une ouverture.
|
||||
*/
|
||||
export const DEFAULT_TIMEZONE = 'Europe/Paris';
|
||||
|
||||
const MAX_NAME_LENGTH = 120;
|
||||
|
||||
/**
|
||||
* Un fuseau valide, jugé par la plateforme et non par une liste tenue à la
|
||||
* main : une liste se périme, et un fuseau inconnu ne se voit qu'au premier
|
||||
* calcul d'horaire — c'est-à-dire trop tard, sur une paie.
|
||||
*/
|
||||
export function isKnownTimezone(timezone: string): boolean {
|
||||
try {
|
||||
new Intl.DateTimeFormat('fr-FR', { timeZone: timezone });
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function nameProblem(value: string, subject: string): string | null {
|
||||
const trimmed = value.trim();
|
||||
if (trimmed.length === 0) return `${subject} est requis.`;
|
||||
if (trimmed.length > MAX_NAME_LENGTH) {
|
||||
return `${subject} ne peut pas dépasser ${MAX_NAME_LENGTH} caractères.`;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adresse électronique plausible.
|
||||
*
|
||||
* Volontairement permissif : la seule validation qui prouve qu'une adresse
|
||||
* existe est l'envoi d'un message. Refuser ici sur une grammaire trop stricte
|
||||
* écarterait des adresses valides — et enfermerait l'exploitant dehors, sans
|
||||
* recours, puisque cet écran ne se rouvre pas.
|
||||
*/
|
||||
function emailProblem(value: string): string | null {
|
||||
const trimmed = value.trim();
|
||||
if (trimmed.length === 0) return 'L’adresse électronique est requise.';
|
||||
if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) {
|
||||
return 'L’adresse électronique n’a pas une forme valide.';
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Motif de refus du formulaire, ou `null` s'il convient.
|
||||
*
|
||||
* L'ordre compte : le premier motif rencontré est celui qui s'affiche, et on
|
||||
* veut qu'il désigne le champ le plus haut dans l'écran.
|
||||
*/
|
||||
export function installationProblem(form: InstallationForm): string | null {
|
||||
const problems = [
|
||||
nameProblem(form.companyName, 'Le nom de l’entreprise'),
|
||||
nameProblem(form.locationName, 'Le nom de l’établissement'),
|
||||
isKnownTimezone(form.timezone)
|
||||
? null
|
||||
: `Le fuseau horaire « ${form.timezone} » est inconnu.`,
|
||||
nameProblem(form.firstName, 'Le prénom'),
|
||||
nameProblem(form.lastName, 'Le nom'),
|
||||
emailProblem(form.email),
|
||||
];
|
||||
|
||||
const first = problems.find((problem) => problem !== null);
|
||||
if (first) return first;
|
||||
|
||||
// Le mot de passe est jugé en dernier, avec le nom et l'adresse déjà validés
|
||||
// pour de bon : c'est ce contexte qui permet de refuser « martin2026 » à
|
||||
// quelqu'un qui s'appelle Martin.
|
||||
const password = passwordProblem(form.password, {
|
||||
firstName: form.firstName,
|
||||
lastName: form.lastName,
|
||||
email: form.email,
|
||||
});
|
||||
if (password) return password;
|
||||
|
||||
if (form.password !== form.passwordConfirmation) {
|
||||
return 'Les deux mots de passe ne correspondent pas.';
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Forme normalisée, telle qu'elle doit être écrite en base. */
|
||||
export function normaliseInstallation(form: InstallationForm) {
|
||||
return {
|
||||
companyName: form.companyName.trim(),
|
||||
locationName: form.locationName.trim(),
|
||||
timezone: form.timezone.trim(),
|
||||
firstName: form.firstName.trim(),
|
||||
lastName: form.lastName.trim(),
|
||||
// L'adresse sert d'identifiant de connexion : la casse ne doit pas décider
|
||||
// si quelqu'un entre ou non.
|
||||
email: form.email.trim().toLowerCase(),
|
||||
password: form.password,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
'use server';
|
||||
|
||||
import { Prisma } from '@prisma/client';
|
||||
import { cookies, headers } from 'next/headers';
|
||||
import { redirect } from 'next/navigation';
|
||||
|
||||
import {
|
||||
installationProblem,
|
||||
normaliseInstallation,
|
||||
type InstallationForm,
|
||||
} from '@/domain/install/rules';
|
||||
import {
|
||||
SESSION_COOKIE,
|
||||
SESSION_COOKIE_OPTIONS,
|
||||
signIn,
|
||||
} from '@/server/auth/session';
|
||||
import {
|
||||
hashOwnerPassword,
|
||||
installAccount,
|
||||
INSTALLATION_ID,
|
||||
} from '@/server/install/install';
|
||||
import { isInstalled, markInstalled } from '@/server/install/state';
|
||||
import { unscoped } from '@/server/tenant';
|
||||
|
||||
export interface InstallState {
|
||||
error?: string;
|
||||
}
|
||||
|
||||
function read(formData: FormData, field: string): string {
|
||||
const value = formData.get(field);
|
||||
return typeof value === 'string' ? value : '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Première installation — PLAN.md §5.
|
||||
*
|
||||
* La seule action de l'application qui s'exécute sans session, et la seule qui
|
||||
* crée un propriétaire. Deux garde-fous, et non un :
|
||||
*
|
||||
* 1. Un refus explicite si l'instance est déjà installée, pour donner un
|
||||
* message lisible plutôt qu'une erreur de contrainte.
|
||||
* 2. L'écriture du marqueur **dans la même transaction** que la création du
|
||||
* compte. C'est celui-là qui protège vraiment : deux requêtes simultanées
|
||||
* sur une instance vierge passent toutes deux le premier contrôle, puis se
|
||||
* disputent une clé primaire — la perdante annule tout son travail au lieu
|
||||
* de poser un second propriétaire.
|
||||
*/
|
||||
export async function installAction(
|
||||
_previous: InstallState,
|
||||
formData: FormData,
|
||||
): Promise<InstallState> {
|
||||
if (await isInstalled()) {
|
||||
return {
|
||||
error:
|
||||
'Cette instance est déjà installée. Connectez-vous, ou faites-vous inviter par son administrateur.',
|
||||
};
|
||||
}
|
||||
|
||||
const form: InstallationForm = {
|
||||
companyName: read(formData, 'companyName'),
|
||||
locationName: read(formData, 'locationName'),
|
||||
timezone: read(formData, 'timezone'),
|
||||
firstName: read(formData, 'firstName'),
|
||||
lastName: read(formData, 'lastName'),
|
||||
email: read(formData, 'email'),
|
||||
password: read(formData, 'password'),
|
||||
passwordConfirmation: read(formData, 'passwordConfirmation'),
|
||||
};
|
||||
|
||||
const problem = installationProblem(form);
|
||||
if (problem) return { error: problem };
|
||||
|
||||
const data = normaliseInstallation(form);
|
||||
|
||||
// Avant la transaction : argon2 est délibérément lent, et le faire tourner
|
||||
// une connexion ouverte l'immobiliserait sans rien y gagner.
|
||||
const passwordHash = await hashOwnerPassword(data.password);
|
||||
|
||||
try {
|
||||
await unscoped().$transaction(async (tx) => {
|
||||
const instance = await installAccount(tx, form, passwordHash);
|
||||
await tx.installation.create({
|
||||
data: { id: INSTALLATION_ID, accountId: instance.accountId },
|
||||
});
|
||||
});
|
||||
} catch (error) {
|
||||
if (
|
||||
error instanceof Prisma.PrismaClientKnownRequestError &&
|
||||
error.code === 'P2002'
|
||||
) {
|
||||
return {
|
||||
error:
|
||||
'Cette instance vient d’être installée par ailleurs. Rechargez la page pour vous connecter.',
|
||||
};
|
||||
}
|
||||
// Le détail part au journal du serveur, pas à l'écran : il peut contenir le
|
||||
// schéma de la base, et cet écran est ouvert sans authentification.
|
||||
console.error('[installation] échec', error);
|
||||
return {
|
||||
error:
|
||||
'L’installation a échoué. Le journal du serveur en donne la raison ; rien n’a été enregistré.',
|
||||
};
|
||||
}
|
||||
|
||||
markInstalled();
|
||||
|
||||
// Ouvrir la session par le chemin ordinaire plutôt que d'en fabriquer une :
|
||||
// le verrouillage après échecs, le second facteur et la révocation vivent
|
||||
// tous là, et une session posée à côté échapperait à ces règles.
|
||||
const requestHeaders = await headers();
|
||||
const session = await signIn({
|
||||
email: data.email,
|
||||
password: data.password,
|
||||
ip: requestHeaders.get('x-forwarded-for'),
|
||||
userAgent: requestHeaders.get('user-agent'),
|
||||
});
|
||||
|
||||
if (!session.ok) {
|
||||
// L'installation, elle, a réussi : renvoyer vers la connexion plutôt que
|
||||
// laisser croire le contraire.
|
||||
redirect('/connexion');
|
||||
}
|
||||
|
||||
(await cookies()).set(SESSION_COOKIE, session.token, {
|
||||
...SESSION_COOKIE_OPTIONS,
|
||||
expires: session.expiresAt,
|
||||
});
|
||||
|
||||
// Le rôle propriétaire donne accès aux rémunérations et à la distribution des
|
||||
// droits : le layout applicatif exigera aussitôt un second facteur. C'est
|
||||
// voulu — c'est le compte le plus exposé de l'instance.
|
||||
redirect('/');
|
||||
}
|
||||
@@ -0,0 +1,191 @@
|
||||
import { randomUUID } from 'node:crypto';
|
||||
|
||||
import type { Prisma } from '@prisma/client';
|
||||
|
||||
import {
|
||||
DEFAULT_ROLE_PERMISSIONS,
|
||||
PERMISSION_DEFINITIONS,
|
||||
SYSTEM_ROLES,
|
||||
} from '@/domain/access/permissions';
|
||||
import {
|
||||
FIRST_EMPLOYEE_NUMBER,
|
||||
normaliseInstallation,
|
||||
type InstallationForm,
|
||||
} from '@/domain/install/rules';
|
||||
import { hashPassword } from '@/server/auth/session';
|
||||
|
||||
/**
|
||||
* Contenu d'une instance neuve — PLAN.md §5.
|
||||
*
|
||||
* Le seed, lui, installe une démonstration : deux établissements, des salariés
|
||||
* fictifs, quatre semaines de planning. Il refuse de tourner en production, et
|
||||
* c'est bien ainsi. Il restait donc un trou : après les migrations, une
|
||||
* instance de production a le schéma et rien d'autre — pas de compte, pas
|
||||
* d'utilisateur, personne pour se connecter.
|
||||
*
|
||||
* Ce module comble ce trou, et **rien de plus** : le catalogue des capacités,
|
||||
* les rôles fournis, un compte, un établissement, un propriétaire. Aucune
|
||||
* donnée d'exemple.
|
||||
*/
|
||||
|
||||
export interface InstalledInstance {
|
||||
accountId: string;
|
||||
membershipId: string;
|
||||
userId: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pose le contenu minimal d'un compte dans une transaction déjà ouverte.
|
||||
*
|
||||
* Séparé de l'action pour deux raisons. La transaction appartient à l'appelant,
|
||||
* qui seul peut y écrire le marqueur d'installation dans le même souffle — un
|
||||
* compte à demi installé, sans marqueur, laisserait l'écran ouvert sur une base
|
||||
* déjà peuplée. Et cette forme se laisse éprouver contre une vraie base dans
|
||||
* une transaction que le test annule, ce qu'une fonction qui scelle
|
||||
* l'installation ne permettrait pas : le marqueur, lui, ne se supprime pas.
|
||||
*/
|
||||
export async function installAccount(
|
||||
tx: Prisma.TransactionClient,
|
||||
form: InstallationForm,
|
||||
passwordHash: string,
|
||||
): Promise<InstalledInstance> {
|
||||
const data = normaliseInstallation(form);
|
||||
|
||||
// L'identifiant est tiré ici, et non laissé à la base, parce qu'il faut
|
||||
// l'annoncer **avant** de créer le compte.
|
||||
//
|
||||
// La politique d'insertion d'`Account` accepte tout — il faut bien pouvoir
|
||||
// créer le premier. Mais sa politique de lecture, elle, n'ouvre que le compte
|
||||
// courant, et un `INSERT ... RETURNING` relit la ligne qu'il vient d'écrire :
|
||||
// sans compte courant, l'insertion réussit et la relecture est refusée.
|
||||
// Poser le compte d'abord est la même règle que partout ailleurs — une
|
||||
// transaction porte son compte — appliquée à celle qui le crée.
|
||||
const accountId = randomUUID();
|
||||
await tx.$executeRaw`SELECT set_config('app.account_id', ${accountId}, true)`;
|
||||
|
||||
const account = await tx.account.create({
|
||||
data: { id: accountId, name: data.companyName },
|
||||
});
|
||||
|
||||
// Référentiel global, sans compte : les capacités sont définies par le
|
||||
// produit. L'upsert vaut pour une instance dont le catalogue a déjà été posé
|
||||
// par un seed ou une migration de données.
|
||||
for (const permission of PERMISSION_DEFINITIONS) {
|
||||
await tx.permission.upsert({
|
||||
where: { code: permission.code },
|
||||
update: { category: permission.category, label: permission.label },
|
||||
create: permission,
|
||||
});
|
||||
}
|
||||
|
||||
const permissionIds = new Map(
|
||||
(await tx.permission.findMany({ select: { id: true, code: true } })).map(
|
||||
(permission) => [permission.code, permission.id],
|
||||
),
|
||||
);
|
||||
|
||||
const roleIds = new Map<string, string>();
|
||||
for (const role of SYSTEM_ROLES) {
|
||||
const created = await tx.role.create({
|
||||
data: {
|
||||
accountId: account.id,
|
||||
key: role.key,
|
||||
name: role.name,
|
||||
isSystem: true,
|
||||
},
|
||||
});
|
||||
roleIds.set(role.key, created.id);
|
||||
|
||||
await tx.rolePermission.createMany({
|
||||
data: DEFAULT_ROLE_PERMISSIONS[role.key]
|
||||
.map((code) => permissionIds.get(code))
|
||||
.filter((id): id is string => Boolean(id))
|
||||
.map((permissionId) => ({ roleId: created.id, permissionId })),
|
||||
skipDuplicates: true,
|
||||
});
|
||||
}
|
||||
|
||||
await tx.location.create({
|
||||
data: {
|
||||
accountId: account.id,
|
||||
name: data.locationName,
|
||||
timezone: data.timezone,
|
||||
},
|
||||
});
|
||||
|
||||
const user = await tx.user.create({
|
||||
data: {
|
||||
email: data.email,
|
||||
firstName: data.firstName,
|
||||
lastName: data.lastName,
|
||||
passwordHash,
|
||||
},
|
||||
});
|
||||
|
||||
const membership = await tx.membership.create({
|
||||
data: {
|
||||
accountId: account.id,
|
||||
userId: user.id,
|
||||
roleId: roleIds.get('owner') as string,
|
||||
employeeNumber: FIRST_EMPLOYEE_NUMBER,
|
||||
status: 'ACTIVE',
|
||||
},
|
||||
});
|
||||
|
||||
// Le registre du personnel exige le nom, et il le lit sur le dossier et non
|
||||
// sur le compte : la plupart des salariés n'ont pas de compte.
|
||||
await tx.employeeProfile.create({
|
||||
data: {
|
||||
membershipId: membership.id,
|
||||
accountId: account.id,
|
||||
firstName: data.firstName,
|
||||
lastName: data.lastName,
|
||||
},
|
||||
});
|
||||
|
||||
// Tous les établissements, y compris ceux qui n'existent pas encore : la
|
||||
// personne qui installe l'instance ne doit pas perdre la vue sur le deuxième
|
||||
// établissement le jour de son ouverture.
|
||||
await tx.membershipScope.create({
|
||||
data: {
|
||||
accountId: account.id,
|
||||
membershipId: membership.id,
|
||||
allLocations: true,
|
||||
},
|
||||
});
|
||||
|
||||
// Première entrée du journal, et elle compte : elle date la création du
|
||||
// compte propriétaire, seul accès à l'instance jusqu'à la première
|
||||
// invitation. Le journal est append-only.
|
||||
await tx.auditLog.create({
|
||||
data: {
|
||||
accountId: account.id,
|
||||
actorMembershipId: membership.id,
|
||||
action: 'install.complete',
|
||||
entityType: 'Account',
|
||||
entityId: account.id,
|
||||
after: {
|
||||
companyName: data.companyName,
|
||||
locationName: data.locationName,
|
||||
timezone: data.timezone,
|
||||
ownerEmail: data.email,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
return {
|
||||
accountId: account.id,
|
||||
membershipId: membership.id,
|
||||
userId: user.id,
|
||||
};
|
||||
}
|
||||
|
||||
/** Empreinte du mot de passe du propriétaire. */
|
||||
export function hashOwnerPassword(password: string): Promise<string> {
|
||||
// Hors transaction, à dessein : argon2 est délibérément lent, et le faire
|
||||
// tourner une connexion ouverte immobiliserait celle-ci pour rien.
|
||||
return hashPassword(password);
|
||||
}
|
||||
|
||||
/** Identifiant unique de la ligne d'installation, contraint en base. */
|
||||
export const INSTALLATION_ID = 'singleton';
|
||||
@@ -0,0 +1,51 @@
|
||||
import { unscoped } from '@/server/tenant';
|
||||
|
||||
/**
|
||||
* Cette instance a-t-elle déjà été installée ? — PLAN.md §5.
|
||||
*
|
||||
* La question se pose à chaque affichage de la connexion et de l'application,
|
||||
* c'est-à-dire à chaque requête. Elle ne peut pas être posée à `Account` : la
|
||||
* politique RLS n'y laisse voir que le compte courant, si bien qu'une instance
|
||||
* installée paraîtrait vierge à qui n'a pas de session — et l'écran
|
||||
* d'installation, qui crée un propriétaire, se rouvrirait à tout venant. D'où
|
||||
* la table `Installation`, délibérément hors RLS.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Mémorisation **du seul résultat « installée »**.
|
||||
*
|
||||
* L'asymétrie est le point : une instance installée ne redevient pas vierge —
|
||||
* le trigger `installation_append_only` l'interdit — donc ce résultat ne se
|
||||
* périme jamais et la requête peut être évitée. L'inverse ne tient pas : une
|
||||
* instance vierge le devient d'un instant à l'autre, et mémoriser cela ferait
|
||||
* boucler l'écran d'installation après son propre succès.
|
||||
*/
|
||||
let known = false;
|
||||
|
||||
export async function isInstalled(): Promise<boolean> {
|
||||
if (known) return true;
|
||||
|
||||
const row = await unscoped().installation.findFirst({
|
||||
select: { accountId: true },
|
||||
});
|
||||
known = row !== null;
|
||||
return known;
|
||||
}
|
||||
|
||||
/**
|
||||
* À appeler après une installation réussie.
|
||||
*
|
||||
* Sans cela, le premier affichage suivant repasserait par la base pour
|
||||
* apprendre ce que le processus vient lui-même d'écrire.
|
||||
*/
|
||||
export function markInstalled(): void {
|
||||
known = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remet la mémorisation à zéro. Réservé aux tests, qui installent et
|
||||
* désinstallent dans une transaction annulée.
|
||||
*/
|
||||
export function forgetInstallationState(): void {
|
||||
known = false;
|
||||
}
|
||||
Reference in new issue
Block a user