@everysk/apps-sdk 0.1.0-beta.0

package/dist/hooks/workflow/useFetchWorkerExecution.d.ts

@@ -0,0 +1,198 @@
+import type { WorkerExecution } from "../../types/workflow.d.ts";
+import type { EntityQueryOptions } from "../../types/entityQuery.d.ts";
+export type FetchWorkerExecutionProps<TData = WorkerExecution, TSelected = TData> = {
+    workflowId: string;
+    workerExecutionId: string;
+    workspace: string;
+    queryOptions?: EntityQueryOptions<TData, TSelected>;
+};
+/**
+ * useFetchWorkerExecution
+ *
+ * Data-fetching hook built on TanStack Query to retrieve a single worker execution.
+ *
+ * It also:
+ * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+ * - triggers an error alert via `useAppAlert` whenever `query.error` is present
+ *
+ * @param workflowId - Workflow identifier the worker execution belongs to (required).
+ * @param workerExecutionId - Worker execution identifier (required).
+ * @param workspace - Workspace the workflow belongs to (required).
+ * @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * @returns TanStack Query result extended with `queryKey`.
+ *
+ * Example:
+ * ```ts
+ * const { data, isLoading } = useFetchWorkerExecution({
+ *   workflowId: "wf-123",
+ *   workerExecutionId: "wkex-456",
+ *   workspace: "main",
+ * });
+ * // data -> WorkerExecution
+ * ```
+ */
+export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId, workspace, queryOptions }: FetchWorkerExecutionProps) => {
+    queryKey: string[];
+    data: WorkerExecution;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: WorkerExecution;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: WorkerExecution;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+};
+//# sourceMappingURL=useFetchWorkerExecution.d.ts.map

package/dist/hooks/workflow/useFetchWorkerExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkerExecution.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkerExecution.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,yBAAyB,CAAC,KAAK,GAAG,eAAe,EAAE,SAAS,GAAG,KAAK,IAAI;IAChF,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;CACvD,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,uBAAuB,GAAI,4DAAkF,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BlJ,CAAC"}

package/dist/hooks/workflow/useFetchWorkerExecution.js

@@ -0,0 +1,69 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.js";
+import { getWorkerExecution } from "../../api/workflow.js";
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+//#region src/hooks/workflow/useFetchWorkerExecution.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkerExecution
+*
+* Data-fetching hook built on TanStack Query to retrieve a single worker execution.
+*
+* It also:
+* - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+* - triggers an error alert via `useAppAlert` whenever `query.error` is present
+*
+* @param workflowId - Workflow identifier the worker execution belongs to (required).
+* @param workerExecutionId - Worker execution identifier (required).
+* @param workspace - Workspace the workflow belongs to (required).
+* @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+*
+* @returns TanStack Query result extended with `queryKey`.
+*
+* Example:
+* ```ts
+* const { data, isLoading } = useFetchWorkerExecution({
+*   workflowId: "wf-123",
+*   workerExecutionId: "wkex-456",
+*   workspace: "main",
+* });
+* // data -> WorkerExecution
+* ```
+*/
+var useFetchWorkerExecution = ({ workflowId, workerExecutionId, workspace, queryOptions = defaultQueryOptions }) => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	const queryKey = [
+		"worker_execution",
+		workflowId,
+		workerExecutionId,
+		workspace
+	];
+	const query = useQuery({
+		queryKey,
+		queryFn: async () => {
+			return await getWorkerExecution(api, workflowId, workerExecutionId, workspace);
+		},
+		...queryOptions ?? {}
+	});
+	useEffect(() => {
+		if (!query.error) return;
+		showAlert({
+			severity: "error",
+			message: query.error.message
+		});
+	}, [query.error, showAlert]);
+	return {
+		...query,
+		queryKey
+	};
+};
+//#endregion
+export { useFetchWorkerExecution };
+
+//# sourceMappingURL=useFetchWorkerExecution.js.map

