@revenexx/studio-integrations 1.0.0 → 1.1.0

package/dist/runtime/pages/integrations/schedules.vue

@@ -2,14 +2,23 @@
 import { ClockCircle as Clock, Globus as Globe } from "#solar-icons";
 import { Badge } from "@revenexx/studio";
 import { cadenceRank, describeCron } from "../../utils/schedule";
+import { runStatusLabel } from "../../utils/statusStyle";
 const t = useIntegrationsT();
 useHead({ title: () => t("integration.schedules.head.title") });
 const router = useRouter();
-const { entries, activeCount, loading, load } = useIntegrationsSchedules();
+const { entries, activeCount, timezonesInUse, loading, error, load } = useIntegrationsSchedules();
 onMounted(() => {
   void load(true);
 });
-function formatRelative(iso) {
+function inScheduleZone(iso, timezone) {
+  const parts = { month: "short", day: "2-digit", hour: "2-digit", minute: "2-digit" };
+  try {
+    return new Date(iso).toLocaleString(void 0, { ...parts, timeZone: timezone });
+  } catch {
+    return new Date(iso).toLocaleString(void 0, parts);
+  }
+}
+function formatRelative(iso, timezone) {
   if (!iso) return "\u2014";
   const ms = new Date(iso).getTime() - Date.now();
   if (Math.abs(ms) < 6e4) return ms > 0 ? t("integration.schedules.time.inLessThanMinute") : t("integration.common.time.justNow");
@@ -21,7 +30,11 @@ function formatRelative(iso) {
     const hrs = Math.round(Math.abs(ms) / 36e5);
     return ms > 0 ? t("integration.schedules.time.inHours", hrs) : t("integration.common.time.hoursAgo", hrs);
   }
-  return new Date(iso).toLocaleString(void 0, { month: "short", day: "2-digit", hour: "2-digit", minute: "2-digit" });
+  return inScheduleZone(iso, timezone);
+}
+function lastRunText(e) {
+  if (e.lastRunAt) return formatRelative(e.lastRunAt, e.timezone);
+  return e.lastRunStatus ? runStatusLabel(e.lastRunStatus) : "\u2014";
 }
 const filterTabs = computed(() => [
   {
@@ -40,7 +53,10 @@ const filterTabs = computed(() => [
     key: "timezone",
     label: t("integration.schedules.table.column.timezone"),
     getter: (e) => e.timezone,
-    options: [...new Set(entries.value.map((e) => e.timezone))].sort().map((tz) => ({ value: tz, label: tz }))
+    // The zones the platform reports as in use across the tenant, not the ones
+    // visible in the rows: with the list narrowed, deriving them from the rows
+    // would shrink the menu to what the previous choice left standing.
+    options: timezonesInUse.value.map((tz) => ({ value: tz, label: tz }))
   }
 ]);
 const columns = computed(() => [
@@ -76,7 +92,25 @@ const columns = computed(() => [
       </template>
     </PageHeader>
 
+    <!--
+      A refused read says so. Without this the page fell through to the table's
+      own empty text, so a 503 and a tenant with no schedules were one screen —
+      and the message it needed was already written and translated
+      (`specs/schedules.md` AC-13). An alert rather than a bare div, so it is
+      announced and not only visible.
+    -->
+    <div v-if="error" role="alert" class="m-4 rounded-md border border-rose-500/20 bg-rose-500/5 px-3 py-2 text-sm text-rose-700">
+      {{ error }}
+    </div>
+
     <div class="p-4">
+      <!--
+        The empty text answers the error too, so the table cannot go on saying
+        "No schedules yet" underneath a banner explaining that there was no
+        answer to count. Two renderings of one fact rather than two facts: the
+        banner carries the platform's own words, which may be specific, and this
+        is why the list is blank.
+      -->
       <DataTable
         :loading="loading"
         :data="entries"
@@ -85,7 +119,7 @@ const columns = computed(() => [
         :default-sort="{ column: 'nextRun', direction: 'asc' }"
         :search="{ placeholder: t('integration.schedules.search.placeholder') }"
         :filter-tabs="filterTabs"
-        :empty-text="t('integration.schedules.state.empty')"
+        :empty-text="error ? t('integration.schedules.error.loadFailed') : t('integration.schedules.state.empty')"
         @row-click="(e2) => router.push(`/integrations/workflows/${e2.workflowId}`)"
       >
         <template #cell-workflow="{ row: e }">
@@ -143,12 +177,35 @@ const columns = computed(() => [
           semantics in the shared table (PO-233, and a gap in
           `specs/accessibility.md`).
         -->
+        <!--
+          The instant the platform holds, shown as a distance from now, with the
+          moment in the schedule's own zone as its title: "in 6d" answers when,
+          and "2026-08-24T08:30:00+02:00" answers which side of a clock change it
+          falls on. Neither is worked out here — a browser doing summer-time
+          arithmetic that a wrong answer makes worse than no answer is exactly
+          what this replaced.
+        -->
         <template #cell-nextRun="{ row: e }">
-          <span :aria-label="t('integration.schedules.table.column.nextRun')" class="text-sm tabular-nums">{{ formatRelative(e.nextRunAt) }}</span>
+          <span
+            :aria-label="t('integration.schedules.table.column.nextRun')"
+            :title="e.nextRunLocal ?? void 0"
+            class="text-sm tabular-nums"
+          >{{ formatRelative(e.nextRunAt, e.timezone) }}</span>
         </template>
 
+        <!--
+          The last run carries a title too, and it is the instant rather than a
+          zone reading: the platform reports no local form for a run the way it
+          does for a firing, and inventing one here is what this page stopped
+          doing. Without it a run further back than a day was readable to the
+          minute and to no greater precision than the cell's own text.
+        -->
         <template #cell-lastRun="{ row: e }">
-          <span :aria-label="t('integration.schedules.table.column.lastRun')" class="text-sm tabular-nums text-muted-foreground">{{ formatRelative(e.lastRunAt) }}</span>
+          <span
+            :aria-label="t('integration.schedules.table.column.lastRun')"
+            :title="e.lastRunAt ?? void 0"
+            class="text-sm tabular-nums text-muted-foreground"
+          >{{ lastRunText(e) }}</span>
         </template>
 
         <template #cell-status="{ row: e }">

package/dist/runtime/types/integrations.d.ts

@@ -339,6 +339,18 @@ export interface NodeManifest {
     /** Empty marks a terminal node (PO-201): the run ends there, so the canvas
      *  draws no output handle and no edge may leave it. */
     outputs: NodeManifestOutput[];
+    /**
+     * When true, the node runs whatever is wired to its `item` output once per
+     * element, and its `done` output once afterwards — so the canvas marks that
+     * part as repeating (PO-277, `specs/editor-loop-body.md`).
+     *
+     * **Nothing publishes it yet** (later phase; harmless now, like
+     * `resolveOutputs` above). The worker derives the same fact at bundle-build
+     * time by duck-typing the implementation, and no field of `GET /nodes` carries
+     * it, so until one does the editor falls back to the published iterator's slug
+     * — `ITERATOR_SLUGS` in `data/loopBody.ts`, which this field is here to retire.
+     */
+    iteration?: boolean;
     config?: ConfigField[];
     /** Source package (editor-side enrichment from GET /nodes; not manifest data). */
     __package?: {
@@ -453,6 +465,12 @@ export interface WebhookEntry {
     lastFiredAt: string | null;
     callCount24h: number;
 }
+/**
+ * Why a schedule holds no next firing. Mirrors the conditions under which the
+ * platform's scheduler would never select it, so a paused schedule and one whose
+ * expression nobody can read stop reading the same way.
+ */
+export type ScheduleNotFiringReason = 'trigger_paused' | 'workflow_inactive' | 'workflow_not_ready' | 'no_cron' | 'invalid_cron' | 'unknown_timezone' | 'unsatisfiable';
 export interface ScheduleEntry {
     id: string;
     workflowId: number;
@@ -462,8 +480,29 @@ export interface ScheduleEntry {
     cron: string | null;
     timezone: string;
     active: boolean;
+    /** Whether the workflow the schedule belongs to is active. */
+    workflowActive: boolean;
+    /**
+     * The next firing the platform holds, as an instant, or `null` when it holds
+     * none. Not computed here: a browser working it out from the expression has to
+     * do summer-time arithmetic that a wrong answer makes worse than no answer.
+     */
     nextRunAt: string | null;
+    /** The same moment in the schedule's own zone, offset included. */
+    nextRunLocal: string | null;
+    /** When the schedule last actually ran — `null` when it never has. */
     lastRunAt: string | null;
+    /** How that run ended. */
+    lastRunStatus: string | null;
+    /**
+     * When the scheduler last DECIDED to fire this schedule. Stamped before the
+     * run exists, so it can differ from `lastRunAt` — a firing that was dispatched
+     * and then lost.
+     */
+    lastDispatchAt: string | null;
+    /** False whenever the platform would not fire this schedule. */
+    holdsFirings: boolean;
+    notFiringReason: ScheduleNotFiringReason | null;
 }
 export type TemplateCategory = 'sync' | 'notification' | 'enrichment' | 'fulfilment' | 'reporting' | 'finance' | 'commerce' | 'sales';
 export interface WorkflowTemplate {

package/dist/runtime/utils/statusStyle.d.ts

@@ -42,4 +42,56 @@ export declare const RUN_STATUS_WORDS: readonly ["running", "succeeded", "failed
  * never disagree about which status they mean.
  */
 export declare function normalisedRunStatus(status: string | null | undefined): string;
+/**
+ * The classes a run's status badge is drawn with — the colour half of
+ * {@link runStatusLabel}, and it reads the same word.
+ *
+ * `statusClass` on its own is handed whatever the platform wrote, and the map it
+ * looks in knows the studio's vocabulary rather than Temporal's: `terminated` and
+ * `timed_out` are in no branch of it, so a run the operator terminated was drawn
+ * neutral — the colour a *cancelled* run wears — while its badge said "failed".
+ * Two runs reading the same, in two colours, because the word went through
+ * {@link normalisedRunStatus} and the colour did not.
+ *
+ * So this normalises first. Every surface drawing a run's state calls it rather
+ * than `statusClass`, which stays what it is: one map from a status *word* to a
+ * tone, for the many vocabularies across the cockpit that already speak it.
+ */
+export declare function runStatusClass(status: string | null | undefined): string;
 export declare function runStatusLabel(status: string | null | undefined): string;
+/**
+ * A missed run's state, as a word written for the operator.
+ *
+ * The counterpart to {@link runStatusLabel} for the entry a trigger firing leaves
+ * when its workflow could not run. A state the catalogue does not know is named as
+ * unknown and carries the platform's own value inside that frame, so an operator
+ * can still quote what arrived without the studio claiming the word as one of its
+ * own. Nothing in, nothing out — the same answer `runStatusLabel` gives, for a
+ * column that is never actually empty.
+ *
+ * **The match is exact, unlike `runStatusLabel`'s**, and that is the point rather
+ * than an omission. Everything else that reads this field compares it strictly —
+ * whether an entry offers replay and discard, and whether it counts towards the
+ * firings still waiting — so a value differing by case or a stray space is one the
+ * studio does not act on. Saying "waiting" for it would promise an action that is
+ * not offered; saying it is unknown is what the rest of the studio already
+ * believes.
+ *
+ * The frame carries the value with its surrounding whitespace off and nothing else
+ * touched. Not verbatim, twice over, and neither is worth chasing: the badge is
+ * HTML, which collapses whitespace, and it draws its text uppercased — so an
+ * operator reads the letters that arrived rather than the casing, exactly as they
+ * do for the three states the studio does have words for.
+ */
+export declare function deadLetterStatusLabel(status: string | null | undefined): string;
+/**
+ * The classes a missed run's state badge is drawn with, on every surface that lists
+ * one.
+ *
+ * The colour half of {@link deadLetterStatusLabel}, reading the same map by the same
+ * exact match, so the two cannot disagree about which states the studio knows: a
+ * state named as unknown is drawn as unknown. Tones come from the shared palette,
+ * so this is one more vocabulary mapped into the studio's colours rather than a
+ * second set of colours.
+ */
+export declare function deadLetterStatusClass(status: string | null | undefined): string;

package/dist/runtime/utils/statusStyle.js

@@ -89,13 +89,39 @@ export function normalisedRunStatus(status) {
     case "terminated":
     case "timed_out":
       return "failed";
+    // Temporal spells a cancellation the American way and the studio does not, so
+    // without this the *word* half of the promise fails on the surfaces that read
+    // the platform's answer directly: the row said `cancelled`, the record
+    // `canceled`, and in German the record said it in English.
+    case "canceled":
+      return "cancelled";
     default:
       return s;
   }
 }
+export function runStatusClass(status) {
+  return statusClass(normalisedRunStatus(status));
+}
 export function runStatusLabel(status) {
   const normalized = normalisedRunStatus(status);
   if (!normalized) return "";
   if (!RUN_STATUS_WORD_SET.has(normalized)) return normalized;
   return useIntegrationsT()(`integration.runs.status.${normalized}`);
 }
+const MISSED_RUN_STATUS_TONE = /* @__PURE__ */ new Map([
+  ["pending", "warning"],
+  ["replayed", "success"],
+  ["discarded", "neutral"]
+]);
+export function deadLetterStatusLabel(status) {
+  if (!status) return "";
+  const raw = String(status);
+  if (!MISSED_RUN_STATUS_TONE.has(raw)) {
+    return useIntegrationsT()("integration.deadLetters.status.unknown", { status: raw.trim() || raw });
+  }
+  return useIntegrationsT()(`integration.deadLetters.status.${raw}`);
+}
+export function deadLetterStatusClass(status) {
+  const tone = status ? MISSED_RUN_STATUS_TONE.get(String(status)) : void 0;
+  return toneClass(tone ?? "neutral");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {