@acmekit/dashboard 2.13.34 → 2.13.35

package/src/routes/workflow-scheduled/workflow-scheduled-list.tsx

@@ -0,0 +1,269 @@
+import { Badge, Button, Container, Heading, Text, toast } from "@acmekit/ui"
+import { keepPreviousData } from "@tanstack/react-query"
+import { formatDistanceToNow } from "date-fns"
+import { useTranslation } from "react-i18next"
+import { SingleColumnPage } from "../../components/layout/pages"
+import {
+  useWorkflowDefinitions,
+} from "../../hooks/api/workflow-definitions"
+import { useRunWorkflow } from "../../hooks/api/workflow-executions"
+
+/**
+ * Very small cron → human-readable description utility.
+ * Handles the most common patterns without an external library.
+ */
+function describeCron(cron: string): string {
+  const parts = cron.trim().split(/\s+/)
+  if (parts.length < 5) return cron
+
+  const [minute, hour, dom, month, dow] = parts
+
+  if (
+    minute === "*" &&
+    hour === "*" &&
+    dom === "*" &&
+    month === "*" &&
+    dow === "*"
+  ) {
+    return "Every minute"
+  }
+
+  if (
+    minute !== "*" &&
+    hour === "*" &&
+    dom === "*" &&
+    month === "*" &&
+    dow === "*"
+  ) {
+    return `Every hour at minute ${minute}`
+  }
+
+  if (
+    minute !== "*" &&
+    hour !== "*" &&
+    dom === "*" &&
+    month === "*" &&
+    dow === "*"
+  ) {
+    const h = parseInt(hour, 10)
+    const m = parseInt(minute, 10)
+    const ampm = h >= 12 ? "PM" : "AM"
+    const h12 = h % 12 || 12
+    return `Daily at ${h12}:${String(m).padStart(2, "0")} ${ampm}`
+  }
+
+  if (
+    minute !== "*" &&
+    hour !== "*" &&
+    dom === "*" &&
+    month === "*" &&
+    dow !== "*"
+  ) {
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+    const dayNames = dow
+      .split(",")
+      .map((d) => days[parseInt(d, 10)] ?? d)
+      .join(", ")
+    const h = parseInt(hour, 10)
+    const m = parseInt(minute, 10)
+    const ampm = h >= 12 ? "PM" : "AM"
+    const h12 = h % 12 || 12
+    return `${dayNames} at ${h12}:${String(m).padStart(2, "0")} ${ampm}`
+  }
+
+  if (
+    minute !== "*" &&
+    hour !== "*" &&
+    dom !== "*" &&
+    month === "*" &&
+    dow === "*"
+  ) {
+    return `Monthly on day ${dom} at ${hour}:${String(parseInt(minute, 10)).padStart(2, "0")}`
+  }
+
+  return cron
+}
+
+/**
+ * Rough next-run estimate using date-fns (not exact; just indicative).
+ */
+function getNextRunLabel(cron: string): string {
+  try {
+    const parts = cron.trim().split(/\s+/)
+    if (parts.length < 5) return "Unknown"
+
+    const [minuteStr, hourStr] = parts
+    const now = new Date()
+    const next = new Date(now)
+
+    if (minuteStr === "*") {
+      // every minute
+      next.setSeconds(0, 0)
+      next.setMinutes(now.getMinutes() + 1)
+    } else if (hourStr === "*") {
+      // every hour at :MM
+      const m = parseInt(minuteStr, 10)
+      next.setMinutes(m, 0, 0)
+      if (next <= now) next.setHours(now.getHours() + 1)
+    } else {
+      // daily at HH:MM (simplified)
+      const h = parseInt(hourStr, 10)
+      const m = parseInt(minuteStr, 10)
+      next.setHours(h, m, 0, 0)
+      if (next <= now) next.setDate(now.getDate() + 1)
+    }
+
+    return formatDistanceToNow(next, { addSuffix: true })
+  } catch {
+    return "Unknown"
+  }
+}
+
+type WorkflowDef = {
+  id: string
+  handler_count: number
+  steps: Array<{ action: string; depth: number; noCompensation: boolean }>
+  options: Record<string, unknown>
+}
+
+const ScheduledRow = ({ def }: { def: WorkflowDef }) => {
+  const { t } = useTranslation()
+
+  const schedule = def.options?.schedule as
+    | { cron?: string; interval?: string }
+    | string
+    | undefined
+
+  const cronStr =
+    typeof schedule === "string"
+      ? schedule
+      : typeof schedule === "object"
+        ? schedule?.cron ?? String(schedule?.interval ?? "")
+        : ""
+
+  const humanSchedule = cronStr ? describeCron(cronStr) : "—"
+  const nextRun = cronStr ? getNextRunLabel(cronStr) : "—"
+
+  const { mutateAsync: runWorkflow, isPending } = useRunWorkflow(def.id)
+
+  const handleRunNow = async () => {
+    await runWorkflow(
+      { input: {} },
+      {
+        onSuccess: () => {
+          toast.success(t("workflowExecutions.actions.retrySuccess"))
+        },
+      }
+    )
+  }
+
+  return (
+    <div className="grid grid-cols-[1fr_1fr_1fr_auto] items-center gap-x-4 px-6 py-3">
+      <div className="flex flex-col gap-y-0.5">
+        <Text size="small" weight="plus" leading="compact">
+          {def.id}
+        </Text>
+        <Text size="xsmall" className="text-ui-fg-muted">
+          {def.handler_count}{" "}
+          {t("workflowExecutions.definitions.handlers")}
+        </Text>
+      </div>
+      <div>
+        <Badge size="2xsmall" className="font-mono">
+          {cronStr || "—"}
+        </Badge>
+        <Text size="xsmall" className="text-ui-fg-subtle mt-0.5">
+          {humanSchedule}
+        </Text>
+      </div>
+      <Text size="small" className="text-ui-fg-subtle">
+        {nextRun}
+      </Text>
+      <Button
+        size="small"
+        variant="secondary"
+        isLoading={isPending}
+        onClick={handleRunNow}
+      >
+        {t("workflowExecutions.scheduled.runNow")}
+      </Button>
+    </div>
+  )
+}
+
+export const WorkflowScheduledList = () => {
+  const { t } = useTranslation()
+
+  const { workflow_definitions, isPending } = useWorkflowDefinitions(
+    undefined,
+    { placeholderData: keepPreviousData }
+  )
+
+  const scheduled = (workflow_definitions ?? []).filter((def) => {
+    const opts = def.options
+    return opts && (opts.schedule || opts.cron)
+  })
+
+  return (
+    <SingleColumnPage widgets={{ before: [], after: [] }}>
+      <Container className="divide-y p-0">
+        <div className="flex items-center justify-between px-6 py-4">
+          <div>
+            <Heading>{t("workflowExecutions.scheduled.domain")}</Heading>
+            <Text className="text-ui-fg-subtle" size="small">
+              {t("workflowExecutions.scheduled.subtitle")}
+            </Text>
+          </div>
+        </div>
+
+        {/* Table header */}
+        <div className="grid grid-cols-[1fr_1fr_1fr_auto] gap-x-4 border-b border-ui-border-base px-6 py-2">
+          <Text
+            size="xsmall"
+            weight="plus"
+            className="text-ui-fg-subtle uppercase"
+          >
+            Workflow
+          </Text>
+          <Text
+            size="xsmall"
+            weight="plus"
+            className="text-ui-fg-subtle uppercase"
+          >
+            {t("workflowExecutions.scheduled.schedule")}
+          </Text>
+          <Text
+            size="xsmall"
+            weight="plus"
+            className="text-ui-fg-subtle uppercase"
+          >
+            {t("workflowExecutions.scheduled.nextRun")}
+          </Text>
+          <div />
+        </div>
+
+        {isPending && (
+          <div className="px-6 py-4">
+            <Text size="small" className="text-ui-fg-muted">
+              Loading...
+            </Text>
+          </div>
+        )}
+
+        {!isPending && scheduled.length === 0 && (
+          <div className="px-6 py-8 text-center">
+            <Text size="small" className="text-ui-fg-muted">
+              {t("workflowExecutions.scheduled.noRecordsMessage")}
+            </Text>
+          </div>
+        )}
+
+        {scheduled.map((def) => (
+          <ScheduledRow key={def.id} def={def} />
+        ))}
+      </Container>
+    </SingleColumnPage>
+  )
+}
+
+export const Component = WorkflowScheduledList

