Console d'instance : organisations, plafonds, bascule tracée

  d'un exercice doit rester **fictif** : une capture d'écran réelle peut contenir des données

  personnelles.

## Administration de l'instance

Un compte `INSTANCE_ADMIN` administre le **service**, pas les exercices. Il crée, règle,

suspend et supprime des organisations — il n'a **aucun droit ambiant** sur leurs données.

- **Entrer dans une organisation est une action explicite.** Elle exige un **motif**, dure

  **30 minutes**, et est en **lecture seule** sauf demande explicite d'écriture. Chaque entrée

  est consignée (`InstanceAudit`), avec son motif : c'est ce qui permet de répondre à « qui a

  accédé à nos données, quand et pourquoi ». Le patron est celui du « voir comme » joueur.

- **Le garde d'instance ne croit pas le jeton** : il relit les appartenances pour vérifier le

  rôle *et* l'organisation système. Il refuse aussi les sessions déjà basculées — un

  administrateur entré chez un client ne peut pas, depuis cette session, continuer à

  administrer l'instance. La seule écriture qui lui reste est d'en sortir.

- **Le journal survit à la suppression.** `InstanceAudit` n'a volontairement aucune clé

  étrangère vers `Tenant` : supprimer une organisation effacerait sinon la preuve de ce qui

  lui est arrivé. Le nom est recopié, pas référencé.

- **La suppression demande le slug** en confirmation : la cascade efface tous les exercices,

  messages, documents et participants de l'organisation.

- **Suspendre coupe l'accès sans attendre l'expiration des jetons.** Le garde de session

  consulte l'état de l'organisation à chaque requête, via un cache court invalidé à chaque

  changement. Prise d'effet immédiate sur une instance unique ; jusqu'à 30 secondes si

  plusieurs instances de l'API tournent en parallèle, chacune avec son cache.

## Sessions en observation

Le garde de session (`apps/api/src/auth/auth.guard.ts`) refuse toute méthode autre que

- **Minimisation** : les joueurs n'ont pas de compte ; les scénarios doivent utiliser des

  **données fictives** (ne jamais y verser de vraies données personnelles).

- **Rétention** : purge automatique des exercices archivés au-delà de `RETENTION_DAYS` jours

  (désactivée par défaut ; à configurer selon votre politique). Purge manuelle possible par un

  administrateur d'organisation.

- **Rétention** : purge automatique des exercices archivés au-delà du délai applicable.

  Chaque organisation peut fixer le sien (`retentionDays`) — en SaaS, la durée de conservation

  relève de la politique du client, pas de celle de l'hébergeur. Sans valeur propre, celle du

  déploiement (`RETENTION_DAYS`) s'applique ; une valeur de `0` refuse explicitement toute

  purge automatique. Purge manuelle possible par un administrateur d'organisation.

- **Droit à l'effacement** : la suppression d'un exercice ou d'un tenant supprime en cascade

  toutes les données associées (messages, journaux, documents, participants…), y compris les

  vérifications d'accès et les réponses au questionnaire de RETEX.

-- Console d'instance : etat, plafonds et retention par organisation, plus un

-- journal d'audit persiste des actions d'administration du service.

-- CreateEnum

CREATE TYPE "TenantStatus" AS ENUM ('ACTIVE', 'SUSPENDED');

-- AlterTable

ALTER TABLE "Tenant" ADD COLUMN "status" "TenantStatus" NOT NULL DEFAULT 'ACTIVE';

ALTER TABLE "Tenant" ADD COLUMN "maxExercises" INTEGER;

ALTER TABLE "Tenant" ADD COLUMN "maxUsers" INTEGER;

ALTER TABLE "Tenant" ADD COLUMN "maxStorageMb" INTEGER;

-- null = valeur du deploiement (RETENTION_DAYS) : aucune organisation existante

-- ne change de comportement.

ALTER TABLE "Tenant" ADD COLUMN "retentionDays" INTEGER;

-- CreateTable

-- Aucune cle etrangere vers "Tenant" : la trace doit survivre a la suppression de

-- l'organisation qu'elle concerne. Le nom est recopie, pas reference.

CREATE TABLE "InstanceAudit" (

    "id" TEXT NOT NULL,

    "actorUserId" TEXT NOT NULL,

    "actorEmail" TEXT NOT NULL,

    "action" TEXT NOT NULL,

    "tenantId" TEXT,

    "tenantName" TEXT,

    "reason" TEXT,

    "details" JSONB,

    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,

    CONSTRAINT "InstanceAudit_pkey" PRIMARY KEY ("id")

);

CREATE INDEX "InstanceAudit_createdAt_idx" ON "InstanceAudit"("createdAt");

CREATE INDEX "InstanceAudit_tenantId_idx" ON "InstanceAudit"("tenantId");

}

/// Une organisation cliente. Porte le cloisonnement multi-tenant (cf. spec-technique §1.2).

/// Etat d'une organisation. Suspendue, elle refuse toute session : ses donnees

