@deveye/types 0.15.0

package/src/features/uptime.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+import {
+    UPTIME_INTERVAL_MAX,
+    UPTIME_INTERVAL_MIN,
+    UPTIME_KEYWORD_MAX_LENGTH,
+    UPTIME_NAME_MAX_LENGTH,
+    UPTIME_THRESHOLD_MAX,
+    UPTIME_TIMEOUT_MAX,
+    UPTIME_TIMEOUT_MIN,
+    UPTIME_URL_MAX_LENGTH,
+    uptimeCheckSchema,
+    uptimeCheckStatsSchema,
+    uptimeIncidentSchema,
+    uptimeMethodSchema,
+    uptimePointSchema,
+    uptimeRangeSchema,
+    uptimeResolutionSchema,
+    uptimeRetentionSchema,
+    uptimeServiceSchema
+} from '../domain/uptime';
+
+const serviceId = z.number().int().positive();
+
+/** Everything the user may set on a service. */
+const uptimeDraftSchema = z.object({
+    name: z.string().min(1).max(UPTIME_NAME_MAX_LENGTH),
+    url: z.string().url().max(UPTIME_URL_MAX_LENGTH),
+    method: uptimeMethodSchema,
+    expectedStatus: z.number().int().min(100).max(599).nullable(),
+    keyword: z.string().max(UPTIME_KEYWORD_MAX_LENGTH).nullable(),
+    intervalSeconds: z.number().int().min(UPTIME_INTERVAL_MIN).max(UPTIME_INTERVAL_MAX),
+    timeoutSeconds: z.number().int().min(UPTIME_TIMEOUT_MIN).max(UPTIME_TIMEOUT_MAX),
+    failureThreshold: z.number().int().min(1).max(UPTIME_THRESHOLD_MAX),
+    retentionDays: uptimeRetentionSchema,
+    enabled: z.boolean()
+});
+
+/**
+ * List the workspace's services in the user's own order, each carrying its live
+ * state and its 24 h / 7 d / 30 d ratios. Never gated: uptime data lives in the
+ * open tier, so the feature opens with no password prompt.
+ */
+export const uptimeList = {
+    command: 'uptime.list' as const,
+    input: z.object({}),
+    output: z.object({ services: z.array(uptimeServiceSchema) })
+};
+
+/**
+ * "N services up out of M" — the only thing the home card and the navbar widget
+ * need. Pure clear metadata, so it costs one indexed count. Paused services are
+ * excluded entirely, and `up + down` may be **below** `total`: one awaiting its
+ * first probe is neither, and must not be reported as a failure.
+ */
+export const uptimeCount = {
+    command: 'uptime.count' as const,
+    input: z.object({}),
+    output: z.object({
+        total: z.number().int().nonnegative(),
+        up: z.number().int().nonnegative(),
+        down: z.number().int().nonnegative()
+    })
+};
+
+export const uptimeAdd = {
+    command: 'uptime.add' as const,
+    input: z.object({ service: uptimeDraftSchema }),
+    output: z.object({ service: uptimeServiceSchema })
+};
+
+/** Replace a service's whole configuration. History and incidents are kept. */
+export const uptimeUpdate = {
+    command: 'uptime.update' as const,
+    input: z.object({ id: serviceId, service: uptimeDraftSchema }),
+    output: z.object({ service: uptimeServiceSchema })
+};
+
+/**
+ * Pause or resume probing without touching the rest of the configuration — a
+ * paused service keeps its history and simply stops being scheduled.
+ */
+export const uptimeSetEnabled = {
+    command: 'uptime.setEnabled' as const,
+    input: z.object({ id: serviceId, enabled: z.boolean() }),
+    output: z.object({ service: uptimeServiceSchema })
+};
+
+/** Destroy a service **and its whole history** — there is no archive here. */
+export const uptimeRemove = {
+    command: 'uptime.remove' as const,
+    input: z.object({ id: serviceId }),
+    output: z.object({ id: serviceId })
+};
+
+/**
+ * Lay out the workspace's services: `ids` is the **complete** list in its final
+ * order (lower index first). Nothing else positions a service — new ones are
+ * appended — so the order is entirely the user's, as it is for notes. Touches no
+ * probe state, so reordering never disturbs monitoring.
+ */
+export const uptimeReorder = {
+    command: 'uptime.reorder' as const,
+    input: z.object({ ids: z.array(serviceId).min(1) }),
+    output: z.object({ ids: z.array(serviceId) })
+};
+
+/** Probe a service right now instead of waiting for its next tick. */
+export const uptimeCheckNow = {
+    command: 'uptime.checkNow' as const,
+    input: z.object({ id: serviceId }),
+    output: z.object({ service: uptimeServiceSchema })
+};
+
+/**
+ * Chart series over a window. The server picks the bucket size from the range
+ * (`raw` up to 24 h, hourly up to 30 d, daily beyond) and reads the long ranges
+ * from the daily rollup, which is never pruned.
+ */
+export const uptimeHistory = {
+    command: 'uptime.history' as const,
+    input: z.object({ id: serviceId, range: uptimeRangeSchema }),
+    output: z.object({
+        resolution: uptimeResolutionSchema,
+        points: z.array(uptimePointSchema)
+    })
+};
+
+/**
+ * Which pings a journal query is about. Shared by {@link uptimeChecks} and
+ * {@link uptimeCheckStats} so a page and its aggregates always describe the
+ * exact same selection.
+ */
+const checkFilterSchema = z.object({
+    /** Keep only probes at or after this epoch second; `null` = the whole history. */
+    since: z.number().int().nonnegative().nullable(),
+    /** Restrict to failed probes. */
+    failuresOnly: z.boolean()
+});
+
+/**
+ * Raw ping journal, most recent first. `before` pages backwards through time
+ * (exclusive upper bound, epoch seconds).
+ */
+export const uptimeChecks = {
+    command: 'uptime.checks' as const,
+    input: z.object({
+        id: serviceId,
+        limit: z.number().int().min(1).max(200),
+        before: z.number().int().nonnegative().optional(),
+        filter: checkFilterSchema
+    }),
+    output: z.object({ checks: z.array(uptimeCheckSchema) })
+};
+
+/**
+ * Aggregates over the same selection {@link uptimeChecks} pages through. Kept a
+ * separate command on purpose: it scans the whole filtered range, so the short
+ * "last few measures" list on the detail view never pays for it.
+ */
+export const uptimeCheckStats = {
+    command: 'uptime.checkStats' as const,
+    input: z.object({ id: serviceId, filter: checkFilterSchema }),
+    output: z.object({ stats: uptimeCheckStatsSchema })
+};
+
+/** Outage history, most recent first; the ongoing one (if any) comes back too. */
+export const uptimeIncidents = {
+    command: 'uptime.incidents' as const,
+    input: z.object({ id: serviceId, limit: z.number().int().min(1).max(100) }),
+    output: z.object({ incidents: z.array(uptimeIncidentSchema) })
+};
+
+export const uptimeCommands = [
+    uptimeList,
+    uptimeCount,
+    uptimeAdd,
+    uptimeUpdate,
+    uptimeSetEnabled,
+    uptimeRemove,
+    uptimeReorder,
+    uptimeCheckNow,
+    uptimeHistory,
+    uptimeChecks,
+    uptimeCheckStats,
+    uptimeIncidents
+] as const;

