@everysk/apps-sdk 0.2.0 → 0.3.0-beta-20261019175049

package/dist/hooks/useEntityInfiniteQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityInfiniteQuery.js","names":[],"sources":["../../src/hooks/useEntityInfiniteQuery.ts"],"sourcesContent":["import { useCallback } from \"react\";\nimport { useInfiniteQuery, type QueryKey } from \"@tanstack/react-query\";\n\nimport type {\n    PagedResponse,\n    EntityInfiniteQueryOptions,\n    ListCache,\n    PageToken,\n} from \"@/types/entityQuery\";\n\n/**\n * Ceiling on `fetchAllPages`. Reaching it fails the read instead of returning what was read so\n * far: a cursor that never ends is a bug, and a consolidated view shown from a partial read is\n * a wrong answer that looks right. A set legitimately this long wants a larger `pageSize`.\n */\nexport const FETCH_ALL_PAGES_LIMIT = 100;\n\n/** The element type of a page's item array. */\nexport type ItemOf<TPage, K extends keyof TPage> = TPage[K] extends (infer TItem)[] ? TItem : never;\n\nexport type EntityInfiniteQueryProps<TPage extends PagedResponse, K extends keyof TPage, TData> = {\n    /**\n     * Must describe everything that changes the response, `fetchAllPages` included, or two reads\n     * share one cache entry. Build it with `buildQueryKey(keys, filters, { order, projection,\n     * pageSize, fetchAllPages })`, and return it from your hook so callers can write to the cache.\n     */\n    queryKey: QueryKey;\n    /** Where a page keeps its items (`\"datastores\"`, `\"files\"`, …). */\n    itemsKey: K;\n    /**\n     * Requests one page; `undefined` asks for the first. `signal` aborts when no screen wants the\n     * read any more — pass it to the request (`api.get(url, { signal })`) to cancel it in flight.\n     */\n    fetchPage: (pageToken: string | undefined, signal?: AbortSignal) => Promise<TPage>;\n    select?: (items: ItemOf<TPage, K>[]) => TData;\n    fetchAllPages?: boolean;\n    /**\n     * Your hook's own precondition for something legitimately not there yet (a selection the\n     * user has not made), ANDed with the caller's `queryOptions.enabled`. Unmet, the query stays\n     * idle. For something that should always be there, use `configError`: idle hides it.\n     */\n    enabled?: boolean;\n    /**\n     * Why the request cannot be right, when it cannot — `missingWorkspaceError(hookName)` in the\n     * SDK's hooks. Set, the query fails at once with it as the error, without a request or a\n     * retry, and logs it with `console.error` once per message, in every environment: a\n     * misconfigured app shows up in the browser console and in test output, not as an empty\n     * screen.\n     * It is reported even while `enabled` is unmet, so an empty id cannot hide a misconfigured\n     * workspace; only the caller's `queryOptions.enabled: false` holds it back.\n     */\n    configError?: string;\n    queryOptions?: EntityInfiniteQueryOptions<TPage, TData>;\n};\n\n/** The `configError` messages already logged, so a render loop does not flood the console. */\nconst loggedConfigErrors = new Set<string>();\n\n/**\n * Fails a query with its `configError`, logging it the first time. Shared by the SDK's query\n * hooks.\n */\nexport const failWithConfigError = (configError: string): never => {\n    if (!loggedConfigErrors.has(configError)) {\n        loggedConfigErrors.add(configError);\n        console.error(configError);\n    }\n\n    throw new Error(configError);\n};\n\nconst defaultQueryOptions = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n} as const;\n\n/**\n * Reads every page into one page, so the cache holds a single entry for the whole set and a\n * refetch rereads all of it.\n *\n * Stops as soon as `signal` aborts. TanStack aborts it when the last screen reading the query\n * unmounts — only because the query function takes it — and without this check the loop would\n * go on requesting every remaining page for nobody.\n */\nconst fetchEveryPage = async <TPage extends PagedResponse, K extends keyof TPage>(\n    fetchPage: (pageToken: string | undefined, signal?: AbortSignal) => Promise<TPage>,\n    itemsKey: K,\n    signal: AbortSignal,\n): Promise<TPage> => {\n    let page = await fetchPage(undefined, signal);\n    const items = [...(page[itemsKey] as unknown[])];\n\n    for (let count = 1; page.next_page_token; count++) {\n        signal.throwIfAborted();\n\n        if (count >= FETCH_ALL_PAGES_LIMIT) {\n            throw new Error(\n                `fetchAllPages stopped after ${FETCH_ALL_PAGES_LIMIT} pages without reaching the end. ` +\n                    \"Raise pageSize, or page on demand instead.\",\n            );\n        }\n\n        page = await fetchPage(page.next_page_token, signal);\n        items.push(...(page[itemsKey] as unknown[]));\n    }\n\n    return { ...page, [itemsKey]: items, next_page_token: null };\n};\n\n/**\n * useEntityInfiniteQuery\n *\n * The list hook every SDK list hook is built on, and the one to build on for an endpoint the\n * SDK does not cover. A hook says how to request a page and where its items are; this merges\n * the pages, applies the caller's `select`, and owns the paging modes (`fetchAllPages`, and\n * `fetchNextPage` for `handleRowsScrollEnd`). It replaced seven copies of the same\n * `useInfiniteQuery` call, which is how one `select` defect had reached all seven — an app\n * copying a list hook instead of composing this would copy the next one too.\n *\n * `select` is composed with the merging after the caller's options are spread, so nothing in\n * `queryOptions` can replace it. The composed function is memoised on the caller's `select`:\n * TanStack skips a select whose data and reference are both unchanged.\n *\n * @returns {UseInfiniteQueryResult} The `useInfiniteQuery` result; `data` is the merged items,\n *   or what `select` makes of them.\n *\n * Example:\n * ```ts\n * export const useFetchReports = <TData = Report[]>({ workspace, select, fetchAllPages = false }: Props<TData>) => {\n *   const { api } = useAxios();\n *   const filters = [{ field: \"workspace\", value: workspace }];\n *   const queryKey = buildQueryKey([\"reports\"], filters, { fetchAllPages });\n *\n *   const query = useEntityInfiniteQuery<ReportListResponse, \"reports\", TData>({\n *     queryKey,\n *     itemsKey: \"reports\",\n *     fetchPage: (pageToken) => listReports(api, workspace, pageToken),\n *     select,\n *     fetchAllPages,\n *     configError: hasWorkspaceFilter(filters) ? undefined : missingWorkspaceError(\"useFetchReports\"),\n *   });\n *\n *   return { query, queryKey };\n * };\n * ```\n */\nexport function useEntityInfiniteQuery<\n    TPage extends PagedResponse,\n    K extends keyof TPage,\n    TData = ItemOf<TPage, K>[],\n>({\n    queryKey,\n    itemsKey,\n    fetchPage,\n    select,\n    fetchAllPages = false,\n    enabled = true,\n    configError,\n    queryOptions,\n}: EntityInfiniteQueryProps<TPage, K, TData>) {\n    const selectMerged = useCallback(\n        (data: ListCache<TPage>): TData => {\n            const items = data.pages.flatMap((page) => page[itemsKey] as ItemOf<TPage, K>[]);\n            return select ? select(items) : (items as unknown as TData);\n        },\n        [itemsKey, select],\n    );\n\n    return useInfiniteQuery<TPage, Error, TData, QueryKey, PageToken>({\n        ...defaultQueryOptions,\n        ...queryOptions,\n\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n        queryFn: async ({ pageParam, signal }) => {\n            if (configError) return failWithConfigError(configError);\n\n            return fetchAllPages\n                ? fetchEveryPage(fetchPage, itemsKey, signal)\n                : fetchPage(pageParam ?? undefined, signal);\n        },\n        // A retry would rerun the same check and delay an error that cannot resolve itself.\n        ...(configError ? { retry: false } : {}),\n\n        select: selectMerged,\n        // A config error runs past the hook's own precondition, so that an empty id cannot hide a\n        // misconfigured workspace; the caller's `enabled` still wins. Kept as the caller wrote it,\n        // so a function still works.\n        enabled: configError || enabled ? (queryOptions?.enabled ?? true) : false,\n    });\n}\n"],"mappings":";;;;;;;;AAeA,IAAa,wBAAwB;;AAyCrC,IAAM,qCAAqB,IAAI,IAAY;;;;;AAM3C,IAAa,uBAAuB,gBAA+B;CAC/D,IAAI,CAAC,mBAAmB,IAAI,WAAW,GAAG;EACtC,mBAAmB,IAAI,WAAW;EAClC,QAAQ,MAAM,WAAW;CAC7B;CAEA,MAAM,IAAI,MAAM,WAAW;AAC/B;AAEA,IAAM,sBAAsB;CACxB,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;AAUA,IAAM,iBAAiB,OACnB,WACA,UACA,WACiB;CACjB,IAAI,OAAO,MAAM,UAAU,KAAA,GAAW,MAAM;CAC5C,MAAM,QAAQ,CAAC,GAAI,KAAK,SAAuB;CAE/C,KAAK,IAAI,QAAQ,GAAG,KAAK,iBAAiB,SAAS;EAC/C,OAAO,eAAe;EAEtB,IAAI,SAAA,KACA,MAAM,IAAI,MACN,4GAEJ;EAGJ,OAAO,MAAM,UAAU,KAAK,iBAAiB,MAAM;EACnD,MAAM,KAAK,GAAI,KAAK,SAAuB;CAC/C;CAEA,OAAO;EAAE,GAAG;GAAO,WAAW;EAAO,iBAAiB;CAAK;AAC/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,uBAId,EACE,UACA,UACA,WACA,QACA,gBAAgB,OAChB,UAAU,MACV,aACA,gBAC0C;CAC1C,MAAM,eAAe,aAChB,SAAkC;EAC/B,MAAM,QAAQ,KAAK,MAAM,SAAS,SAAS,KAAK,SAA+B;EAC/E,OAAO,SAAS,OAAO,KAAK,IAAK;CACrC,GACA,CAAC,UAAU,MAAM,CACrB;CAEA,OAAO,iBAA2D;EAC9D,GAAG;EACH,GAAG;EAEH;EACA,kBAAkB;EAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;EAC5D,SAAS,OAAO,EAAE,WAAW,aAAa;GACtC,IAAI,aAAa,OAAO,oBAAoB,WAAW;GAEvD,OAAO,gBACD,eAAe,WAAW,UAAU,MAAM,IAC1C,UAAU,aAAa,KAAA,GAAW,MAAM;EAClD;EAEA,GAAI,cAAc,EAAE,OAAO,MAAM,IAAI,CAAC;EAEtC,QAAQ;EAIR,SAAS,eAAe,UAAW,cAAc,WAAW,OAAQ;CACxE,CAAC;AACL"}

