@burdenoff/fluidgrids-fe-sdk 2026.1114.5 → 2026.1114.7

package/dist/useConnections-CmnwGk09.js

@@ -0,0 +1,439 @@
+"use client";
+import { n as getFluidGridsClient } from "./client-Ctl4jmY3.js";
+import { o as throwIfResultError } from "./errors-xPZ-IbQd.js";
+import { useCallback, useEffect, useState } from "react";
+import { gql } from "@apollo/client";
+
+// src/modules/connections/hooks/useConnections.ts
+/**
+* Custom hooks for fetching connections from the integrations service.
+*
+* These hooks query the wspace-integrations-svc via the federated GraphQL gateway.
+* Connections replace the legacy credentials system for third-party authentication.
+*/
+const PROVIDER_FIELDS = gql`
+  fragment ProviderFields on IntegrationProvider {
+    id
+    key
+    name
+    description
+    category
+    authType
+    icon
+    color
+    website
+    docsUrl
+    isBuiltIn
+    isEnabled
+    availableScopes
+    # How this provider can be authenticated, as data. The builder renders the
+    # form from this rather than from a per-provider React component, so a
+    # provider or a new method added by an administrator shows up here with no
+    # frontend change.
+    authMethods {
+      key
+      displayName
+      description
+      flow
+      authType
+      configSchema
+      availableScopes
+      defaultScopes
+      isConfigured
+      isEnabled
+      displayOrder
+    }
+  }
+`;
+const CONNECTION_FIELDS = gql`
+  ${PROVIDER_FIELDS}
+  fragment ConnectionFields on IntegrationConnection {
+    id
+    name
+    description
+    providerId
+    provider {
+      ...ProviderFields
+    }
+    status
+    lastHealthCheck
+    lastUsedAt
+    errorMessage
+    externalAccountId
+    externalAccountEmail
+    externalAccountName
+    grantedScopes
+    createdBy
+    createdAt
+    updatedAt
+    visibility
+    myAccess
+    canUse
+  }
+`;
+const GET_CONNECTIONS = gql`
+  ${CONNECTION_FIELDS}
+  query GetConnections(
+    $filter: ConnectionFilterInput
+    $pagination: IntegrationsPaginationInput
+  ) {
+    getConnections(filter: $filter, pagination: $pagination) {
+      items {
+        ...ConnectionFields
+      }
+      total
+      hasMore
+    }
+  }
+`;
+/** Ids and names only: what a code export needs to name connections. */
+const GET_CONNECTION_NAMES = gql`
+  query GetConnectionNames($pagination: IntegrationsPaginationInput) {
+    getConnections(pagination: $pagination) {
+      items {
+        id
+        name
+      }
+      total
+      hasMore
+    }
+  }
+`;
+const GET_CONNECTION = gql`
+  ${CONNECTION_FIELDS}
+  query GetConnection($id: ID!) {
+    getConnection(id: $id) {
+      ...ConnectionFields
+    }
+  }
+`;
+const GET_CONNECTIONS_BY_PROVIDER = gql`
+  ${CONNECTION_FIELDS}
+  query GetConnectionsByProvider(
+    $providerId: ID!
+    $pagination: IntegrationsPaginationInput
+  ) {
+    getConnectionsByProvider(providerId: $providerId, pagination: $pagination) {
+      items {
+        ...ConnectionFields
+      }
+      total
+      hasMore
+    }
+  }
+`;
+const GET_PROVIDERS = gql`
+  ${PROVIDER_FIELDS}
+  query GetProviders(
+    $filter: ProviderFilterInput
+    $pagination: IntegrationsPaginationInput
+  ) {
+    getProviders(filter: $filter, pagination: $pagination) {
+      items {
+        ...ProviderFields
+      }
+      total
+      hasMore
+    }
+  }
+`;
+const INITIATE_OAUTH = gql`
+  mutation InitiateOAuth($input: InitiateOAuthInput!) {
+    initiateOAuth(input: $input) {
+      redirectUrl
+      state
+    }
+  }
+`;
+const CREATE_CONNECTION = gql`
+  ${CONNECTION_FIELDS}
+  mutation CreateConnection($input: CreateConnectionInput!) {
+    createConnection(input: $input) {
+      ...ConnectionFields
+    }
+  }
+`;
+/** Page size the integrations service allows; it clamps larger limits to 100. */
+const CONNECTIONS_PAGE_SIZE = 100;
+/**
+* Every page of a connection list. A picker that accepts any provider (the
+* HTTP Request node) must offer every saved connection, not the first 100.
+*
+* Reads until the server says there is no more, the reported total is reached,
+* or a page adds no connection it has not already returned, so a server that
+* keeps answering `hasMore` without progressing cannot loop forever.
+*/
+async function fetchAllConnectionPages(fetchPage) {
+	const items = [];
+	const seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	let hasMore = false;
+	for (let offset = 0;; offset += 100) {
+		const result = await fetchPage(offset);
+		const fresh = (result?.items ?? []).filter((item) => !seen.has(item.id));
+		for (const item of fresh) {
+			seen.add(item.id);
+			items.push(item);
+		}
+		total = result?.total ?? items.length;
+		hasMore = result?.hasMore ?? false;
+		if (!hasMore || fresh.length === 0 || items.length >= total) break;
+	}
+	return {
+		items,
+		total,
+		hasMore: hasMore && items.length < total
+	};
+}
+/**
+* Names of the workspace's saved connections, by id, for the ids asked for.
+* Code exports use them to write `connection: '<name>'` instead of an id
+* (`ExportOptionsInput.connectionNameMap`). Ids without a saved connection
+* are left out.
+*/
+async function fetchConnectionNames(ids) {
+	const wanted = new Set(ids);
+	if (wanted.size === 0) return {};
+	const client = getFluidGridsClient();
+	const list = await fetchAllConnectionPages(async (offset) => {
+		return throwIfResultError(await client.query({
+			query: GET_CONNECTION_NAMES,
+			variables: { pagination: {
+				limit: 100,
+				offset
+			} },
+			fetchPolicy: "network-only"
+		})).data?.getConnections;
+	});
+	const names = {};
+	for (const connection of list.items) if (wanted.has(connection.id) && connection.name.trim()) names[connection.id] = connection.name;
+	return names;
+}
+/**
+* Hook to fetch list of connections from the integrations service.
+*/
+function useConnections(filter) {
+	const [connections, setConnections] = useState([]);
+	const [total, setTotal] = useState(0);
+	const [hasMore, setHasMore] = useState(false);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(null);
+	const filterKey = JSON.stringify(filter);
+	const fetchData = useCallback(async () => {
+		setLoading(true);
+		setError(null);
+		try {
+			const client = getFluidGridsClient();
+			const parsedFilter = filterKey ? JSON.parse(filterKey) : void 0;
+			const list = await fetchAllConnectionPages(async (offset) => {
+				return (await client.query({
+					query: GET_CONNECTIONS,
+					variables: {
+						filter: parsedFilter,
+						pagination: {
+							limit: 100,
+							offset
+						}
+					},
+					fetchPolicy: "network-only"
+				})).data?.getConnections;
+			});
+			setConnections(list.items);
+			setTotal(list.total);
+			setHasMore(list.hasMore);
+		} catch (err) {
+			setError(err);
+		} finally {
+			setLoading(false);
+		}
+	}, [filterKey]);
+	useEffect(() => {
+		fetchData();
+	}, [fetchData]);
+	return {
+		connections,
+		total,
+		hasMore,
+		loading,
+		error,
+		refetch: fetchData
+	};
+}
+/**
+* Hook to fetch a single connection by ID.
+*/
+function useConnection(connectionId) {
+	const [connection, setConnection] = useState(null);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(null);
+	const fetchData = useCallback(async () => {
+		if (!connectionId) {
+			setLoading(false);
+			return;
+		}
+		setLoading(true);
+		setError(null);
+		try {
+			const result = await getFluidGridsClient().query({
+				query: GET_CONNECTION,
+				variables: { id: connectionId },
+				fetchPolicy: "cache-first"
+			});
+			setConnection(result.data?.getConnection ?? null);
+		} catch (err) {
+			setError(err);
+		} finally {
+			setLoading(false);
+		}
+	}, [connectionId]);
+	useEffect(() => {
+		fetchData();
+	}, [fetchData]);
+	return {
+		connection,
+		loading,
+		error,
+		refetch: fetchData
+	};
+}
+/**
+* Hook to fetch connections for a specific provider.
+*/
+function useConnectionsByProvider(providerId) {
+	const [connections, setConnections] = useState([]);
+	const [total, setTotal] = useState(0);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(null);
+	const fetchData = useCallback(async () => {
+		if (!providerId) {
+			setLoading(false);
+			return;
+		}
+		setLoading(true);
+		setError(null);
+		try {
+			const result = await getFluidGridsClient().query({
+				query: GET_CONNECTIONS_BY_PROVIDER,
+				variables: {
+					providerId,
+					pagination: { limit: 100 }
+				},
+				fetchPolicy: "network-only"
+			});
+			setConnections(result.data?.getConnectionsByProvider?.items ?? []);
+			setTotal(result.data?.getConnectionsByProvider?.total ?? 0);
+		} catch (err) {
+			setError(err);
+		} finally {
+			setLoading(false);
+		}
+	}, [providerId]);
+	useEffect(() => {
+		fetchData();
+	}, [fetchData]);
+	return {
+		connections,
+		total,
+		loading,
+		error,
+		refetch: fetchData
+	};
+}
+/**
+* Hook to fetch available integration providers.
+*/
+function useProviders(filter) {
+	const [providers, setProviders] = useState([]);
+	const [total, setTotal] = useState(0);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(null);
+	const filterKey = JSON.stringify(filter);
+	const fetchData = useCallback(async () => {
+		setLoading(true);
+		setError(null);
+		try {
+			const client = getFluidGridsClient();
+			const parsedFilter = filterKey ? JSON.parse(filterKey) : void 0;
+			const result = await client.query({
+				query: GET_PROVIDERS,
+				variables: {
+					filter: parsedFilter,
+					pagination: { limit: 100 }
+				},
+				fetchPolicy: "cache-first"
+			});
+			setProviders(result.data?.getProviders?.items ?? []);
+			setTotal(result.data?.getProviders?.total ?? 0);
+		} catch (err) {
+			setError(err);
+		} finally {
+			setLoading(false);
+		}
+	}, [filterKey]);
+	useEffect(() => {
+		fetchData();
+	}, [fetchData]);
+	return {
+		providers,
+		total,
+		loading,
+		error,
+		refetch: fetchData
+	};
+}
+/**
+* Hook to create a new connection.
+*/
+function useCreateConnection() {
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	return {
+		createConnection: useCallback(async (input) => {
+			setLoading(true);
+			setError(null);
+			try {
+				const client = getFluidGridsClient();
+				return throwIfResultError(await client.mutate({
+					mutation: CREATE_CONNECTION,
+					variables: { input }
+				})).data?.createConnection ?? null;
+			} catch (err) {
+				setError(err);
+				return null;
+			} finally {
+				setLoading(false);
+			}
+		}, []),
+		loading,
+		error
+	};
+}
+/**
+* Hook to initiate OAuth flow for a connection.
+*/
+function useInitiateOAuth() {
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	return {
+		initiateOAuth: useCallback(async (input) => {
+			setLoading(true);
+			setError(null);
+			try {
+				const client = getFluidGridsClient();
+				return throwIfResultError(await client.mutate({
+					mutation: INITIATE_OAUTH,
+					variables: { input }
+				})).data?.initiateOAuth ?? null;
+			} catch (err) {
+				setError(err);
+				return null;
+			} finally {
+				setLoading(false);
+			}
+		}, []),
+		loading,
+		error
+	};
+}
+
+export { useCreateConnection as a, useConnectionsByProvider as i, useConnection as n, useInitiateOAuth as o, useConnections as r, useProviders as s, fetchConnectionNames as t };

