@deveye/types 0.15.0

package/src/features/note.ts

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+import {
+    NOTE_FOLDER_MAX_LENGTH,
+    NOTE_MAX_BLOCKS,
+    NOTE_TITLE_MAX_LENGTH,
+    noteBlockSchema,
+    noteFolderSchema,
+    noteSchema,
+    noteSummarySchema
+} from '../domain/note';
+
+const folderId = z.number().int().positive();
+
+/**
+ * Commandes des notes et de leurs dossiers.
+ *
+ * L'espace visé n'apparaît dans aucune entrée : il voyage sur l'enveloppe WS
+ * (voir `protocol/envelope`) et le dispatcheur le résout avant le handler.
+ */
+
+/** The editable shape of a note — everything the client may set. */
+const noteDraftSchema = z.object({
+    title: z.string().max(NOTE_TITLE_MAX_LENGTH),
+    folderId: folderId.nullable(),
+    blocks: z.array(noteBlockSchema).max(NOTE_MAX_BLOCKS),
+    /** Encrypt the body with the password-protected key rather than the open one. */
+    private: z.boolean()
+});
+
+/**
+ * List the notes of the active workspace. Never gated: regular notes are decrypted with the
+ * open key, and private notes come back **masked** (metadata only,
+ * `masked: true`) while the session is locked. Unlocking and re-listing reveals
+ * them — no per-command password is involved.
+ *
+ * `archived` swaps the two disjoint sets: the active notes (default) or the
+ * archive, most recently archived first.
+ */
+export const noteList = {
+    command: 'note.list' as const,
+    input: z.object({ archived: z.boolean().optional() }),
+    output: z.object({ notes: z.array(noteSummarySchema) })
+};
+
+/**
+ * Count the **active** notes of the active workspace. Pure clear metadata: every
+ * row is counted the same way — private notes included, no special case —
+ * without decrypting anything, so the dashboard widget always shows a number
+ * even when the session is locked. Archived notes are excluded.
+ */
+export const noteCount = {
+    command: 'note.count' as const,
+    input: z.object({}),
+    output: z.object({ count: z.number().int().nonnegative() })
+};
+
+/**
+ * Fetch one note in full. A private note requires the session to be unlocked;
+ * otherwise the server replies `locked` and the client opens the usual unlock
+ * prompt before retrying.
+ */
+export const noteGet = {
+    command: 'note.get' as const,
+    input: z.object({ noteId: z.number().int().positive() }),
+    output: z.object({ note: noteSchema })
+};
+
+export const noteAdd = {
+    command: 'note.add' as const,
+    input: z.object({ note: noteDraftSchema }),
+    output: z.object({ note: noteSchema })
+};
+
+/**
+ * Edit a note. Touching a note that is (or becomes) private requires the session
+ * to be unlocked; the draft's `private` flag decides which key the new body is
+ * written with, so flipping it re-encrypts the note into the other tier.
+ */
+export const noteEdit = {
+    command: 'note.edit' as const,
+    input: z.object({
+        noteId: z.number().int().positive(),
+        note: noteDraftSchema
+    }),
+    output: z.object({ note: noteSchema })
+};
+
+/**
+ * Archive a note: it leaves the main list but nothing is destroyed. This is what
+ * "supprimer" does in the UI — {@link noteDelete} is the deliberate second step.
+ */
+export const noteArchive = {
+    command: 'note.archive' as const,
+    input: z.object({ noteId: z.number().int().positive() }),
+    output: z.object({ noteId: z.number().int().positive() })
+};
+
+/** Bring an archived note back into the active list. */
+export const noteRestore = {
+    command: 'note.restore' as const,
+    input: z.object({ noteId: z.number().int().positive() }),
+    output: z.object({ noteId: z.number().int().positive() })
+};
+
+/**
+ * Destroy a note for good. Only ever accepted on an **archived** note (`conflict`
+ * otherwise), so nothing can be lost in one click. Like archiving, it requires
+ * the session to be unlocked when the note is private.
+ */
+export const noteDelete = {
+    command: 'note.delete' as const,
+    input: z.object({ noteId: z.number().int().positive() }),
+    output: z.object({ noteId: z.number().int().positive() })
+};
+
+/**
+ * Lay out one folder: `noteIds` is its **complete** content in its final order
+ * (lower index first), and every listed note is filed into `folderId` on the way.
+ * One command covers both reordering inside a folder and moving a note across
+ * folders — the destination's new order is all the server needs.
+ *
+ * Notes carry no automatic ordering: this, plus appending new notes at the end,
+ * is the only thing that positions them. Never touches the encrypted body, so it
+ * works on masked private notes too.
+ */
+export const noteReorder = {
+    command: 'note.reorder' as const,
+    input: z.object({
+        folderId: folderId.nullable(),
+        noteIds: z.array(z.number().int().positive()).min(1)
+    }),
+    output: z.object({
+        folderId: folderId.nullable(),
+        noteIds: z.array(z.number().int().positive())
+    })
+};
+
+/** List the active workspace's folders (names decrypted server-side). */
+export const folderList = {
+    command: 'folder.list' as const,
+    input: z.object({}),
+    output: z.object({ folders: z.array(noteFolderSchema) })
+};
+
+export const folderAdd = {
+    command: 'folder.add' as const,
+    input: z.object({ name: z.string().min(1).max(NOTE_FOLDER_MAX_LENGTH) }),
+    output: z.object({ folder: noteFolderSchema })
+};
+
+export const folderRename = {
+    command: 'folder.rename' as const,
+    input: z.object({ folderId, name: z.string().min(1).max(NOTE_FOLDER_MAX_LENGTH) }),
+    output: z.object({ folder: noteFolderSchema })
+};
+
+/**
+ * Reorder all of the active workspace's folders; `folderIds` is the new
+ * full order (lower index = listed first). Used by the move up/down controls.
+ */
+export const folderReorder = {
+    command: 'folder.reorder' as const,
+    input: z.object({ folderIds: z.array(folderId).min(1) }),
+    output: z.object({ folders: z.array(noteFolderSchema) })
+};
+
+/** Delete a folder; its notes are un-filed (folderId → null), not destroyed. */
+export const folderDelete = {
+    command: 'folder.delete' as const,
+    input: z.object({ folderId }),
+    output: z.object({ folderId })
+};
+
+export const noteCommands = [
+    noteList,
+    noteCount,
+    noteGet,
+    noteAdd,
+    noteEdit,
+    noteArchive,
+    noteRestore,
+    noteDelete,
+    noteReorder,
+    folderList,
+    folderAdd,
+    folderRename,
+    folderReorder,
+    folderDelete
+] as const;