package/dist/chunk-LKWTBYYC.mjs

@@ -1,35 +0,0 @@
-import {
-  queryKeysFactory
-} from "./chunk-774WSTCC.mjs";
-import {
-  sdk
-} from "./chunk-DTY37DDZ.mjs";
-
-// src/hooks/api/workflow-executions.tsx
-import { useQuery } from "@tanstack/react-query";
-var WORKFLOW_EXECUTIONS_QUERY_KEY = "workflow_executions";
-var workflowExecutionsQueryKeys = queryKeysFactory(
-  WORKFLOW_EXECUTIONS_QUERY_KEY
-);
-var useWorkflowExecutions = (query, options) => {
-  const { data, ...rest } = useQuery({
-    queryFn: () => sdk.admin.workflowExecution.list(query),
-    queryKey: workflowExecutionsQueryKeys.list(query),
-    ...options
-  });
-  return { ...data, ...rest };
-};
-var useWorkflowExecution = (id, options) => {
-  const { data, ...rest } = useQuery({
-    queryFn: () => sdk.admin.workflowExecution.retrieve(id),
-    queryKey: workflowExecutionsQueryKeys.detail(id),
-    ...options
-  });
-  return { ...data, ...rest };
-};
-
-export {
-  workflowExecutionsQueryKeys,
-  useWorkflowExecutions,
-  useWorkflowExecution
-};

