@deveye/types 0.15.2 → 0.16.0

package/src/domain/uptime.ts

@@ -1,216 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Uptime monitoring: user-defined HTTP services the server pings on a schedule,
- * with long-term history, incidents and notifications.
- *
- * Storage split (see `Docs/SECURITY_MODEL.md`): everything the scheduler needs
- * to *plan* a check (cadence, timeout, enabled…) and everything a chart
- * aggregates (status, latency, timestamps) lives in clear columns; what
- * identifies the target — name, URL, expected keyword — and the error strings
- * are encrypted with the **open** tier, since the checker runs in the
- * background, with no session and no password.
- */
-
-export const UPTIME_NAME_MAX_LENGTH = 80;
-export const UPTIME_URL_MAX_LENGTH = 2048;
-export const UPTIME_KEYWORD_MAX_LENGTH = 200;
-/** Bounds of a service's cadence, in seconds (30 s → 24 h). */
-export const UPTIME_INTERVAL_MIN = 30;
-export const UPTIME_INTERVAL_MAX = 86400;
-/** Bounds of a single request's timeout, in seconds. */
-export const UPTIME_TIMEOUT_MIN = 1;
-export const UPTIME_TIMEOUT_MAX = 120;
-/** Consecutive failures required before a service is declared down. */
-export const UPTIME_THRESHOLD_MAX = 10;
-
-/** HTTP verb used for the probe. `POST` sends no body — it only pokes the route. */
-export const uptimeMethodSchema = z.enum(['GET', 'HEAD', 'POST']);
-export type UptimeMethod = z.infer<typeof uptimeMethodSchema>;
-
-/** `unknown` = never probed yet (just created, or paused before its first check). */
-export const uptimeStatusSchema = z.enum(['up', 'down', 'unknown']);
-export type UptimeStatus = z.infer<typeof uptimeStatusSchema>;
-
-/**
- * How long a service keeps its **raw** per-ping rows. The daily rollup is never
- * pruned, so uptime ratios stay readable years back whatever this is set to.
- * `null` = keep every ping forever (the default).
- */
-export const uptimeRetentionSchema = z.number().int().positive().max(3650).nullable();
-
-/** Window a chart or a ratio is computed over. */
-export const uptimeRangeSchema = z.enum(['24h', '7d', '30d', '90d', '1y', 'all']);
-export type UptimeRange = z.infer<typeof uptimeRangeSchema>;
-
-/**
- * Bucket size the server picked for a history query: one point per ping (`raw`),
- * per hour, or per day. Chosen from the range so a year-long chart never carries
- * hundreds of thousands of points.
- */
-export const uptimeResolutionSchema = z.enum(['raw', 'hour', 'day']);
-export type UptimeResolution = z.infer<typeof uptimeResolutionSchema>;
-
-/** One monitored service: its configuration, its live state and its ratios. */
-export const uptimeServiceSchema = z.object({
-    id: z.number().int().positive(),
-    name: z.string(),
-    url: z.string(),
-    method: uptimeMethodSchema,
-    /** Exact status code required, or `null` to accept any 2xx/3xx. */
-    expectedStatus: z.number().int().min(100).max(599).nullable(),
-    /** Substring the response body must contain, or `null` to skip the check. */
-    keyword: z.string().nullable(),
-    intervalSeconds: z.number().int().positive(),
-    timeoutSeconds: z.number().int().positive(),
-    failureThreshold: z.number().int().positive(),
-    retentionDays: uptimeRetentionSchema,
-    /** Paused services keep their history but are never probed. */
-    enabled: z.boolean(),
-    /** Rank in the list; only the user's drag & drop changes it. */
-    sortOrder: z.number().int().nonnegative(),
-    /**
-     * Ce service vient d'un **autre espace**, qui le projette ici.
-     *
-     * Il se lit et se modifie normalement — c'est tout l'objet de la projection
-     * — mais l'écran le signale : sans ça, le supprimer depuis l'espace où on le
-     * voit donnerait l'impression de retirer une ligne locale, alors qu'on
-     * toucherait la donnée d'ailleurs.
-     */
-    foreign: z.boolean(),
-
-    status: uptimeStatusSchema,
-    lastCheckedAt: z.number().int().nonnegative().nullable(),
-    lastResponseMs: z.number().int().nonnegative().nullable(),
-    lastHttpStatus: z.number().int().nullable(),
-    /** Why the last probe failed, or `null` when it succeeded. */
-    lastError: z.string().nullable(),
-    /** Start of the ongoing outage, or `null` while the service is healthy. */
-    downSince: z.number().int().nonnegative().nullable(),
-
-    /** Share of successful pings over the window (0 → 1), `null` without data. */
-    ratio24h: z.number().min(0).max(1).nullable(),
-    ratio7d: z.number().min(0).max(1).nullable(),
-    ratio30d: z.number().min(0).max(1).nullable(),
-    /** Mean response time over the last 24 h, in ms. */
-    avgMs24h: z.number().int().nonnegative().nullable(),
-
-    created: z.number().int().nonnegative()
-});
-export type UptimeService = z.infer<typeof uptimeServiceSchema>;
-
-/** A single recorded probe — the "journal des pings". */
-export const uptimeCheckSchema = z.object({
-    at: z.number().int().nonnegative(),
-    up: z.boolean(),
-    httpStatus: z.number().int().nullable(),
-    responseMs: z.number().int().nonnegative().nullable(),
-    error: z.string().nullable()
-});
-export type UptimeCheck = z.infer<typeof uptimeCheckSchema>;
-
-/**
- * Aggregates over a filtered slice of a service's raw pings — what the measures
- * browser shows above its list, computed over the **whole** selection rather
- * than the loaded page.
- */
-export const uptimeCheckStatsSchema = z.object({
-    count: z.number().int().nonnegative(),
-    failures: z.number().int().nonnegative(),
-    avgMs: z.number().int().nonnegative().nullable(),
-    minMs: z.number().int().nonnegative().nullable(),
-    maxMs: z.number().int().nonnegative().nullable(),
-    /** Bounds of the selection; `null` when it holds nothing. */
-    firstAt: z.number().int().nonnegative().nullable(),
-    lastAt: z.number().int().nonnegative().nullable()
-});
-export type UptimeCheckStats = z.infer<typeof uptimeCheckStatsSchema>;
-
-/**
- * One chart point. A `raw` point is a single ping (`checks === 1`); an `hour` or
- * `day` point aggregates every ping of its bucket, which is what keeps a
- * multi-year chart cheap.
- */
-export const uptimePointSchema = z.object({
-    /** Bucket start, epoch seconds. */
-    at: z.number().int().nonnegative(),
-    checks: z.number().int().positive(),
-    upChecks: z.number().int().nonnegative(),
-    avgMs: z.number().int().nonnegative().nullable(),
-    minMs: z.number().int().nonnegative().nullable(),
-    maxMs: z.number().int().nonnegative().nullable()
-});
-export type UptimePoint = z.infer<typeof uptimePointSchema>;
-
-/**
- * A continuous outage. Opened when a service crosses its failure threshold,
- * closed on the first successful probe — so the list reads as a plain incident
- * history, and it survives raw-history pruning.
- */
-export const uptimeIncidentSchema = z.object({
-    id: z.number().int().positive(),
-    startedAt: z.number().int().nonnegative(),
-    /** `null` while the outage is still ongoing. */
-    endedAt: z.number().int().nonnegative().nullable(),
-    httpStatus: z.number().int().nullable(),
-    error: z.string().nullable()
-});
-export type UptimeIncident = z.infer<typeof uptimeIncidentSchema>;
-
-/** Database row shapes (server-only). Mirror the columns exactly. */
-export interface UptimeServiceRow {
-    id: number;
-    user_id: number;
-    workspace_id: number;
-    /** Encrypted `{ name, url, keyword }` (open tier). */
-    content: string;
-    method: UptimeMethod;
-    expected_status: number | null;
-    interval_seconds: number;
-    timeout_seconds: number;
-    failure_threshold: number;
-    retention_days: number | null;
-    enabled: number;
-    sort_order: number;
-    status: UptimeStatus;
-    consecutive_failures: number;
-    last_checked_at: number | null;
-    last_response_ms: number | null;
-    last_http_status: number | null;
-    /** Encrypted error string (open tier), or null after a success. */
-    last_error: string | null;
-    created: number;
-}
-
-export interface UptimeCheckRow {
-    id: number;
-    service_id: number;
-    checked_at: number;
-    up: number;
-    http_status: number | null;
-    response_ms: number | null;
-    /** Encrypted error string (open tier). */
-    error: string | null;
-}
-
-export interface UptimeDayRow {
-    service_id: number;
-    day: number;
-    checks: number;
-    up_checks: number;
-    total_ms: number;
-    ms_samples: number;
-    min_ms: number | null;
-    max_ms: number | null;
-}
-
-export interface UptimeIncidentRow {
-    id: number;
-    service_id: number;
-    started_at: number;
-    ended_at: number | null;
-    http_status: number | null;
-    /** Encrypted error string (open tier). */
-    error: string | null;
-    notified: number;
-}