package/src/features/notify.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+
+import {
+    notificationChannelInputSchema,
+    notificationChannelSchema,
+    notificationChannelUsageSchema,
+    notificationFeatureSchema,
+    notificationRouteInputSchema,
+    notificationRouteSchema,
+    notificationRouteTargetSchema,
+    notificationTestSchema
+} from '../domain/notifications';
+
+/**
+ * Les canaux d'alerte de l'espace, et les routes qui pointent vers eux.
+ *
+ * ## Pourquoi un module à part, et pas trois commandes par émetteur
+ *
+ * Il y en avait quinze — `getSettings`, `setSettings`, `testNotification`, pour
+ * chacun des cinq émetteurs — strictement identiques à leur préfixe près. Le
+ * dialogue client les reconstituait déjà par concaténation
+ * (`` `${feature}.getSettings` ``), ce qui disait tout : la fonctionnalité
+ * n'était pas dans la commande, elle était dans un **argument**. Elle l'est
+ * désormais pour de bon.
+ *
+ * Conséquence directe : brancher un sixième émetteur ne coûte plus trois
+ * commandes, trois entrées de registre et trois handlers, mais une valeur de
+ * plus dans `notificationFeatureSchema`.
+ *
+ * ## Deux étages d'autorisation, et ils ne sont pas les mêmes
+ *
+ * Gérer les **canaux** d'une fonctionnalité relève du champ `channels` de son
+ * grant de rôle (migration 093) : un canal appartient à une fonctionnalité
+ * (091), et son adresse ne se livre qu'à qui gère les canaux de celle-ci. Les
+ * **routes**, elles, relèvent de la fonctionnalité visée (`{ feature, level:
+ * 'write' }`) : décider où Uptime écrit fait partie du réglage d'Uptime, et n'a
+ * pas à ouvrir la gestion des destinations. C'est la séparation qui permet de
+ * confier le routage d'une fonctionnalité sans confier l'adresse de
+ * l'astreinte.
+ */
+
+const channelId = z.number().int().positive();
+
+/** Les canaux d'une fonctionnalité, ordonnés, avec leur nombre d'usages. */
+export const notifyChannelList = {
+    command: 'notify.channelList' as const,
+    input: z.object({ feature: notificationFeatureSchema }),
+    output: z.object({ channels: z.array(notificationChannelSchema) })
+};
+
+export const notifyChannelAdd = {
+    command: 'notify.channelAdd' as const,
+    /** `feature` : la fonctionnalité propriétaire, immuable ensuite. */
+    input: notificationChannelInputSchema.extend({ feature: notificationFeatureSchema }),
+    output: z.object({ channel: notificationChannelSchema })
+};
+
+export const notifyChannelUpdate = {
+    command: 'notify.channelUpdate' as const,
+    input: notificationChannelInputSchema.extend({ id: channelId, enabled: z.boolean() }),
+    output: z.object({ channel: notificationChannelSchema })
+};
+
+/**
+ * Ce qu'une suppression emporterait, **sans rien supprimer**.
+ *
+ * Lue par la confirmation pour nommer les routes qui vont cesser de prévenir.
+ * Séparée de la suppression elle-même parce qu'un écran qui demande « êtes-vous
+ * sûr ? » sans dire de quoi ne fait pas confirmer, il fait cliquer.
+ */
+export const notifyChannelUsage = {
+    command: 'notify.channelUsage' as const,
+    input: z.object({ id: channelId }),
+    output: notificationChannelUsageSchema
+};
+
+export const notifyChannelDelete = {
+    command: 'notify.channelDelete' as const,
+    input: z.object({ id: channelId }),
+    output: z.object({ ok: z.literal(true) })
+};
+
+export const notifyChannelReorder = {
+    command: 'notify.channelReorder' as const,
+    input: z.object({ ids: z.array(channelId).max(64) }),
+    output: z.object({ ok: z.literal(true) })
+};
+
+/**
+ * Un envoi d'essai **sur un seul canal**, tel qu'il est enregistré.
+ *
+ * L'ancien dialogue devait enregistrer avant de tester, faute de quoi l'essai
+ * partait sur les réglages précédents. Un canal étant une entité à part entière,
+ * l'essai vise directement son identifiant : plus d'enregistrement forcé, et
+ * plus de doute sur ce qui vient d'être éprouvé.
+ */
+export const notifyChannelTest = {
+    command: 'notify.channelTest' as const,
+    input: z.object({ id: channelId }),
+    output: notificationTestSchema
+};
+
+/** Où écrit une fonctionnalité, ou un de ses éléments. */
+export const notifyRouteGet = {
+    command: 'notify.routeGet' as const,
+    input: notificationRouteTargetSchema,
+    output: z.object({
+        route: notificationRouteSchema,
+        /**
+         * Les canaux de la route qui **n'appartiennent pas à cet espace**.
+         *
+         * Le cas d'un élément projeté depuis ailleurs : ses destinations vivent
+         * dans son espace d'origine. Sans cette liste, l'écran afficherait
+         * « aucun canal » sur un élément qui prévient bel et bien — le mensonge
+         * exact que la projection devait éviter.
+         *
+         * Rendus **masqués** : leur genre (« Salon Discord d'un autre espace »),
+         * jamais leur identité ni leur adresse.
+         */
+        foreign: z.array(notificationChannelSchema),
+        /**
+         * Cette route se règle-t-elle **d'ici** ?
+         *
+         * Faux sur un élément projeté depuis un autre espace : ses canaux
+         * appartiennent à cet espace-là, et l'ordonnanceur qui le sonde y
+         * tourne. Laisser l'écran proposer le réglage produirait un geste que
+         * le serveur refuse — un écran qui ment, pas une garde.
+         */
+        managedHere: z.boolean(),
+        /**
+         * L'espace **où cette route se règle** : le domicile de l'élément.
+         * Égal à l'espace de l'enveloppe quand `managedHere` est vrai. C'est ce
+         * qui permet à l'écran, sur un élément projeté, de proposer d'aller
+         * régler chez lui plutôt que d'expliquer un refus.
+         */
+        homeWorkspaceId: z.number().int().positive()
+    })
+};
+
+export const notifyRouteSet = {
+    command: 'notify.routeSet' as const,
+    input: notificationRouteInputSchema,
+    output: z.object({ route: notificationRouteSchema })
+};
+
+/** Un essai sur la route entière, héritage compris — ce que verrait une vraie alerte. */
+export const notifyRouteTest = {
+    command: 'notify.routeTest' as const,
+    input: notificationRouteTargetSchema,
+    output: notificationTestSchema
+};
+
+export const notifyCommands = [
+    notifyChannelList,
+    notifyChannelAdd,
+    notifyChannelUpdate,
+    notifyChannelUsage,
+    notifyChannelDelete,
+    notifyChannelReorder,
+    notifyChannelTest,
+    notifyRouteGet,
+    notifyRouteSet,
+    notifyRouteTest
+] as const;

