@burdenoff/fluidgrids-fe-sdk 2026.1103.2 → 2026.1104.2

package/dist/{chunk-RFOKJE3A.js → chunk-WTV6SQYK.js}

@@ -1,16 +1,16 @@
-import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-G2FPOWN5.js';
-import { useDurableParityRunFields, useRunMetadata, useRunPending, ExecutionStatusBadge, NodeTimeline, RunLogViewer, setRunVersioningOverride } from './chunk-K6HD5GC7.js';
-import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-6WPW42TX.js';
-import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-H2KIJEYM.js';
-import { useRunPolicyDecisions, RunPolicyDecisions } from './chunk-BVCMAGLJ.js';
-import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-OBWB73Y7.js';
-import { buildNodeDisplayMap, formatRunVersion } from './chunk-PC3CICOW.js';
+import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-D4WA2M2N.js';
+import { useDurableParityRunFields, useRunMetadata, useRunPending, ExecutionStatusBadge, NodeTimeline, RunLogViewer, setRunVersioningOverride } from './chunk-XNU2PLJ2.js';
+import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-5D4XS3WJ.js';
+import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-SS7Y66P5.js';
+import { useRunPolicyDecisions, RunPolicyDecisions } from './chunk-NGXJHYV5.js';
+import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-BIB7IH26.js';
+import { buildNodeDisplayMap, formatRunVersion } from './chunk-F7LQL43U.js';
 import { AiCreditBalanceSlot } from './chunk-Y53CVZVV.js';
-import { useWorkflowVersions } from './chunk-QXACKASD.js';
-import { throwIfResultError, useDurableFunctionNodesEnabled, useDurableParityEnabled, runSignalTargets, canSignalRun, useWorkflowTestsEnabled, describeOperationError } from './chunk-YC76QFWZ.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ZUVFD5KV.js';
+import { useWorkflowVersions } from './chunk-AFX3EKFN.js';
+import { throwIfResultError, useDurableFunctionNodesEnabled, useDurableParityEnabled, runSignalTargets, canSignalRun, useWorkflowTestsEnabled, describeOperationError } from './chunk-AAIZ6S6E.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-5375NUIO.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
-import { RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument } from './chunk-JTQFBZTV.js';
+import { RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument } from './chunk-AVHBWJRY.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';

package/dist/{chunk-SIVS3XSV.js → chunk-X6PIU7FE.js}

@@ -1,10 +1,11 @@
-import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-YC76QFWZ.js';
-import { ExportWorkflowCodeDocument } from './chunk-JTQFBZTV.js';
+import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-AAIZ6S6E.js';
+import { ExportWorkflowCodeDocument, ShareWorkflowDocument, WorkflowSharingDocument } from './chunk-AVHBWJRY.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
-import { useState, useRef, useCallback, useEffect } from 'react';
-import { AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction } from '@burdenoff/fe-libs/ui';
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { createSharePrincipalLister, ResourceShareDialog } from '@burdenoff/fe-libs/connections';
 import { jsx, jsxs } from 'react/jsx-runtime';
+import { AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction } from '@burdenoff/fe-libs/ui';
 
 // src/utils/workflow-transfer.ts
 function asRecord(value) {
@@ -70,13 +71,36 @@ function downloadWorkflowExport(workflow) {
     blob
   );
 }
