@everysk/apps-sdk 0.1.0 → 0.3.0-beta-20261016180126

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

@@ -1,52 +1,190 @@
-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[]>> & {
+import type { FetchEntityProps } from "../../types/entityQuery.d.ts";
+import type { WorkerExecutionGroup } from "../../types/workflow.d.ts";
+export type FetchWorkerExecutionsProps<TData = WorkerExecutionGroup[], TSelected = TData> = FetchEntityProps<TData, TSelected> & {
     workflowId: string;
     workflowExecutionId: string;
-    pageSize?: number;
+    workspace: string;
+    /** Include each run's `result` and `input_params`. The API leaves them out by default. */
+    withResult?: boolean;
 };
 /**
  * useFetchWorkerExecutions
  *
- * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
- * worker executions for a given workflow with cursor-based pagination.
+ * Fetches every worker execution of one workflow execution, grouped by worker; `data` is the
+ * groups, or whatever `select` makes of them. Narrow a group on `is_parallel_execution`: a
+ * worker that ran in parallel carries every run under `executions`, any other one its run as
+ * `execution`. Idle while an id is empty; fails loudly, without a request, while `workspace` is.
+ * A failure is shown as an error alert.
  *
- * Automatically flattens all pages into a single `WorkerExecution[]` via `select`.
+ * A plain query, not an infinite one, and so shaped like the single-entity hooks: the endpoint
+ * returns the whole set at once, with no cursor to page by. It used to be paged, over a JSON
+ * query the endpoint ignores, and typed as a flat list of worker executions.
  *
- * 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 ?? [];
- * ```
+ * @param {FetchWorkerExecutionsProps} props - Workflow and execution ids, workspace,
+ *   `withResult`, `select` and TanStack `queryOptions`.
+ * @returns {object} The `useQuery` result, plus `queryKey`.
  */
-export declare function useFetchWorkerExecutions({ workflowId, workflowExecutionId, filters, order, projection, pageSize, queryOptions }: FetchInfiniteWorkerExecutionProps): {
-    query: import("@tanstack/react-query").UseInfiniteQueryResult<WorkerExecution[], Error>;
-    queryKey: unknown[];
+export declare const useFetchWorkerExecutions: <TSelected = WorkerExecutionGroup[]>({ workflowId, workflowExecutionId, workspace, withResult, select, queryOptions, }: FetchWorkerExecutionsProps<WorkerExecutionGroup[], TSelected>) => {
+    queryKey: (string | boolean | null)[];
+    data: TSelected;
+    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<TSelected, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: (string | boolean | null)[];
+    data: TSelected;
+    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<TSelected, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: (string | boolean | null)[];
+    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<TSelected, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: (string | boolean | null)[];
+    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<TSelected, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: (string | boolean | null)[];
+    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<TSelected, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: (string | boolean | null)[];
+    data: TSelected;
+    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<TSelected, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
 };
-export {};
 //# sourceMappingURL=useFetchWorkerExecutions.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkerExecutions.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkerExecutions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,MAAM,MAAM,0BAA0B,CAClC,KAAK,GAAG,oBAAoB,EAAE,EAC9B,SAAS,GAAG,KAAK,IACjB,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,GAAG,oBAAoB,EAAE,EAAE,mFAO1E,0BAA0B,CAAC,oBAAoB,EAAE,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B/D,CAAC"}

package/dist/hooks/workflow/useFetchWorkerExecutions.js

@@ -1,82 +1,49 @@
 import { useAxios } from "../useAxios.js";
-import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { useEntityQuery } from "../useEntityQuery.js";
+import { missingWorkspaceError } 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.
+* Fetches every worker execution of one workflow execution, grouped by worker; `data` is the
+* groups, or whatever `select` makes of them. Narrow a group on `is_parallel_execution`: a
+* worker that ran in parallel carries every run under `executions`, any other one its run as
+* `execution`. Idle while an id is empty; fails loudly, without a request, while `workspace` is.
+* A failure is shown as an error alert.
 *
-* @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`.
+* A plain query, not an infinite one, and so shaped like the single-entity hooks: the endpoint
+* returns the whole set at once, with no cursor to page by. It used to be paged, over a JSON
+* query the endpoint ignores, and typed as a flat list of worker executions.
 *
-* @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 ?? [];
-* ```
+* @param {FetchWorkerExecutionsProps} props - Workflow and execution ids, workspace,
+*   `withResult`, `select` and TanStack `queryOptions`.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 */
-function useFetchWorkerExecutions({ workflowId, workflowExecutionId, filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+var useFetchWorkerExecutions = ({ workflowId, workflowExecutionId, workspace, withResult, select, queryOptions }) => {
 	const { api } = useAxios();
-	const queryKey = buildQueryKey([
+	const queryKey = [
 		"worker_executions",
 		workflowId,
-		workflowExecutionId
-	], filters);
-	const mergedQueryOptions = useMemo(() => ({
-		...defaultQueryOptions,
-		...queryOptions ?? {}
-	}), [queryOptions]);
+		workflowExecutionId,
+		workspace,
+		withResult ?? null
+	];
 	return {
-		query: useInfiniteQuery({
+		...useEntityQuery({
 			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
+			fetchEntity: async (signal) => (await listWorkerExecutions(api, workflowId, workflowExecutionId, {
+				workspace,
+				withResult
+			}, signal)).worker_executions,
+			select,
+			enabled: Boolean(workflowId) && Boolean(workflowExecutionId),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchWorkerExecutions"),
+			queryOptions
 		}),
 		queryKey
 	};
-}
+};
 //#endregion
 export { useFetchWorkerExecutions };
 

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkerExecutions.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkerExecutions.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { listWorkerExecutions } from \"@/api/workflow\";\nimport { missingWorkspaceError } from \"@/api/entityQuery\";\nimport type { FetchEntityProps } from \"@/types/entityQuery\";\nimport type { WorkerExecutionGroup } from \"@/types/workflow\";\n\nexport type FetchWorkerExecutionsProps<\n    TData = WorkerExecutionGroup[],\n    TSelected = TData,\n> = FetchEntityProps<TData, TSelected> & {\n    workflowId: string;\n    workflowExecutionId: string;\n    workspace: string;\n    /** Include each run's `result` and `input_params`. The API leaves them out by default. */\n    withResult?: boolean;\n};\n\n/**\n * useFetchWorkerExecutions\n *\n * Fetches every worker execution of one workflow execution, grouped by worker; `data` is the\n * groups, or whatever `select` makes of them. Narrow a group on `is_parallel_execution`: a\n * worker that ran in parallel carries every run under `executions`, any other one its run as\n * `execution`. Idle while an id is empty; fails loudly, without a request, while `workspace` is.\n * A failure is shown as an error alert.\n *\n * A plain query, not an infinite one, and so shaped like the single-entity hooks: the endpoint\n * returns the whole set at once, with no cursor to page by. It used to be paged, over a JSON\n * query the endpoint ignores, and typed as a flat list of worker executions.\n *\n * @param {FetchWorkerExecutionsProps} props - Workflow and execution ids, workspace,\n *   `withResult`, `select` and TanStack `queryOptions`.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n */\nexport const useFetchWorkerExecutions = <TSelected = WorkerExecutionGroup[]>({\n    workflowId,\n    workflowExecutionId,\n    workspace,\n    withResult,\n    select,\n    queryOptions,\n}: FetchWorkerExecutionsProps<WorkerExecutionGroup[], TSelected>) => {\n    const { api } = useAxios();\n\n    const queryKey = [\n        \"worker_executions\",\n        workflowId,\n        workflowExecutionId,\n        workspace,\n        withResult ?? null,\n    ];\n\n    const query = useEntityQuery<WorkerExecutionGroup[], TSelected>({\n        queryKey,\n        fetchEntity: async (signal) =>\n            (\n                await listWorkerExecutions(\n                    api,\n                    workflowId,\n                    workflowExecutionId,\n                    { workspace, withResult },\n                    signal,\n                )\n            ).worker_executions,\n        select,\n        enabled: Boolean(workflowId) && Boolean(workflowExecutionId),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchWorkerExecutions\"),\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAa,4BAAgE,EACzE,YACA,qBACA,WACA,YACA,QACA,mBACiE;CACjE,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW;EACb;EACA;EACA;EACA;EACA,cAAc;CAClB;CAoBA,OAAO;EAAE,GAlBK,eAAkD;GAC5D;GACA,aAAa,OAAO,YAEZ,MAAM,qBACF,KACA,YACA,qBACA;IAAE;IAAW;GAAW,GACxB,MACJ,EAAA,CACF;GACN;GACA,SAAS,QAAQ,UAAU,KAAK,QAAQ,mBAAmB;GAC3D,aAAa,YAAY,KAAA,IAAY,sBAAsB,0BAA0B;GACrF;EACJ,CAEY;EAAO;CAAS;AAChC"}

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

@@ -1,37 +1,18 @@
 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>;
+import type { FetchEntityByIdProps } from "../../types/entityQuery.d.ts";
+export type FetchWorkflowProps<TData = Workflow, TSelected = TData> = FetchEntityByIdProps<TData, TSelected>;
 /**
  * useFetchWorkflow
  *
- * Data-fetching hook built on TanStack Query to retrieve a single workflow by ID.
+ * Fetches one workflow; `data` is the workflow, or whatever `select` makes of it. Idle while
+ * `id` is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.
  *
- * 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
- * ```
+ * @param {FetchWorkflowProps} props - `id`, `workspace`, `select` and TanStack `queryOptions`.
+ * @returns {object} The `useQuery` result, plus `queryKey`.
  */
-export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWorkflowProps) => {
+export declare const useFetchWorkflow: <TSelected = Workflow>({ id, workspace, select, queryOptions, }: FetchWorkflowProps<Workflow, TSelected>) => {
     queryKey: string[];
-    data: Workflow;
+    data: TSelected;
     error: Error;
     isError: true;
     isPending: false;
@@ -54,11 +35,11 @@ export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWo
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
-    data: Workflow;
+    data: TSelected;
     error: null;
     isError: false;
     isPending: false;
@@ -81,7 +62,7 @@ export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWo
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -108,7 +89,7 @@ export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWo
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -135,7 +116,7 @@ export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWo
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -162,11 +143,11 @@ export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWo
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
-    data: Workflow;
+    data: TSelected;
     isError: false;
     error: null;
     isPending: false;
@@ -189,7 +170,7 @@ export declare const useFetchWorkflow: ({ id, workspace, queryOptions }: FetchWo
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workflow, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 };
 //# sourceMappingURL=useFetchWorkflow.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkflow.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflow.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,MAAM,MAAM,kBAAkB,CAAC,KAAK,GAAG,QAAQ,EAAE,SAAS,GAAG,KAAK,IAAI,oBAAoB,CACtF,KAAK,EACL,SAAS,CACZ,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,GAAG,QAAQ,EAAE,0CAKpD,kBAAkB,CAAC,QAAQ,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAezC,CAAC"}

package/dist/hooks/workflow/useFetchWorkflow.js

@@ -1,66 +1,33 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityQuery } from "../useEntityQuery.js";
+import { missingWorkspaceError } from "../../api/entityQuery.js";
 import { getWorkflow } from "../../api/workflow.js";
-import { useEffect } from "react";
-import { useQuery } from "@tanstack/react-query";
 //#region src/hooks/workflow/useFetchWorkflow.ts
-var defaultQueryOptions = {
-	refetchOnMount: "always",
-	staleTime: 0,
-	gcTime: 0
-};
 /**
 * 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 });
-*   ```
+* Fetches one workflow; `data` is the workflow, or whatever `select` makes of it. Idle while
+* `id` is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.
 *
-* Example:
-* ```ts
-* const { data, isLoading } = useFetchWorkflow({ id: "wf-123", workspace: "main" });
-* // data -> Workflow
-* ```
+* @param {FetchWorkflowProps} props - `id`, `workspace`, `select` and TanStack `queryOptions`.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 */
-var useFetchWorkflow = ({ id, workspace, queryOptions = defaultQueryOptions }) => {
+var useFetchWorkflow = ({ id, workspace, select, queryOptions }) => {
 	const { api } = useAxios();
-	const { showAlert } = useAppAlert();
 	const queryKey = [
 		"workflow",
 		id,
 		workspace
 	];
-	const query = useQuery({
-		queryKey,
-		queryFn: async () => {
-			return await getWorkflow(api, id, workspace);
-		},
-		...queryOptions ?? {}
-	});
-	useEffect(() => {
-		if (!query.error) return;
-		showAlert({
-			severity: "error",
-			message: query.error.message
-		});
-	}, [query.error, showAlert]);
 	return {
-		...query,
+		...useEntityQuery({
+			queryKey,
+			fetchEntity: (signal) => getWorkflow(api, id, workspace, signal),
+			select,
+			enabled: Boolean(id),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchWorkflow"),
+			queryOptions
+		}),
 		queryKey
 	};
 };

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

@@ -1 +1 @@
-{"version":3,"file":"useFetchWorkflow.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflow.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 { getWorkflow } from \"@/api/workflow\";\nimport type { Workflow } from \"@/types/workflow\";\nimport type { EntityQueryOptions, FetchEntityParams } from \"@/types/entityQuery\";\n\nexport type FetchWorkflowProps<TData = Workflow, TSelected = TData> = FetchEntityParams<TData, TSelected>;\n\nconst defaultQueryOptions: EntityQueryOptions<Workflow> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0\n}\n\n/**\n * useFetchWorkflow\n *\n * Data-fetching hook built on TanStack Query to retrieve a single workflow by ID.\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 id - Workflow 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 * Tip:\n * - The returned `queryKey` can be reused by mutation hooks for cache invalidation:\n *   ```ts\n *   const fetch = useFetchWorkflow({ id: \"wf-123\", workspace: \"main\" });\n *   useWorkflowMutations({ queryKey: fetch.queryKey });\n *   ```\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchWorkflow({ id: \"wf-123\", workspace: \"main\" });\n * // data -> Workflow\n * ```\n */\nexport const useFetchWorkflow = ({ id, workspace, queryOptions = defaultQueryOptions }: FetchWorkflowProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"workflow\", id, workspace];\n\n    const query = useQuery<Workflow>({\n        queryKey,\n        queryFn: async () => {\n            const workflow = await getWorkflow(api, id, workspace);\n            return workflow;\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":";;;;;;AAYA,IAAM,sBAAoD;CACtD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,oBAAoB,EAAE,IAAI,WAAW,eAAe,0BAA8C;CAE3G,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EAAC;EAAY;EAAI;CAAS;CAE3C,MAAM,QAAQ,SAAmB;EAC7B;EACA,SAAS,YAAY;GAEjB,OAAO,MADgB,YAAY,KAAK,IAAI,SAAS;EAEzD;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"}
+{"version":3,"file":"useFetchWorkflow.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflow.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { missingWorkspaceError } from \"@/api/entityQuery\";\nimport { getWorkflow } from \"@/api/workflow\";\nimport type { Workflow } from \"@/types/workflow\";\nimport type { FetchEntityByIdProps } from \"@/types/entityQuery\";\n\nexport type FetchWorkflowProps<TData = Workflow, TSelected = TData> = FetchEntityByIdProps<\n    TData,\n    TSelected\n>;\n\n/**\n * useFetchWorkflow\n *\n * Fetches one workflow; `data` is the workflow, or whatever `select` makes of it. Idle while\n * `id` is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.\n *\n * @param {FetchWorkflowProps} props - `id`, `workspace`, `select` and TanStack `queryOptions`.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n */\nexport const useFetchWorkflow = <TSelected = Workflow>({\n    id,\n    workspace,\n    select,\n    queryOptions,\n}: FetchWorkflowProps<Workflow, TSelected>) => {\n    const { api } = useAxios();\n\n    const queryKey = [\"workflow\", id, workspace];\n\n    const query = useEntityQuery<Workflow, TSelected>({\n        queryKey,\n        fetchEntity: (signal) => getWorkflow(api, id, workspace, signal),\n        select,\n        enabled: Boolean(id),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchWorkflow\"),\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;;;;;;;;;;;AAqBA,IAAa,oBAA0C,EACnD,IACA,WACA,QACA,mBAC2C;CAC3C,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW;EAAC;EAAY;EAAI;CAAS;CAW3C,OAAO;EAAE,GATK,eAAoC;GAC9C;GACA,cAAc,WAAW,YAAY,KAAK,IAAI,WAAW,MAAM;GAC/D;GACA,SAAS,QAAQ,EAAE;GACnB,aAAa,YAAY,KAAA,IAAY,sBAAsB,kBAAkB;GAC7E;EACJ,CAEY;EAAO;CAAS;AAChC"}