@acmekit/dashboard 2.13.35 → 2.13.37

package/src/i18n/translations/en.json

@@ -2975,10 +2975,7 @@
     "stepsCompletedLabel_one": "{{completed}} of {{count}} step",
     "stepsCompletedLabel_other": "{{completed}} of {{count}} steps",
     "list": {
-      "noRecordsMessage": "No workflows have been executed, yet.",
-      "noFilterResults": "No executions match your current filters.",
-      "clearFilters": "Clear filters",
-      "viewAll": "View all executions"
+      "noRecordsMessage": "No workflows have been executed, yet."
     },
     "history": {
       "sectionTitle": "History",
@@ -2991,11 +2988,7 @@
       "outputLabel": "Output",
       "compensateInputLabel": "Compensate input",
       "revertedLabel": "Reverted",
-      "errorLabel": "Error",
-      "idempotencyKeyLabel": "Idempotency key",
-      "showCompensation": "Show compensation",
-      "showInvoke": "Show invoke",
-      "retryFromStep": "Retry from this step"
+      "errorLabel": "Error"
     },
     "state": {
       "done": "Done",
@@ -3003,8 +2996,7 @@
       "reverted": "Reverted",
       "invoking": "Invoking",
       "compensating": "Compensating",
-      "notStarted": "Not started",
-      "waitingResponse": "Waiting for response"
+      "notStarted": "Not started"
     },
     "transaction": {
       "state": {
@@ -3018,127 +3010,6 @@
         "dormant": "Dormant",
         "timeout": "Timeout"
       }
-    },
-    "actions": {
-      "retry": "Retry",
-      "retryWithSameInput": "Retry with same input",
-      "retryWithNewInput": "Retry with new input...",
-      "cancel": "Cancel execution",
-      "cancelConfirmTitle": "Cancel workflow execution?",
-      "cancelConfirmDescription": "This will stop {{workflow_id}} and run compensation for all completed steps.",
-      "cancelReasonLabel": "Reason (optional)",
-      "cancelSuccess": "Workflow execution cancelled successfully",
-      "retrySuccess": "Workflow re-run started successfully",
-      "retryStepSuccess": "Step retry initiated successfully",
-      "runWorkflow": "Run workflow",
-      "exportJson": "Export as JSON",
-      "exportCsv": "Export as CSV",
-      "completeStep": "Complete step",
-      "markAsSuccessful": "Mark as successful",
-      "markAsFailed": "Mark as failed",
-      "viewDetails": "View details"
-    },
-    "rerun": {
-      "title": "Re-run workflow",
-      "inputLabel": "Input (JSON)",
-      "transactionIdLabel": "Transaction ID (optional)",
-      "submit": "Run workflow",
-      "autoGenerated": "auto-generated",
-      "success": "Workflow re-run started successfully"
-    },
-    "error": {
-      "failureAtStep": "Failure at step: {{step}}",
-      "jumpToStep": "Jump to step",
-      "attemptInfo": "Attempt {{attempt}} of {{maxAttempts}}",
-      "failedAt": "Failed at {{time}}"
-    },
-    "filters": {
-      "savedViews": "Saved views",
-      "saveCurrentFilter": "Save current filter",
-      "savedViewName": "View name",
-      "autoRefresh": "Auto-refresh",
-      "refreshNow": "Refresh now",
-      "everyNSeconds": "Every {{n}}s",
-      "off": "Off",
-      "hasErrors": "Has errors",
-      "all": "All",
-      "allExecutions": "All executions",
-      "running": "Running",
-      "failedToday": "Failed today"
-    },
-    "definitions": {
-      "domain": "Definitions",
-      "subtitle": "Browse all registered workflow definitions.",
-      "name": "Name",
-      "steps": "Steps",
-      "stepCount": "Steps",
-      "handlers": "Handlers",
-      "lastRun": "Last run",
-      "nextRun": "Next run",
-      "scheduled": "Scheduled",
-      "runThisWorkflow": "Run this workflow",
-      "noRecordsMessage": "No workflow definitions found."
-    },
-    "scheduled": {
-      "domain": "Scheduled",
-      "subtitle": "View and manage scheduled workflow executions.",
-      "schedule": "Schedule",
-      "nextRun": "Next run",
-      "lastRun": "Last run",
-      "pause": "Pause",
-      "resume": "Resume",
-      "runNow": "Run now",
-      "noRecordsMessage": "No scheduled workflows found."
-    },
-    "analytics": {
-      "domain": "Analytics",
-      "subtitle": "Workflow execution metrics and trends.",
-      "executions24h": "Executions (24h)",
-      "successRate": "Success rate",
-      "avgDuration": "Avg duration",
-      "runningNow": "Running now",
-      "executionsOverTime": "Executions over time",
-      "perWorkflowBreakdown": "Per-workflow breakdown",
-      "slowestSteps": "Slowest steps",
-      "noDataMessage": "No metrics data available yet."
-    },
-    "asyncStep": {
-      "waitingBanner": "Waiting for external response",
-      "waitingDescription": "Step {{step}} is awaiting a webhook callback.",
-      "idempotencyKey": "Idempotency key",
-      "completeTitle": "Complete step: {{step}}",
-      "responsePayload": "Response payload (JSON)",
-      "expiresIn": "Expires in {{time}}",
-      "stepLabel": "Step",
-      "outcomeLabel": "Outcome",
-      "success": "Success",
-      "failure": "Failure",
-      "markSuccess": "Mark as success",
-      "markFailure": "Mark as failure",
-      "completedSuccess": "Step completed successfully"
-    },
-    "tabs": {
-      "executions": "Executions",
-      "definitions": "Definitions",
-      "scheduled": "Scheduled",
-      "analytics": "Analytics"
-    },
-    "payload": {
-      "inputPayload": "Input payload",
-      "fullCheckpoint": "Full checkpoint",
-      "stepOutputs": "Step outputs",
-      "errors": "Errors",
-      "copyAll": "Copy all",
-      "downloadJson": "Download as JSON"
-    },
-    "codeSnippet": {
-      "curl": "cURL",
-      "sdk": "SDK",
-      "replicateCall": "Replicate this call"
-    },
-    "compare": {
-      "title": "Compare executions",
-      "selectExecution": "Select execution to compare"
     }
   },
   "shippingOptionTypes": {

package/src/routes/workflow-executions/constants.ts

@@ -36,19 +36,3 @@ export const TRANSACTION_IN_PROGRESS_STATES: HttpTypes.TransactionState[] = [
   TransactionState.WAITING_TO_COMPENSATE,
   TransactionState.COMPENSATING,
 ]
-
-export const TRANSACTION_TERMINAL_STATES: HttpTypes.TransactionState[] = [
-  TransactionState.DONE,
-  TransactionState.FAILED,
-  TransactionState.REVERTED,
-]
-
-export const TRANSACTION_ACTIVE_STATES: HttpTypes.TransactionState[] = [
-  TransactionState.INVOKING,
-  TransactionState.COMPENSATING,
-  TransactionState.WAITING_TO_COMPENSATE,
-]
-
-export const STEP_WAITING_STATES: HttpTypes.TransactionStepState[] = [
-  TransactionStepState.INVOKING, // waiting_response comes through as invoking state in the step
-]

package/src/routes/workflow-executions/utils.ts

@@ -4,12 +4,10 @@ import {
   STEP_ERROR_STATES,
   STEP_INACTIVE_STATES,
   STEP_IN_PROGRESS_STATES,
+  TRANSACTION_ERROR_STATES,
+  TRANSACTION_IN_PROGRESS_STATES,
 } from "./constants"
-import {
-  TransactionState,
-  TransactionStepState,
-  TransactionStepStatus,
-} from "./types"
+import { TransactionState, TransactionStepState } from "./types"
 
 export const adminExecutionKey = {
   detail: (id: string) => ["workflow_executions", "detail", id],
@@ -22,23 +20,18 @@ export const adminExecutionKey = {
 
 export const getTransactionStateColor = (
   state: TransactionState
-): "green" | "orange" | "red" | "blue" | "purple" | "grey" => {
-  switch (state) {
-    case TransactionState.DONE:
-      return "green"
-    case TransactionState.FAILED:
-    case TransactionState.REVERTED:
-      return "red"
-    case TransactionState.INVOKING:
-      return "blue"
-    case TransactionState.COMPENSATING:
-    case TransactionState.WAITING_TO_COMPENSATE:
-      return "orange"
-    case TransactionState.NOT_STARTED:
-      return "grey"
-    default:
-      return "grey"
+): "green" | "orange" | "red" => {
+  let statusColor: "green" | "red" | "orange" = "green"
+
+  if (TRANSACTION_ERROR_STATES.includes(state)) {
+    statusColor = "red"
   }
+
+  if (TRANSACTION_IN_PROGRESS_STATES.includes(state)) {
+    statusColor = "orange"
+  }
+
+  return statusColor
 }
 
 export const getTransactionState = (
@@ -108,152 +101,3 @@ export const getStepState = (
       return t("workflowExecutions.step.state.timeout")
   }
 }
-
-export const isTerminalState = (state: TransactionState): boolean => {
-  return [
-    TransactionState.DONE,
-    TransactionState.FAILED,
-    TransactionState.REVERTED,
-  ].includes(state)
-}
-
-export const getFailedSteps = (
-  execution: HttpTypes.AdminWorkflowExecution
-): Array<{ stepId: string; error?: any }> => {
-  const steps = execution?.execution?.steps || {}
-  const errors = execution?.context?.errors || []
-  const failed: Array<{ stepId: string; error?: any }> = []
-
-  for (const [stepId, step] of Object.entries(steps)) {
-    if (stepId === "_root") continue
-    const invokeStatus = (step as any)?.invoke?.status
-    if (invokeStatus === TransactionStepStatus.PERMANENT_FAILURE) {
-      const stepError = errors.find((e: any) => e.action === stepId)
-      failed.push({ stepId, error: stepError })
-    }
-  }
-
-  return failed
-}
-
-export const getWaitingSteps = (
-  execution: HttpTypes.AdminWorkflowExecution
-): Array<{ stepId: string }> => {
-  const steps = execution?.execution?.steps || {}
-  const waiting: Array<{ stepId: string }> = []
-
-  for (const [stepId, step] of Object.entries(steps)) {
-    if (stepId === "_root") continue
-    const invokeStatus = (step as any)?.invoke?.status
-    if (invokeStatus === TransactionStepStatus.WAITING) {
-      waiting.push({ stepId })
-    }
-  }
-
-  return waiting
-}
-
-export const formatStepDuration = (
-  startedAt?: number,
-  endedAt?: number
-): string => {
-  if (!startedAt || !endedAt) return ""
-
-  const ms = endedAt - startedAt
-  if (ms < 1000) return `${ms}ms`
-  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`
-  const minutes = Math.floor(ms / 60_000)
-  const seconds = Math.round((ms % 60_000) / 1000)
-  return `${minutes}m ${seconds}s`
-}
-
-export const computeIdempotencyKey = (
-  workflowId: string,
-  transactionId: string,
-  stepId: string,
-  action: "invoke" | "compensate" = "invoke"
-): string => {
-  return `${workflowId}:${transactionId}:${stepId}:${action}`
-}
-
-export const mergeStepEvent = (
-  current: HttpTypes.AdminWorkflowExecutionResponse | undefined,
-  event: {
-    event_type: string
-    workflow_id: string
-    transaction_id: string
-    step?: Record<string, unknown>
-    response?: Record<string, unknown>
-    result?: Record<string, unknown>
-    errors?: Array<Record<string, unknown>>
-  }
-): HttpTypes.AdminWorkflowExecutionResponse | undefined => {
-  if (!current) return current
-
-  const updated = JSON.parse(
-    JSON.stringify(current)
-  ) as HttpTypes.AdminWorkflowExecutionResponse
-
-  const execution = updated.workflow_execution
-  if (!execution?.execution?.steps) return updated
-
-  const stepId = (event.step as any)?.id
-  if (!stepId) return updated
-
-  const step = execution.execution.steps[stepId] as any
-  if (!step) return updated
-
-  const eventType = event.event_type
-  switch (eventType) {
-    case "onStepBegin":
-      if (step.invoke) step.invoke.state = TransactionStepState.INVOKING
-      break
-    case "onStepSuccess":
-      if (step.invoke) {
-        step.invoke.state = TransactionStepState.DONE
-        step.invoke.status = TransactionStepStatus.OK
-      }
-      break
-    case "onStepFailure":
-      if (step.invoke) {
-        step.invoke.state = TransactionStepState.FAILED
-        step.invoke.status = TransactionStepStatus.PERMANENT_FAILURE
-      }
-      break
-    case "onStepAwaiting":
-      if (step.invoke) {
-        step.invoke.status = TransactionStepStatus.WAITING
-      }
-      break
-    case "onCompensateBegin":
-      if (step.compensate) {
-        step.compensate.state = TransactionStepState.COMPENSATING
-      }
-      break
-    case "onCompensateStepSuccess":
-      if (step.compensate) {
-        step.compensate.state = TransactionStepState.REVERTED
-      }
-      break
-    case "onCompensateStepFailure":
-      if (step.compensate) {
-        step.compensate.state = TransactionStepState.FAILED
-      }
-      break
-    case "onStepSkipped":
-      if (step.invoke) {
-        step.invoke.state = TransactionStepState.SKIPPED
-      }
-      break
-    case "onFinish":
-      execution.state = TransactionState.DONE
-      break
-    case "onTimeout":
-      if (step.invoke) {
-        step.invoke.state = TransactionStepState.TIMEOUT
-      }
-      break
-  }
-
-  return updated
-}

package/src/routes/workflow-executions/workflow-execution-detail/breadcrumb.tsx

@@ -22,11 +22,5 @@ export const WorkflowExecutionDetailBreadcrumb = (
 
   const cleanId = workflow_execution.id.replace("wf_exec_", "")
 
-  return (
-    <span>
-      {workflow_execution.workflow_id}
-      <span className="text-ui-fg-muted"> / </span>
-      {cleanId}
-    </span>
-  )
+  return <span>{cleanId}</span>
 }

package/src/routes/workflow-executions/workflow-execution-detail/components/workflow-execution-history-section/workflow-execution-history-section.tsx

@@ -1,15 +1,12 @@
 import { Spinner, TriangleDownMini } from "@acmekit/icons"
 import { HttpTypes } from "@acmekit/types"
 import {
-  Button,
   clx,
   CodeBlock,
   Container,
-  Copy,
   Heading,
   IconButton,
   Text,
-  toast,
 } from "@acmekit/ui"
 import { format } from "date-fns"
 import { Collapsible as RadixCollapsible } from "radix-ui"
@@ -23,12 +20,7 @@ import {
   STEP_OK_STATES,
   STEP_SKIPPED_STATES,
 } from "../../../constants"
-import { TransactionState, TransactionStepState, TransactionStepStatus } from "../../../types"
-import {
-  computeIdempotencyKey,
-  formatStepDuration,
-} from "../../../utils"
-import { useRetryStep } from "../../../../../hooks/api/workflow-executions"
+import { TransactionStepState, TransactionStepStatus } from "../../../types"
 
 type WorkflowExecutionHistorySectionProps = {
   execution: HttpTypes.AdminWorkflowExecution
@@ -42,14 +34,6 @@ export const WorkflowExecutionHistorySection = ({
   const map = Object.values(execution.execution?.steps || {})
   const steps = map.filter((step) => step.id !== "_root")
 
-  const hasCompensation = [
-    TransactionState.COMPENSATING,
-    TransactionState.REVERTED,
-    TransactionState.WAITING_TO_COMPENSATE,
-  ].includes(execution.state as TransactionState)
-
-  const [showCompensation, setShowCompensation] = useState(false)
-
   // check if any of the steps have a .invoke.state of "permanent_failure" and if that is the case then return its id
   const unreachableStepId = steps.find(
     (step) => step.invoke.status === TransactionStepStatus.PERMANENT_FAILURE
@@ -71,17 +55,6 @@ export const WorkflowExecutionHistorySection = ({
         <Heading level="h2">
           {t("workflowExecutions.history.sectionTitle")}
         </Heading>
-        {hasCompensation && (
-          <Button
-            size="small"
-            variant="secondary"
-            onClick={() => setShowCompensation((v) => !v)}
-          >
-            {showCompensation
-              ? t("workflowExecutions.history.showInvoke")
-              : t("workflowExecutions.history.showCompensation")}
-          </Button>
-        )}
       </div>
       <div className="flex flex-col gap-y-0.5 px-6 py-4">
         {steps.map((step, index) => {
@@ -104,8 +77,6 @@ export const WorkflowExecutionHistorySection = ({
               stepError={error}
               isLast={index === steps.length - 1}
               isUnreachable={unreachableSteps.includes(step.id)}
-              execution={execution}
-              showCompensation={showCompensation}
             />
           )
         })}
@@ -120,16 +91,12 @@ const Event = ({
   stepError,
   isLast,
   isUnreachable,
-  execution,
-  showCompensation,
 }: {
   step: HttpTypes.AdminWorkflowExecutionStep
   stepInvokeContext: HttpTypes.StepInvokeResult | undefined
   stepError?: HttpTypes.StepError | undefined
   isLast: boolean
   isUnreachable?: boolean
-  execution: HttpTypes.AdminWorkflowExecution
-  showCompensation?: boolean
 }) => {
   const [open, setOpen] = useState(false)
 
@@ -147,37 +114,6 @@ const Event = ({
   }, [hash, stepId])
 
   const identifier = step.id.split(".").pop()
-  const isPermanentFailure =
-    step.invoke.status === TransactionStepStatus.PERMANENT_FAILURE
-  const isWaiting = step.invoke.status === TransactionStepStatus.WAITING
-
-  const idempotencyKey = computeIdempotencyKey(
-    execution.workflow_id,
-    execution.transaction_id,
-    stepId,
-    "invoke"
-  )
-
-  const duration = formatStepDuration(
-    step.startedAt ?? undefined,
-    (step as any).endedAt ?? undefined
-  )
-
-  const { mutateAsync: retryStep, isPending: isRetrying } = useRetryStep(
-    execution.workflow_id,
-    execution.transaction_id
-  )
-
-  const handleRetryStep = async () => {
-    await retryStep(
-      { step_id: stepId },
-      {
-        onSuccess: () => {
-          toast.success(t("workflowExecutions.actions.retryStepSuccess"))
-        },
-      }
-    )
-  }
 
   return (
     <div
@@ -195,10 +131,9 @@ const Event = ({
                 "bg-ui-tag-green-icon": STEP_OK_STATES.includes(
                   step.invoke.state
                 ),
-                "bg-ui-tag-purple-icon": isWaiting,
-                "bg-ui-tag-orange-icon":
-                  !isWaiting &&
-                  STEP_IN_PROGRESS_STATES.includes(step.invoke.state),
+                "bg-ui-tag-orange-icon": STEP_IN_PROGRESS_STATES.includes(
+                  step.invoke.state
+                ),
                 "bg-ui-tag-red-icon": STEP_ERROR_STATES.includes(
                   step.invoke.state
                 ),
@@ -219,29 +154,15 @@ const Event = ({
           />
         </div>
       </div>
-      <RadixCollapsible.Root
-        open={open}
-        onOpenChange={(isOpen) => {
-          setOpen(isOpen)
-          if (isOpen) {
-            window.history.replaceState(null, "", `#${stepId}`)
-          }
-        }}
-      >
+      <RadixCollapsible.Root open={open} onOpenChange={setOpen}>
         <RadixCollapsible.Trigger asChild>
           <div className="group flex cursor-pointer items-start justify-between outline-none">
             <Text size="small" leading="compact" weight="plus">
               {identifier}
             </Text>
             <div className="flex items-center gap-x-2">
-              {duration && (
-                <Text size="small" leading="compact" className="text-ui-fg-muted">
-                  {duration}
-                </Text>
-              )}
               <StepState
                 state={step.invoke.state}
-                status={step.invoke.status}
                 startedAt={step.startedAt}
                 isUnreachable={isUnreachable}
               />
@@ -253,35 +174,6 @@ const Event = ({
         </RadixCollapsible.Trigger>
         <RadixCollapsible.Content ref={ref}>
           <div className="flex flex-col gap-y-2 pb-4 pt-2">
-            {/* Idempotency key */}
-            <div className="flex items-center justify-between">
-              <Text size="xsmall" className="text-ui-fg-muted">
-                {t("workflowExecutions.history.idempotencyKeyLabel")}
-              </Text>
-              <Copy content={idempotencyKey} asChild>
-                <Text
-                  size="xsmall"
-                  className="text-ui-fg-subtle cursor-pointer font-mono"
-                >
-                  {idempotencyKey}
-                </Text>
-              </Copy>
-            </div>
-
-            {/* Retry from this step — only for permanent failures */}
-            {isPermanentFailure && (
-              <div className="flex justify-end">
-                <Button
-                  size="small"
-                  variant="secondary"
-                  isLoading={isRetrying}
-                  onClick={handleRetryStep}
-                >
-                  {t("workflowExecutions.history.retryFromStep")}
-                </Button>
-              </div>
-            )}
-
             <div className="text-ui-fg-subtle flex flex-col gap-y-2">
               <Text size="small" leading="compact">
                 {t("workflowExecutions.history.definitionLabel")}
@@ -323,37 +215,7 @@ const Event = ({
                 </CodeBlock>
               </div>
             )}
-            {showCompensation && step.compensate.state !== TransactionStepState.NOT_STARTED && (
-              <div className="border-ui-tag-orange-border bg-ui-tag-orange-bg rounded-md border p-3">
-                <Text size="xsmall" weight="plus" className="text-ui-tag-orange-text mb-2">
-                  ↩ {t("workflowExecutions.history.revertedLabel")} — {step.compensate.state}
-                </Text>
-                {!!stepInvokeContext?.output?.compensateInput && (
-                  <div className="flex flex-col gap-y-1">
-                    <Text size="xsmall" className="text-ui-fg-subtle">
-                      {t("workflowExecutions.history.compensateInputLabel")}
-                    </Text>
-                    <CodeBlock
-                      snippets={[
-                        {
-                          code: JSON.stringify(
-                            stepInvokeContext?.output?.compensateInput ?? {},
-                            null,
-                            2
-                          ),
-                          label: t("workflowExecutions.history.compensateInputLabel"),
-                          language: "json",
-                          hideLineNumbers: true,
-                        },
-                      ]}
-                    >
-                      <CodeBlock.Body />
-                    </CodeBlock>
-                  </div>
-                )}
-              </div>
-            )}
-            {!showCompensation && !!stepInvokeContext?.output?.compensateInput &&
+            {!!stepInvokeContext?.output?.compensateInput &&
               step.compensate.state === TransactionStepState.REVERTED && (
                 <div className="text-ui-fg-subtle flex flex-col gap-y-2">
                   <Text size="small" leading="compact">
@@ -415,12 +277,10 @@ const Event = ({
 
 const StepState = ({
   state,
-  status,
   startedAt,
   isUnreachable,
 }: {
   state: HttpTypes.TransactionStepState
-  status?: HttpTypes.TransactionStepStatus
   startedAt?: number | null
   isUnreachable?: boolean
 }) => {
@@ -428,7 +288,6 @@ const StepState = ({
 
   const isFailed = state === TransactionStepState.FAILED
   const isRunning = state === TransactionStepState.INVOKING
-  const isWaitingResponse = status === TransactionStepStatus.WAITING
   const isSkipped = state === TransactionStepState.SKIPPED
   const isSkippedFailure = state === TransactionStepState.SKIPPED_FAILURE
 
@@ -436,16 +295,6 @@ const StepState = ({
     return null
   }
 
-  if (isWaitingResponse) {
-    return (
-      <div className="flex items-center gap-x-1">
-        <Text size="small" leading="compact" className="text-ui-tag-purple-text">
-          {t("workflowExecutions.history.awaitingState")}
-        </Text>
-      </div>
-    )
-  }
-
   if (isRunning) {
     return (
       <div className="flex items-center gap-x-1">