@burdenoff/fluidgrids-fe-sdk 2026.1022.5 → 2026.1022.7

package/dist/chunk-VGIH3SOT.js

@@ -0,0 +1,476 @@
+import { REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS } from './chunk-QBFAJNUC.js';
+import { useExecutionsStore } from './chunk-UZG3ZIQM.js';
+import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-SAZVBFMO.js';
+import { throwIfResultError, openRunQuotaUpgradePrompt } from './chunk-4UAWCWS7.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { gql } from '@apollo/client';
+
+gql`
+  subscription NodeStateUpdated($runId: String!) {
+    _empty
+  }
+`;
+gql`
+  subscription WorkflowCompleted($runId: String!) {
+    _empty
+  }
+`;
+gql`
+  subscription WorkflowError($runId: String!) {
+    _empty
+  }
+`;
+gql`
+  subscription ExecutionUpdated($runId: String!) {
+    _empty
+  }
+`;
+gql`
+  subscription ExecutionNodeStateUpdated($runId: String!) {
+    _empty
+  }
+`;
+gql`
+  subscription ExecutionCompleted($runId: String!) {
+    _empty
+  }
+`;
+gql`
+  subscription ExecutionError($runId: String!) {
+    _empty
+  }
+`;
+
+// src/modules/executions/utils/date-range.ts
+function toDate(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function validateDateRange(start, end, preset) {
+  const startDate = toDate(start);
+  const endDate = toDate(end);
+  if (startDate && endDate && startDate.getTime() > endDate.getTime()) {
+    return { valid: false, start: null, end: null, preset: preset ?? "all" };
+  }
+  return {
+    valid: true,
+    start: startDate,
+    end: endDate,
+    preset: preset ?? "all"
+  };
+}
+function dateRangeToInput(start, end) {
+  const {
+    valid,
+    start: validatedStart,
+    end: validatedEnd
+  } = validateDateRange(start, end);
+  if (!valid) return {};
+  const input = {};
+  if (validatedStart) input.startDate = validatedStart.toISOString();
+  if (validatedEnd) input.endDate = validatedEnd.toISOString();
+  return input;
+}
+
+// src/modules/executions/utils/retry.ts
+var NON_REPLAYABLE_CONTEXT_KEYS = ["isScheduled", "workspaceId"];
+function buildRetryTriggerInput(run) {
+  if (!run.workflowKey || !run.version || !run.triggerNodeId) return null;
+  const context = {};
+  const original = run.context;
+  if (original && typeof original === "object" && !Array.isArray(original)) {
+    for (const [key, value] of Object.entries(
+      original
+    )) {
+      if (NON_REPLAYABLE_CONTEXT_KEYS.includes(key)) {
+        continue;
+      }
+      context[key] = value;
+    }
+  }
+  context.retryOfRunId = run.id;
+  return {
+    workflowKey: run.workflowKey,
+    version: run.version,
+    triggerNodeId: run.triggerNodeId,
+    triggerData: run.triggerData ?? void 0,
+    context
+  };
+}
+
+// src/modules/executions/hooks/useExecutions.ts
+function useExecutions(input = {}) {
+  const [executions, setExecutions] = useState([]);
+  const [total, setTotal] = useState(0);
+  const [hasMore, setHasMore] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const inputKey = JSON.stringify(input);
+  const reqIdRef = useRef(0);
+  const fetchData = useCallback(async () => {
+    const reqId = ++reqIdRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = await client.query({
+        query: ExecutionsListDocument,
+        variables: { input: JSON.parse(inputKey) },
+        fetchPolicy: "network-only"
+      });
+      if (reqId !== reqIdRef.current) return;
+      setExecutions(result.data?.workflowRuns?.items ?? []);
+      setTotal(result.data?.workflowRuns?.total ?? 0);
+      setHasMore(result.data?.workflowRuns?.hasMore ?? false);
+    } catch (err) {
+      if (reqId !== reqIdRef.current) return;
+      setError(err);
+    } finally {
+      if (reqId === reqIdRef.current) setLoading(false);
+    }
+  }, [inputKey]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    executions,
+    total,
+    hasMore,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useExecution(id) {
+  const [execution, setExecution] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchData = useCallback(async () => {
+    if (!id) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = await client.query({
+        query: ExecutionDetailDocument,
+        variables: { id },
+        fetchPolicy: "network-only"
+      });
+      setExecution(result.data?.workflowRun ?? null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [id]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    execution,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useExecutionStats(options = {}) {
+  const [stats, setStats] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const optionsKey = JSON.stringify(options);
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = await client.query({
+        query: ExecutionStatsDocument,
+        variables: JSON.parse(optionsKey),
+        fetchPolicy: "network-only"
+      });
+      setStats(result.data?.dashboardSummary ?? null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [optionsKey]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    stats,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useExecutionActions() {
+  const tr = useTr();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const pauseExecution = useCallback(async (id) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = throwIfResultError(
+        await client.mutate({
+          mutation: PauseExecutionDocument,
+          variables: { id }
+        })
+      );
+      return result.data?.pauseWorkflowRun ?? null;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const resumeExecution = useCallback(async (id) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = throwIfResultError(
+        await client.mutate({
+          mutation: ResumeExecutionDocument,
+          variables: { id }
+        })
+      );
+      return result.data?.resumeWorkflowRun ?? null;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const cancelExecution = useCallback(async (id) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = throwIfResultError(
+        await client.mutate({
+          mutation: CancelExecutionDocument,
+          variables: { id }
+        })
+      );
+      return result.data?.cancelWorkflowRun ?? null;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const retryNode = useCallback(async (runId, nodeId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = throwIfResultError(
+        await client.mutate({
+          mutation: RetryNodeDocument,
+          variables: { id: runId, nodeId }
+        })
+      );
+      return result.data?.retryNode ?? null;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const retryExecution = useCallback(
+    async (execution) => {
+      const input = buildRetryTriggerInput(execution);
+      if (!input) {
+        const message = "This run has no trigger node, so it cannot be re-run.";
+        setError(new Error(message));
+        return { ok: false, message };
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: TriggerWorkflowDocument,
+            variables: { input }
+          })
+        );
+        const run = result.data?.triggerWorkflow;
+        if (!run) {
+          const message = "The workflow did not start.";
+          setError(new Error(message));
+          return { ok: false, message };
+        }
+        return { ok: true, run };
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        openRunQuotaUpgradePrompt(err, tr);
+        return { ok: false, message: error2.message };
+      } finally {
+        setLoading(false);
+      }
+    },
+    [tr]
+  );
+  const replayExecution = useCallback(
+    async (runId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: REPLAY_WORKFLOW_RUN,
+            variables: { runId }
+          })
+        );
+        return result.data?.replayWorkflowRun ?? null;
+      } catch (err) {
+        setError(err);
+        openRunQuotaUpgradePrompt(err, tr);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [tr]
+  );
+  const retryExecutions = useCallback(
+    async (runIds) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: RETRY_WORKFLOW_RUNS,
+            variables: { runIds }
+          })
+        );
+        return result.data?.retryWorkflowRuns ?? [];
+      } catch (err) {
+        setError(err);
+        openRunQuotaUpgradePrompt(err, tr);
+        return [];
+      } finally {
+        setLoading(false);
+      }
+    },
+    [tr]
+  );
+  const terminateExecution = useCallback(
+    async (runId, reason) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: TerminateExecutionDocument,
+            variables: { runId, reason }
+          })
+        );
+        return result.data?.terminateWorkflow ?? null;
+      } catch (err) {
+        setError(err);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    []
+  );
+  return {
+    pauseExecution,
+    resumeExecution,
+    cancelExecution,
+    retryNode,
+    retryExecution,
+    replayExecution,
+    retryExecutions,
+    terminateExecution,
+    loading,
+    error
+  };
+}
+var EXECUTIONS_SEARCH_DEBOUNCE_MS = 350;
+function useExecutionsWithStore() {
+  const { filter, pagination, setTotal } = useExecutionsStore();
+  const [debouncedSearch, setDebouncedSearch] = useState(filter.search);
+  useEffect(() => {
+    const timer = setTimeout(
+      () => setDebouncedSearch(filter.search),
+      EXECUTIONS_SEARCH_DEBOUNCE_MS
+    );
+    return () => clearTimeout(timer);
+  }, [filter.search]);
+  const input = useMemo(() => {
+    const baseInput = {
+      limit: pagination.pageSize,
+      offset: (pagination.page - 1) * pagination.pageSize
+    };
+    if (filter.status !== "all") {
+      baseInput.status = filter.status;
+    }
+    if (filter.workflowKey) {
+      baseInput.workflowKey = filter.workflowKey;
+    }
+    Object.assign(
+      baseInput,
+      dateRangeToInput(filter.dateRange.start, filter.dateRange.end)
+    );
+    const term = debouncedSearch.trim();
+    if (term) {
+      baseInput.search = term;
+    }
+    if (filter.triggerType !== "all") {
+      baseInput.triggerType = filter.triggerType;
+    }
+    if (filter.durationMinSeconds !== null) {
+      baseInput.durationMinSeconds = filter.durationMinSeconds;
+    }
+    if (filter.durationMaxSeconds !== null) {
+      baseInput.durationMaxSeconds = filter.durationMaxSeconds;
+    }
+    if (filter.errorType !== "all") {
+      baseInput.errorType = filter.errorType;
+    }
+    if (filter.nodeId.trim()) {
+      baseInput.nodeId = filter.nodeId.trim();
+    }
+    return baseInput;
+  }, [filter, debouncedSearch, pagination.page, pagination.pageSize]);
+  const result = useExecutions(input);
+  useEffect(() => {
+    if (result.total !== pagination.total) {
+      setTotal(result.total);
+    }
+  }, [result.total, pagination.total, setTotal]);
+  return result;
+}
+function useAutoRefresh(refetchFn, enabled = true, interval = 5e3) {
+  useEffect(() => {
+    if (!enabled) return;
+    const timer = setInterval(() => {
+      refetchFn();
+    }, interval);
+    return () => clearInterval(timer);
+  }, [enabled, interval, refetchFn]);
+}
+
+export { useAutoRefresh, useExecution, useExecutionActions, useExecutionStats, useExecutions, useExecutionsWithStore, validateDateRange };

