@runwisp/ui 0.13.0 → 0.15.0

package/src/lib/components/dashboard/run-filters.ts

@@ -8,7 +8,7 @@ export type RunsListSortDirection = "asc" | "desc" | "";
 /**
  * The single filter shape shared by the runs list, the filter popover, the
  * SSE-merge source, and the bulk selector. Every field beyond `search` and
- * `sort_direction` is an optional dimension applied server-side; the zero
+ * `sortDirection` is an optional dimension applied server-side; the zero
  * value (`emptyRunFilters`) matches every run.
  *
  * `statuses` is a multi-select set joined to a comma-separated string only at
@@ -19,26 +19,26 @@ export type RunsListSortDirection = "asc" | "desc" | "";
 export interface RunsListFilters {
     search: string;
     statuses: string[];
-    sort_direction: RunsListSortDirection;
+    sortDirection: RunsListSortDirection;
     // Optional dimensions explicitly admit `undefined` so a dimension can be
     // cleared by reassignment (`{ ...f, x: undefined }`) under the project's
     // exactOptionalPropertyTypes — a fresh object reference is what re-triggers
     // the parent's fetch effect through several levels of `bind:`.
-    task_name?: string | undefined;
-    created_after?: string | undefined;
-    created_before?: string | undefined;
-    triggered_by?: string | undefined;
+    taskName?: string | undefined;
+    createdAfter?: string | undefined;
+    createdBefore?: string | undefined;
+    triggeredBy?: string | undefined;
     // A human exit-code expression — a bare code (`137`), a comparison (`>100`,
     // `<=150`), or a space-separated combination (`>100 <150`). Normalized to an
     // inclusive [min, max] range (`exitCodeRange`) at the wire boundary; the
-    // server only ever sees `exit_code_min` / `exit_code_max`.
-    exit_code?: string | undefined;
-    retries_only?: boolean | undefined;
+    // server only ever sees `exitCodeMin` / `exitCodeMax`.
+    exitCode?: string | undefined;
+    retriesOnly?: boolean | undefined;
 }
 
 /** A fresh default filter — no dimensions active, newest-first. */
 export function emptyRunFilters(): RunsListFilters {
-    return { search: "", statuses: [], sort_direction: "desc" };
+    return { search: "", statuses: [], sortDirection: "desc" };
 }
 
 /**
@@ -131,14 +131,14 @@ function exactBucket(statuses: string[]): StatusBucket | undefined {
  * page the task name is the page scope (injected at fetch time), never a
  * popover-set filter, so it stays absent from those filters and is not counted.
  */
-export type FilterDimension = "status" | "time" | "task" | "triggered_by" | "exit_code" | "retries";
+export type FilterDimension = "status" | "time" | "task" | "triggeredBy" | "exitCode" | "retries";
 
 const DIMENSION_ORDER: FilterDimension[] = [
     "status",
     "time",
     "task",
-    "triggered_by",
-    "exit_code",
+    "triggeredBy",
+    "exitCode",
     "retries",
 ];
 
@@ -148,15 +148,15 @@ export function dimensionActive(f: RunsListFilters, dim: FilterDimension): boole
         case "status":
             return f.statuses.length > 0;
         case "time":
-            return Boolean(f.created_after) || Boolean(f.created_before);
+            return Boolean(f.createdAfter) || Boolean(f.createdBefore);
         case "task":
-            return Boolean(f.task_name);
-        case "triggered_by":
-            return Boolean(f.triggered_by);
-        case "exit_code":
-            return exitCodeRangeActive(f.exit_code);
+            return Boolean(f.taskName);
+        case "triggeredBy":
+            return Boolean(f.triggeredBy);
+        case "exitCode":
+            return exitCodeRangeActive(f.exitCode);
         case "retries":
-            return Boolean(f.retries_only);
+            return Boolean(f.retriesOnly);
     }
 }
 
@@ -176,15 +176,15 @@ export function clearDimension(f: RunsListFilters, dim: FilterDimension): RunsLi
         case "status":
             return { ...f, statuses: [] };
         case "time":
-            return { ...f, created_after: undefined, created_before: undefined };
+            return { ...f, createdAfter: undefined, createdBefore: undefined };
         case "task":
-            return { ...f, task_name: undefined };
-        case "triggered_by":
-            return { ...f, triggered_by: undefined };
-        case "exit_code":
-            return { ...f, exit_code: undefined };
+            return { ...f, taskName: undefined };
+        case "triggeredBy":
+            return { ...f, triggeredBy: undefined };
+        case "exitCode":
+            return { ...f, exitCode: undefined };
         case "retries":