package/src/features/user.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { userColorSchema, userSettingFlagSchema } from '../domain/user';
+
+/**
+ * Upper bound on the avatar data URL length (characters ≈ bytes for base64
+ * ASCII). ~1.5 MB comfortably fits a client-resized JPEG/PNG/WebP thumbnail
+ * while bounding the WS payload and the `users.avatar` column.
+ */
+export const AVATAR_MAX_LENGTH = 1_500_000;
+
+/** Accepted image data URL prefixes for an uploaded avatar. */
+const avatarDataUrl = z
+    .string()
+    .min(1)
+    .max(AVATAR_MAX_LENGTH)
+    .regex(
+        /^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/]+=*$/,
+        'Avatar must be a base64 image data URL'
+    );
+
+export const userSetAvatar = {
+    command: 'user.setAvatar' as const,
+    input: z.object({ avatar: avatarDataUrl }),
+    output: z.object({ avatar: z.string() })
+};
+
+/** Max length of a wallpaper data URL stored in the theme (~4 MB in base64). */
+export const THEME_IMAGE_MAX_LENGTH = 4_200_000;
+
+/** Number of saved background slots kept in the appearance gallery. */
+export const THEME_SLOT_COUNT = 5;
+
+/**
+ * Upper bound on one saved slot value. Slots hold *compressed* data URLs (the
+ * client downscales before saving) or a short raw URL, so this is a safety cap,
+ * not the typical size — it keeps the whole theme JSON (5 slots + active image)
+ * within the browser's localStorage budget and the `users.theme` column.
+ */
+export const THEME_SLOT_IMAGE_MAX_LENGTH = 1_500_000;
+
+export const themeStateSchema = z.object({
+    accent: z.string().nullable(),
+    bgPreset: z.string().nullable(),
+    bgImage: z.string().max(THEME_IMAGE_MAX_LENGTH).nullable(),
+    /**
+     * Saved background gallery: up to THEME_SLOT_COUNT slots, each a compressed
+     * data URL / raw URL, or null for an empty slot. Defaults to empty so themes
+     * saved before this field parse cleanly.
+     */
+    bgImages: z
+        .array(z.string().max(THEME_SLOT_IMAGE_MAX_LENGTH).nullable())
+        .max(THEME_SLOT_COUNT)
+        .default([]),
+    bgDim: z.number().int().min(0).max(100),
+    bgBlur: z.number().int().min(0).max(100)
+});
+
+export type ThemeStateDTO = z.infer<typeof themeStateSchema>;
+
+export const userSetTheme = {
+    command: 'user.setTheme' as const,
+    input: themeStateSchema,
+    output: z.object({ ok: z.literal(true) })
+};
+
+/**
+ * Couleur d'identité du compte. En `scope: 'account'` côté serveur : elle suit
+ * le compte, pas l'espace depuis lequel on la change.
+ */
+export const userSetColor = {
+    command: 'user.setColor' as const,
+    input: z.object({ color: userColorSchema }),
+    output: z.object({ color: userColorSchema })
+};
+
+/**
+ * Pose ou retire un drapeau de compte. Une commande unique pour tous les
+ * drapeaux plutôt qu'une par réglage : le serveur n'a alors qu'un seul chemin de
+ * lecture-modification-écriture sur `users.settings`, et un nouveau drapeau ne
+ * coûte qu'une entrée dans `userSettingFlagSchema`.
+ *
+ * La sortie renvoie le sac **complet** tel qu'il vient d'être écrit : le client
+ * peut s'aligner dessus au lieu de rejouer sa propre arithmétique.
+ */
+export const userSetSetting = {
+    command: 'user.setSetting' as const,
+    input: z.object({ flag: userSettingFlagSchema, enabled: z.boolean() }),
+    output: z.object({ settings: z.array(z.string()) })
+};
+
+export const userCommands = [userSetAvatar, userSetTheme, userSetColor, userSetSetting] as const;

