@deveye/types 0.15.2 → 0.16.0

package/src/features/backup.ts

@@ -1,230 +0,0 @@
-import { z } from 'zod';
-import {
-    BACKUP_ACCESS_KEY_MAX,
-    BACKUP_BUCKET_MAX,
-    BACKUP_DESTINATION_NAME_MAX,
-    BACKUP_ENDPOINT_MAX,
-    BACKUP_JOB_NAME_MAX,
-    BACKUP_PATH_MAX,
-    BACKUP_SECRET_MAX,
-    backupDestinationKindSchema,
-    backupDestinationProbeSchema,
-    backupDestinationSchema,
-    backupEncryptionSchema,
-    backupJobSchema,
-    backupRunSchema,
-    backupScheduleKindSchema,
-    backupSourceCandidateSchema,
-    backupSourceKindSchema
-} from '../domain/backup';
-
-/**
- * Commandes des sauvegardes.
- *
- * Deux moitiés qui ne se recouvrent pas: les **destinations** (où) et les
- * **travaux** (quoi, quand, combien de copies). Tout est à l'étage ouvert, donc
- * aucune de ces commandes ne demande de session déverrouillée — c'est la
- * condition pour qu'une sauvegarde parte à 3 h du matin.
- *
- * `backup.deveyeDump` n'existe pas comme commande: la base de DevEye se
- * sauvegarde par un travail de source `deveye` comme les autres, et il n'y a
- * aucune raison de lui inventer un chemin à part.
- */
-
-const destinationId = z.number().int().positive();
-const jobId = z.number().int().positive();
-
-// ---------------------------------------------------------- destinations
-
-/** Les destinations de l'espace, dans l'ordre où elles ont été déclarées. */
-export const backupDestinationList = {
-    command: 'backup.destinationList' as const,
-    input: z.object({}),
-    output: z.object({ destinations: z.array(backupDestinationSchema) })
-};
-
-/**
- * Déclare une destination.
- *
- * Un seul schéma pour les trois genres, avec les champs des deux autres à
- * `null`: la forme alternative (trois commandes, ou une union discriminée)
- * obligerait l'écran à trois formulaires là où il n'en a qu'un, dont les champs
- * apparaissent selon le genre choisi.
- */
-export const backupDestinationAdd = {
-    command: 'backup.destinationAdd' as const,
-    input: z.object({
-        kind: backupDestinationKindSchema,
-        name: z.string().min(1).max(BACKUP_DESTINATION_NAME_MAX),
-        deviceId: z.uuid().nullable(),
-        path: z.string().max(BACKUP_PATH_MAX),
-        endpoint: z.string().max(BACKUP_ENDPOINT_MAX).nullable(),
-        region: z.string().max(64).nullable(),
-        bucket: z.string().max(BACKUP_BUCKET_MAX).nullable(),
-        accessKeyId: z.string().max(BACKUP_ACCESS_KEY_MAX).nullable(),
-        secret: z.string().max(BACKUP_SECRET_MAX).nullable(),
-        pathStyle: z.boolean()
-    }),
-    output: z.object({ destination: backupDestinationSchema })
-};
-
-/** `secret` omis = inchangé: le serveur ne l'a jamais rendu, on ne le réécrit pas. */
-export const backupDestinationUpdate = {
-    command: 'backup.destinationUpdate' as const,
-    input: z.object({
-        destinationId,
-        name: z.string().min(1).max(BACKUP_DESTINATION_NAME_MAX),
-        deviceId: z.uuid().nullable(),
-        path: z.string().max(BACKUP_PATH_MAX),
-        endpoint: z.string().max(BACKUP_ENDPOINT_MAX).nullable(),
-        region: z.string().max(64).nullable(),
-        bucket: z.string().max(BACKUP_BUCKET_MAX).nullable(),
-        accessKeyId: z.string().max(BACKUP_ACCESS_KEY_MAX).nullable(),
-        secret: z.string().max(BACKUP_SECRET_MAX).optional(),
-        pathStyle: z.boolean()
-    }),
-    output: z.object({ destination: backupDestinationSchema })
-};
-
-/**
- * Retire une destination. **Refusée** tant qu'un travail la vise.
- *
- * Contrairement aux jetons de déploiement, qui laissent la cible orpheline mais
- * vivante: un travail sans destination n'a aucun comportement raisonnable — il
- * ne peut ni s'exécuter ni le dire à l'avance. Mieux vaut obliger à trancher.
- */
-export const backupDestinationRemove = {
-    command: 'backup.destinationRemove' as const,
-    input: z.object({ destinationId }),
-    output: z.object({ destinationId })
-};
-
-/**
- * Contrôle qu'une destination est joignable et inscriptible, **maintenant**.
- *
- * Écrit puis relit puis efface un petit objet témoin: lister un bucket ne prouve
- * pas qu'on peut y écrire, et découvrir le contraire à 3 h du matin est
- * exactement ce que cette commande existe pour éviter.
- */
-export const backupDestinationTest = {
-    command: 'backup.destinationTest' as const,
-    input: z.object({ destinationId }),
-    output: backupDestinationProbeSchema
-};
-
-// ---------------------------------------------------------------- travaux
-
-/** Les travaux de l'espace, avec l'état de leur dernier passage. */
-export const backupJobList = {
-    command: 'backup.jobList' as const,
-    input: z.object({}),
-    output: z.object({ jobs: z.array(backupJobSchema) })
-};
-
-/** Compte les travaux actifs. Métadonnée en clair pure, pour la tuile d'accueil. */
-export const backupCount = {
-    command: 'backup.count' as const,
-    input: z.object({}),
-    output: z.object({
-        count: z.number().int().nonnegative(),
-        /** Combien ont échoué à leur dernier passage — ce que la tuile signale. */
-        failing: z.number().int().nonnegative()
-    })
-};
-
-/** Un travail et son historique, du plus récent au plus ancien. */
-export const backupJobGet = {
-    command: 'backup.jobGet' as const,
-    input: z.object({ jobId, limit: z.number().int().positive().max(100).optional() }),
-    output: z.object({ job: backupJobSchema, runs: z.array(backupRunSchema) })
-};
-
-const jobBody = {
-    name: z.string().min(1).max(BACKUP_JOB_NAME_MAX),
-    destinationId,
-    encryption: backupEncryptionSchema,
-    source: backupSourceKindSchema,
-    sourceId: z.number().int().positive().nullable(),
-    enabled: z.boolean(),
-    schedule: backupScheduleKindSchema,
-    scheduleHour: z.number().int().min(0).max(23),
-    scheduleWeekday: z.number().int().min(0).max(6),
-    scheduleDay: z.number().int().min(1).max(28),
-    keepLast: z.number().int().min(1).max(365)
-};
-
-export const backupJobAdd = {
-    command: 'backup.jobAdd' as const,
-    input: z.object(jobBody),
-    output: z.object({ job: backupJobSchema })
-};
-
-export const backupJobUpdate = {
-    command: 'backup.jobUpdate' as const,
-    input: z.object({ jobId, ...jobBody }),
-    output: z.object({ job: backupJobSchema })
-};
-
-/**
- * Supprime un travail et son historique.
- *
- * Les archives déjà écrites ne sont **pas** touchées: DevEye a produit des
- * fichiers chez quelqu'un d'autre, et les effacer parce qu'on range sa
- * configuration serait le contraire d'une sauvegarde. L'écran le dit.
- */
-export const backupJobRemove = {
-    command: 'backup.jobRemove' as const,
-    input: z.object({ jobId }),
-    output: z.object({ jobId })
-};
-
-/**
- * Lance un travail tout de suite.
- *
- * Ne rend pas l'archive: une sauvegarde dure des minutes, et attendre la réponse
- * d'une commande WS pendant ce temps-là ne marcherait pas. Elle inscrit
- * l'exécution en `running` et rend sa ligne; l'avancement se lit en
- * re-sollicitant, comme partout ailleurs (le sujet `backup` est diffusé à
- * chaque transition).
- */
-export const backupJobRun = {
-    command: 'backup.jobRun' as const,
-    input: z.object({ jobId }),
-    output: z.object({ run: backupRunSchema })
-};
-
-/** Les sources sauvegardables de l'espace, pour remplir le sélecteur. */
-export const backupSources = {
-    command: 'backup.sources' as const,
-    input: z.object({}),
-    output: z.object({ candidates: z.array(backupSourceCandidateSchema) })
-};
-
-/**
- * Les dernières exécutions de l'espace, tous travaux confondus.
- *
- * Ce que la vue d'ensemble montre: on veut savoir « est-ce que mes sauvegardes
- * tournent », pas ouvrir sept fiches pour le découvrir.
- */
-export const backupRuns = {
-    command: 'backup.runs' as const,
-    input: z.object({ limit: z.number().int().positive().max(200).optional() }),
-    output: z.object({ runs: z.array(backupRunSchema) })
-};
-
-export const backupCommands = [
-    backupDestinationList,
-    backupDestinationAdd,
-    backupDestinationUpdate,
-    backupDestinationRemove,
-    backupDestinationTest,
-    backupJobList,
-    backupCount,
-    backupJobGet,
-    backupJobAdd,
-    backupJobUpdate,
-    backupJobRemove,
-    backupJobRun,
-    backupSources,
-    backupRuns
-] as const;