-            return { ...f, retries_only: undefined };
+            return { ...f, retriesOnly: undefined };
     }
 }
 
@@ -196,12 +196,12 @@ export function clearPopoverFilters(f: RunsListFilters): RunsListFilters {
     return {
         ...f,
         statuses: [],
-        created_after: undefined,
-        created_before: undefined,
-        task_name: undefined,
-        triggered_by: undefined,
-        exit_code: undefined,
-        retries_only: undefined,
+        createdAfter: undefined,
+        createdBefore: undefined,
+        taskName: undefined,
+        triggeredBy: undefined,
+        exitCode: undefined,
+        retriesOnly: undefined,
     };
 }
 

package/src/lib/components/dashboard/run-helpers.test.ts

@@ -2,29 +2,54 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RUN_STATUSES } from "@runwisp/common";
 import {
     runDuration,
     runStartDelay,
+    runVerdict,
     formatTriggeredByLabel,
     runRetryLabel,
     instanceSuffix,
 } from "./run-helpers.js";
 
+describe("runVerdict", () => {
+    it("covers every run status", () => {
+        for (const status of RUN_STATUSES) {
+            expect(runVerdict(status).verb, status).toBeTruthy();
+        }
+    });
+
+    it("phrases a timed outcome so a duration reads after it", () => {
+        expect(runVerdict("success")).toEqual({ verb: "succeeded in", timed: true });
+        expect(runVerdict("failed")).toEqual({ verb: "failed after", timed: true });
+    });
+
+    it("marks statuses that never produced a duration as untimed", () => {
+        // These end without ever running, so the caller renders the verb alone
+        // rather than "skipped after —".
+        expect(runVerdict("missed").timed).toBe(false);
+        expect(runVerdict("skipped").timed).toBe(false);
+        expect(runVerdict("dst_skipped").timed).toBe(false);
+        expect(runVerdict("queue_full").timed).toBe(false);
+        expect(runVerdict("pending").timed).toBe(false);
+    });
+});
+
 describe("runDuration", () => {
-    it("returns undefined when start_at is not set", () => {
+    it("returns undefined when startAt is not set", () => {
         expect(runDuration({})).toBeUndefined();
     });
 
-    it("returns formatted duration when both start_at and end_at are set", () => {
+    it("returns formatted duration when both startAt and endAt are set", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const end = "2024-06-15T12:00:05.000Z";
-        expect(runDuration({ start_at: start, end_at: end })).toBe("5s");
+        expect(runDuration({ startAt: start, endAt: end })).toBe("5s");
     });
 
     it("returns ms duration for sub-second runs", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const end = "2024-06-15T12:00:00.500Z";
-        expect(runDuration({ start_at: start, end_at: end })).toBe("500ms");
+        expect(runDuration({ startAt: start, endAt: end })).toBe("500ms");
     });
 
     describe("with fake clock", () => {
@@ -36,35 +61,35 @@ describe("runDuration", () => {
             vi.useRealTimers();
         });
 
-        it("uses current time when end_at is not set (run still in progress)", () => {
-            expect(runDuration({ start_at: "2024-06-15T12:00:00.000Z" })).toBe("2s");
+        it("uses current time when endAt is not set (run still in progress)", () => {
+            expect(runDuration({ startAt: "2024-06-15T12:00:00.000Z" })).toBe("2s");
         });
     });
 
     it("counts against an injected now for an in-progress run", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const now = new Date("2024-06-15T12:00:07.000Z").getTime();
-        expect(runDuration({ start_at: start }, now)).toBe("7s");
+        expect(runDuration({ startAt: start }, now)).toBe("7s");
     });
 
     it("ignores the injected now once the run has ended", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const end = "2024-06-15T12:00:05.000Z";
         const now = new Date("2024-06-15T12:01:00.000Z").getTime();
-        expect(runDuration({ start_at: start, end_at: end }, now)).toBe("5s");
+        expect(runDuration({ startAt: start, endAt: end }, now)).toBe("5s");
     });
 });
 
 describe("runStartDelay", () => {
-    it("returns undefined when start_at is not set", () => {
-        expect(runStartDelay({ created_at: "2024-06-15T12:00:00.000Z" })).toBeUndefined();
+    it("returns undefined when startAt is not set", () => {
+        expect(runStartDelay({ createdAt: "2024-06-15T12:00:00.000Z" })).toBeUndefined();
     });
 
     it("returns undefined when the run started within a second of its tick", () => {
         expect(
             runStartDelay({
-                created_at: "2024-06-15T12:00:00.000Z",
-                start_at: "2024-06-15T12:00:00.300Z",
+                createdAt: "2024-06-15T12:00:00.000Z",
+                startAt: "2024-06-15T12:00:00.300Z",
             }),
         ).toBeUndefined();
     });
@@ -72,8 +97,8 @@ describe("runStartDelay", () => {
     it("formats the jitter/queue gap when the run started meaningfully later", () => {
         expect(
             runStartDelay({
-                created_at: "2024-06-15T03:00:00.000Z",
-                start_at: "2024-06-15T03:07:12.000Z",
+                createdAt: "2024-06-15T03:00:00.000Z",
+                startAt: "2024-06-15T03:07:12.000Z",
             }),
         ).toBe("7m 12s");
     });
@@ -91,15 +116,15 @@ describe("formatTriggeredByLabel", () => {
 
 describe("runRetryLabel", () => {
     it("returns undefined for a first attempt that is not a retry", () => {
-        expect(runRetryLabel({ retry_attempt: 0 })).toBeUndefined();
+        expect(runRetryLabel({ retryAttempt: 0 })).toBeUndefined();
     });
 
     it("labels a run with a positive attempt number", () => {
-        expect(runRetryLabel({ retry_attempt: 2 })).toBe("retry #2");
+        expect(runRetryLabel({ retryAttempt: 2 })).toBe("retry #2");
     });
 
     it("labels a run that points back at the run it re-attempts", () => {
-        expect(runRetryLabel({ retry_attempt: 1, retry_of_run_id: "01JABC" })).toBe("retry #1");
+        expect(runRetryLabel({ retryAttempt: 1, retryOfRunId: "01JABC" })).toBe("retry #1");
     });
 });
 

package/src/lib/components/dashboard/run-helpers.ts

@@ -1,30 +1,68 @@
 // SPDX-FileCopyrightText: PoppyCake, s.r.o.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Run } from "@runwisp/common";
+import type { Run, RunStatus } from "@runwisp/common";
 import { formatDuration } from "../../utils/format.js";
 
+export interface RunVerdict {
+    /** Verb phrase for the outcome, ending in its preposition when `timed`. */
+    verb: string;
+    /**
+     * Whether the phrase expects a duration after it. False for statuses that
+     * never produced one (nothing ran, or nothing has yet), so the caller
+     * renders the verb alone rather than "skipped after —".
+     */
+    timed: boolean;
+}
+
+/**
+ * The run's outcome as a verb phrase, so a detail view can state it as one
+ * sentence ("succeeded in 933ms") instead of a status badge competing with a
+ * separate duration readout for the same glance.
+ */
+const RUN_VERDICTS: Record<RunStatus, RunVerdict> = {
+    success: { verb: "succeeded in", timed: true },
+    failed: { verb: "failed after", timed: true },
+    crashed: { verb: "crashed after", timed: true },
+    timeout: { verb: "timed out after", timed: true },
+    stopped: { verb: "stopped after", timed: true },
+    daemon_stopped: { verb: "cut short after", timed: true },
+    log_overflow: { verb: "killed after", timed: true },
+    start_failed: { verb: "gave up after", timed: true },
+    ended: { verb: "ended after", timed: true },
+    running: { verb: "running for", timed: true },
+    pending: { verb: "queued", timed: false },
+    missed: { verb: "never ran", timed: false },
+    skipped: { verb: "skipped", timed: false },
+    dst_skipped: { verb: "skipped", timed: false },
+    queue_full: { verb: "skipped", timed: false },
+};
+
+export function runVerdict(status: RunStatus): RunVerdict {
+    return RUN_VERDICTS[status];
+}
+
 export function runDuration(
-    run: Pick<Run, "start_at" | "end_at">,
+    run: Pick<Run, "startAt" | "endAt">,
     now: number = Date.now(),
 ): string | undefined {
-    if (!run.start_at) return undefined;
-    const start = new Date(run.start_at).getTime();
-    const end = run.end_at ? new Date(run.end_at).getTime() : now;
+    if (!run.startAt) return undefined;
+    const start = new Date(run.startAt).getTime();
+    const end = run.endAt ? new Date(run.endAt).getTime() : now;
     return formatDuration(end - start);
 }
 
 /**
- * Gap between when a run was scheduled (`created_at`, the cron tick) and when
- * it actually started (`start_at`), formatted — or undefined when the two are
+ * Gap between when a run was scheduled (`createdAt`, the cron tick) and when
+ * it actually started (`startAt`), formatted — or undefined when the two are
  * within a second of each other. This is the visible face of `jitter`: a
  * jittered run is created at its tick but starts later inside the window, and
  * this is by how much. It also surfaces queue-wait, since a queued run is
  * created when it joins the line and started when the line clears.
  */
-export function runStartDelay(run: Pick<Run, "created_at" | "start_at">): string | undefined {
-    if (!run.start_at) return undefined;
-    const delay = new Date(run.start_at).getTime() - new Date(run.created_at).getTime();
+export function runStartDelay(run: Pick<Run, "createdAt" | "startAt">): string | undefined {
+    if (!run.startAt) return undefined;
+    const delay = new Date(run.startAt).getTime() - new Date(run.createdAt).getTime();
     if (delay < 1000) return undefined;
     return formatDuration(delay);
 }
@@ -44,8 +82,8 @@ export function instanceSuffix(instanceIndex: number, instanceCount: number): st
     return "";
 }
 
-/** Human label for why a run fired (the `triggered_by` source). */
-export function formatTriggeredByLabel(triggeredBy: Run["triggered_by"]): string {
+/** Human label for why a run fired (the `triggeredBy` source). */
+export function formatTriggeredByLabel(triggeredBy: Run["triggeredBy"]): string {
     if (triggeredBy === "api") return "API";
     if (triggeredBy === "cron") return "Cron";
     if (triggeredBy === "service") return "Service";
@@ -58,11 +96,9 @@ export function formatTriggeredByLabel(triggeredBy: Run["triggered_by"]): string
  * A run is a retry if it carries a positive attempt number or points back at
  * the run it re-attempts.
  */
-export function runRetryLabel(
-    run: Pick<Run, "retry_attempt" | "retry_of_run_id">,
-): string | undefined {
-    if (run.retry_attempt > 0 || run.retry_of_run_id) {
-        return `retry #${String(run.retry_attempt)}`;
+export function runRetryLabel(run: Pick<Run, "retryAttempt" | "retryOfRunId">): string | undefined {
+    if (run.retryAttempt > 0 || run.retryOfRunId) {
+        return `retry #${String(run.retryAttempt)}`;
     }
     return undefined;
 }

package/src/lib/components/dashboard/status-config.ts

@@ -45,7 +45,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         border: "border-success-soft",
         dot: "bg-success-surface",
         badge: "bg-success-soft text-success-soft-text",
-        description: "The run finished with exit code 0.",
+        description: "The run finished with exit code 0 - everything OK.",
     },
     failed: {
         icon: CircleX,
@@ -64,7 +64,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         dot: "bg-danger-surface",
         badge: "bg-danger-soft text-danger-soft-text",
         description:
-            "The process was killed, or the daemon found it still 'running' after a hard crash and marked it crashed (exit -2). It was not resumed.",
+            "The process was killed, or the daemon found it still 'running' after a hard crash and marked it crashed. It was not resumed.",
     },
     stopped: {
         icon: CircleStop,
@@ -73,7 +73,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         border: "border-warning-soft",
         dot: "bg-warning-surface",
         badge: "bg-warning-soft text-warning-soft-text",
-        description: "An operator stopped this run before it finished.",
+        description: "A human or an external script manually stopped this run before it finished.",
     },
     timeout: {
         icon: TimerOff,
@@ -82,7 +82,8 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         border: "border-warning-soft",
         dot: "bg-warning-surface",
         badge: "bg-warning-soft text-warning-soft-text",
-        description: "The run exceeded its configured timeout and was terminated.",
+        description:
+            "The run exceeded its configured timeout and was terminated. Timeout duration can be changed.",
     },
     skipped: {
         icon: SkipForward,
@@ -101,7 +102,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         border: "border-danger-soft",
         dot: "bg-danger-surface",
         badge: "bg-danger-soft text-danger-soft-text",
-        description: "The run hit log_max_size and was handled per log_on_full.",
+        description: "The run hit log_max_size and was handled because of log_on_full.",
     },
     queue_full: {
         icon: SkipForward,
@@ -150,7 +151,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         dot: "bg-danger-surface",
         badge: "bg-danger-soft text-danger-soft-text",
         description:
-            "The service kept failing to stay up for healthy_after; after start_retries the supervisor gave up (FATAL) and stopped restarting it.",
+            "The service kept failing to stay up for healthy_after; after restart_attempts the supervisor gave up (FATAL) and stopped restarting it.",
     },
     pending: {
         icon: Clock,
@@ -176,6 +177,6 @@ export function getRunStatusConfig(status: RunStatus): RunStatusConfig {
     return RUN_STATUS_CONFIG[status];
 }
 
-export function runDisplayStatus(run: Pick<Run, "status" | "end_reason">): RunStatus {
-    return displayStatus(run.status, run.end_reason);
+export function runDisplayStatus(run: Pick<Run, "status" | "endReason">): RunStatus {
+    return displayStatus(run.status, run.endReason);
 }