package/dist/{useWorkflowCodeExport-lRmbjY49.js → useWorkflowCodeExport-ChAzmhi6.js}

@@ -1,13 +1,14 @@
 "use client";
 import { o as throwIfResultError, t as describeOperationError } from "./errors-xPZ-IbQd.js";
 import { n as getFluidGridsClient } from "./client-Ctl4jmY3.js";
+import { un as useFluidGridsAnalytics } from "./FluidGridsProvider-C-WGQwuT.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
-import { o as UpdateWorkflowDefinitionDocument } from "./WorkflowVersionsDocument-DRVOp8Uj.js";
-import { t as QuotaExhaustedDialog } from "./QuotaExhaustedDialog-YjKgRTmu.js";
-import { o as buildExportDownload } from "./workflow-code-transfer-BsLPUrKP.js";
-import { t as downloadBlob } from "./workflow-transfer-CQnQC-ke.js";
+import { i as WORKFLOWS_QUOTA_NAME } from "./quota-Cdt8yz7N.js";
+import { c as emitWorkflowLimitHit, o as emitUpgradeClicked } from "./fluidgridsEvents-Dm5CaHtr.js";
+import { l as buildExportDownload, t as downloadBlob } from "./workflow-transfer-CktP7o1c.js";
 import { useCallback, useEffect, useRef, useState } from "react";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle } from "@burdenoff/fe-libs/ui";
 
 // src/generated/documents/wspace/ExportWorkflowCodeDocument.ts
 const ExportWorkflowCodeDocument = {
@@ -79,6 +80,24 @@ const ExportWorkflowCodeDocument = {
 					}
 				},
 				"directives": []