package/dist/hooks/useEntityMutation.d.ts

@@ -0,0 +1,47 @@
+import { type QueryKey } from "@tanstack/react-query";
+export type EntityMutationProps<TVariables, TResult> = {
+    /** Sends the write. Receives the variables passed to `mutate`, and only those. */
+    mutationFn: (variables: TVariables) => Promise<TResult>;
+    /**
+     * Invalidated after a success, so the screens reading it refetch. Pass the `queryKey` a fetch
+     * hook returned, or a prefix of it (`["datastores"]`) to refresh every list of that entity.
+     */
+    queryKey?: QueryKey;
+    /** Shown as a success alert. */
+    successMessage: string;
+    /** Shown as an error alert when the failure carries no message of its own. */
+    errorMessage: string;
+};
+/**
+ * useEntityMutation
+ *
+ * The write hook every SDK mutation is built on, and the one to build on for an endpoint the SDK
+ * does not cover — the counterpart of `useEntityQuery`. A hook says how to send the write and
+ * what to tell the user; this owns the cache invalidation and the alerts.
+ *
+ * It replaced nine copies of the same `useMutation` call across `useDatastoreMutations`,
+ * `useFileMutations` and `usePortfolioMutations`, which had already drifted apart in wording.
+ *
+ * The invalidation is awaited before the mutation resolves, so code after `mutateAsync` sees the
+ * refetched data rather than racing it.
+ *
+ * @returns {UseMutationResult} The `useMutation` result.
+ *
+ * Example:
+ * ```ts
+ * export const useReportMutations = ({ queryKey }: { queryKey?: QueryKey }) => {
+ *   const { api } = useAxios();
+ *
+ *   const share = useEntityMutation({
+ *     mutationFn: ({ id, workspace }: ShareReportProps) => shareReport(api, id, workspace),
+ *     queryKey,
+ *     successMessage: "Report shared successfully.",
+ *     errorMessage: "Unable to share the report. Please try again.",
+ *   });
+ *
+ *   return { share };
+ * };
+ * ```
+ */
+export declare function useEntityMutation<TVariables, TResult>({ mutationFn, queryKey, successMessage, errorMessage, }: EntityMutationProps<TVariables, TResult>): import("@tanstack/react-query").UseMutationResult<TResult, Error, TVariables, unknown>;
+//# sourceMappingURL=useEntityMutation.d.ts.map