package/src/features/database.ts

@@ -1,461 +0,0 @@
-import { z } from 'zod';
-import {
-    DATABASE_ALERT_MESSAGE_MAX_LENGTH,
-    DATABASE_ALERT_NAME_MAX_LENGTH,
-    DATABASE_HOST_MAX_LENGTH,
-    DATABASE_NAME_MAX_LENGTH,
-    DATABASE_SECRET_MAX_LENGTH,
-    DATABASE_SQL_MAX_LENGTH,
-    DATABASE_USER_MAX_LENGTH,
-    databaseAccessKindSchema,
-    databaseAlertSchema,
-    databaseCellSchema,
-    databaseCombinatorSchema,
-    databaseConditionSchema,
-    databaseEngineSchema,
-    databaseExecutionSchema,
-    databaseExportFormatSchema,
-    databaseFilterSchema,
-    databaseIdRangeSchema,
-    databaseProbeSchema,
-    databaseRowsSchema,
-    databaseSchema,
-    databaseSortSchema,
-    databaseSshAuthSchema,
-    databaseStructureSchema,
-    databaseTableSchema,
-    databaseUsageSchema
-} from '../domain/database';
-
-/**
- * Commandes des bases de données de l'espace.
- *
- * Préfixe unique `database.`, comme `git.` et `project.` — d'où le camelCase
- * derrière le point.
- *
- * ⚠️ Conséquence à connaître : le filet de démarrage (`MUTATION_VERB` dans
- * `src/features/_topics.ts`) cherche un verbe **juste après le point**. Il ne
- * verra donc **aucune** de ces commandes, et un `mutates` oublié ne produira
- * aucun avertissement. Il se relit à la main.
- *
- * ## Rien ne se connecte tout seul
- *
- * Seules `test`, `inspect`, `tableList`, `tableRows` et `alertTest` joignent la
- * base, et toutes sont déclenchées par un geste explicite. `list` et `get`
- * lisent le cache local — ouvrir la feature ne réveille aucun serveur.
- *
- * L'espace visé n'apparaît dans aucune entrée : il voyage sur l'enveloppe WS et
- * le dispatcheur le résout, appartenance vérifiée, avant le handler.
- */
-
-const databaseId = z.number().int().positive();
-const alertId = z.number().int().positive();
-
-/** La partie réglable d'un accès, secret compris (jamais rendu en retour). */
-const accessInput = z.object({
-    kind: databaseAccessKindSchema,
-    host: z.string().max(DATABASE_HOST_MAX_LENGTH),
-    port: z.number().int().min(1).max(65535).nullable(),
-    username: z.string().max(DATABASE_USER_MAX_LENGTH),
-    auth: databaseSshAuthSchema,
-    /**
-     * Mot de passe SSH ou clé privée. Absent = on garde celui en place ; une
-     * chaîne vide l'efface. Le client ne le reçoit jamais, il ne peut donc pas
-     * le renvoyer inchangé — d'où cette convention plutôt qu'un champ obligatoire.
-     */
-    secret: z.string().max(DATABASE_SECRET_MAX_LENGTH).optional()
-});
-
-// ------------------------------------------------------------------- bases
-
-/** Le nombre de bases de l'espace, pour la tuile de l'accueil. */
-export const databaseCount = {
-    command: 'database.count' as const,
-    input: z.object({}),
-    output: z.object({ count: z.number().int().nonnegative() })
-};
-
-/** Les bases de l'espace, dans l'ordre de l'utilisateur. Lit le cache local. */
-export const databaseList = {
-    command: 'database.list' as const,
-    input: z.object({}),
-    output: z.object({ databases: z.array(databaseSchema) })
-};
-
-/** Une base, avec les projets qui s'en servent et ses alertes. */
-export const databaseGet = {
-    command: 'database.get' as const,
-    input: z.object({ databaseId }),
-    output: z.object({
-        database: databaseSchema,
-        usage: z.array(databaseUsageSchema),
-        alerts: z.array(databaseAlertSchema)
-    })
-};
-
-export const databaseAdd = {
-    command: 'database.add' as const,
-    input: z.object({
-        engine: databaseEngineSchema,
-        name: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        host: z.string().min(1).max(DATABASE_HOST_MAX_LENGTH),
-        port: z.number().int().min(1).max(65535),
-        database: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        username: z.string().max(DATABASE_USER_MAX_LENGTH),
-        password: z.string().max(DATABASE_SECRET_MAX_LENGTH),
-        access: accessInput,
-        monitorEnabled: z.boolean(),
-        intervalSeconds: z.number().int().min(60).max(86400),
-        autoLoadTables: z.boolean()
-    }),
-    output: z.object({ database: databaseSchema })
-};
-
-/**
- * Modifie une base. `password` absent = on garde celui en place ; une chaîne
- * vide l'efface. Même convention que le secret du tunnel, et pour la même
- * raison : un secret rendu au client est un secret qu'on ne peut plus reprendre.
- */
-export const databaseUpdate = {
-    command: 'database.update' as const,
-    input: z.object({
-        databaseId,
-        name: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        host: z.string().min(1).max(DATABASE_HOST_MAX_LENGTH),
-        port: z.number().int().min(1).max(65535),
-        database: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        username: z.string().max(DATABASE_USER_MAX_LENGTH),
-        password: z.string().max(DATABASE_SECRET_MAX_LENGTH).optional(),
-        access: accessInput,
-        monitorEnabled: z.boolean(),
-        intervalSeconds: z.number().int().min(60).max(86400),
-        autoLoadTables: z.boolean()
-    }),
-    output: z.object({ database: databaseSchema })
-};
-
-/**
- * Retire une base de l'espace, avec ses alertes et toutes ses liaisons.
- *
- * Les projets liés ne sont **pas** touchés : ils perdent leur base, rien
- * d'autre. Le serveur distant, lui, n'est évidemment jamais atteint.
- */
-export const databaseRemove = {
-    command: 'database.remove' as const,
-    input: z.object({ databaseId }),
-    output: z.object({ databaseId })
-};
-
-/**
- * Range les bases de l'espace : `ids` est la liste **complète** dans son ordre
- * final. Une nouvelle base prend le rang suivant, donc la fin de la liste.
- */
-export const databaseReorder = {
-    command: 'database.reorder' as const,
-    input: z.object({ ids: z.array(databaseId).min(1) }),
-    output: z.object({ ids: z.array(databaseId) })
-};
-
-// ------------------------------------------------------- à la demande
-
-/**
- * Essaie de joindre la base, maintenant.
- *
- * Ne lève **jamais** sur un échec de connexion : un serveur injoignable est une
- * réponse, pas une erreur de commande. Le message revient dans `error`, déjà
- * traduit, et l'interface le montre sans rien bloquer.
- */
-export const databaseTest = {
-    command: 'database.test' as const,
-    input: z.object({ databaseId }),
-    output: z.object({ probe: databaseProbeSchema })
-};
-
-/**
- * Essaie une connexion **avant** de l'enregistrer.
- *
- * Le formulaire d'ajout décrit une base qui n'existe pas encore : `test` ne peut
- * rien pour lui, il part d'un identifiant. Celui-ci prend les réglages tels
- * qu'ils sont saisis, et n'écrit rien — ni ligne, ni état.
- *
- * `databaseId` sert à la modification : les secrets ne redescendant jamais au
- * client, un champ laissé intact n'a rien à renvoyer, et le serveur reprend
- * alors celui qu'il détient déjà. Sans cela, « Tester » échouerait sur une base
- * qui fonctionne, faute de mot de passe.
- */
-export const databaseTestDraft = {
-    command: 'database.testDraft' as const,
-    input: z.object({
-        databaseId: databaseId.optional(),
-        engine: databaseEngineSchema,
-        host: z.string().min(1).max(DATABASE_HOST_MAX_LENGTH),
-        port: z.number().int().min(1).max(65535),
-        database: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        username: z.string().max(DATABASE_USER_MAX_LENGTH),
-        password: z.string().max(DATABASE_SECRET_MAX_LENGTH).optional(),
-        access: accessInput
-    }),
-    output: z.object({ probe: databaseProbeSchema })
-};
-
-/**
- * Relève l'inventaire maintenant : version du serveur, taille, nombre de
- * tables, et l'état des alertes. C'est ce que fait le relevé périodique, sur
- * demande explicite — ce qui le rend utile même sur une base au repos.
- */
-export const databaseInspect = {
-    command: 'database.inspect' as const,
-    input: z.object({ databaseId }),
-    output: z.object({ database: databaseSchema, probe: databaseProbeSchema })
-};
-
-/** Les tables de la base, lues chez le serveur au moment de la demande. */
-export const databaseTableList = {
-    command: 'database.tableList' as const,
-    input: z.object({ databaseId }),
-    output: z.object({ tables: z.array(databaseTableSchema) })
-};
-
-/**
- * Le contenu d'une table, page par page.
- *
- * ## Rien de ce qui vient du client n'entre tel quel dans une requête
- *
- * Un identifiant ne peut pas être un paramètre lié : nom de table, nom de
- * colonne, sens du tri sont donc **confrontés au catalogue réel** avant d'être
- * cités, et un nom qui n'y figure pas n'atteint jamais le moteur. Les valeurs,
- * elles, sont toujours liées ; l'opérateur d'un filtre est choisi dans une
- * énumération fermée. Aucun fragment de SQL ne traverse le contrat.
- *
- * `withStructure` évite un second aller-retour à la sélection d'une table : la
- * structure et la première page arrivent alors dans la **même session**, ce qui
- * compte quand chaque connexion rouvre un tunnel SSH.
- */
-export const databaseTableRows = {
-    command: 'database.tableRows' as const,
-    input: z.object({
-        databaseId,
-        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
-        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        offset: z.number().int().nonnegative().max(1_000_000).optional(),
-        limit: z.number().int().positive().max(200).optional(),
-        filters: z.array(databaseFilterSchema).max(8).optional(),
-        combinator: databaseCombinatorSchema.optional(),
-        sort: databaseSortSchema.optional(),
-        withStructure: z.boolean().optional()
-    }),
-    output: z.object({ rows: databaseRowsSchema, structure: databaseStructureSchema.optional() })
-};
-
-/** La structure seule : colonnes, clé primaire, clés étrangères, index. */
-export const databaseTableStructure = {
-    command: 'database.tableStructure' as const,
-    input: z.object({
-        databaseId,
-        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
-        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH)
-    }),
-    output: z.object({ structure: databaseStructureSchema })
-};
-
-// ------------------------------------------------------- écrire des lignes
-
-/**
- * Les trois écritures de l'explorateur.
- *
- * ## Ce que le serveur refuse, et pourquoi
- *
- * Modifier ou supprimer exige une **clé primaire**. Sans elle, aucune condition
- * ne désigne *une* ligne : un `UPDATE` en toucherait plusieurs, un `DELETE` en
- * emporterait autant, et rien ne permettrait de revenir en arrière. Le serveur
- * refuse alors, avec la raison ; l'interface ne propose même pas le geste.
- *
- * ## Ce qui décide en dernier ressort
- *
- * Le compte saisi dans les réglages de la base. DevEye peut demander une
- * écriture ; c'est le serveur distant qui l'accorde ou la refuse. Un compte en
- * lecture seule rend donc tout ceci inoffensif, ce que dit le formulaire.
- */
-export const databaseRowInsert = {
-    command: 'database.rowInsert' as const,
-    input: z.object({
-        databaseId,
-        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
-        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        values: z.array(databaseCellSchema).min(1).max(200)
-    }),
-    output: z.object({ inserted: z.number().int().nonnegative() })
-};
-
-export const databaseRowUpdate = {
-    command: 'database.rowUpdate' as const,
-    input: z.object({
-        databaseId,
-        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
-        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        /** La ligne visée, par ses colonnes de clé primaire. */
-        key: z.array(databaseCellSchema).min(1).max(16),
-        values: z.array(databaseCellSchema).min(1).max(200)
-    }),
-    output: z.object({ updated: z.number().int().nonnegative() })
-};
-
-export const databaseRowDelete = {
-    command: 'database.rowDelete' as const,
-    input: z.object({
-        databaseId,
-        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
-        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
-        /** Une entrée par ligne, chacune par ses colonnes de clé primaire. */
-        keys: z.array(z.array(databaseCellSchema).min(1).max(16)).min(1).max(200)
-    }),
-    output: z.object({ deleted: z.number().int().nonnegative() })
-};
-
-/**
- * Une instruction libre, écriture comprise — le terminal.
- *
- * Distincte de `query`, qui refuse tout ce qui n'est pas une lecture parce
- * qu'elle sert à mettre au point une condition d'alerte. Ici l'intention est
- * l'inverse : administrer. Une seule instruction à la fois malgré tout, le
- * point-virgule interne restant refusé — c'est ce qui empêche qu'un copier-coller
- * en exécute trois quand on en visait une.
- */
-export const databaseExecute = {
-    command: 'database.execute' as const,
-    input: z.object({ databaseId, sql: z.string().min(1).max(DATABASE_SQL_MAX_LENGTH) }),
-    output: z.object({ result: databaseExecutionSchema })
-};
-
-/**
- * Exporte une table, ou toute la base.
- *
- * L'export est **complet** : il lit tout ce que la portée désigne, page par
- * page. Le seul plafond qui subsiste est un garde-fou mémoire du serveur, très
- * au-dessus de ce qu'un export normal atteint ; s'il est touché, `truncated` le
- * dit et l'interface le répète. Pour une copie fidèle d'un serveur entier,
- * `mysqldump` et `pg_dump` restent malgré tout les bons outils — eux savent
- * rejouer schéma, index et contraintes.
- *
- * `idRanges` restreint l'export aux lignes dont la **clé primaire** tombe dans
- * l'une des plages. Réservé à une portée d'une seule table : sur toute la base,
- * les clés n'ont ni le même nom ni le même sens d'une table à l'autre.
- */
-export const databaseExport = {
-    command: 'database.export' as const,
-    input: z.object({
-        databaseId,
-        format: databaseExportFormatSchema,
-        /** Absents : toute la base. Présents : cette table seule. */
-        schema: z.string().max(DATABASE_NAME_MAX_LENGTH).optional(),
-        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH).optional(),
-        /** Plages d'identifiants, bornes comprises. Sans effet sans `table`. */
-        idRanges: z.array(databaseIdRangeSchema).max(64).optional()
-    }),
-    output: z.object({
-        filename: z.string(),
-        content: z.string(),
-        rowCount: z.number().int().nonnegative(),
-        tableCount: z.number().int().nonnegative(),
-        /** Le plafond a été atteint : ce qui suit manque. */
-        truncated: z.boolean()
-    })
-};
-
-// ----------------------------------------------------------------- alertes
-
-export const databaseAlertList = {
-    command: 'database.alertList' as const,
-    input: z.object({ databaseId }),
-    output: z.object({ alerts: z.array(databaseAlertSchema) })
-};
-
-export const databaseAlertAdd = {
-    command: 'database.alertAdd' as const,
-    input: z.object({
-        databaseId,
-        name: z.string().min(1).max(DATABASE_ALERT_NAME_MAX_LENGTH),
-        enabled: z.boolean(),
-        combinator: databaseCombinatorSchema,
-        conditions: z.array(databaseConditionSchema).min(1).max(8),
-        message: z.string().min(1).max(DATABASE_ALERT_MESSAGE_MAX_LENGTH)
-    }),
-    output: z.object({ alert: databaseAlertSchema })
-};
-
-export const databaseAlertUpdate = {
-    command: 'database.alertUpdate' as const,
-    input: z.object({
-        alertId,
-        name: z.string().min(1).max(DATABASE_ALERT_NAME_MAX_LENGTH),
-        enabled: z.boolean(),
-        combinator: databaseCombinatorSchema,
-        conditions: z.array(databaseConditionSchema).min(1).max(8),
-        message: z.string().min(1).max(DATABASE_ALERT_MESSAGE_MAX_LENGTH)
-    }),
-    output: z.object({ alert: databaseAlertSchema })
-};
-
-export const databaseAlertRemove = {
-    command: 'database.alertRemove' as const,
-    input: z.object({ alertId }),
-    output: z.object({ alertId })
-};
-
-/**
- * Évalue une alerte tout de suite et rend ce que chaque condition a mesuré,
- * **sans notifier personne**.
- *
- * C'est ce qui rend une condition écrivable : on voit le nombre que rend sa
- * requête avant de choisir un seuil, au lieu d'attendre une notification pour
- * découvrir qu'on s'est trompé de colonne.
- */
-export const databaseAlertTest = {
-    command: 'database.alertTest' as const,
-    input: z.object({
-        databaseId,
-        combinator: databaseCombinatorSchema,
-        conditions: z.array(databaseConditionSchema).min(1).max(8)
-    }),
-    output: z.object({
-        firing: z.boolean(),
-        values: z.array(z.number().nullable()),
-        /** L'erreur de chaque condition, à sa place — `null` si elle a abouti. */
-        errors: z.array(z.string().nullable()),
-        elapsedMs: z.number().int().nonnegative()
-    })
-};
-
-/** Une requête libre en lecture seule, pour mettre au point une condition. */
-export const databaseQuery = {
-    command: 'database.query' as const,
-    input: z.object({ databaseId, sql: z.string().min(1).max(DATABASE_SQL_MAX_LENGTH) }),
-    output: z.object({ rows: databaseRowsSchema })
-};
-
-export const databaseCommands = [
-    databaseCount,
-    databaseList,
-    databaseGet,
-    databaseAdd,
-    databaseUpdate,
-    databaseRemove,
-    databaseReorder,
-    databaseTest,
-    databaseTestDraft,
-    databaseInspect,
-    databaseTableList,
-    databaseTableRows,
-    databaseTableStructure,
-    databaseRowInsert,
-    databaseRowUpdate,
-    databaseRowDelete,
-    databaseExecute,
-    databaseExport,
-    databaseAlertList,
-    databaseAlertAdd,
-    databaseAlertUpdate,
-    databaseAlertRemove,
-    databaseAlertTest,
-    databaseQuery
-] as const;