package/src/features/audience.ts

@@ -1,275 +0,0 @@
-import { z } from 'zod';
-import {
-    AUDIENCE_BREAKDOWN_MAX,
-    AUDIENCE_FUNNEL_MAX_STEPS,
-    AUDIENCE_FUNNEL_NAME_MAX_LENGTH,
-    AUDIENCE_MAX_ORIGINS,
-    AUDIENCE_ORIGIN_MAX_LENGTH,
-    AUDIENCE_RETENTION_MAX_DAYS,
-    AUDIENCE_RETENTION_MIN_DAYS,
-    AUDIENCE_SITE_DESCRIPTION_MAX_LENGTH,
-    AUDIENCE_SITE_NAME_MAX_LENGTH,
-    audienceActivitySchema,
-    audienceBreakdownItemSchema,
-    audienceDimensionSchema,
-    audienceFunnelSchema,
-    audienceFunnelStepDraftSchema,
-    audienceLiveSchema,
-    audienceOverviewSchema,
-    audiencePlatformSchema,
-    audienceRangeSchema,
-    audienceVisitorModeSchema,
-    audienceSiteSchema,
-    audienceUsageSchema
-} from '../domain/audience';
-
-/**
- * Commandes de l'audience d'un espace.
- *
- * Préfixe unique `audience.`, comme `git.`, `database.` 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.
- *
- * ## Ce qui n'est pas ici
- *
- * L'**ingestion** n'est pas une commande. Elle entre par HTTP, sans session,
- * depuis des machines qui ne connaissent pas DevEye — voir `POST /api/t/b`. Ces
- * commandes-ci ne font que *lire* ce qu'elle a écrit, et *déclarer* les sites.
- *
- * 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 siteId = z.number().int().positive();
-
-/** Ce qu'on peut régler sur un site — identique à l'ajout et à la modification. */
-const siteBody = {
-    name: z.string().min(1).max(AUDIENCE_SITE_NAME_MAX_LENGTH),
-    description: z.string().max(AUDIENCE_SITE_DESCRIPTION_MAX_LENGTH),
-    platform: audiencePlatformSchema,
-    visitorMode: audienceVisitorModeSchema,
-    /**
-     * Les hôtes autorisés à écrire. Le client envoie des hôtes nus
-     * (`exemple.fr`) ou des origines complètes (`https://exemple.fr`) : le
-     * serveur normalise, parce que c'est lui qui compare.
-     */
-    origins: z.array(z.string().max(AUDIENCE_ORIGIN_MAX_LENGTH)).max(AUDIENCE_MAX_ORIGINS),
-    active: z.boolean(),
-    retentionDays: z
-        .number()
-        .int()
-        .min(AUDIENCE_RETENTION_MIN_DAYS)
-        .max(AUDIENCE_RETENTION_MAX_DAYS)
-};
-
-// ------------------------------------------------------------------ sites
-
-/** Le nombre de sites de l'espace, pour la tuile de l'accueil. */
-export const audienceCount = {
-    command: 'audience.count' as const,
-    input: z.object({}),
-    output: z.object({ count: z.number().int().nonnegative() })
-};
-
-/** Les sites de l'espace, dans l'ordre de l'utilisateur. */
-export const audienceList = {
-    command: 'audience.list' as const,
-    input: z.object({}),
-    output: z.object({ sites: z.array(audienceSiteSchema) })
-};
-
-/**
- * Un site, avec les projets qui le suivent et l'adresse de sa balise.
- *
- * `ingestOrigin` vient du serveur (`AUDIENCE_ORIGIN`, à défaut `PUBLIC_ORIGIN`)
- * et non de l'origine du navigateur : l'application est derrière le VPN, alors
- * que l'ingestion doit être joignable sans lui — les deux adresses diffèrent
- * donc par construction. La déduire côté client aurait donné une balise juste en
- * développement et fausse en production, ce qui est le pire des deux mondes.
- */
-export const audienceGet = {
-    command: 'audience.get' as const,
-    input: z.object({ siteId }),
-    output: z.object({
-        site: audienceSiteSchema,
-        usage: z.array(audienceUsageSchema),
-        ingestOrigin: z.string()
-    })
-};
-
-/**
- * Déclare un site. La clé publique est **engendrée par le serveur** : la laisser
- * choisir permettrait de viser celle d'un site existant d'un autre espace.
- */
-export const audienceSiteAdd = {
-    command: 'audience.siteAdd' as const,
-    input: z.object(siteBody),
-    output: z.object({ site: audienceSiteSchema })
-};
-
-export const audienceSiteUpdate = {
-    command: 'audience.siteUpdate' as const,
-    input: z.object({ siteId, ...siteBody }),
-    output: z.object({ site: audienceSiteSchema })
-};
-
-/**
- * Supprime un site **et tout son historique**.
- *
- * Contrairement aux projets, rien ne s'archive ici : un site retiré n'a pas de
- * seconde vie, et garder des millions d'événements orphelins pour un objet que
- * plus rien ne nomme ne rendrait service à personne. Les liaisons de projet
- * tombent avec (`CASCADE`), les projets eux-mêmes ne bougent pas.
- */
-export const audienceSiteRemove = {
-    command: 'audience.siteRemove' as const,
-    input: z.object({ siteId }),
-    output: z.object({ ok: z.literal(true) })
-};
-
-/**
- * Renouvelle la clé publique.
- *
- * Le geste utile quand une clé s'est retrouvée là où elle n'aurait pas dû —
- * dépôt public, capture d'écran. L'ancienne cesse d'entrer **immédiatement** ;
- * l'historique déjà collecté, lui, reste : il a été mesuré, il est vrai.
- */
-export const audienceSiteRotateKey = {
-    command: 'audience.siteRotateKey' as const,
-    input: z.object({ siteId }),
-    output: z.object({ site: audienceSiteSchema })
-};
-
-export const audienceReorder = {
-    command: 'audience.reorder' as const,
-    input: z.object({ siteIds: z.array(siteId).min(1) }),
-    output: z.object({ ok: z.literal(true) })
-};
-
-// ------------------------------------------------------------ statistiques
-
-/** Le bandeau, la comparaison à la période précédente, et la courbe. */
-export const audienceOverview = {
-    command: 'audience.overview' as const,
-    input: z.object({ siteId, range: audienceRangeSchema }),
-    output: audienceOverviewSchema
-};
-
-/**
- * Un classement sur l'axe demandé.
- *
- * Une commande pour les neuf axes plutôt que neuf commandes : ils rendent tous
- * la même forme, se lisent par la même requête, et l'écran en affiche plusieurs
- * côte à côte. Neuf entrées auraient divergé au premier ajustement.
- */
-export const audienceBreakdown = {
-    command: 'audience.breakdown' as const,
-    input: z.object({
-        siteId,
-        range: audienceRangeSchema,
-        dimension: audienceDimensionSchema,
-        limit: z.number().int().min(1).max(AUDIENCE_BREAKDOWN_MAX).optional()
-    }),
-    output: z.object({ items: z.array(audienceBreakdownItemSchema) })
-};
-
-/** La carte jour × heure, en heure **locale du visiteur**, et les fuseaux. */
-export const audienceActivity = {
-    command: 'audience.activity' as const,
-    input: z.object({ siteId, range: audienceRangeSchema }),
-    output: audienceActivitySchema
-};
-
-/**
- * Qui est là en ce moment (cinq dernières minutes).
- *
- * Volontairement séparée de `overview` : elle est minuscule, elle se relit
- * souvent, et la faire voyager avec le bandeau obligerait à recalculer tout
- * l'agrégat pour rafraîchir un compteur.
- */
-export const audienceLive = {
-    command: 'audience.live' as const,
-    input: z.object({ siteId }),
-    output: audienceLiveSchema
-};
-
-// ------------------------------------------------------------ entonnoirs
-
-const funnelId = z.number().int().positive();
-
-/** Les marches, dans l'ordre. Un entonnoir d'une seule marche n'en est pas un. */
-const steps = z.array(audienceFunnelStepDraftSchema).min(2).max(AUDIENCE_FUNNEL_MAX_STEPS);
-
-/**
- * Les entonnoirs d'un site, **avec leurs chiffres** sur la fenêtre demandée.
- *
- * Définitions et mesures dans la même réponse : l'écran n'affiche jamais l'une
- * sans l'autre, et les séparer aurait fait deux allers-retours pour dessiner un
- * seul graphique. Les entonnoirs se comptent en unités, pas en milliers.
- */
-export const audienceFunnelList = {
-    command: 'audience.funnelList' as const,
-    input: z.object({ siteId, range: audienceRangeSchema }),
-    output: z.object({ funnels: z.array(audienceFunnelSchema) })
-};
-
-/**
- * Définit un entonnoir à partir de ce que le site a **déjà** émis.
- *
- * C'est tout le découpage : le site pose des signaux nommés, l'entonnoir se
- * compose ici. Mesurer autre chose ne demande donc aucun redéploiement — ni
- * même de prévenir qui que ce soit.
- */
-export const audienceFunnelAdd = {
-    command: 'audience.funnelAdd' as const,
-    input: z.object({
-        siteId,
-        name: z.string().min(1).max(AUDIENCE_FUNNEL_NAME_MAX_LENGTH),
-        steps
-    }),
-    output: z.object({ funnelId })
-};
-
-export const audienceFunnelUpdate = {
-    command: 'audience.funnelUpdate' as const,
-    input: z.object({
-        funnelId,
-        name: z.string().min(1).max(AUDIENCE_FUNNEL_NAME_MAX_LENGTH),
-        steps
-    }),
-    output: z.object({ ok: z.literal(true) })
-};
-
-/**
- * Supprime un entonnoir. **Aucune mesure n'est perdue** : un entonnoir n'est
- * qu'une lecture des événements déjà là, jamais une collecte à part. Le
- * recréer à l'identique rendrait exactement les mêmes chiffres.
- */
-export const audienceFunnelRemove = {
-    command: 'audience.funnelRemove' as const,
-    input: z.object({ funnelId }),
-    output: z.object({ ok: z.literal(true) })
-};
-
-export const audienceCommands = [
-    audienceCount,
-    audienceList,
-    audienceGet,
-    audienceSiteAdd,
-    audienceSiteUpdate,
-    audienceSiteRemove,
-    audienceSiteRotateKey,
-    audienceReorder,
-    audienceOverview,
-    audienceBreakdown,
-    audienceActivity,
-    audienceLive,
-    audienceFunnelList,
-    audienceFunnelAdd,
-    audienceFunnelUpdate,
-    audienceFunnelRemove
-] as const;