+			},
+			{
+				"kind": "VariableDefinition",
+				"variable": {
+					"kind": "Variable",
+					"name": {
+						"kind": "Name",
+						"value": "options"
+					}
+				},
+				"type": {
+					"kind": "NamedType",
+					"name": {
+						"kind": "Name",
+						"value": "ExportOptionsInput"
+					}
+				},
+				"directives": []
 			}
 		],
 		"directives": [],
@@ -132,6 +151,20 @@ const ExportWorkflowCodeDocument = {
 								"value": "format"
 							}
 						}
+					},
+					{
+						"kind": "Argument",
+						"name": {
+							"kind": "Name",
+							"value": "options"
+						},
+						"value": {
+							"kind": "Variable",
+							"name": {
+								"kind": "Name",
+								"value": "options"
+							}
+						}
 					}
 				],
 				"directives": [],
@@ -292,121 +325,51 @@ const ExportWorkflowCodeDocument = {
 	}]
 };
 
-// src/components/shared/CreateWorkflowRefusalDialog.tsx
+// src/components/shared/QuotaExhaustedDialog.tsx
 /**
-* Says why "Create Workflow" created nothing, on the page it was pressed on.
-* The builder shows it too when saving a new workflow is refused by a plan
-* quota (BOFF-9998), since that save is the create.
-*
-* - `quota-exhausted`: the plan's workflow slots are used up (G43 copy).
-* - `quota-not-provisioned`: the workspace has no plan that includes FluidGrids
-*   workflows. Nothing is used up; choosing a plan for the workspace is the way
-*   past it, so the dialog still offers View plans (round-3 verification: the
-*   refusal toast vanished and nothing pointed at billing).
-* - `failed`: no dialog. The shell's backend-error toast already shows the
-*   server's message, and nothing navigated.
+* Alert shown when a workflow-creating action (save/duplicate/import) is
+* rejected with `QUOTA_EXHAUSTED` for `fluidgrids.workflows.count`. Mirrors
+* the "Folder Limit Reached" dialog in microfe-files' BrowserPage.tsx, built
+* on the same `AlertDialog` primitives already used elsewhere in this SDK
+* (see card-workflow.tsx's delete-confirmation dialog).
 */
