@deveye/types 0.15.0

package/src/domain/user.ts

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { userRoleSchema } from './role';
+
+/**
+ * État d'un compte au niveau du site. `suspended` conserve toutes les données
+ * mais refuse la connexion — c'est une révocation réversible, pas une
+ * suppression.
+ */
+export const userStatusSchema = z.enum(['active', 'suspended']);
+export type UserStatus = z.infer<typeof userStatusSchema>;
+
+/**
+ * Couleur d'identité du compte : son curseur chez les autres, sa bulle dans la
+ * barre du haut, la bordure du nœud où il se trouve. Une identité visuelle, donc
+ * portée par le compte et non par l'adhésion à un espace.
+ *
+ * Huit teintes, le cyan exclu — c'est celui de `--accent`, un curseur de cette
+ * couleur se lirait comme un élément de l'interface. La valeur est toujours
+ * rendue via le jeton `--user-<nom>` (Styles/theme.css), jamais en hexadécimal.
+ */
+export const userColorSchema = z.enum([
+    'red',
+    'orange',
+    'yellow',
+    'green',
+    'blue',
+    'indigo',
+    'purple',
+    'pink'
+]);
+export type UserColor = z.infer<typeof userColorSchema>;
+
+/** L'ordre fait foi : `defaultUserColor` et la migration 059 l'indexent tous deux. */
+export const USER_COLORS = userColorSchema.options;
+
+/**
+ * Teinte attribuée d'office à un compte, depuis son identifiant. Deux comptes
+ * créés à la suite n'ont pas la même, et aucun compte n'existe sans couleur —
+ * la migration 059 colorie l'existant, `usersRepo.create` fait de même à
+ * l'inscription.
+ */
+export function defaultUserColor(userId: number): UserColor {
+    return USER_COLORS[Math.abs(userId) % USER_COLORS.length];
+}
+
+export const minimalUserSchema = z.object({
+    id: z.number().int().nonnegative(),
+    email: z.string().email(),
+    username: z.string().min(1),
+    avatar: z.string(),
+    color: userColorSchema,
+    /** Époque Unix de la dernière connexion ; `0` pour un compte jamais venu. */
+    lastLogin: z.number().int().nonnegative(),
+    created: z.number().int().nonnegative()
+});
+
+export type MinimalUser = z.infer<typeof minimalUserSchema>;
+
+/**
+ * Account security posture, surfaced in the profile as "Sécurité → x / 3".
+ * Each flag is one of the three main protections.
+ */
+export const userSecuritySchema = z.object({
+    /** TOTP two-factor authentication is enabled. */
+    twoFactor: z.boolean(),
+    /** Password-based encryption (DEK wrapped by the user's password) is on. */
+    passwordEncryption: z.boolean(),
+    /**
+     * Password re-validation window is configured to a strict value: enabled and
+     * short enough (≤ 5 min) to count as a protection. Disabled (0) or a long
+     * window does not count.
+     */
+    reAuthValidation: z.boolean()
+});
+
+export type UserSecurity = z.infer<typeof userSecuritySchema>;
+
+/**
+ * Drapeaux de compte, rangés dans `users.settings` — un simple sac de chaînes.
+ *
+ * L'**absence** d'un drapeau est sa valeur par défaut : un compte créé avant
+ * qu'un drapeau existe se comporte donc comme le reste, sans migration ni
+ * rattrapage. C'est ce qui fait de cette colonne le bon endroit pour un réglage
+ * booléen privé, là où une colonne dédiée (le modèle de `color`) se justifie
+ * quand la valeur n'est pas binaire ou qu'elle intéresse d'autres comptes.
+ *
+ * - `hideLiveCursors` : ne pas afficher les curseurs des autres membres. La
+ *   coupure est **réciproque** — le client cesse aussi d'émettre le sien (voir
+ *   `live/LiveProvider.tsx`), si bien qu'on ne peut pas regarder sans être vu.
+ */
+export const userSettingFlagSchema = z.enum(['hideLiveCursors']);
+export type UserSettingFlag = z.infer<typeof userSettingFlagSchema>;
+
+export const userSchema = z.object({
+    id: z.number().int().nonnegative(),
+    email: z.string().email(),
+    username: z.string().min(1),
+    avatar: z.string(),
+    color: userColorSchema,
+    role: userRoleSchema,
+    /** Les drapeaux posés — voir `userSettingFlagSchema`. Un drapeau inconnu du
+     *  client (compte revenu d'une version plus récente) est simplement ignoré,
+     *  d'où le tableau de chaînes plutôt qu'un tableau d'énumérés. */
+    settings: z.array(z.string()),
+    security: userSecuritySchema,
+    /** Espace personnel du compte : créé avec lui, toujours présent. */
+    personalWorkspaceId: z.number().int().positive(),
+    /**
+     * Espace « favori », chargé en premier à la connexion et au rechargement.
+     * `null` → l'espace personnel. Pointe sur un espace dont le compte est
+     * membre ; il repasse à `null` si cet espace disparaît ou si l'accès est
+     * révoqué.
+     */
+    defaultWorkspaceId: z.number().int().positive().nullable(),
+    lastLogin: z.number().int().nonnegative(),
+    created: z.number().int().nonnegative()
+});
+
+export type User = z.infer<typeof userSchema>;
+
+/**
+ * Database row shape (server-only). Mirrors columns exactly.
+ */
+export interface UserRow {
+    id: number;
+    email: string;
+    username: string;
+    password_hash: string;
+    avatar: string;
+    color: UserColor;
+    role: string;
+    status: UserStatus;
+    settings: string;
+    /** Espace personnel du compte (FK `workspaces.id`), unique par utilisateur. */
+    personal_workspace_id: number;
+    /** Espace favori chargé en premier ; `null` → l'espace personnel. */
+    default_workspace_id: number | null;
+    re_auth_interval: number | null;
+    last_login: number;
+    created: number;
+}