package/src/features/workspace.ts

@@ -0,0 +1,200 @@
+import { z } from 'zod';
+import { homeLayoutSchema } from '../domain/home';
+import { workspaceSchema } from '../domain/workspace';
+import {
+    WORKSPACE_ROLE_NAME_MAX,
+    workspaceCapabilitySchema,
+    workspaceFeatureGrantSchema,
+    workspacePermissionsSchema,
+    workspaceRoleSchema
+} from '../domain/workspaceRole';
+import { themeStateSchema } from './user';
+
+export const workspaceAdd = {
+    command: 'workspace.add' as const,
+    input: z.object({ name: z.string().min(1).max(120) }),
+    output: z.object({ workspace: workspaceSchema })
+};
+
+export const workspaceDelete = {
+    command: 'workspace.delete' as const,
+    input: z.object({ workspaceId: z.number().int().positive() }),
+    output: z.object({ workspaceId: z.number().int().positive() })
+};
+
+/**
+ * Bascule vers un espace : renvoie son apparence et sa disposition d'accueil.
+ *
+ * L'espace visé n'apparaît pas dans l'entrée — il voyage sur l'enveloppe, et le
+ * dispatcheur a déjà vérifié l'appartenance avant d'appeler le handler. Passer
+ * par `/api/auth/me` ne conviendrait pas : cette route recalcule l'espace actif à
+ * partir du favori et renverrait l'apparence de l'espace qu'*elle* choisit, pas
+ * de celui vers lequel on bascule.
+ */
+export const workspaceActivate = {
+    command: 'workspace.activate' as const,
+    input: z.object({}),
+    output: z.object({
+        theme: themeStateSchema.nullable(),
+        homeLayout: homeLayoutSchema.nullable(),
+        /** Droits dans l'espace rejoint : l'UI s'y conforme dès la bascule. */
+        permissions: workspacePermissionsSchema
+    })
+};
+
+/**
+ * Définit (ou efface) l'espace favori du compte : celui chargé en premier à la
+ * connexion. `null` → l'espace personnel.
+ */
+export const workspaceSetFavorite = {
+    command: 'workspace.setFavorite' as const,
+    input: z.object({ workspaceId: z.number().int().positive().nullable() }),
+    output: z.object({ workspaceId: z.number().int().positive().nullable() })
+};
+
+/** Renomme l'espace actif. Réservé à son propriétaire. */
+export const workspaceRename = {
+    command: 'workspace.rename' as const,
+    input: z.object({ name: z.string().min(1).max(120) }),
+    output: z.object({ workspace: workspaceSchema })
+};
+
+/**
+ * Quitte l'espace actif. Le propriétaire ne le peut pas : il supprime son espace
+ * ou le transmet, il ne l'abandonne pas avec ses membres dedans.
+ */
+export const workspaceLeave = {
+    command: 'workspace.leave' as const,
+    input: z.object({}),
+    output: z.object({ workspaceId: z.number().int().positive() })
+};
+
+/** Exclut un membre de l'espace actif. Réservé au propriétaire. */
+export const workspaceRemoveMember = {
+    command: 'workspace.removeMember' as const,
+    input: z.object({ userId: z.number().int().positive() }),
+    output: z.object({ userId: z.number().int().positive() })
+};
+
+/**
+ * Ajoute un membre à l'espace actif, désigné par son adresse.
+ *
+ * Pas de lien, pas d'acceptation : le compte existe déjà (l'inscription est sur
+ * invitation d'un administrateur), donc le désigner suffit. Un lien serait un
+ * détour — et un secret transmissible de plus à surveiller.
+ */
+export const workspaceAddMember = {
+    command: 'workspace.addMember' as const,
+    input: z.object({ email: z.string().email() }),
+    output: z.object({ workspace: workspaceSchema })
+};
+
+/**
+ * État de la clé d'espace : déjà active, applicable, et ce qui l'empêcherait.
+ */
+export const workspaceSharedKeyStatus = {
+    command: 'workspace.sharedKeyStatus' as const,
+    input: z.object({}),
+    output: z.object({
+        /** L'espace utilise déjà sa propre clé. */
+        enabled: z.boolean(),
+        /** Faux pour un espace personnel, qui garde la clé de son propriétaire. */
+        applicable: z.boolean(),
+        /** Obstacles à lever avant conversion, rédigés pour l'utilisateur. */
+        blockers: z.array(z.string())
+    })
+};
+
+/**
+ * Convertit l'espace vers sa propre clé. Exige le propriétaire, session
+ * déverrouillée : le contenu existant doit être relu avec sa clé avant d'être
+ * réécrit sous celle de l'espace.
+ */
+export const workspaceEnableSharedKey = {
+    command: 'workspace.enableSharedKey' as const,
+    input: z.object({}),
+    output: z.object({ converted: z.number().int().nonnegative() })
+};
+
+/** Le contenu modifiable d'un rôle. */
+const roleDraftSchema = z.object({
+    name: z.string().min(1).max(WORKSPACE_ROLE_NAME_MAX),
+    color: z.string().regex(/^#[0-9a-fA-F]{6}$/),
+    capabilities: z.array(workspaceCapabilitySchema),
+    features: z.array(workspaceFeatureGrantSchema)
+});
+
+export const workspaceRoleList = {
+    command: 'workspace.roleList' as const,
+    input: z.object({}),
+    output: z.object({
+        roles: z.array(workspaceRoleSchema),
+        /** Quel membre porte quel rôle. `null` = aucun, donc aucun droit. */
+        memberRoles: z.array(
+            z.object({
+                userId: z.number().int().positive(),
+                roleId: z.number().int().positive().nullable()
+            })
+        ),
+        /** Droits effectifs de l'appelant, pour que l'UI n'affiche que l'accessible. */
+        permissions: workspacePermissionsSchema
+    })
+};
+
+export const workspaceRoleCreate = {
+    command: 'workspace.roleCreate' as const,
+    input: roleDraftSchema,
+    output: z.object({ role: workspaceRoleSchema })
+};
+
+export const workspaceRoleUpdate = {
+    command: 'workspace.roleUpdate' as const,
+    input: roleDraftSchema.extend({ roleId: z.number().int().positive() }),
+    output: z.object({ role: workspaceRoleSchema })
+};
+
+/** Refusé tant que des membres le portent : on ne révoque personne par surprise. */
+export const workspaceRoleDelete = {
+    command: 'workspace.roleDelete' as const,
+    input: z.object({ roleId: z.number().int().positive() }),
+    output: z.object({ roleId: z.number().int().positive() })
+};
+
+/** Désigne le rôle attribué d'office à qui rejoint l'espace. */
+export const workspaceRoleSetDefault = {
+    command: 'workspace.roleSetDefault' as const,
+    input: z.object({ roleId: z.number().int().positive() }),
+    output: z.object({ roleId: z.number().int().positive() })
+};
+
+/** Attribue un rôle à un membre. `null` le laisse sans aucun droit. */
+export const workspaceAssignRole = {
+    command: 'workspace.assignRole' as const,
+    input: z.object({
+        userId: z.number().int().positive(),
+        roleId: z.number().int().positive().nullable()
+    }),
+    output: z.object({
+        userId: z.number().int().positive(),
+        roleId: z.number().int().positive().nullable()
+    })
+};
+
+export const workspaceCommands = [
+    workspaceRoleList,
+    workspaceRoleCreate,
+    workspaceRoleUpdate,
+    workspaceRoleDelete,
+    workspaceRoleSetDefault,
+    workspaceAssignRole,
+    workspaceSharedKeyStatus,
+    workspaceEnableSharedKey,
+    workspaceRename,
+    workspaceLeave,
+    workspaceRemoveMember,
+    workspaceAddMember,
+    workspaceAdd,
+    workspaceDelete,
+    workspaceActivate,
+    workspaceSetFavorite
+] as const;

package/src/http/auth.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { homeLayoutSchema } from '../domain/home';
+import { userSchema } from '../domain/user';
+import { workspaceSchema } from '../domain/workspace';
+import { workspacePermissionsSchema } from '../domain/workspaceRole';
+import { themeStateSchema } from '../features/user';
+
+/**
+ * Contenu commun à `/login`, `/refresh` et `/me` : le compte, les espaces
+ * auxquels il a accès, et **l'espace actif seul** — son thème et sa disposition
+ * d'accueil.
+ *
+ * Le thème des autres espaces n'est délibérément pas embarqué : `bgImages` peut
+ * contenir plusieurs data URLs, et les livrer tous multiplierait la charge utile
+ * par le nombre d'espaces. Basculer d'espace va chercher les siens.
+ */
+export const sessionBundleSchema = z.object({
+    user: userSchema,
+    workspaces: z.array(workspaceSchema),
+    /** Espace chargé à l'ouverture : le favori s'il est encore accessible, sinon le personnel. */
+    activeWorkspaceId: z.number().int().positive(),
+    theme: themeStateSchema.nullable(),
+    homeLayout: homeLayoutSchema.nullable(),
+    /** Droits de l'appelant dans l'espace actif, pour que l'UI masque le reste. */
+    permissions: workspacePermissionsSchema
+});
+
+export type SessionBundle = z.infer<typeof sessionBundleSchema>;
+
+export const loginRequestSchema = z.object({
+    username: z.string().min(1).max(120),
+    password: z.string().min(1).max(512)
+});
+
+export type LoginRequest = z.infer<typeof loginRequestSchema>;
+
+/**
+ * L'inscription n'est plus libre : elle exige un jeton d'invitation émis par un
+ * administrateur. La route existait déjà, ouverte à tous et connectant
+ * automatiquement — simplement inatteignable depuis l'interface, ce qui n'est
+ * pas une protection.
+ */
+export const registerRequestSchema = z.object({
+    inviteToken: z.string().min(1),
+    username: z
+        .string()
+        .min(3)
+        .max(64)
+        .regex(/^[a-zA-Z0-9_.-]+$/, 'username may only contain letters, digits, _ . -'),
+    email: z.string().email().max(320),
+    password: z.string().min(8).max(512)
+});
+
+export type RegisterRequest = z.infer<typeof registerRequestSchema>;
+
+export const changePasswordRequestSchema = z.object({
+    currentPassword: z.string().min(1).max(512),
+    newPassword: z.string().min(8).max(512)
+});
+
+export type ChangePasswordRequest = z.infer<typeof changePasswordRequestSchema>;
+
+export const changePasswordResponseSchema = z.object({ changed: z.literal(true) });
+
+export type ChangePasswordResponse = z.infer<typeof changePasswordResponseSchema>;
+
+/**
+ * The auth flow returns the authenticated user and its workspaces in one shot.
+ * Tokens are delivered as HttpOnly cookies, never in the JSON body.
+ *
+ * When 2FA is enabled, login first replies with `twoFactorRequired` and an
+ * interim challenge token (cookie); the client then posts a TOTP/backup code.
+ */
+export const loginResponseSchema = z.discriminatedUnion('twoFactorRequired', [
+    sessionBundleSchema.extend({ twoFactorRequired: z.literal(false) }),
+    z.object({ twoFactorRequired: z.literal(true) })
+]);
+
+export type LoginResponse = z.infer<typeof loginResponseSchema>;
+
+export const twoFactorChallengeRequestSchema = z.object({
+    /** A 6-digit TOTP code or a recovery backup code. */
+    code: z.string().min(6).max(16)
+});
+
+export type TwoFactorChallengeRequest = z.infer<typeof twoFactorChallengeRequestSchema>;
+
+export const refreshResponseSchema = sessionBundleSchema;
+
+export type RefreshResponse = z.infer<typeof refreshResponseSchema>;
+
+export const meResponseSchema = sessionBundleSchema;
+
+export type MeResponse = z.infer<typeof meResponseSchema>;