package/src/features/password.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { passwordEntryMaskedSchema, passwordEntrySchema } from '../domain/password';
+
+/**
+ * Commandes du coffre de mots de passe.
+ *
+ * L'espace visé n'apparaît dans aucune entrée : il voyage sur l'enveloppe WS
+ * (voir `protocol/envelope`) et le dispatcheur le résout avant le handler.
+ */
+
+export const passwordList = {
+    command: 'password.list' as const,
+    input: z.object({}),
+    output: z.object({ entries: z.array(passwordEntryMaskedSchema) })
+};
+
+/**
+ * Compte les entrées de l'espace. Métadonnées claires uniquement (un nombre de
+ * lignes, aucun déchiffrement) : contrairement à `password.list`, la commande
+ * n'exige jamais que le chiffrement par mot de passe soit déverrouillé, donc le
+ * widget d'accueil affiche toujours un nombre, même session verrouillée.
+ */
+export const passwordCount = {
+    command: 'password.count' as const,
+    input: z.object({}),
+    output: z.object({ count: z.number().int().nonnegative() })
+};
+
+export const passwordGet = {
+    command: 'password.get' as const,
+    input: z.object({ passwordId: z.number().int().positive() }),
+    output: z.object({ entry: passwordEntrySchema })
+};
+
+export const passwordAdd = {
+    command: 'password.add' as const,
+    input: z.object({ entry: passwordEntrySchema.omit({ id: true }) }),
+    output: z.object({ entry: passwordEntrySchema })
+};
+
+export const passwordEdit = {
+    command: 'password.edit' as const,
+    input: z.object({ entry: passwordEntrySchema }),
+    output: z.object({ entry: passwordEntrySchema })
+};
+
+export const passwordDelete = {
+    command: 'password.delete' as const,
+    input: z.object({ passwordId: z.number().int().positive() }),
+    output: z.object({ passwordId: z.number().int().positive() })
+};
+
+export const passwordUnlock = {
+    command: 'password.unlock' as const,
+    input: z.object({ password: z.string().min(1) }),
+    output: z.object({ unlocked: z.literal(true) })
+};
+
+export const passwordCommands = [
+    passwordList,
+    passwordCount,
+    passwordGet,
+    passwordAdd,
+    passwordEdit,
+    passwordDelete,
+    passwordUnlock
+] as const;