package/src/domain/workspace.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { minimalUserSchema } from './user';
+
+/**
+ * Nature d'un espace.
+ *
+ * - `personal` : créé avec le compte, un seul membre (son propriétaire), ni
+ *   quittable ni supprimable, jamais partageable. C'est le repli implicite quand
+ *   une commande ne vise aucun espace en particulier.
+ * - `shared` : créé à la demande, plusieurs membres, rôles et invitations.
+ *
+ * Les deux sont de vraies lignes de `workspaces` : il n'existe plus d'espace
+ * virtuel d'id 0.
+ */
+export const workspaceKindSchema = z.enum(['personal', 'shared']);
+export type WorkspaceKind = z.infer<typeof workspaceKindSchema>;
+
+export const workspaceSchema = z.object({
+    id: z.number().int().positive(),
+    kind: workspaceKindSchema,
+    name: z.string().min(1),
+    logo: z.string(),
+    /** Propriétaire : tous les droits, ne peut être ni exclu ni rétrogradé. */
+    ownerUserId: z.number().int().positive(),
+    users: z.array(minimalUserSchema),
+    features: z.array(z.string().min(1)),
+    created: z.number().int().nonnegative()
+});
+
+export type Workspace = z.infer<typeof workspaceSchema>;
+
+/**
+ * Ligne SQL (serveur uniquement). `theme` et `home_layout` sont portés par
+ * l'espace, pas par l'utilisateur : chaque espace a sa propre apparence et sa
+ * propre disposition d'accueil.
+ */
+export interface WorkspaceRow {
+    id: number;
+    kind: WorkspaceKind;
+    name: string;
+    logo: string;
+    owner_user_id: number;
+    features: string;
+    /** ThemeStateDTO sérialisé, ou null tant qu'aucun thème n'a été enregistré. */
+    theme: string | null;
+    /** HomeLayout sérialisé, ou null tant qu'aucune disposition n'a été enregistrée. */
+    home_layout: string | null;
+    created: number;
+}
+
+export interface WorkspaceMemberRow {
+    id: number;
+    user_id: number;
+    workspace_id: number;
+    date: number;
+}

package/src/domain/workspaceRole.ts