package/dist/hooks/useEntityMutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityMutation.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityMutation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAInF,MAAM,MAAM,mBAAmB,CAAC,UAAU,EAAE,OAAO,IAAI;IACnD,kFAAkF;IAClF,UAAU,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,YAAY,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,OAAO,EAAE,EACnD,UAAU,EACV,QAAQ,EACR,cAAc,EACd,YAAY,GACf,EAAE,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,0FAe1C"}

package/dist/hooks/useEntityMutation.js

@@ -0,0 +1,58 @@
+import { useAppAlert } from "../contexts/appAlertContext/useAppAlert.js";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+//#region src/hooks/useEntityMutation.ts
+/**
+* useEntityMutation
+*
+* The write hook every SDK mutation is built on, and the one to build on for an endpoint the SDK
+* does not cover — the counterpart of `useEntityQuery`. A hook says how to send the write and
+* what to tell the user; this owns the cache invalidation and the alerts.
+*
+* It replaced nine copies of the same `useMutation` call across `useDatastoreMutations`,
+* `useFileMutations` and `usePortfolioMutations`, which had already drifted apart in wording.
+*
+* The invalidation is awaited before the mutation resolves, so code after `mutateAsync` sees the
+* refetched data rather than racing it.
+*
+* @returns {UseMutationResult} The `useMutation` result.
+*
+* Example:
+* ```ts
+* export const useReportMutations = ({ queryKey }: { queryKey?: QueryKey }) => {
+*   const { api } = useAxios();
+*
+*   const share = useEntityMutation({
+*     mutationFn: ({ id, workspace }: ShareReportProps) => shareReport(api, id, workspace),
+*     queryKey,
+*     successMessage: "Report shared successfully.",
+*     errorMessage: "Unable to share the report. Please try again.",
+*   });
+*
+*   return { share };
+* };
+* ```
+*/
+function useEntityMutation({ mutationFn, queryKey, successMessage, errorMessage }) {
+	const { showAlert } = useAppAlert();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (variables) => mutationFn(variables),
+		onSuccess: async () => {
+			if (queryKey?.length) await queryClient.invalidateQueries({ queryKey });
+			showAlert({
+				severity: "success",
+				message: successMessage
+			});
+		},
+		onError: (error) => {
+			showAlert({
+				severity: "error",
+				message: error.message || errorMessage
+			});
+		}
+	});
+}
+//#endregion
+export { useEntityMutation };
+
+//# sourceMappingURL=useEntityMutation.js.map

