@burdenoff/fluidgrids-fe-sdk 2026.1107.1 → 2026.1108.2

package/dist/chunk-YASVILWQ.js

@@ -0,0 +1,398 @@
+import { RunControlFieldsDocument, WorkflowRunHistoryArchiveDocument, QueryWorkflowRunDocument, UpdateWorkflowRunDocument, WorkflowRunUpdateDocument, PauseActivityDocument, UnpauseActivityDocument, ResetActivityDocument, UpdateActivityOptionsDocument, CompleteActivityByIdDocument, FailActivityByIdDocument, ResetWorkflowRunDocument, ResetWorkflowRunToLastCleanTaskDocument, WorkflowSignalTokensDocument, CreateWorkflowSignalTokenDocument, RevokeWorkflowSignalTokenDocument, WorkflowSearchAttributesDocument, CreateWorkflowSearchAttributeDocument, DeleteWorkflowSearchAttributeDocument, UpsertWorkflowRunSearchAttributesDocument, WorkflowActivityPauseRulesDocument, CreateActivityPauseRuleDocument, DeleteActivityPauseRuleDocument, CodecServerSettingsDocument, UpdateCodecServerSettingsDocument, ArchiveSettingsDocument, UpdateArchiveSettingsDocument, StartBatchOperationDocument, StartBatchTerminateDocument, StartBatchExportDocument, CancelBatchOperationDocument, WorkflowBatchOperationDocument, WorkflowBatchOperationsDocument, WorkflowScheduleDescribeDocument, TriggerWorkflowScheduleDocument, BackfillWorkflowScheduleDocument, PauseWorkflowScheduleDocument, UnpauseWorkflowScheduleDocument, WorkflowCodeBundleSdkDocument } from './chunk-GOZR72NK.js';
+import { getFluidGridsClient } from './chunk-PDODDDHY.js';
+import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { Label, Textarea } from '@burdenoff/fe-libs/ui';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/graphql/typed-calls.ts
+async function readTyped(query, variables) {
+  const result = await getFluidGridsClient().query({
+    query,
+    variables,
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  if (!result.data) throw new Error("The request returned no data");
+  return result.data;
+}
+async function writeTyped(mutation, variables) {
+  const result = await getFluidGridsClient().mutate({
+    mutation,
+    variables
+  });
+  throwIfResultError(result);
+  if (!result.data) throw new Error("The request returned no data");
+  return result.data;
+}
+
+// src/modules/run-control/api.ts
+function jsonArg(value) {
+  if (value === void 0) return null;
+  return value;
+}
+async function fetchRunControlFields(runId) {
+  return (await readTyped(RunControlFieldsDocument, { id: runId })).workflowRun ?? null;
+}
+async function fetchRunHistoryArchive(runId) {
+  return (await readTyped(WorkflowRunHistoryArchiveDocument, { runId })).workflowRunHistory;
+}
+async function queryRun(input) {
+  return (await readTyped(QueryWorkflowRunDocument, {
+    runId: input.runId,
+    name: input.name,
+    args: jsonArg(input.args),
+    rejectCondition: input.rejectCondition ?? null
+  })).queryWorkflowRun;
+}
+async function sendRunUpdate(input) {
+  return (await writeTyped(UpdateWorkflowRunDocument, {
+    runId: input.runId,
+    name: input.name,
+    args: jsonArg(input.args),
+    updateId: input.updateId,
+    waitFor: input.waitFor,
+    timeoutMs: input.timeoutMs ?? null
+  })).updateWorkflowRun;
+}
+async function fetchRunUpdate(runId, updateId) {
+  return (await readTyped(WorkflowRunUpdateDocument, { runId, updateId })).workflowRunUpdate;
+}
+async function pauseActivities(input) {
+  await writeTyped(PauseActivityDocument, input);
+}
+async function unpauseActivities(input) {
+  await writeTyped(UnpauseActivityDocument, {
+    runId: input.runId,
+    selector: input.selector,
+    resetAttempts: input.resetAttempts ?? false,
+    resetHeartbeat: input.resetHeartbeat ?? false
+  });
+}
+async function resetActivities(input) {
+  await writeTyped(ResetActivityDocument, {
+    runId: input.runId,
+    selector: input.selector,
+    resetHeartbeat: input.resetHeartbeat ?? false
+  });
+}
+async function updateActivityOptions(input) {
+  await writeTyped(UpdateActivityOptionsDocument, input);
+}
+async function completeActivityById(input) {
+  return (await writeTyped(CompleteActivityByIdDocument, {
+    runId: input.runId,
+    activityId: input.activityId,
+    result: jsonArg(input.result)
+  })).completeActivityById;
+}
+async function failActivityById(input) {
+  return (await writeTyped(FailActivityByIdDocument, input)).failActivityById;
+}
+async function resetRun(input) {
+  return (await writeTyped(ResetWorkflowRunDocument, {
+    runId: input.runId,
+    to: input.to,
+    reason: input.reason?.trim() || null,
+    reapplySignals: input.reapplySignals ?? true,
+    reapplyUpdates: input.reapplyUpdates ?? true
+  })).resetWorkflowRun;
+}
+async function resetRunToLastCleanTask(input) {
+  return (await writeTyped(ResetWorkflowRunToLastCleanTaskDocument, {
+    runId: input.runId,
+    reason: input.reason?.trim() || null
+  })).resetWorkflowRunToLastCleanTask;
+}
+async function fetchSignalTokens(runId) {
+  return (await readTyped(WorkflowSignalTokensDocument, { runId })).workflowSignalTokens;
+}
+async function createSignalToken(input) {
+  return (await writeTyped(CreateWorkflowSignalTokenDocument, { input })).createWorkflowSignalToken;
+}
+async function revokeSignalToken(id) {
+  return (await writeTyped(RevokeWorkflowSignalTokenDocument, { id })).revokeWorkflowSignalToken;
+}
+async function fetchSearchAttributes() {
+  return (await readTyped(WorkflowSearchAttributesDocument, {})).workflowSearchAttributes;
+}
+async function createSearchAttribute(input) {
+  return (await writeTyped(CreateWorkflowSearchAttributeDocument, {
+    input: {
+      name: input.name.trim(),
+      type: input.type,
+      description: input.description?.trim() || null
+    }
+  })).createWorkflowSearchAttribute;
+}
+async function deleteSearchAttribute(id) {
+  return (await writeTyped(DeleteWorkflowSearchAttributeDocument, { id })).deleteWorkflowSearchAttribute;
+}
+async function upsertRunSearchAttributes(runId, attributes) {
+  return (await writeTyped(UpsertWorkflowRunSearchAttributesDocument, {
+    runId,
+    attributes
+  })).upsertWorkflowRunSearchAttributes.searchAttributes;
+}
+async function fetchPauseRules() {
+  return (await readTyped(WorkflowActivityPauseRulesDocument, {})).workflowActivityPauseRules;
+}
+async function createPauseRule(input) {
+  return (await writeTyped(CreateActivityPauseRuleDocument, { input })).createActivityPauseRule;
+}
+async function deletePauseRule(id) {
+  return (await writeTyped(DeleteActivityPauseRuleDocument, { id })).deleteActivityPauseRule;
+}
+async function fetchCodecServerSettings() {
+  const settings = (await readTyped(CodecServerSettingsDocument, {})).workflowExecutionSettings;
+  return settings ?? {
+    __typename: "WorkflowExecutionSettings",
+    codecServerUrl: null,
+    codecServerIncludeCredentials: false
+  };
+}
+async function saveCodecServerSettings(input) {
+  return (await writeTyped(UpdateCodecServerSettingsDocument, input)).updateWorkflowExecutionSettings;
+}
+async function fetchArchiveSettings() {
+  const data = await readTyped(ArchiveSettingsDocument, {});
+  return data.workflowExecutionSettings?.archive ?? null;
+}
+async function saveArchiveSettings(archive) {
+  return (await writeTyped(UpdateArchiveSettingsDocument, {
+    archive,
+    clearArchive: null
+  })).updateWorkflowExecutionSettings.archive ?? null;
+}
+async function clearArchiveSettings() {
+  await writeTyped(UpdateArchiveSettingsDocument, {
+    archive: null,
+    clearArchive: true
+  });
+}
+async function startBatchOperation(input) {
+  return (await writeTyped(StartBatchOperationDocument, { input })).startBatchOperation;
+}
+async function startBatchTerminate(input) {
+  return (await writeTyped(StartBatchTerminateDocument, { input })).startBatchTerminate;
+}
+async function startBatchExport(input) {
+  return (await writeTyped(StartBatchExportDocument, { input })).startBatchExport;
+}
+async function cancelBatchOperation(id) {
+  return (await writeTyped(CancelBatchOperationDocument, { id })).cancelBatchOperation;
+}
+async function fetchBatchOperation(id) {
+  return (await readTyped(WorkflowBatchOperationDocument, { id })).workflowBatchOperation;
+}
+async function fetchBatchOperations(input) {
+  const page = (await readTyped(WorkflowBatchOperationsDocument, {
+    status: input.status ?? null,
+    first: input.first ?? 20,
+    after: input.after ?? null
+  })).workflowBatchOperations;
+  return { items: page.items, nextCursor: page.nextCursor ?? null };
+}
+async function describeSchedule(workflowKey, triggerNodeId) {
+  return (await readTyped(WorkflowScheduleDescribeDocument, { workflowKey, triggerNodeId })).workflowScheduleDescribe;
+}
+async function triggerSchedule(input) {
+  return (await writeTyped(TriggerWorkflowScheduleDocument, {
+    workflowKey: input.workflowKey,
+    triggerNodeId: input.triggerNodeId,
+    overlapPolicy: input.overlapPolicy ?? null
+  })).triggerWorkflowSchedule;
+}
+async function backfillSchedule(input) {
+  return (await writeTyped(BackfillWorkflowScheduleDocument, {
+    ...input,
+    overlapPolicy: input.overlapPolicy ?? null
+  })).backfillWorkflowSchedule;
+}
+async function pauseSchedule(input) {
+  return (await writeTyped(PauseWorkflowScheduleDocument, {
+    workflowKey: input.workflowKey,
+    triggerNodeId: input.triggerNodeId,
+    note: input.note?.trim() || null
+  })).pauseWorkflowSchedule;
+}
+async function unpauseSchedule(input) {
+  return (await writeTyped(UnpauseWorkflowScheduleDocument, input)).unpauseWorkflowSchedule;
+}
+async function fetchCodeBundleSdk(workflowKey, version) {
+  return (await readTyped(WorkflowCodeBundleSdkDocument, { workflowKey, version })).workflowCodeBundle ?? null;
+}
+function useResource(key, enabled, load, {
+  live = false,
+  intervalMs = 0
+} = {}) {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const request = useRef(0);
+  const loadRef = useRef(load);
+  loadRef.current = load;
+  const active = enabled && key !== null;
+  const refetch = useCallback(async () => {
+    if (!enabled || key === null) return;
+    const id = ++request.current;
+    setLoading(true);
+    try {
+      const next = await loadRef.current();
+      if (id !== request.current) return;
+      setData(next);
+      setError(null);
+    } catch (err) {
+      if (id !== request.current) return;
+      setError(describeOperationError(err));
+    } finally {
+      if (id === request.current) setLoading(false);
+    }
+  }, [enabled, key]);
+  useEffect(() => {
+    request.current += 1;
+    setData(null);
+    setError(null);
+    setLoading(false);
+    void refetch();
+  }, [refetch]);
+  useEffect(() => {
+    if (!live || !active || intervalMs <= 0) return;
+    const timer = setInterval(() => void refetch(), intervalMs);
+    return () => clearInterval(timer);
+  }, [live, active, intervalMs, refetch]);
+  const set = useCallback((value) => {
+    request.current += 1;
+    setData(value);
+    setError(null);
+    setLoading(false);
+  }, []);
+  return { data: active ? data : null, loading, error, refetch, set };
+}
+
+// src/modules/run-control/utils/json-input.ts
+function parseJsonInput(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return { ok: true, value: void 0 };
+  try {
+    return { ok: true, value: JSON.parse(trimmed) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function parseJsonObjectInput(text) {
+  const parsed = parseJsonInput(text);
+  if (!parsed.ok) return parsed;
+  const value = parsed.value;
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return { ok: false, error: 'Enter a JSON object, for example {"key": 1}' };
+  return { ok: true, value: Object.fromEntries(Object.entries(value)) };
+}
+function formatJson(value) {
+  if (value === void 0 || value === null) return "\u2014";
+  if (typeof value === "string") return JSON.stringify(value);
+  return JSON.stringify(value, null, 2);
+}
+function newRunControlId(prefix) {
+  const random = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  return `${prefix}-${random}`;
+}
+var RUN_CONTROL_DIALOG_STYLE = { zIndex: 1100 };
+function FieldError({
+  message,
+  testId
+}) {
+  if (!message) return null;
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      role: "alert",
+      className: "text-sm text-[var(--color-status-error-text)]",
+      "data-testid": testId,
+      children: message
+    }
+  );
+}
+function JsonField({
+  id,
+  label,
+  value,
+  onChange,
+  placeholder,
+  error,
+  rows = 4,
+  testId
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+    /* @__PURE__ */ jsx(Label, { htmlFor: id, children: label }),
+    /* @__PURE__ */ jsx(
+      Textarea,
+      {
+        id,
+        value,
+        onChange: (event) => onChange(event.target.value),
+        placeholder,
+        rows,
+        className: "font-mono text-xs",
+        "data-testid": testId
+      }
+    ),
+    /* @__PURE__ */ jsx(FieldError, { message: error })
+  ] });
+}
+function JsonBlock({
+  value,
+  testId
+}) {
+  return /* @__PURE__ */ jsx(
+    "pre",
+    {
+      className: "max-h-64 overflow-auto whitespace-pre-wrap break-words rounded-md bg-background-primary p-3 font-mono text-xs text-text-primary",
+      "data-testid": testId,
+      children: formatJson(value)
+    }
+  );
+}
+function NativeSelect({
+  id,
+  value,
+  onChange,
+  children,
+  testId,
+  disabled,
+  ariaLabel
+}) {
+  return /* @__PURE__ */ jsx(
+    "select",
+    {
+      id,
+      value,
+      disabled,
+      "aria-label": ariaLabel,
+      onChange: (event) => onChange(event.target.value),
+      className: "h-9 w-full rounded-md border border-border-primary bg-background-primary px-2 text-sm text-text-primary",
+      "data-testid": testId,
+      children
+    }
+  );
+}
+function StatusPill({
+  tone,
+  children,
+  testId
+}) {
+  const classes = tone === "neutral" ? "border-border-secondary bg-background-tertiary text-text-secondary" : `border-[var(--color-status-${tone}-border)] bg-[var(--color-status-${tone}-bg-subtle)] text-[var(--color-status-${tone}-text)]`;
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: `inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium ${classes}`,
+      "data-testid": testId,
+      children
+    }
+  );
+}
+
+export { FieldError, JsonBlock, JsonField, NativeSelect, RUN_CONTROL_DIALOG_STYLE, StatusPill, backfillSchedule, cancelBatchOperation, clearArchiveSettings, completeActivityById, createPauseRule, createSearchAttribute, createSignalToken, deletePauseRule, deleteSearchAttribute, describeSchedule, failActivityById, fetchArchiveSettings, fetchBatchOperation, fetchBatchOperations, fetchCodeBundleSdk, fetchCodecServerSettings, fetchPauseRules, fetchRunControlFields, fetchRunHistoryArchive, fetchRunUpdate, fetchSearchAttributes, fetchSignalTokens, jsonArg, newRunControlId, parseJsonInput, parseJsonObjectInput, pauseActivities, pauseSchedule, queryRun, readTyped, resetActivities, resetRun, resetRunToLastCleanTask, revokeSignalToken, saveArchiveSettings, saveCodecServerSettings, sendRunUpdate, startBatchExport, startBatchOperation, startBatchTerminate, triggerSchedule, unpauseActivities, unpauseSchedule, updateActivityOptions, upsertRunSearchAttributes, useResource, writeTyped };