+function isN8nNodeType(type) {
+  return typeof type === "string" && (type.startsWith("n8n-nodes-") || type.startsWith("@n8n/"));
+}
+function isN8nWorkflowJson(value) {
+  const root = asRecord(value);
+  if (!root || !Array.isArray(root.nodes) || root.nodes.length === 0)
+    return false;
+  if (root.connections !== void 0 && !asRecord(root.connections))
+    return false;
+  const nodes = root.nodes.map(asRecord);
+  return nodes.every(
+    (node) => node !== null && typeof node.name === "string" && typeof node.type === "string" && node.type.length > 0
+  ) && nodes.some((node) => isN8nNodeType(node?.type));
+}
 function parseWorkflowImport(raw) {
   const parsed = JSON.parse(raw);
   const root = asRecord(parsed);
   if (!root) throw new Error("Import must contain a JSON object");
+  if (isN8nWorkflowJson(root)) {
+    return {
+      source: "n8n",
+      definitionJson: root,
+      name: typeof root.name === "string" && root.name.trim() ? root.name.trim() : "Imported n8n workflow",
+      nodeReferences: []
+    };
+  }
   const definitionJson = asRecord(root.definitionJson) ?? root;
   const name = typeof root.name === "string" && root.name.trim() ? root.name : "Imported workflow";
   return {
+    source: "fluidgrids",
     definitionJson,
     name,
     workflowKey: typeof root.workflowKey === "string" ? root.workflowKey : void 0,
@@ -406,6 +430,201 @@ function useExportWorkflowAs(save = downloadBlob) {
   );
   return { exportAs, exporting };
 }
+
+// src/utils/workflow-sharing.ts
+function canShareWorkflow(access) {
+  return access === "OWNER" /* Owner */ || access === "EDITOR" /* Editor */ || access === "ADMINISTRATOR" /* Administrator */;
+}
+function canEditWorkflow(access) {
+  return access !== "VIEWER" /* Viewer */;
+}
+var VISIBILITY_OUT = {
+  WORKSPACE: "WORKSPACE" /* Workspace */,
+  RESTRICTED: "RESTRICTED" /* Restricted */
+};
+var VISIBILITY_IN = {
+  ["WORKSPACE" /* Workspace */]: "WORKSPACE",
+  ["RESTRICTED" /* Restricted */]: "RESTRICTED"
+};
+var PRINCIPAL_OUT = {
+  USER: "USER" /* User */,
+  GROUP: "GROUP" /* Group */,
+  PROJECT: "PROJECT" /* Project */
+};
+var PRINCIPAL_IN = {
+  ["USER" /* User */]: "USER",
+  ["GROUP" /* Group */]: "GROUP",
+  ["PROJECT" /* Project */]: "PROJECT"
+};
+var ROLE_OUT = {
+  VIEWER: "VIEWER" /* Viewer */,
+  EDITOR: "EDITOR" /* Editor */
+};
+var ROLE_IN = {
+  ["VIEWER" /* Viewer */]: "VIEWER",
+  ["EDITOR" /* Editor */]: "EDITOR"
+};
+function toResourceSharing(sharing, name = sharing.workflowKey) {
+  const shares = sharing.shares.map(
+    (share) => ({
+      principalType: PRINCIPAL_IN[share.principalType],
+      principalId: share.principalId,
+      role: ROLE_IN[share.role]
+    })
+  );
+  return {
+    id: sharing.workflowKey,
+    name,
+    ownerId: sharing.ownerId ?? "",
+    visibility: VISIBILITY_IN[sharing.visibility],
+    canManage: canShareWorkflow(sharing.myAccess),
+    administrator: sharing.canTransferOwnership,
+    shares
+  };
+}
+function workflowSharingApi(client, listPrincipals) {
+  return {
+    async getSharing(workflowKey) {
+      const result = await client.query({
+        query: WorkflowSharingDocument,
+        variables: { workflowKey },
+        fetchPolicy: "network-only"
+      });
+      if (!result.data) throw new Error("Workflow not found");
+      return toResourceSharing(result.data.workflowSharing);
+    },
+    listPrincipals,
+    async share(input) {
+      const result = await client.mutate({
+        mutation: ShareWorkflowDocument,
+        variables: {
+          input: {
+            workflowKey: input.resourceId,
+            visibility: VISIBILITY_OUT[input.visibility],
+            shares: input.shares.map((share) => ({
+              principalType: PRINCIPAL_OUT[share.principalType],
+              principalId: share.principalId,
+              role: ROLE_OUT[share.role]
+            })),
+            ...input.ownerId ? { ownerId: input.ownerId } : {}
+          }
+        }
+      });
+      if (!result.data) throw new Error("Workflow not found");
+      return toResourceSharing(result.data.shareWorkflow);
+    }
+  };
+}
+function workflowShareCopy(tr, name) {
+  return {
+    title: (loaded) => tr("fluidgrids.sharing.title", "Share {{name}}", {
+      name: name || loaded
+    }),
+    titleLoading: tr("fluidgrids.sharing.titleLoading", "Share workflow"),
+    loading: tr("fluidgrids.sharing.loading", "Loading sharing\u2026"),
+    readOnly: tr(
+      "fluidgrids.sharing.readOnly",
+      "Only the owner, editors and workspace admins can change who can open this workflow."
+    ),
+    save: tr("fluidgrids.sharing.save", "Save"),
+    cancel: tr("fluidgrids.sharing.cancel", "Cancel"),
+    close: tr("fluidgrids.sharing.close", "Close"),
+    owner: tr("fluidgrids.sharing.owner", "Owner"),
+    add: tr("fluidgrids.sharing.add", "Share with people, groups or projects"),
+    addPlaceholder: tr(
+      "fluidgrids.sharing.addPlaceholder",
+      "Search by name or email"
+    ),
+    sharedWith: tr("fluidgrids.sharing.sharedWith", "Shared with"),
+    onlyOwner: tr(
+      "fluidgrids.sharing.onlyOwner",
+      "No one else yet. Only the owner and workspace admins can open it."
+    ),
+    none: tr("fluidgrids.sharing.none", "No one in particular."),
+    principalType: {
+      USER: tr("fluidgrids.sharing.type.user", "Person"),
+      GROUP: tr("fluidgrids.sharing.type.group", "Group"),
+      PROJECT: tr("fluidgrids.sharing.type.project", "Project")
+    },
+    roleFor: (grantee) => tr("fluidgrids.sharing.roleFor", "Access for {{name}}", {
+      name: grantee
+    }),
+    remove: (grantee) => tr("fluidgrids.sharing.remove", "Stop sharing with {{name}}", {
+      name: grantee
+    }),
+    visibility: {
+      legend: tr(
+        "fluidgrids.sharing.visibility.label",
+        "Who can open this workflow"
+      ),
+      restricted: tr(
+        "fluidgrids.sharing.visibility.restricted",
+        "Only people I choose"
+      ),
+      restrictedHint: tr(
+        "fluidgrids.sharing.visibility.restrictedHint",
+        "You, the people, groups or projects you share it with, and workspace admins. Everyone else cannot find it."
+      ),
+      workspace: tr(
+        "fluidgrids.sharing.visibility.workspace",
+        "Everyone in this workspace"
+      ),
+      workspaceHint: tr(
+        "fluidgrids.sharing.visibility.workspaceHint",
+        "Anyone in the workspace can open it, as their workspace role allows."
+      )
+    }
+  };
+}
+function WorkflowShareDialog({
+  open,
+  onClose,
+  workflowKey,
+  workflowName,
+  workspaceId,
+  client,
+  onShared,
+  api: apiOverride
+}) {
+  const tr = useTr();
+  const api = useMemo(() => {
+    if (apiOverride) return apiOverride;
+    const apollo = client ?? getFluidGridsClient();
+    return workflowSharingApi(apollo, createSharePrincipalLister(apollo));
+  }, [apiOverride, client]);
+  const copy = useMemo(
+    () => workflowShareCopy(tr, workflowName),
+    [tr, workflowName]
+  );
+  const roles = useMemo(
+    () => [
+      {
+        value: "VIEWER",
+        label: tr("fluidgrids.sharing.role.viewer", "Can view")
+      },
+      {
+        value: "EDITOR",
+        label: tr("fluidgrids.sharing.role.editor", "Can edit")
+      }
+    ],
+    [tr]
+  );
+  return /* @__PURE__ */ jsx(
+    ResourceShareDialog,
+    {
+      open,
+      onClose,
+      api,
+      resourceId: workflowKey,
+      workspaceId,
+      roles,
+      copy,
+      testIdPrefix: "share-workflow",
+      translate: tr,
+      onShared: onShared ? () => onShared() : void 0
+    }
+  );
+}
 function QuotaExhaustedDialog({
   open,
   onOpenChange,
@@ -458,4 +677,4 @@ function QuotaExhaustedDialog({
   ] }) });
 }
 