package/dist/hooks/workflow/useFetchWorkerExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkerExecution.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkerExecution.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { getWorkerExecution } from \"@/api/workflow\";\nimport type { WorkerExecution } from \"@/types/workflow\";\nimport type { EntityQueryOptions } from \"@/types/entityQuery\";\n\nexport type FetchWorkerExecutionProps<TData = WorkerExecution, TSelected = TData> = {\n    workflowId: string;\n    workerExecutionId: string;\n    workspace: string;\n    queryOptions?: EntityQueryOptions<TData, TSelected>;\n};\n\nconst defaultQueryOptions: EntityQueryOptions<WorkerExecution> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkerExecution\n *\n * Data-fetching hook built on TanStack Query to retrieve a single worker execution.\n *\n * It also:\n * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * @param workflowId - Workflow identifier the worker execution belongs to (required).\n * @param workerExecutionId - Worker execution identifier (required).\n * @param workspace - Workspace the workflow belongs to (required).\n * @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *\n * @returns TanStack Query result extended with `queryKey`.\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchWorkerExecution({\n *   workflowId: \"wf-123\",\n *   workerExecutionId: \"wkex-456\",\n *   workspace: \"main\",\n * });\n * // data -> WorkerExecution\n * ```\n */\nexport const useFetchWorkerExecution = ({ workflowId, workerExecutionId, workspace, queryOptions = defaultQueryOptions }: FetchWorkerExecutionProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"worker_execution\", workflowId, workerExecutionId, workspace];\n\n    const query = useQuery<WorkerExecution>({\n        queryKey,\n        queryFn: async () => {\n            return await getWorkerExecution(api, workflowId, workerExecutionId, workspace);\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;AAiBA,IAAM,sBAA2D;CAC7D,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,2BAA2B,EAAE,YAAY,mBAAmB,WAAW,eAAe,0BAAqD;CAEpJ,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EAAC;EAAoB;EAAY;EAAmB;CAAS;CAE9E,MAAM,QAAQ,SAA0B;EACpC;EACA,SAAS,YAAY;GACjB,OAAO,MAAM,mBAAmB,KAAK,YAAY,mBAAmB,SAAS;EACjF;EACA,GAAG,gBAAgB,CAAC;CACxB,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GACN,UAAU;GACV,SAAS,MAAM,MAAM;EACzB,CAAC;CACL,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;EACH,GAAG;EACH;CACJ;AACJ"}

package/dist/hooks/workflow/useFetchWorkerExecutions.d.ts

@@ -0,0 +1,52 @@
+import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
+import type { FetchEntitiesParams } from "../../types/entityQuery.d.ts";
+import type { WorkerExecution, WorkerExecutionListResponse } from "../../types/workflow.d.ts";
+type PageToken = string | null;
+type InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkerExecutionListResponse, Error, TData, QueryKey, PageToken>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+export type FetchInfiniteWorkerExecutionProps = FetchEntitiesParams<WorkerExecution[], InfiniteOptions<WorkerExecution[]>> & {
+    workflowId: string;
+    workflowExecutionId: string;
+    pageSize?: number;
+};
+/**
+ * useFetchWorkerExecutions
+ *
+ * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+ * worker executions for a given workflow with cursor-based pagination.
+ *
+ * Automatically flattens all pages into a single `WorkerExecution[]` via `select`.
+ *
+ * Note: `query.data` returns a flat `WorkerExecution[]` with all fetched items merged across pages.
+ *
+ * @param workflowId - Workflow identifier whose worker executions to fetch (required).
+ * @param workflowExecutionId - Workflow execution identifier to filter worker executions (required).
+ * @param filters - Filters applied to every page request. Must include a `workspace` filter.
+ * @param order - Sorting applied to every page request.
+ * @param projection - Single field to project: `"field"` returns only that field (others come
+ *   back null), `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
+ * @param pageSize - Number of executions to fetch per page. Defaults to `10`.
+ * @param queryOptions - TanStack Query options passed through to `useInfiniteQuery`.
+ *
+ * @returns
+ *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * @example
+ * ```ts
+ * const { query } = useFetchWorkerExecutions({
+ *   workflowId: "wf-123",
+ *   workflowExecutionId: "wfex-456",
+ *   filters: [{ field: "workspace", value: "main" }],
+ *   pageSize: 20,
+ * });
+ *
+ * // Flat list of all fetched worker executions
+ * const workerExecutions = query.data ?? [];
+ * ```
+ */
+export declare function useFetchWorkerExecutions({ workflowId, workflowExecutionId, filters, order, projection, pageSize, queryOptions }: FetchInfiniteWorkerExecutionProps): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<WorkerExecution[], Error>;
+    queryKey: unknown[];
+};
+export {};
+//# sourceMappingURL=useFetchWorkerExecutions.d.ts.map

package/dist/hooks/workflow/useFetchWorkerExecutions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkerExecutions.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkerExecutions.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAErF,KAAK,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/B,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC,uBAAuB,CAAC,2BAA2B,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CAAC,CAAC;AAE9L,MAAM,MAAM,iCAAiC,GAAG,mBAAmB,CAAC,eAAe,EAAE,EAAE,eAAe,CAAC,eAAe,EAAE,CAAC,CAAC,GAAG;IACzH,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,UAAU,EAAE,mBAAmB,EAAE,OAAY,EAAE,KAAU,EAAE,UAAe,EAAE,QAAa,EAAE,YAAY,EAAE,EAAE,iCAAiC;;;EAoCtL"}

package/dist/hooks/workflow/useFetchWorkerExecutions.js