-function CreateWorkflowRefusalDialog({ refusal, onClose, onUpgrade, surface }) {
+function QuotaExhaustedDialog({ open, onOpenChange, onUpgrade, title, description, surface, limitHit = true }) {
 	const tr = useTr();
-	const notProvisioned = refusal?.kind === "quota-not-provisioned";
-	const open = refusal?.kind === "quota-exhausted" || refusal?.kind === "quota-not-provisioned";
-	return /* @__PURE__ */ jsx(QuotaExhaustedDialog, {
+	const { bus, workspaceId } = useFluidGridsAnalytics();
+	const wasOpen = useRef(false);
+	useEffect(() => {
+		if (open && !wasOpen.current && limitHit) emitWorkflowLimitHit(bus, {
+			workspaceId,
+			surface
+		});
+		wasOpen.current = open;
+	}, [
+		open,
+		bus,
+		workspaceId,
 		surface,
+		limitHit
+	]);
+	const handleUpgrade = () => {
+		emitUpgradeClicked(bus, {
+			workspaceId,
+			surface: "quota-dialog",
+			quotaKey: WORKFLOWS_QUOTA_NAME
+		});
+		onUpgrade();
+	};
+	const resolvedTitle = title ?? tr("fluidgrids.components.quotaExhaustedDialog.title", "Workflow Limit Reached");
+	const resolvedDescription = description ?? tr("fluidgrids.components.quotaExhaustedDialog.description", "You've reached the workflow limit for your plan. Upgrade your plan to create more workflows.");
+	return /* @__PURE__ */ jsx(AlertDialog, {
 		open,
-		limitHit: !notProvisioned,
-		onOpenChange: (next) => {
-			if (!next) onClose();
-		},
-		onUpgrade: () => {
-			onUpgrade();
-			onClose();
-		},
-		...notProvisioned ? {
-			title: tr("fluidgrids.components.createRefusal.notProvisionedTitle", "Workflows aren't in this workspace's plan"),
-			description: tr("fluidgrids.components.createRefusal.notProvisionedDescription", "This workspace has no plan that includes FluidGrids workflows, so no workflow was created. Choose a plan for this workspace, or ask a workspace admin to add one.")
-		} : {}
+		onOpenChange,
+		children: /* @__PURE__ */ jsxs(AlertDialogContent, { children: [/* @__PURE__ */ jsxs(AlertDialogHeader, { children: [/* @__PURE__ */ jsx(AlertDialogTitle, { children: resolvedTitle }), /* @__PURE__ */ jsx(AlertDialogDescription, { children: resolvedDescription })] }), /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [/* @__PURE__ */ jsx(AlertDialogCancel, { children: tr("fluidgrids.components.quotaExhaustedDialog.dismiss", "Dismiss") }), /* @__PURE__ */ jsx(AlertDialogAction, {
+			onClick: handleUpgrade,
+			children: tr("fluidgrids.components.quotaExhaustedDialog.viewPlans", "View plans")
+		})] })] })
 	});
 }
 
-// src/utils/workflow-description.ts
-/** The longest description the editors accept. */
-const WORKFLOW_DESCRIPTION_MAX_LENGTH = 500;
-/**
-* Descriptions older builder saves wrote in place of a real one: every save
-* copied the workflow's name into its description, with these fallbacks for an
-* unnamed workflow. A description that only repeats the name says nothing.
-*/
-const LEGACY_PLACEHOLDERS = /* @__PURE__ */ new Set([
-	"Untitled Workflow",
-	"Workflow update",
-	"Workflow Description"
-]);
-/** The description as it is stored: surrounding whitespace removed. */
-function normalizeWorkflowDescription(text) {
-	return text.trim();
-}
-/**
-* The description worth showing for a workflow: empty when there is none, or
-* when it is a placeholder an older builder save wrote (the name again, or one
-* of the unnamed-workflow fallbacks).
-*/
-function visibleWorkflowDescription(description, name) {
-	const text = normalizeWorkflowDescription(description ?? "");
-	if (!text) return "";
-	if (text === (name ?? "").trim()) return "";
-	if (LEGACY_PLACEHOLDERS.has(text)) return "";
-	return text;
-}
-/** Decide what to do with `draft`, given the description shown before editing. */
-function commitWorkflowDescription(shown, draft) {
-	const description = normalizeWorkflowDescription(draft);
-	if (description.length > 500) return {
-		kind: "too-long",
-		length: description.length
-	};
-	if (description === normalizeWorkflowDescription(shown)) return { kind: "unchanged" };
-	return {
-		kind: "save",
-		description
-	};
-}
-/** The characters left for a draft; negative once it is too long. */
-function workflowDescriptionCharactersLeft(draft) {
-	return 500 - normalizeWorkflowDescription(draft).length;
-}
-/**
-* The `updateWorkflowDefinition` input that changes only the description. An
-* empty description is sent as "" (not null), which is what clears it.
-*/
-function workflowDescriptionUpdateInput(description, guard = {}) {
-	return {
-		description: normalizeWorkflowDescription(description),
-		...guard.expectedRevision !== void 0 ? { expectedRevision: guard.expectedRevision } : {},
-		...guard.editSessionId ? { editSessionId: guard.editSessionId } : {}
-	};
-}
-/**
-* Save `description` on the version `id`, in place. Throws the service's
-* refusal (permission, a conflict, a viewer of a shared workflow) so the
-* caller can roll its optimistic copy back and say why.
-*/
-async function saveWorkflowDescription(client, id, description, guard = {}) {
-	const { data } = throwIfResultError(await client.mutate({
-		mutation: UpdateWorkflowDefinitionDocument,
-		variables: {
-			id,
-			input: workflowDescriptionUpdateInput(description, guard)
-		}
-	}));
-	const saved = data?.updateWorkflowDefinition;
-	if (!saved) throw new Error("The description was not saved");
-	return {
-		id: saved.id,
-		description: saved.description ?? "",
-		revision: saved.revision
-	};
-}
-
 // src/hooks/useWorkflowCodeExport.ts
 /**
 * Code-first export (BOFF-9904): read a workflow version lifted to
@@ -424,7 +387,8 @@ async function fetchWorkflowCodeExport(target) {
 		variables: {
 			workflowKey: target.workflowKey,
 			version: target.version || null,
-			format: target.format
+			format: target.format,
+			...target.options ? { options: target.options } : {}
 		},
 		fetchPolicy: "network-only"
 	});
@@ -508,4 +472,4 @@ function useExportWorkflowAs(save = downloadBlob) {
 	};
 }
 
-export { saveWorkflowDescription as a, CreateWorkflowRefusalDialog as c, normalizeWorkflowDescription as i, ExportWorkflowCodeDocument as l, useWorkflowCodeExport as n, visibleWorkflowDescription as o, commitWorkflowDescription as r, workflowDescriptionCharactersLeft as s, useExportWorkflowAs as t };
+export { ExportWorkflowCodeDocument as a, QuotaExhaustedDialog as i, useExportWorkflowAs as n, useWorkflowCodeExport as r, fetchWorkflowCodeExport as t };

package/dist/workflow-builder.js

@@ -1,6 +1,6 @@
 "use client";
-import { n as WorkflowBuilderCore, t as WorkflowBuilder } from "./WorkflowBuilder-CjsO7i-D.js";
-import { t as WorkflowBuilder$1 } from "./WorkflowBuilder-DkzzbrNn.js";
+import { n as WorkflowBuilderCore, t as WorkflowBuilder } from "./WorkflowBuilder-Bzx-e5lX.js";
+import { t as WorkflowBuilder$1 } from "./WorkflowBuilder-CdcGE0Mf.js";
 import { A as useFlowStore } from "./node-operation-selection-DHbtGNrG.js";
 import { m as refetchStoreNodes } from "./FluidGridsProvider-C-WGQwuT.js";
 import { t as WorkflowSearchRedirect } from "./WorkflowSearchRedirect-0MLrCjDn.js";