package/dist/{chunk-P3R3RFAC.js → chunk-WFZD44CK.js}

@@ -1,4 +1,5 @@
-import { useExecution, buildNodeDisplayMap, useExecutionActions, useAutoRefresh, ExecutionStatusBadge, formatRunVersion, NodeTimeline, RunLogViewer } from './chunk-HIXQIM22.js';
+import { buildNodeDisplayMap, ExecutionStatusBadge, formatRunVersion, NodeTimeline, RunLogViewer } from './chunk-CV56O5R4.js';
+import { useExecution, useExecutionActions, useAutoRefresh } from './chunk-VGIH3SOT.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ONVGFVNH.js';
 import { getFluidGridsConfig } from './chunk-UZG3ZIQM.js';
 import { RunLogsDocument, RunLogAppendedDocument } from './chunk-SAZVBFMO.js';

package/dist/chunk-YGBDZ424.js

@@ -0,0 +1,64 @@
+// src/utils/workflow-open.ts
+var NEW_WORKFLOW_STATE = { createWorkflow: true };
+var NEW_WORKFLOW_NAV = { state: NEW_WORKFLOW_STATE };
+function isCreateIntent(state) {
+  return typeof state === "object" && state !== null && state.createWorkflow === true;
+}
+function decideMissingWorkflow(input) {
+  if (input.otherVersionExists) return "open-newest";
+  return input.createIntent ? "create" : "not-found";
+}
+
+// src/onboarding/firstWorkflow.ts
+var GUIDED_FIRST_WORKFLOW_STATE = {
+  ...NEW_WORKFLOW_STATE,
+  guidedTour: true
+};
+var GUIDED_FIRST_WORKFLOW_NAV = {
+  state: GUIDED_FIRST_WORKFLOW_STATE
+};
+function isGuidedTourIntent(state) {
+  return typeof state === "object" && state !== null && state.guidedTour === true;
+}
+function withoutGuidedTourIntent(state) {
+  if (typeof state !== "object" || state === null) return state;
+  if (!("guidedTour" in state)) return state;
+  const rest = {};
+  for (const [key, value] of Object.entries(state)) {
+    if (key !== "guidedTour") rest[key] = value;
+  }
+  return Object.keys(rest).length > 0 ? rest : null;
+}
+function byMostRecent(a, b) {
+  const at = a.updatedAt ? Date.parse(a.updatedAt) : 0;
+  const bt = b.updatedAt ? Date.parse(b.updatedAt) : 0;
+  return (Number.isNaN(bt) ? 0 : bt) - (Number.isNaN(at) ? 0 : at);
+}
+function firstWorkflowProgress(workflows, runsTotal) {
+  const created = workflows.length > 0;
+  const ran = runsTotal !== null && runsTotal > 0;
+  const activated = workflows.some((w) => w.status === "ACTIVE");
+  const ordered = [...workflows].sort(byMostRecent);
+  const runTarget = ordered[0] ?? null;
+  const activateTarget = ordered.find((w) => (w.status ?? "DRAFT") === "DRAFT") ?? runTarget;
+  const remaining = [created, ran, activated].filter((done) => !done).length;
+  return {
+    created,
+    ran,
+    activated,
+    complete: remaining === 0,
+    remaining,
+    runTarget,
+    activateTarget
+  };
+}
+function builderPathFor(workflow) {
+  return `../workflow/${encodeURIComponent(workflow.workflowKey)}/${encodeURIComponent(workflow.version)}`;
+}
+function pickGuidedTour(pageTours, pageId) {
+  const playable = pageTours.filter((tour) => (tour.steps?.length ?? 0) > 0).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  if (!pageId) return null;
+  return playable.find((tour) => tour.pageId === pageId) ?? null;
+}
+
+export { GUIDED_FIRST_WORKFLOW_NAV, GUIDED_FIRST_WORKFLOW_STATE, NEW_WORKFLOW_NAV, builderPathFor, decideMissingWorkflow, firstWorkflowProgress, isCreateIntent, isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent };

package/dist/executions.js

@@ -1,7 +1,8 @@
 import './chunk-AD3BXTJS.js';
-export { ExecutionsListPage } from './chunk-PG2JFX63.js';
-export { ExecutionDetailPage } from './chunk-P3R3RFAC.js';
-import './chunk-HIXQIM22.js';
+export { ExecutionsListPage } from './chunk-QMZGUJI3.js';
+export { ExecutionDetailPage } from './chunk-WFZD44CK.js';
+import './chunk-CV56O5R4.js';
+import './chunk-VGIH3SOT.js';
 import './chunk-QBFAJNUC.js';
 import './chunk-ONVGFVNH.js';
 import './chunk-JL7CASN5.js';