@@ -0,0 +1,83 @@
+import { useAxios } from "../useAxios.js";
+import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { listWorkerExecutions } from "../../api/workflow.js";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/workflow/useFetchWorkerExecutions.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkerExecutions
+*
+* Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+* worker executions for a given workflow with cursor-based pagination.
+*
+* Automatically flattens all pages into a single `WorkerExecution[]` via `select`.
+*
+* Note: `query.data` returns a flat `WorkerExecution[]` with all fetched items merged across pages.
+*
+* @param workflowId - Workflow identifier whose worker executions to fetch (required).
+* @param workflowExecutionId - Workflow execution identifier to filter worker executions (required).
+* @param filters - Filters applied to every page request. Must include a `workspace` filter.
+* @param order - Sorting applied to every page request.
+* @param projection - Single field to project: `"field"` returns only that field (others come
+*   back null), `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
+* @param pageSize - Number of executions to fetch per page. Defaults to `10`.
+* @param queryOptions - TanStack Query options passed through to `useInfiniteQuery`.
+*
+* @returns
+*   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+*   - `queryKey`: the cache key used by React Query
+*
+* @example
+* ```ts
+* const { query } = useFetchWorkerExecutions({
+*   workflowId: "wf-123",
+*   workflowExecutionId: "wfex-456",
+*   filters: [{ field: "workspace", value: "main" }],
+*   pageSize: 20,
+* });
+*
+* // Flat list of all fetched worker executions
+* const workerExecutions = query.data ?? [];
+* ```
+*/
+function useFetchWorkerExecutions({ workflowId, workflowExecutionId, filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+	const { api } = useAxios();
+	const queryKey = buildQueryKey([
+		"worker_executions",
+		workflowId,
+		workflowExecutionId
+	], filters);
+	const mergedQueryOptions = useMemo(() => ({
+		...defaultQueryOptions,
+		...queryOptions ?? {}
+	}), [queryOptions]);
+	return {
+		query: useInfiniteQuery({
+			queryKey,
+			initialPageParam: null,
+			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+			queryFn: async ({ pageParam }) => {
+				const queryFilter = buildQueryObject({
+					filters,
+					order,
+					projection,
+					pageSize,
+					pageToken: pageParam ?? void 0
+				});
+				return await listWorkerExecutions(api, workflowId, workflowExecutionId, queryFilter);
+			},
+			select: (data) => data.pages.flatMap((p) => p.worker_executions),
+			...mergedQueryOptions
+		}),
+		queryKey
+	};
+}
+//#endregion
+export { useFetchWorkerExecutions };
+
+//# sourceMappingURL=useFetchWorkerExecutions.js.map

package/dist/hooks/workflow/useFetchWorkerExecutions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkerExecutions.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkerExecutions.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useInfiniteQuery, type UseInfiniteQueryOptions, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { listWorkerExecutions } from \"@/api/workflow\";\nimport type { FetchEntitiesParams } from \"@/types/entityQuery\";\nimport { buildQueryKey, buildQueryObject } from \"@/api/entityQuery\";\nimport type { WorkerExecution, WorkerExecutionListResponse } from \"@/types/workflow\";\n\ntype PageToken = string | null;\n\ntype InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkerExecutionListResponse, Error, TData, QueryKey, PageToken>, \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\">;\n\nexport type FetchInfiniteWorkerExecutionProps = FetchEntitiesParams<WorkerExecution[], InfiniteOptions<WorkerExecution[]>> & {\n    workflowId: string;\n    workflowExecutionId: string;\n    pageSize?: number;\n};\n\nconst defaultQueryOptions: InfiniteOptions<WorkerExecution[]> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkerExecutions\n *\n * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve\n * worker executions for a given workflow with cursor-based pagination.\n *\n * Automatically flattens all pages into a single `WorkerExecution[]` via `select`.\n *\n * Note: `query.data` returns a flat `WorkerExecution[]` with all fetched items merged across pages.\n *\n * @param workflowId - Workflow identifier whose worker executions to fetch (required).\n * @param workflowExecutionId - Workflow execution identifier to filter worker executions (required).\n * @param filters - Filters applied to every page request. Must include a `workspace` filter.\n * @param order - Sorting applied to every page request.\n * @param projection - Single field to project: `\"field\"` returns only that field (others come\n *   back null), `\"-field\"` returns every field except that one. One field only — lists 500. Omitted when empty.\n * @param pageSize - Number of executions to fetch per page. Defaults to `10`.\n * @param queryOptions - TanStack Query options passed through to `useInfiniteQuery`.\n *\n * @returns\n *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)\n *   - `queryKey`: the cache key used by React Query\n *\n * @example\n * ```ts\n * const { query } = useFetchWorkerExecutions({\n *   workflowId: \"wf-123\",\n *   workflowExecutionId: \"wfex-456\",\n *   filters: [{ field: \"workspace\", value: \"main\" }],\n *   pageSize: 20,\n * });\n *\n * // Flat list of all fetched worker executions\n * const workerExecutions = query.data ?? [];\n * ```\n */\nexport function useFetchWorkerExecutions({ workflowId, workflowExecutionId, filters = [], order = [], projection = \"\", pageSize = 10, queryOptions }: FetchInfiniteWorkerExecutionProps) {\n    const { api } = useAxios();\n\n    const queryKey = buildQueryKey([\"worker_executions\", workflowId, workflowExecutionId], filters);\n\n    const mergedQueryOptions = useMemo<InfiniteOptions<WorkerExecution[]>>(() => ({\n        ...defaultQueryOptions,\n        ...(queryOptions ?? {}),\n    }), [queryOptions]);\n\n    const query = useInfiniteQuery<WorkerExecutionListResponse, Error, WorkerExecution[], QueryKey, PageToken>({\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n\n        queryFn: async ({ pageParam }) => {\n            const queryFilter = buildQueryObject({\n                filters,\n                order,\n                projection,\n                pageSize,\n                pageToken: pageParam ?? undefined,\n            });\n\n            return await listWorkerExecutions(api, workflowId, workflowExecutionId, queryFilter);\n        },\n\n        select: (data) => data.pages.flatMap((p) => p.worker_executions),\n\n        ...mergedQueryOptions,\n    });\n\n    return {\n        query,\n        queryKey,\n    };\n}\n"],"mappings":";;;;;;AAmBA,IAAM,sBAA0D;CAC5D,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,yBAAyB,EAAE,YAAY,qBAAqB,UAAU,CAAC,GAAG,QAAQ,CAAC,GAAG,aAAa,IAAI,WAAW,IAAI,gBAAmD;CACrL,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW,cAAc;EAAC;EAAqB;EAAY;CAAmB,GAAG,OAAO;CAE9F,MAAM,qBAAqB,eAAmD;EAC1E,GAAG;EACH,GAAI,gBAAgB,CAAC;CACzB,IAAI,CAAC,YAAY,CAAC;CAwBlB,OAAO;EACH,OAvBU,iBAA6F;GACvG;GACA,kBAAkB;GAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;GAE5D,SAAS,OAAO,EAAE,gBAAgB;IAC9B,MAAM,cAAc,iBAAiB;KACjC;KACA;KACA;KACA;KACA,WAAW,aAAa,KAAA;IAC5B,CAAC;IAED,OAAO,MAAM,qBAAqB,KAAK,YAAY,qBAAqB,WAAW;GACvF;GAEA,SAAS,SAAS,KAAK,MAAM,SAAS,MAAM,EAAE,iBAAiB;GAE/D,GAAG;EACP,CAGI;EACA;CACJ;AACJ"}