-export { CODE_EXPORT_FORMATS, ImportSourceError, MAX_IMPORT_ARCHIVE_BYTES, MAX_IMPORT_SOURCE_BYTES, QuotaExhaustedDialog, assertImportByteSize, checkTypeScriptImport, downloadWorkflowCodeExport, downloadWorkflowExport, fileBaseName, importAcceptAttribute, importFileKind, isLosslessReport, isLossyFidelityItem, lineOfNode, orderedExportFiles, parseWorkflowImport, primaryImportModule, readProjectArchive, sortFidelityItems, typeScriptImportSource, typeScriptModuleFile, useExportWorkflowAs, useWorkflowCodeExport, workflowNameFromFile };
+export { CODE_EXPORT_FORMATS, ImportSourceError, MAX_IMPORT_ARCHIVE_BYTES, MAX_IMPORT_SOURCE_BYTES, QuotaExhaustedDialog, WorkflowShareDialog, assertImportByteSize, canEditWorkflow, canShareWorkflow, checkTypeScriptImport, downloadWorkflowCodeExport, downloadWorkflowExport, fileBaseName, importAcceptAttribute, importFileKind, isLosslessReport, isLossyFidelityItem, lineOfNode, orderedExportFiles, parseWorkflowImport, primaryImportModule, readProjectArchive, sortFidelityItems, typeScriptImportSource, typeScriptModuleFile, useExportWorkflowAs, useWorkflowCodeExport, workflowNameFromFile };