@@ -0,0 +1,251 @@
+import { z } from 'zod';
+
+/**
+ * Rôles d'un espace de travail : deux dimensions volontairement distinctes.
+ *
+ * Les **capacités** portent sur le gouvernement de l'espace lui-même. L'enum est
+ * court et fermé : il ne grandit que si la notion d'espace grandit.
+ *
+ * Les **droits par feature** forment une carte uniforme `feature → lecture ou
+ * écriture`. Une nouvelle feature coûte une entrée dans un tableau et hérite du
+ * cloisonnement lecture/écriture sans qu'aucun enum ni aucun handler ne change.
+ */
+
+export const workspaceCapabilitySchema = z.enum([
+    /** Renommer l'espace, changer son logo, le supprimer. */
+    'workspace.manage',
+    /** Ajouter un membre par son adresse, l'exclure, lui attribuer un rôle. */
+    'workspace.members',
+    /** Créer, modifier, supprimer et ordonner les rôles. */
+    'workspace.roles',
+    /** Modifier le thème de l'espace. */
+    'workspace.appearance',
+    /** Modifier la disposition de l'accueil de l'espace. */
+    'workspace.layout'
+    // « Gérer les canaux d'alerte » a vécu ici (`workspace.notifications`)
+    // puis est passée PAR FONCTIONNALITÉ (migration 093) : depuis que chaque
+    // émetteur possède ses canaux (091), une capacité d'espace accordait d'un
+    // bloc l'astreinte d'Uptime et le salon des sauvegardes. Voir le champ
+    // `channels` du grant de feature.
+]);
+
+export type WorkspaceCapability = z.infer<typeof workspaceCapabilitySchema>;
+
+export const WORKSPACE_CAPABILITIES = workspaceCapabilitySchema.options;
+
+/**
+ * Features qu'un rôle peut ouvrir. Surensemble de `HomeFeatureId` : `devices`
+ * s'y ajoute, parce que voir la flotte d'un espace est un droit comme un autre
+ * (lecture = voir les appareils et leur supervision, écriture = les appairer,
+ * approuver, renommer, supprimer).
+ *
+ * `monitoring` n'y figure pas : la carte d'agrégat du même nom est réservée à
+ * l'administrateur global dans son espace personnel, donc aucun rôle d'espace
+ * ne peut l'accorder. Les vues d'appareil, elles, relèvent de `devices`.
+ */
+export const workspaceFeatureIdSchema = z.enum([
+    'devices',
+    /**
+     * Sentinelle. Distincte de `devices` exprès : voir la supervision d'une
+     * machine et voir ce qu'un détecteur soupçonne d'elle ne se confondent pas.
+     * `read` = consulter constats et posture, `write` = acquitter, régler les
+     * cadences, relancer un relevé.
+     */
+    'sentinel',
+    'weather',
+    'password',
+    'notes',
+    'cloudsync',
+    'uptime',
+    'mail',
+    'projects',
+    'git',
+    /**
+     * Déploiement. `read` = voir les cibles de l'espace et leur historique,
+     * `write` = déclarer une cible, poser la clé d'API de l'instance, et
+     * **déclencher une mise en production**.
+     *
+     * ⚠️ Le droit le plus lourd de conséquences hors de DevEye : c'est le seul
+     * qui pousse quelque chose chez un tiers. Distinct de `projects` exprès —
+     * piloter le travail et livrer ne se confondent pas, et tout le monde n'a
+     * pas à pouvoir faire les deux.
+     */
+    'deploy',
+    'database',
+    /**
+     * Sauvegardes. Les destinations de l'espace (dossier serveur, dossier d'une
+     * machine enrôlée, bucket S3) et les travaux qui y écrivent.
+     *
+     * `read` = voir les destinations, les travaux et leur historique, `write` =
+     * déclarer une destination, poser sa clé secrète, créer un travail et le
+     * déclencher.
+     *
+     * ⚠️ Le droit le plus lourd en lecture après `finance`, et pour une raison
+     * différente: la liste des destinations dit **où sont les copies de tout**.
+     * Qui la lit sait quel bucket viser pour obtenir la base entière sans jamais
+     * toucher à DevEye. Distinct de `database` exprès — superviser une base et
+     * savoir où en dorment les vidages ne se confondent pas.
+     */
+    'backup',
+    /**
+     * Finances. Le grand livre de l'espace: comptes, opérations, budgets,
+     * échéances.
+     *
+     * `read` = consulter soldes, journal et tableau de bord, `write` = saisir et
+     * corriger des opérations, tenir comptes, catégories, budgets et échéances.
+     *
+     * ⚠️ Le droit dont la lecture seule est déjà lourde: un livre de comptes dit
+     * ce qu'une structure gagne, ce qu'elle doit et à qui elle paie quoi. Le
+     * distinguer de `projects` n'est donc pas une commodité de rangement, c'est
+     * la raison d'être de la séparation.
+     */
+    'finance',
+    /**
+     * Audience. Le suivi d'usage des sites livrés — dernier maillon de la même
+     * famille que `projects`, `git` et `database` : un objet de l'**espace**
+     * qu'un projet ne fait que pointer.
+     *
+     * `read` = consulter les statistiques, `write` = déclarer un site, changer
+     * ses origines autorisées, sa rétention, le supprimer.
+     *
+     * ⚠️ Distinct de `projects` exprès, comme `git` l'est déjà : voir les
+     * chiffres d'un site livré et piloter le travail qui le produit ne se
+     * confondent pas, et tout le monde n'a pas à voir les deux.
+     */
+    'audience',
+    /**
+     * OSINT. `read` = chercher et consulter l'historique de l'espace, `write` =
+     * effacer l'historique et poser les clés d'API des fournisseurs.
+     */
+    'osint'
+]);
+
+export type WorkspaceFeatureId = z.infer<typeof workspaceFeatureIdSchema>;
+
+export const WORKSPACE_FEATURE_IDS = workspaceFeatureIdSchema.options;
+
+/**
+ * Identifiant d'une feature **externe** (module tiers compilé dans l'app).
+ *
+ * Le préfixe `x-` porte trois garanties d'un coup : aucune collision possible
+ * avec les seize ids natifs ni avec les sujets réservés (`workspace`, `home`,
+ * `account`, `notify`, `projectsChat`), aucune confusion avec un UUID
+ * d'appareil dans une disposition d'accueil (un UUID commence par un chiffre
+ * hexadécimal, jamais par `x`), et un tri visuel immédiat dans un grant ou un
+ * journal. Pas de tiret intérieur : l'id sert tel quel de préfixe de commande
+ * (`x-crypto.list`) et de valeur de segment live.
+ */
+export const EXTERNAL_FEATURE_ID_PATTERN = /^x-[a-z][a-z0-9]{1,24}$/;
+
+export type ExternalFeatureId = `x-${string}`;
+
+export const externalFeatureIdSchema = z
+    .string()
+    .regex(EXTERNAL_FEATURE_ID_PATTERN) as unknown as z.ZodType<ExternalFeatureId>;
+
+/**
+ * Toute feature adressable par un droit : native (enum fermé) ou externe.
+ *
+ * Le surensemble est **pur** : chaque valeur déjà persistée (grants JSON,
+ * dispositions) parse inchangée. Une valeur externe inconnue de l'installation
+ * courante parse aussi : un rôle peut garder le grant d'un module retiré, il
+ * reste simplement inerte tant qu'aucun module ne porte cet id.
+ */
+export const featureIdSchema = z.union([workspaceFeatureIdSchema, externalFeatureIdSchema]);
+
+export type FeatureId = WorkspaceFeatureId | ExternalFeatureId;
+
+/** Cette valeur est-elle l'id d'une feature externe ? */
+export function isExternalFeatureId(id: string): id is ExternalFeatureId {
+    return EXTERNAL_FEATURE_ID_PATTERN.test(id);
+}
+
+/** `write` implique `read` : il n'existe pas d'écriture aveugle. */
+export const featureAccessSchema = z.enum(['read', 'write']);
+export type FeatureAccess = z.infer<typeof featureAccessSchema>;
+
+/**
+ * Un droit accordé. L'**absence** d'entrée vaut « aucun accès », et la feature
+ * disparaît alors de l'interface du membre — une seule règle à retenir, et pas
+ * d'état ternaire à normaliser partout.
+ */
+export const workspaceFeatureGrantSchema = z.object({
+    feature: featureIdSchema,
+    access: featureAccessSchema,
+    /**
+     * Gérer les **canaux d'alerte** de cette fonctionnalité : en déclarer,
+     * corriger une adresse ou une URL, en supprimer, lire leurs destinations.
+     *
+     * Par fonctionnalité et non par espace (migration 093) : depuis que chaque
+     * émetteur possède ses canaux (091), l'adresse de l'astreinte d'Uptime et
+     * le salon des sauvegardes ne se confient pas d'un bloc. Distinct de
+     * `access` exprès : régler où Uptime écrit relève de `access: write`, et
+     * se donne sans livrer les destinations elles-mêmes. Sans effet sur une
+     * fonctionnalité qui n'émet pas de notifications.
+     */
+    channels: z.boolean(),
+    /**
+     * Permissions **déclarées par la feature elle-même** (module externe, ou
+     * native modernisée) au-delà de lecture/écriture : la clé vient de son
+     * manifest (`extraPermissions`), la valeur est un booléen (`toggle`) ou la
+     * valeur d'un choix (`choice`).
+     *
+     * Fermeture par défaut, une seule règle : une clé **absente** vaut « refusé »
+     * pour un toggle et « valeur par défaut du manifest » (la moins privilégiée)
+     * pour un choix. Le propriétaire, qui a tout, reçoit `true` / la valeur
+     * `ownerValue`. Une clé inconnue du manifest courant est rejetée à
+     * l'écriture du rôle et ignorée à la lecture ; un grant survivant à la
+     * dépose d'un module reste donc inerte, jamais dangereux.
+     */
+    extras: z.record(z.string().max(24), z.union([z.boolean(), z.string().max(32)])).default({})
+});
+
+export type WorkspaceFeatureGrant = z.infer<typeof workspaceFeatureGrantSchema>;
+
+export const WORKSPACE_ROLE_NAME_MAX = 64;
+
+export const workspaceRoleSchema = z.object({
+    id: z.number().int().positive(),
+    name: z.string().min(1).max(WORKSPACE_ROLE_NAME_MAX),
+    /** Pastille de couleur dans la liste des membres. */
+    color: z.string().regex(/^#[0-9a-fA-F]{6}$/),
+    /** Ordre d'affichage seul : aucune hiérarchie implicite entre rôles. */
+    position: z.number().int().nonnegative(),
+    capabilities: z.array(workspaceCapabilitySchema),
+    features: z.array(workspaceFeatureGrantSchema),
+    /** Attribué d'office à qui rejoint l'espace par invitation. */
+    isDefault: z.boolean(),
+    memberCount: z.number().int().nonnegative()
+});
+
+export type WorkspaceRole = z.infer<typeof workspaceRoleSchema>;
+
+/** Ligne SQL (serveur uniquement). */
+export interface WorkspaceRoleRow {
+    id: number;
+    workspace_id: number;
+    name: string;
+    color: string;
+    position: number;
+    /** Tableau JSON de `WorkspaceCapability`. */
+    capabilities: string;
+    /** Tableau JSON de `WorkspaceFeatureGrant`. */
+    features: string;
+    is_default: number;
+    created: number;
+}
+
+/**
+ * Droits effectifs de l'appelant dans l'espace actif, tels que le client les
+ * reçoit pour n'afficher que ce qui est réellement accessible.
+ *
+ * L'interface s'en sert pour masquer, jamais pour autoriser : chaque commande
+ * est de toute façon vérifiée côté serveur.
+ */
+export const workspacePermissionsSchema = z.object({
+    isOwner: z.boolean(),
+    capabilities: z.array(workspaceCapabilitySchema),
+    features: z.array(workspaceFeatureGrantSchema)
+});
+
+export type WorkspacePermissions = z.infer<typeof workspacePermissionsSchema>;

package/src/features/admin.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { userRoleSchema } from '../domain/role';
+import { userStatusSchema } from '../domain/user';
+
+/**
+ * Administration des comptes, à l'échelle du site et non d'un espace.
+ *
+ * Toutes ces commandes déclarent `admin: true` côté serveur : elles sont
+ * réservées au rôle global, seul niveau au-dessus des espaces.
+ */
+
+/** Un compte, tel que la page Utilisateurs l'affiche. */
+export const adminUserSchema = z.object({
+    id: z.number().int().positive(),
+    username: z.string(),
+    email: z.string(),
+    avatar: z.string(),
+    role: userRoleSchema,
+    status: userStatusSchema,
+    /** Nombre d'espaces auxquels le compte a accès, personnel compris. */
+    workspaceCount: z.number().int().nonnegative(),
+    lastLogin: z.number().int().nonnegative(),
+    created: z.number().int().nonnegative()
+});
+
+export type AdminUser = z.infer<typeof adminUserSchema>;
+
+/** Invitation à créer un compte, en attente d'être consommée. */
+export const adminInviteSchema = z.object({
+    token: z.string(),
+    url: z.string(),
+    /** Adresse sur laquelle l'invitation est verrouillée, ou `null`. */
+    email: z.string().nullable(),
+    /** Espace rejoint dès la création du compte, ou `null`. */
+    workspaceName: z.string().nullable(),
+    expiresAt: z.number().int().nullable(),
+    maxUses: z.number().int().positive().nullable(),
+    uses: z.number().int().nonnegative(),
+    createdBy: z.string(),
+    created: z.number().int().nonnegative()
+});
+
+export type AdminInvite = z.infer<typeof adminInviteSchema>;
+
+export const adminUserList = {
+    command: 'admin.userList' as const,
+    input: z.object({}),
+    output: z.object({ users: z.array(adminUserSchema) })
+};
+
+export const adminSetUserRole = {
+    command: 'admin.setUserRole' as const,
+    input: z.object({ userId: z.number().int().positive(), role: userRoleSchema }),
+    output: z.object({ userId: z.number().int().positive(), role: userRoleSchema })
+};
+
+/** Suspendre refuse la connexion sans rien détruire : c'est réversible. */
+export const adminSetUserStatus = {
+    command: 'admin.setUserStatus' as const,
+    input: z.object({ userId: z.number().int().positive(), status: userStatusSchema }),
+    output: z.object({ userId: z.number().int().positive(), status: userStatusSchema })
+};
+
+/**
+ * Supprime un compte **et tout ce qu'il possède** : son espace personnel, les
+ * espaces partagés dont il est propriétaire, et leur contenu, par cascade.
+ */
+export const adminDeleteUser = {
+    command: 'admin.deleteUser' as const,
+    input: z.object({ userId: z.number().int().positive() }),
+    output: z.object({ userId: z.number().int().positive() })
+};
+
+export const adminInviteList = {
+    command: 'admin.inviteList' as const,
+    input: z.object({}),
+    output: z.object({ invites: z.array(adminInviteSchema) })
+};
+
+export const adminInviteCreate = {
+    command: 'admin.inviteCreate' as const,
+    input: z.object({
+        /** Verrouille l'invitation sur une adresse ; vide = ouverte. */
+        email: z.string().max(320),
+        /** Espace rejoint à la création du compte ; `null` = aucun. */
+        workspaceId: z.number().int().positive().nullable(),
+        ttlSeconds: z
+            .number()
+            .int()
+            .positive()
+            .max(30 * 24 * 3600)
+            .nullable(),
+        maxUses: z.number().int().positive().max(100).nullable()
+    }),
+    output: z.object({ invite: adminInviteSchema })
+};
+
+export const adminInviteRevoke = {
+    command: 'admin.inviteRevoke' as const,
+    input: z.object({ token: z.string().min(1) }),
+    output: z.object({ token: z.string().min(1) })
+};
+
+export const adminCommands = [
+    adminUserList,
+    adminSetUserRole,
+    adminSetUserStatus,
+    adminDeleteUser,
+    adminInviteList,
+    adminInviteCreate,
+    adminInviteRevoke
+] as const;