package/dist/hooks/workflow/useFetchWorkflow.d.ts

@@ -0,0 +1,195 @@
+import type { Workflow } from "../../types/workflow.d.ts";
+import type { FetchEntityParams } from "../../types/entityQuery.d.ts";
+export type FetchWorkflowProps<TData = Workflow, TSelected = TData> = FetchEntityParams<TData, TSelected>;
+/**
+ * useFetchWorkflow
+ *
+ * Data-fetching hook built on TanStack Query to retrieve a single workflow by ID.
+ *
+ * It also:
+ * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+ * - triggers an error alert via `useAppAlert` whenever `query.error` is present
+ *
+ * @param id - Workflow identifier (required).
+ * @param workspace - Workspace the workflow belongs to (required).
+ * @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * @returns TanStack Query result extended with `queryKey`.
+ *
+ * Tip:
+ * - The returned `queryKey` can be reused by mutation hooks for cache invalidation:
+ *   ```ts
+ *   const fetch = useFetchWorkflow({ id: "wf-123", workspace: "main" });
+ *   useWorkflowMutations({ queryKey: fetch.queryKey });
+ *   ```
+ *
+ * Example:
+ * ```ts
+ * const { data, isLoading } = useFetchWorkflow({ id: "wf-123", workspace: "main" });
+ * // data -> Workflow
+ * ```
+ */
+export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWorkflowProps) => {
+    queryKey: string[];
+    data: Workflow;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: Workflow;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: Workflow;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+};
+//# sourceMappingURL=useFetchWorkflow.d.ts.map

package/dist/hooks/workflow/useFetchWorkflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflow.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflow.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAEjF,MAAM,MAAM,kBAAkB,CAAC,KAAK,GAAG,QAAQ,EAAE,SAAS,GAAG,KAAK,IAAI,iBAAiB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAQ1G;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,GAAI,iCAAuD,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BzG,CAAC"}