package/dist/hooks/useEntityMutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityMutation.js","names":[],"sources":["../../src/hooks/useEntityMutation.ts"],"sourcesContent":["import { useMutation, useQueryClient, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\n\nexport type EntityMutationProps<TVariables, TResult> = {\n    /** Sends the write. Receives the variables passed to `mutate`, and only those. */\n    mutationFn: (variables: TVariables) => Promise<TResult>;\n    /**\n     * Invalidated after a success, so the screens reading it refetch. Pass the `queryKey` a fetch\n     * hook returned, or a prefix of it (`[\"datastores\"]`) to refresh every list of that entity.\n     */\n    queryKey?: QueryKey;\n    /** Shown as a success alert. */\n    successMessage: string;\n    /** Shown as an error alert when the failure carries no message of its own. */\n    errorMessage: string;\n};\n\n/**\n * useEntityMutation\n *\n * The write hook every SDK mutation is built on, and the one to build on for an endpoint the SDK\n * does not cover — the counterpart of `useEntityQuery`. A hook says how to send the write and\n * what to tell the user; this owns the cache invalidation and the alerts.\n *\n * It replaced nine copies of the same `useMutation` call across `useDatastoreMutations`,\n * `useFileMutations` and `usePortfolioMutations`, which had already drifted apart in wording.\n *\n * The invalidation is awaited before the mutation resolves, so code after `mutateAsync` sees the\n * refetched data rather than racing it.\n *\n * @returns {UseMutationResult} The `useMutation` result.\n *\n * Example:\n * ```ts\n * export const useReportMutations = ({ queryKey }: { queryKey?: QueryKey }) => {\n *   const { api } = useAxios();\n *\n *   const share = useEntityMutation({\n *     mutationFn: ({ id, workspace }: ShareReportProps) => shareReport(api, id, workspace),\n *     queryKey,\n *     successMessage: \"Report shared successfully.\",\n *     errorMessage: \"Unable to share the report. Please try again.\",\n *   });\n *\n *   return { share };\n * };\n * ```\n */\nexport function useEntityMutation<TVariables, TResult>({\n    mutationFn,\n    queryKey,\n    successMessage,\n    errorMessage,\n}: EntityMutationProps<TVariables, TResult>) {\n    const { showAlert } = useAppAlert();\n    const queryClient = useQueryClient();\n\n    return useMutation<TResult, Error, TVariables>({\n        // TanStack passes a context as a second argument; the request gets the variables alone.\n        mutationFn: (variables) => mutationFn(variables),\n        onSuccess: async () => {\n            if (queryKey?.length) await queryClient.invalidateQueries({ queryKey });\n            showAlert({ severity: \"success\", message: successMessage });\n        },\n        onError: (error) => {\n            showAlert({ severity: \"error\", message: error.message || errorMessage });\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAgB,kBAAuC,EACnD,YACA,UACA,gBACA,gBACyC;CACzC,MAAM,EAAE,cAAc,YAAY;CAClC,MAAM,cAAc,eAAe;CAEnC,OAAO,YAAwC;EAE3C,aAAa,cAAc,WAAW,SAAS;EAC/C,WAAW,YAAY;GACnB,IAAI,UAAU,QAAQ,MAAM,YAAY,kBAAkB,EAAE,SAAS,CAAC;GACtE,UAAU;IAAE,UAAU;IAAW,SAAS;GAAe,CAAC;EAC9D;EACA,UAAU,UAAU;GAChB,UAAU;IAAE,UAAU;IAAS,SAAS,MAAM,WAAW;GAAa,CAAC;EAC3E;CACJ,CAAC;AACL"}

package/dist/hooks/useEntityQuery.d.ts

@@ -0,0 +1,68 @@
+import { type QueryKey } from "@tanstack/react-query";
+import type { EntityQueryOptions } from "../types/entityQuery.d.ts";
+export type EntityQueryProps<TEntity, TData> = {
+    /** Must describe everything that changes the response: the entity's ids and workspace. */
+    queryKey: QueryKey;
+    /**
+     * Requests the entity. `signal` aborts when no screen wants it any more — pass it to the
+     * request (`api.get(url, { signal })`) to cancel it in flight.
+     */
+    fetchEntity: (signal: AbortSignal) => Promise<TEntity>;
+    select?: (entity: TEntity) => TData;
+    /**
+     * Your hook's own precondition for something legitimately not there yet — an id from a
+     * selection the user has not made — ANDed with the caller's `queryOptions.enabled`. Unmet,
+     * the query stays idle rather than send an empty id, which reaches another endpoint entirely.
+     */
+    enabled?: boolean;
+    /**
+     * Why the request cannot be right, when it cannot — `missingWorkspaceError(hookName)` in the
+     * SDK's hooks. Set, the query fails at once with it, without a request or a retry, logs it once
+     * with `console.error` and shows it as the error alert. See `useEntityInfiniteQuery`.
+     * It is reported even while `enabled` is unmet, so an empty id cannot hide a misconfigured
+     * workspace; only the caller's `queryOptions.enabled: false` holds it back.
+     */
+    configError?: string;
+    /** Replaces the SDK's defaults for this hook, as the profile does. */
+    defaultQueryOptions?: EntityQueryOptions<TEntity, TData>;
+    queryOptions?: EntityQueryOptions<TEntity, TData>;
+};
+/**
+ * useEntityQuery
+ *
+ * The single-entity hook every SDK single-entity hook is built on, and the one to build on for
+ * an endpoint the SDK does not cover — the counterpart of `useEntityInfiniteQuery`. A hook says
+ * how to request the entity; this owns the defaults, the idle precondition, `select` and the
+ * error alert.
+ *
+ * It replaced eight copies of the same `useQuery` call, which is how one defect had reached all
+ * eight: each declared `queryOptions = defaultQueryOptions`, so passing any option replaced the
+ * defaults and the query fell back to TanStack's own (a 5-minute cache instead of none). Here
+ * the caller's options are merged over the defaults.
+ *
+ * A failure is shown through `useAppAlert`, as the entity hooks always have.
+ *
+ * @returns {UseQueryResult} The `useQuery` result; `data` is the entity, or what `select` makes
+ *   of it. The SDK's hooks spread it and add `queryKey`.
+ *
+ * Example:
+ * ```ts
+ * export const useFetchReport = <TData = Report>({ id, workspace, select, queryOptions }: Props<TData>) => {
+ *   const { api } = useAxios();
+ *   const queryKey = ["report", id, workspace];
+ *
+ *   const query = useEntityQuery<Report, TData>({
+ *     queryKey,
+ *     fetchEntity: (signal) => getReport(api, id, workspace, signal),
+ *     select,
+ *     enabled: Boolean(id),
+ *     configError: workspace ? undefined : missingWorkspaceError("useFetchReport"),
+ *     queryOptions,
+ *   });
+ *
+ *   return { ...query, queryKey };
+ * };
+ * ```
+ */
+export declare function useEntityQuery<TEntity, TData = TEntity>({ queryKey, fetchEntity, select, enabled, configError, defaultQueryOptions, queryOptions, }: EntityQueryProps<TEntity, TData>): import("@tanstack/react-query").UseQueryResult<TData, Error>;
+//# sourceMappingURL=useEntityQuery.d.ts.map

package/dist/hooks/useEntityQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityQuery.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIhE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,gBAAgB,CAAC,OAAO,EAAE,KAAK,IAAI;IAC3C,0FAA0F;IAC1F,QAAQ,EAAE,QAAQ,CAAC;IACnB;;;OAGG;IACH,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,CAAC;IACpC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,mBAAmB,CAAC,EAAE,kBAAkB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACzD,YAAY,CAAC,EAAE,kBAAkB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;CACrD,CAAC;AAYF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,KAAK,GAAG,OAAO,EAAE,EACrD,QAAQ,EACR,WAAW,EACX,MAAM,EACN,OAAc,EACd,WAAW,EACX,mBAA4C,EAC5C,YAAY,GACf,EAAE,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,gEA0BlC"}

package/dist/hooks/useEntityQuery.js

@@ -0,0 +1,75 @@
+import { useAppAlert } from "../contexts/appAlertContext/useAppAlert.js";
+import { failWithConfigError } from "./useEntityInfiniteQuery.js";
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+//#region src/hooks/useEntityQuery.ts
+/**
+* The entity hooks read data the platform keeps changing, so by default nothing is cached:
+* refetched on every mount, dropped as soon as no screen reads it.
+*/
+var sdkDefaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useEntityQuery
+*
+* The single-entity hook every SDK single-entity hook is built on, and the one to build on for
+* an endpoint the SDK does not cover — the counterpart of `useEntityInfiniteQuery`. A hook says
+* how to request the entity; this owns the defaults, the idle precondition, `select` and the
+* error alert.
+*
+* It replaced eight copies of the same `useQuery` call, which is how one defect had reached all
+* eight: each declared `queryOptions = defaultQueryOptions`, so passing any option replaced the
+* defaults and the query fell back to TanStack's own (a 5-minute cache instead of none). Here
+* the caller's options are merged over the defaults.
+*
+* A failure is shown through `useAppAlert`, as the entity hooks always have.
+*
+* @returns {UseQueryResult} The `useQuery` result; `data` is the entity, or what `select` makes
+*   of it. The SDK's hooks spread it and add `queryKey`.
+*
+* Example:
+* ```ts
+* export const useFetchReport = <TData = Report>({ id, workspace, select, queryOptions }: Props<TData>) => {
+*   const { api } = useAxios();
+*   const queryKey = ["report", id, workspace];
+*
+*   const query = useEntityQuery<Report, TData>({
+*     queryKey,
+*     fetchEntity: (signal) => getReport(api, id, workspace, signal),
+*     select,
+*     enabled: Boolean(id),
+*     configError: workspace ? undefined : missingWorkspaceError("useFetchReport"),
+*     queryOptions,
+*   });
+*
+*   return { ...query, queryKey };
+* };
+* ```
+*/
+function useEntityQuery({ queryKey, fetchEntity, select, enabled = true, configError, defaultQueryOptions = sdkDefaultQueryOptions, queryOptions }) {
+	const { showAlert } = useAppAlert();
+	const query = useQuery({
+		...defaultQueryOptions,
+		...queryOptions,
+		queryKey,
+		queryFn: async ({ signal }) => configError ? failWithConfigError(configError) : fetchEntity(signal),
+		...configError ? { retry: false } : {},
+		select,
+		enabled: configError || enabled ? queryOptions?.enabled ?? true : false
+	});
+	useEffect(() => {
+		if (!query.error) return;
+		showAlert({
+			severity: "error",
+			message: query.error.message
+		});
+	}, [query.error, showAlert]);
+	return query;
+}
+//#endregion
+export { useEntityQuery };
+
+//# sourceMappingURL=useEntityQuery.js.map

package/dist/hooks/useEntityQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityQuery.js","names":[],"sources":["../../src/hooks/useEntityQuery.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useQuery, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { failWithConfigError } from \"@/hooks/useEntityInfiniteQuery\";\nimport type { EntityQueryOptions } from \"@/types/entityQuery\";\n\nexport type EntityQueryProps<TEntity, TData> = {\n    /** Must describe everything that changes the response: the entity's ids and workspace. */\n    queryKey: QueryKey;\n    /**\n     * Requests the entity. `signal` aborts when no screen wants it any more — pass it to the\n     * request (`api.get(url, { signal })`) to cancel it in flight.\n     */\n    fetchEntity: (signal: AbortSignal) => Promise<TEntity>;\n    select?: (entity: TEntity) => TData;\n    /**\n     * Your hook's own precondition for something legitimately not there yet — an id from a\n     * selection the user has not made — ANDed with the caller's `queryOptions.enabled`. Unmet,\n     * the query stays idle rather than send an empty id, which reaches another endpoint entirely.\n     */\n    enabled?: boolean;\n    /**\n     * Why the request cannot be right, when it cannot — `missingWorkspaceError(hookName)` in the\n     * SDK's hooks. Set, the query fails at once with it, without a request or a retry, logs it once\n     * with `console.error` and shows it as the error alert. See `useEntityInfiniteQuery`.\n     * It is reported even while `enabled` is unmet, so an empty id cannot hide a misconfigured\n     * workspace; only the caller's `queryOptions.enabled: false` holds it back.\n     */\n    configError?: string;\n    /** Replaces the SDK's defaults for this hook, as the profile does. */\n    defaultQueryOptions?: EntityQueryOptions<TEntity, TData>;\n    queryOptions?: EntityQueryOptions<TEntity, TData>;\n};\n\n/**\n * The entity hooks read data the platform keeps changing, so by default nothing is cached:\n * refetched on every mount, dropped as soon as no screen reads it.\n */\nconst sdkDefaultQueryOptions = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n} as const;\n\n/**\n * useEntityQuery\n *\n * The single-entity hook every SDK single-entity hook is built on, and the one to build on for\n * an endpoint the SDK does not cover — the counterpart of `useEntityInfiniteQuery`. A hook says\n * how to request the entity; this owns the defaults, the idle precondition, `select` and the\n * error alert.\n *\n * It replaced eight copies of the same `useQuery` call, which is how one defect had reached all\n * eight: each declared `queryOptions = defaultQueryOptions`, so passing any option replaced the\n * defaults and the query fell back to TanStack's own (a 5-minute cache instead of none). Here\n * the caller's options are merged over the defaults.\n *\n * A failure is shown through `useAppAlert`, as the entity hooks always have.\n *\n * @returns {UseQueryResult} The `useQuery` result; `data` is the entity, or what `select` makes\n *   of it. The SDK's hooks spread it and add `queryKey`.\n *\n * Example:\n * ```ts\n * export const useFetchReport = <TData = Report>({ id, workspace, select, queryOptions }: Props<TData>) => {\n *   const { api } = useAxios();\n *   const queryKey = [\"report\", id, workspace];\n *\n *   const query = useEntityQuery<Report, TData>({\n *     queryKey,\n *     fetchEntity: (signal) => getReport(api, id, workspace, signal),\n *     select,\n *     enabled: Boolean(id),\n *     configError: workspace ? undefined : missingWorkspaceError(\"useFetchReport\"),\n *     queryOptions,\n *   });\n *\n *   return { ...query, queryKey };\n * };\n * ```\n */\nexport function useEntityQuery<TEntity, TData = TEntity>({\n    queryKey,\n    fetchEntity,\n    select,\n    enabled = true,\n    configError,\n    defaultQueryOptions = sdkDefaultQueryOptions,\n    queryOptions,\n}: EntityQueryProps<TEntity, TData>) {\n    const { showAlert } = useAppAlert();\n\n    const query = useQuery<TEntity, Error, TData>({\n        ...defaultQueryOptions,\n        ...queryOptions,\n\n        queryKey,\n        queryFn: async ({ signal }) =>\n            configError ? failWithConfigError(configError) : fetchEntity(signal),\n        // A retry would rerun the same check and delay an error that cannot resolve itself.\n        ...(configError ? { retry: false } : {}),\n        select,\n        // A config error runs past the hook's own precondition, so that an empty id cannot hide a\n        // misconfigured workspace; the caller's `enabled` still wins. Kept as the caller wrote it,\n        // so a function still works.\n        enabled: configError || enabled ? (queryOptions?.enabled ?? true) : false,\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({ severity: \"error\", message: query.error.message });\n    }, [query.error, showAlert]);\n\n    return query;\n}\n"],"mappings":";;;;;;;;;AAuCA,IAAM,yBAAyB;CAC3B,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,eAAyC,EACrD,UACA,aACA,QACA,UAAU,MACV,aACA,sBAAsB,wBACtB,gBACiC;CACjC,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,QAAQ,SAAgC;EAC1C,GAAG;EACH,GAAG;EAEH;EACA,SAAS,OAAO,EAAE,aACd,cAAc,oBAAoB,WAAW,IAAI,YAAY,MAAM;EAEvE,GAAI,cAAc,EAAE,OAAO,MAAM,IAAI,CAAC;EACtC;EAIA,SAAS,eAAe,UAAW,cAAc,WAAW,OAAQ;CACxE,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GAAE,UAAU;GAAS,SAAS,MAAM,MAAM;EAAQ,CAAC;CACjE,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;AACX"}

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

@@ -1,40 +1,23 @@
 import type { WorkerExecution } from "../../types/workflow.d.ts";
-import type { EntityQueryOptions } from "../../types/entityQuery.d.ts";
-export type FetchWorkerExecutionProps<TData = WorkerExecution, TSelected = TData> = {
+import type { FetchEntityProps } from "../../types/entityQuery.d.ts";
+export type FetchWorkerExecutionProps<TData = WorkerExecution, TSelected = TData> = FetchEntityProps<TData, TSelected> & {
     workflowId: string;
     workerExecutionId: string;
     workspace: string;
-    queryOptions?: EntityQueryOptions<TData, TSelected>;
 };
 /**
  * useFetchWorkerExecution
  *
- * Data-fetching hook built on TanStack Query to retrieve a single worker execution.
+ * Fetches one worker execution; `data` is the execution, or whatever `select` makes of it. Idle
+ * while an 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 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
- * ```
+ * @param {FetchWorkerExecutionProps} props - `workflowId`, `workerExecutionId`, `workspace`,
+ *   `select` and TanStack `queryOptions`.
+ * @returns {object} The `useQuery` result, plus `queryKey`.
  */
-export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId, workspace, queryOptions }: FetchWorkerExecutionProps) => {
+export declare const useFetchWorkerExecution: <TSelected = WorkerExecution>({ workflowId, workerExecutionId, workspace, select, queryOptions, }: FetchWorkerExecutionProps<WorkerExecution, TSelected>) => {
     queryKey: string[];
-    data: WorkerExecution;
+    data: TSelected;
     error: Error;
     isError: true;
     isPending: false;
@@ -57,11 +40,11 @@ export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId,
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, 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: WorkerExecution;
+    data: TSelected;
     error: null;
     isError: false;
     isPending: false;
@@ -84,7 +67,7 @@ export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId,
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -111,7 +94,7 @@ export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId,
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -138,7 +121,7 @@ export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId,
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -165,11 +148,11 @@ export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId,
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, 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: WorkerExecution;
+    data: TSelected;
     isError: false;
     error: null;
     isPending: false;
@@ -192,7 +175,7 @@ export declare const useFetchWorkerExecution: ({ workflowId, workerExecutionId,
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkerExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 };
 //# sourceMappingURL=useFetchWorkerExecution.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkerExecution.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkerExecution.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,yBAAyB,CACjC,KAAK,GAAG,eAAe,EACvB,SAAS,GAAG,KAAK,IACjB,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,GAAG,eAAe,EAAE,qEAMlE,yBAAyB,CAAC,eAAe,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBvD,CAAC"}

package/dist/hooks/workflow/useFetchWorkerExecution.js

@@ -1,65 +1,35 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityQuery } from "../useEntityQuery.js";
+import { missingWorkspaceError } from "../../api/entityQuery.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`.
+* Fetches one worker execution; `data` is the execution, or whatever `select` makes of it. Idle
+* while an id is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.
 *
-* Example:
-* ```ts
-* const { data, isLoading } = useFetchWorkerExecution({
-*   workflowId: "wf-123",
-*   workerExecutionId: "wkex-456",
-*   workspace: "main",
-* });
-* // data -> WorkerExecution
-* ```
+* @param {FetchWorkerExecutionProps} props - `workflowId`, `workerExecutionId`, `workspace`,
+*   `select` and TanStack `queryOptions`.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 */
-var useFetchWorkerExecution = ({ workflowId, workerExecutionId, workspace, queryOptions = defaultQueryOptions }) => {
+var useFetchWorkerExecution = ({ workflowId, workerExecutionId, workspace, select, queryOptions }) => {
 	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,
+		...useEntityQuery({
+			queryKey,
+			fetchEntity: (signal) => getWorkerExecution(api, workflowId, workerExecutionId, workspace, signal),
+			select,
+			enabled: Boolean(workflowId) && Boolean(workerExecutionId),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchWorkerExecution"),
+			queryOptions
+		}),
 		queryKey
 	};
 };

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkerExecution.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkerExecution.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { missingWorkspaceError } from \"@/api/entityQuery\";\nimport { getWorkerExecution } from \"@/api/workflow\";\nimport type { WorkerExecution } from \"@/types/workflow\";\nimport type { FetchEntityProps } from \"@/types/entityQuery\";\n\nexport type FetchWorkerExecutionProps<\n    TData = WorkerExecution,\n    TSelected = TData,\n> = FetchEntityProps<TData, TSelected> & {\n    workflowId: string;\n    workerExecutionId: string;\n    workspace: string;\n};\n\n/**\n * useFetchWorkerExecution\n *\n * Fetches one worker execution; `data` is the execution, or whatever `select` makes of it. Idle\n * while an id is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.\n *\n * @param {FetchWorkerExecutionProps} props - `workflowId`, `workerExecutionId`, `workspace`,\n *   `select` and TanStack `queryOptions`.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n */\nexport const useFetchWorkerExecution = <TSelected = WorkerExecution>({\n    workflowId,\n    workerExecutionId,\n    workspace,\n    select,\n    queryOptions,\n}: FetchWorkerExecutionProps<WorkerExecution, TSelected>) => {\n    const { api } = useAxios();\n\n    const queryKey = [\"worker_execution\", workflowId, workerExecutionId, workspace];\n\n    const query = useEntityQuery<WorkerExecution, TSelected>({\n        queryKey,\n        fetchEntity: (signal) =>\n            getWorkerExecution(api, workflowId, workerExecutionId, workspace, signal),\n        select,\n        enabled: Boolean(workflowId) && Boolean(workerExecutionId),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchWorkerExecution\"),\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;;;;;;;;;;;;AA0BA,IAAa,2BAAwD,EACjE,YACA,mBACA,WACA,QACA,mBACyD;CACzD,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW;EAAC;EAAoB;EAAY;EAAmB;CAAS;CAY9E,OAAO;EAAE,GAVK,eAA2C;GACrD;GACA,cAAc,WACV,mBAAmB,KAAK,YAAY,mBAAmB,WAAW,MAAM;GAC5E;GACA,SAAS,QAAQ,UAAU,KAAK,QAAQ,iBAAiB;GACzD,aAAa,YAAY,KAAA,IAAY,sBAAsB,yBAAyB;GACpF;EACJ,CAEY;EAAO;CAAS;AAChC"}