package/dist/chunk-RPAL6FHW.mjs

@@ -1,73 +0,0 @@
-// src/routes/workflow-executions/constants.ts
-var STEP_IN_PROGRESS_STATES = [
-  "compensating" /* COMPENSATING */,
-  "invoking" /* INVOKING */
-];
-var STEP_SKIPPED_STATES = [
-  "skipped" /* SKIPPED */,
-  "skipped_failure" /* SKIPPED_FAILURE */
-];
-var STEP_OK_STATES = [
-  "done" /* DONE */
-];
-var STEP_ERROR_STATES = [
-  "failed" /* FAILED */,
-  "reverted" /* REVERTED */,
-  "timeout" /* TIMEOUT */,
-  "dormant" /* DORMANT */
-];
-var STEP_INACTIVE_STATES = [
-  "not_started" /* NOT_STARTED */
-];
-var TRANSACTION_OK_STATES = [
-  "done" /* DONE */
-];
-var TRANSACTION_ERROR_STATES = [
-  "failed" /* FAILED */,
-  "reverted" /* REVERTED */
-];
-var TRANSACTION_IN_PROGRESS_STATES = [
-  "invoking" /* INVOKING */,
-  "waiting_to_compensate" /* WAITING_TO_COMPENSATE */,
-  "compensating" /* COMPENSATING */
-];
-
-// src/routes/workflow-executions/utils.ts
-var getTransactionStateColor = (state) => {
-  let statusColor = "green";
-  if (TRANSACTION_ERROR_STATES.includes(state)) {
-    statusColor = "red";
-  }
-  if (TRANSACTION_IN_PROGRESS_STATES.includes(state)) {
-    statusColor = "orange";
-  }
-  return statusColor;
-};
-var getTransactionState = (t, state) => {
-  switch (state) {
-    case "done" /* DONE */:
-      return t("workflowExecutions.state.done");
-    case "failed" /* FAILED */:
-      return t("workflowExecutions.state.failed");
-    case "reverted" /* REVERTED */:
-      return t("workflowExecutions.state.reverted");
-    case "invoking" /* INVOKING */:
-      return t("workflowExecutions.state.invoking");
-    case "waiting_to_compensate" /* WAITING_TO_COMPENSATE */:
-      return t("workflowExecutions.transaction.state.waitingToCompensate");
-    case "compensating" /* COMPENSATING */:
-      return t("workflowExecutions.state.compensating");
-    case "not_started" /* NOT_STARTED */:
-      return t("workflowExecutions.state.notStarted");
-  }
-};
-
-export {
-  STEP_IN_PROGRESS_STATES,
-  STEP_SKIPPED_STATES,
-  STEP_OK_STATES,
-  STEP_ERROR_STATES,
-  STEP_INACTIVE_STATES,
-  getTransactionStateColor,
-  getTransactionState
-};