@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.18

package/dist/useConnections-Cs7LCWEM.js

@@ -0,0 +1,401 @@
+"use client";
+import { _ as throwIfResultError, n as getFluidGridsClient } from "./client-C9XSzSXr.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
+    }
+  }
+`;
+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
+	};
+}
+/**
+* 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 { useInitiateOAuth as a, useCreateConnection as i, useConnections as n, useProviders as o, useConnectionsByProvider as r, useConnection as t };