/// restent intactes mais plus personne n'y travaille.

enum TenantStatus {

  ACTIVE

  SUSPENDED

}

model Tenant {

  id           String           @id @default(cuid())

  name         String

  slug         String           @unique

  status       TenantStatus     @default(ACTIVE)

  /// Organisation systeme : elle heberge les comptes d'administration de

  /// l'instance et n'est jamais listee comme une organisation cliente.

  /// Une seule existe, creee par le seed.

  isSystem     Boolean          @default(false)

  /// Plafonds d'usage. `null` = pas de plafond. Poses des maintenant meme si tout

  /// n'est pas encore applique : les ajouter plus tard sur des organisations

  /// vivantes couterait une migration, alors qu'ils ne coutent rien ici.

  maxExercises  Int?

  maxUsers      Int?

  maxStorageMb  Int?

  /// Duree de conservation propre a l'organisation, en jours. `null` = valeur du

  /// deploiement (RETENTION_DAYS). En SaaS, la retention releve de la politique

  /// de chaque client, pas de celle de l'hebergeur.

  retentionDays Int?

  /// Logo de l'organisation (cle de fichier televerse). Avatar par defaut du

  /// compte officiel sur les reseaux simules ; un exercice peut le remplacer.

  logoPath     String?

  @@index([userId])

}

/// Journal d'audit des actions d'ADMINISTRATION DE L'INSTANCE.

///

/// Volontairement HORS cloisonnement, et volontairement sans relation vers

/// `Tenant` : la trace doit survivre a la suppression de l'organisation qu'elle

/// concerne, sinon supprimer une organisation effacerait la preuve de ce qui lui

/// est arrive. Le nom est donc recopie, pas reference.

model InstanceAudit {

  id          String   @id @default(cuid())

  actorUserId String

  actorEmail  String

  action      String

  tenantId    String?

  tenantName  String?

  /// Motif saisi par l'administrateur, pour les actions qui en demandent un

  /// (entree dans une organisation, suspension).

  reason      String?

  details     Json?

  createdAt   DateTime @default(now())

  @@index([createdAt])

  @@index([tenantId])

}

/// Etat d'un exercice, du brouillon a l'archivage.

enum ExerciseStatus {

  DRAFT

import { ServeStaticModule } from '@nestjs/serve-static';

import { PrismaModule } from './prisma/prisma.module';

import { AuditModule } from './common/audit.module';

import { TenantStatusModule } from './common/tenant-status.module';

import { InstanceModule } from './instance/instance.module';

import { HealthModule } from './health/health.module';

import { AuthModule } from './auth/auth.module';

import { UsersModule } from './users/users.module';

    ConfigModule.forRoot({ isGlobal: true }),

    PrismaModule,

    AuditModule,

    TenantStatusModule,

    HealthModule,

    AuthModule,

    UsersModule,

    InstanceModule,

    ExercisesModule,

    EngineModule,

    MaintenanceModule,

} from '@nestjs/common';

import { JwtService } from '@nestjs/jwt';

import type { Request } from 'express';

import { TenantStatusService } from '../common/tenant-status.service';

import { SESSION_COOKIE, type AuthUser, type JwtPayload } from './auth.types';

const READ_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);

/**

 * Ecritures tolerees en session d'observation. Une seule : SORTIR de l'observation.

 * Sans cette exception, un administrateur d'instance entre en lecture seule

 * resterait enferme jusqu'a l'expiration de son jeton. Meme motif que la liste

 * blanche du garde joueur.

 */

const ALLOWED_IN_READ_ONLY = ['/instance/exit'];

/** Exige une session valide et attache l'utilisateur (`req.user`). */

@Injectable()

export class AuthGuard implements CanActivate {

  constructor(private readonly jwt: JwtService) {}

  constructor(

    private readonly jwt: JwtService,

    private readonly tenants: TenantStatusService,

  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {

    const req = context.switchToHttp().getRequest<Request & { user?: AuthUser }>();

      throw new UnauthorizedException('Session invalide ou expiree');

    }

    // Organisation suspendue (ou disparue) : la session cesse d'etre servie, sans

    // attendre l'expiration du jeton. Lecture mise en cache, cf. TenantStatusService.

    if (await this.tenants.isSuspended(payload.tid)) {

      throw new ForbiddenException('Organisation suspendue');

    }

    req.user = {

      userId: payload.sub,

      tenantId: payload.tid,

    // Point de controle UNIQUE de la lecture seule, sur le modele du garde joueur :

    // une bascule d'administrateur d'instance en observation ne doit rien pouvoir

    // ecrire, et cette regle doit couvrir aussi les routes ajoutees plus tard.

    if (payload.ro && !READ_METHODS.has(req.method)) {

    if (

      payload.ro &&

      !READ_METHODS.has(req.method) &&

      !ALLOWED_IN_READ_ONLY.some((suffix) => req.path.endsWith(suffix))

    ) {

      throw new ForbiddenException('Session en observation : aucune écriture possible');

    }