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

package/dist/hooks/portfolio/usePortfolioMutations.js

@@ -1,9 +1,7 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityMutation } from "../useEntityMutation.js";
 import { createPortfolio, deletePortfolio, updatePortfolio } from "../../api/portfolio.js";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
 //#region src/hooks/portfolio/usePortfolioMutations.ts
-var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? err.message : fallback;
 /**
 * usePortfolioMutations
 *
@@ -38,26 +36,26 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 *   - mutationFn: `createPortfolio(api, data)`
 *   - variables: `{ data: Partial<Portfolio> }`
 *   - success message: "Portfolio created successfully."
-*   - error message: "We couldn't create the portfolio. Please review your inputs and try again." (fallback)
+*   - error message: "Unable to create the portfolio. Please try again." (fallback)
 *
 * - `update`:
 *   - mutationFn: `updatePortfolio(api, id, data)`
 *   - variables: `{ id: string; data: Partial<Portfolio> }`
 *   - success message: "Portfolio updated successfully."
-*   - error message: "We couldn't update the portfolio. Please try again." (fallback)
+*   - error message: "Unable to update the portfolio. Please try again." (fallback)
 *
 * - `remove`:
 *   - mutationFn: `deletePortfolio(api, id, workspace)`
 *   - variables: `{ id: string; workspace: string }`
 *   - success message: "Portfolio deleted successfully."
-*   - error message: "We couldn't delete the portfolio. Please try again." (fallback)
+*   - error message: "Unable to delete the portfolio. Please try again." (fallback)
 *
 * Return value:
 * @returns {object}
 *  Returns an object with the three TanStack Query mutation results:
 *  - `create`: UseMutationResult<Portfolio, Error, CreatePortfolioProps, unknown>
 *  - `update`: UseMutationResult<Portfolio, Error, UpdatePortfolioProps, unknown>
-*  - `remove`: UseMutationResult<Portfolio, Error, DeletePortfolioProps, unknown>
+*  - `remove`: UseMutationResult<DeletedEntity, Error, DeletePortfolioProps, unknown>
 *
 * Each mutation includes standard TanStack Query helpers:
 * - `mutate(variables, options?)`
@@ -155,60 +153,24 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 */
 var usePortfolioMutations = ({ queryKey }) => {
 	const { api } = useAxios();
-	const { showAlert } = useAppAlert();
-	const queryClient = useQueryClient();
-	const invalidate = async () => {
-		if (!queryKey?.length) return;
-		await queryClient.invalidateQueries({ queryKey });
-	};
 	return {
-		create: useMutation({
-			mutationFn: async ({ data }) => createPortfolio(api, data),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "Portfolio created successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "We couldn't create the portfolio. Please review your inputs and try again.")
-				});
-			}
+		create: useEntityMutation({
+			mutationFn: ({ data }) => createPortfolio(api, data),
+			queryKey,
+			successMessage: "Portfolio created successfully.",
+			errorMessage: "Unable to create the portfolio. Please try again."
 		}),
-		update: useMutation({
-			mutationFn: async ({ id, data }) => updatePortfolio(api, id, data),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "Portfolio updated successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "We couldn't update the portfolio. Please try again.")
-				});
-			}
+		update: useEntityMutation({
+			mutationFn: ({ id, data }) => updatePortfolio(api, id, data),
+			queryKey,
+			successMessage: "Portfolio updated successfully.",
+			errorMessage: "Unable to update the portfolio. Please try again."
 		}),
-		remove: useMutation({
-			mutationFn: async ({ id, workspace }) => deletePortfolio(api, id, workspace),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "Portfolio deleted successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "We couldn't delete the portfolio. Please try again.")
-				});
-			}
+		remove: useEntityMutation({
+			mutationFn: ({ id, workspace }) => deletePortfolio(api, id, workspace),
+			queryKey,
+			successMessage: "Portfolio deleted successfully.",
+			errorMessage: "Unable to delete the portfolio. Please try again."
 		})
 	};
 };

package/dist/hooks/portfolio/usePortfolioMutations.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePortfolioMutations.js","names":[],"sources":["../../../src/hooks/portfolio/usePortfolioMutations.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport type { Portfolio } from \"@/types/portfolio\";\nimport { deletePortfolio, createPortfolio, updatePortfolio } from \"@/api/portfolio\";\n\ntype CreatePortfolioProps = {\n    data: Partial<Portfolio>;\n};\n\ntype UpdatePortfolioProps = {\n    id: string;\n    data: Partial<Portfolio>;\n};\n\ntype DeletePortfolioProps = {\n    id: string;\n    workspace: string;\n};\n\ntype UsePortfolioMutationsProps = {\n    queryKey?: unknown[];\n};\n\nconst getErrorMessage = (err: unknown, fallback: string) =>\n    err instanceof Error && err.message ? err.message : fallback;\n\n/**\n * usePortfolioMutations\n *\n * Mutation hook built on TanStack Query to perform Portfolio write operations:\n * - create a portfolio (POST)\n * - update a portfolio (PUT)\n * - delete a portfolio (DELETE)\n *\n * It also:\n * - optionally invalidates a target query cache key after successful mutations\n * - displays success/error alerts via `useAppAlert`\n *\n * Important notes:\n * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchPortfolio`.\n * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run\n *   mutations and show alerts, but it will NOT invalidate any cached queries.\n * - `remove` requires a `workspace` parameter because the underlying API helper `deletePortfolio(api, id, workspace)`\n *   expects it as a query param.\n *\n * Parameters (UsePortfolioMutationsProps):\n * @param {unknown[]} [queryKey]\n *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`\n *  (e.g., portfolio list/detail) so UI data is refreshed automatically after a write.\n *\n *  Tip:\n *  - If you're using `useFetchPortfolio`, you can pass its returned `queryKey` directly:\n *    `const fetch = useFetchPortfolio(...);`\n *    `usePortfolioMutations({ queryKey: fetch.queryKey });`\n *\n * Mutations:\n * - `create`:\n *   - mutationFn: `createPortfolio(api, data)`\n *   - variables: `{ data: Partial<Portfolio> }`\n *   - success message: \"Portfolio created successfully.\"\n *   - error message: \"We couldn't create the portfolio. Please review your inputs and try again.\" (fallback)\n *\n * - `update`:\n *   - mutationFn: `updatePortfolio(api, id, data)`\n *   - variables: `{ id: string; data: Partial<Portfolio> }`\n *   - success message: \"Portfolio updated successfully.\"\n *   - error message: \"We couldn't update the portfolio. Please try again.\" (fallback)\n *\n * - `remove`:\n *   - mutationFn: `deletePortfolio(api, id, workspace)`\n *   - variables: `{ id: string; workspace: string }`\n *   - success message: \"Portfolio deleted successfully.\"\n *   - error message: \"We couldn't delete the portfolio. Please try again.\" (fallback)\n *\n * Return value:\n * @returns {object}\n *  Returns an object with the three TanStack Query mutation results:\n *  - `create`: UseMutationResult<Portfolio, Error, CreatePortfolioProps, unknown>\n *  - `update`: UseMutationResult<Portfolio, Error, UpdatePortfolioProps, unknown>\n *  - `remove`: UseMutationResult<Portfolio, Error, DeletePortfolioProps, unknown>\n *\n * Each mutation includes standard TanStack Query helpers:\n * - `mutate(variables, options?)`\n * - `mutateAsync(variables, options?)`\n * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.\n *\n * Examples:\n *\n * 1) Invalidate a portfolio list query after mutations:\n * ```ts\n * const { create, update, remove } = usePortfolioMutations({ queryKey: [\"portfolio\"] });\n *\n  * // Create (minimal example - other Security fields omitted for brevity)\n * create.mutate({\n *   data: {\n *     name: \"My Portfolio\",\n *     description: \"Test portfolio\",\n *     base_currency: \"USD\",\n *     date: \"2026-01-08\",\n *     workspace: \"ws-1\",\n *     securities: [\n *       {\n *         id: \"sec-1\",\n *         ticker: \"AAPL\",\n *         symbol: \"AAPL\",\n *         name: \"Apple Inc.\",\n *         currency: \"USD\",\n *         quantity: 10,\n *         market_price: 200,\n *         market_value: 2000,\n *         market_value_in_base: 2000,\n *         fx_rate: 1,\n *         instrument_type: \"Equity\",\n *         instrument_class: \"Equity\",\n *         asset_class: \"Equity\",\n *         exchange: \"NASDAQ\",\n *         status: \"active\",\n *         // Other fields are nullable in the Security type and can be omitted here for documentation purposes.\n *       } as Security,\n *     ],\n *   }\n * });\n *\n * // Update (partial)\n * update.mutate({\n *   id: \"pf-123\",\n *   data: {\n *     name: \"Renamed Portfolio\",\n *     tags: [\"tag-1\", \"tag-2\"],\n *     check_securities: true,\n *   }\n * });\n *\n * // Delete\n * remove.mutate({ id: \"pf-123\", workspace: \"ws-1\" });\n * ```\n *\n * 2) Using async/await with `mutateAsync`:\n * ```ts\n * const { create } = usePortfolioMutations({ queryKey: [\"portfolio\"] });\n *\n * await create.mutateAsync({\n *   data: {\n *     name: \"My Portfolio\",\n *     base_currency: \"USD\",\n *     date: \"2026-01-08\",\n *     workspace: \"ws-1\",\n *     securities: [],\n *   }\n * });\n * ```\n *\n * 3) Without cache invalidation (no queryKey):\n * ```ts\n * const { update } = usePortfolioMutations({});\n *\n * update.mutate({\n *   id: \"pf-123\",\n *   data: { description: \"Updated description\" }\n * });\n * // Mutation still runs and alerts are shown, but cached queries are not invalidated.\n * ```\n *\n * 4) Using `useFetchPortfolio` queryKey for automatic invalidation:\n * ```ts\n * const fetch = useFetchPortfolio({\n *   id: null,\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n * });\n *\n * const { remove } = usePortfolioMutations({ queryKey: fetch.queryKey });\n *\n * await remove.mutateAsync({ id: \"pf-123\", workspace: \"ws-1\" });\n * ```\n */\n\nexport const usePortfolioMutations = ({ queryKey }: UsePortfolioMutationsProps) => {\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n    const queryClient = useQueryClient();\n\n    const invalidate = async () => {\n        if (!queryKey?.length) return;\n        await queryClient.invalidateQueries({ queryKey });\n    };\n\n    const create = useMutation({\n        mutationFn: async ({ data }: CreatePortfolioProps) => createPortfolio(api, data),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"Portfolio created successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(\n                    err,\n                    \"We couldn't create the portfolio. Please review your inputs and try again.\"\n                ),\n            });\n        },\n    });\n\n    const update = useMutation({\n        mutationFn: async ({ id, data }: UpdatePortfolioProps) => updatePortfolio(api, id, data),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"Portfolio updated successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(\n                    err,\n                    \"We couldn't update the portfolio. Please try again.\"\n                ),\n            });\n        },\n    });\n\n    const remove = useMutation({\n        mutationFn: async ({ id, workspace }: DeletePortfolioProps) => deletePortfolio(api, id, workspace),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"Portfolio deleted successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(\n                    err,\n                    \"We couldn't delete the portfolio. Please try again.\"\n                ),\n            });\n        },\n    });\n\n    return { create, update, remove };\n};\n"],"mappings":";;;;;AAyBA,IAAM,mBAAmB,KAAc,aACnC,eAAe,SAAS,IAAI,UAAU,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwJxD,IAAa,yBAAyB,EAAE,eAA2C;CAC/E,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAClC,MAAM,cAAc,eAAe;CAEnC,MAAM,aAAa,YAAY;EAC3B,IAAI,CAAC,UAAU,QAAQ;EACvB,MAAM,YAAY,kBAAkB,EAAE,SAAS,CAAC;CACpD;CA8DA,OAAO;EAAE,QA5DM,YAAY;GACvB,YAAY,OAAO,EAAE,WAAiC,gBAAgB,KAAK,IAAI;GAC/E,WAAW,YAAY;IACnB,MAAM,WAAW;IACjB,UAAU;KACN,UAAU;KACV,SAAS;IACb,CAAC;GACL;GACA,UAAU,QAAiB;IACvB,UAAU;KACN,UAAU;KACV,SAAS,gBACL,KACA,4EACJ;IACJ,CAAC;GACL;EACJ,CA0CS;EAAQ,QAxCF,YAAY;GACvB,YAAY,OAAO,EAAE,IAAI,WAAiC,gBAAgB,KAAK,IAAI,IAAI;GACvF,WAAW,YAAY;IACnB,MAAM,WAAW;IACjB,UAAU;KACN,UAAU;KACV,SAAS;IACb,CAAC;GACL;GACA,UAAU,QAAiB;IACvB,UAAU;KACN,UAAU;KACV,SAAS,gBACL,KACA,qDACJ;IACJ,CAAC;GACL;EACJ,CAsBiB;EAAQ,QApBV,YAAY;GACvB,YAAY,OAAO,EAAE,IAAI,gBAAsC,gBAAgB,KAAK,IAAI,SAAS;GACjG,WAAW,YAAY;IACnB,MAAM,WAAW;IACjB,UAAU;KACN,UAAU;KACV,SAAS;IACb,CAAC;GACL;GACA,UAAU,QAAiB;IACvB,UAAU;KACN,UAAU;KACV,SAAS,gBACL,KACA,qDACJ;IACJ,CAAC;GACL;EACJ,CAEyB;CAAO;AACpC"}
+{"version":3,"file":"usePortfolioMutations.js","names":[],"sources":["../../../src/hooks/portfolio/usePortfolioMutations.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityMutation } from \"@/hooks/useEntityMutation\";\nimport type { Portfolio } from \"@/types/portfolio\";\nimport { deletePortfolio, createPortfolio, updatePortfolio } from \"@/api/portfolio\";\n\ntype CreatePortfolioProps = {\n    data: Partial<Portfolio>;\n};\n\ntype UpdatePortfolioProps = {\n    id: string;\n    data: Partial<Portfolio>;\n};\n\ntype DeletePortfolioProps = {\n    id: string;\n    workspace: string;\n};\n\ntype UsePortfolioMutationsProps = {\n    queryKey?: unknown[];\n};\n\n/**\n * usePortfolioMutations\n *\n * Mutation hook built on TanStack Query to perform Portfolio write operations:\n * - create a portfolio (POST)\n * - update a portfolio (PUT)\n * - delete a portfolio (DELETE)\n *\n * It also:\n * - optionally invalidates a target query cache key after successful mutations\n * - displays success/error alerts via `useAppAlert`\n *\n * Important notes:\n * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchPortfolio`.\n * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run\n *   mutations and show alerts, but it will NOT invalidate any cached queries.\n * - `remove` requires a `workspace` parameter because the underlying API helper `deletePortfolio(api, id, workspace)`\n *   expects it as a query param.\n *\n * Parameters (UsePortfolioMutationsProps):\n * @param {unknown[]} [queryKey]\n *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`\n *  (e.g., portfolio list/detail) so UI data is refreshed automatically after a write.\n *\n *  Tip:\n *  - If you're using `useFetchPortfolio`, you can pass its returned `queryKey` directly:\n *    `const fetch = useFetchPortfolio(...);`\n *    `usePortfolioMutations({ queryKey: fetch.queryKey });`\n *\n * Mutations:\n * - `create`:\n *   - mutationFn: `createPortfolio(api, data)`\n *   - variables: `{ data: Partial<Portfolio> }`\n *   - success message: \"Portfolio created successfully.\"\n *   - error message: \"Unable to create the portfolio. Please try again.\" (fallback)\n *\n * - `update`:\n *   - mutationFn: `updatePortfolio(api, id, data)`\n *   - variables: `{ id: string; data: Partial<Portfolio> }`\n *   - success message: \"Portfolio updated successfully.\"\n *   - error message: \"Unable to update the portfolio. Please try again.\" (fallback)\n *\n * - `remove`:\n *   - mutationFn: `deletePortfolio(api, id, workspace)`\n *   - variables: `{ id: string; workspace: string }`\n *   - success message: \"Portfolio deleted successfully.\"\n *   - error message: \"Unable to delete the portfolio. Please try again.\" (fallback)\n *\n * Return value:\n * @returns {object}\n *  Returns an object with the three TanStack Query mutation results:\n *  - `create`: UseMutationResult<Portfolio, Error, CreatePortfolioProps, unknown>\n *  - `update`: UseMutationResult<Portfolio, Error, UpdatePortfolioProps, unknown>\n *  - `remove`: UseMutationResult<DeletedEntity, Error, DeletePortfolioProps, unknown>\n *\n * Each mutation includes standard TanStack Query helpers:\n * - `mutate(variables, options?)`\n * - `mutateAsync(variables, options?)`\n * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.\n *\n * Examples:\n *\n * 1) Invalidate a portfolio list query after mutations:\n * ```ts\n * const { create, update, remove } = usePortfolioMutations({ queryKey: [\"portfolio\"] });\n *\n * // Create (minimal example - other Security fields omitted for brevity)\n * create.mutate({\n *   data: {\n *     name: \"My Portfolio\",\n *     description: \"Test portfolio\",\n *     base_currency: \"USD\",\n *     date: \"2026-01-08\",\n *     workspace: \"ws-1\",\n *     securities: [\n *       {\n *         id: \"sec-1\",\n *         ticker: \"AAPL\",\n *         symbol: \"AAPL\",\n *         name: \"Apple Inc.\",\n *         currency: \"USD\",\n *         quantity: 10,\n *         market_price: 200,\n *         market_value: 2000,\n *         market_value_in_base: 2000,\n *         fx_rate: 1,\n *         instrument_type: \"Equity\",\n *         instrument_class: \"Equity\",\n *         asset_class: \"Equity\",\n *         exchange: \"NASDAQ\",\n *         status: \"active\",\n *         // Other fields are nullable in the Security type and can be omitted here for documentation purposes.\n *       } as Security,\n *     ],\n *   }\n * });\n *\n * // Update (partial)\n * update.mutate({\n *   id: \"pf-123\",\n *   data: {\n *     name: \"Renamed Portfolio\",\n *     tags: [\"tag-1\", \"tag-2\"],\n *     check_securities: true,\n *   }\n * });\n *\n * // Delete\n * remove.mutate({ id: \"pf-123\", workspace: \"ws-1\" });\n * ```\n *\n * 2) Using async/await with `mutateAsync`:\n * ```ts\n * const { create } = usePortfolioMutations({ queryKey: [\"portfolio\"] });\n *\n * await create.mutateAsync({\n *   data: {\n *     name: \"My Portfolio\",\n *     base_currency: \"USD\",\n *     date: \"2026-01-08\",\n *     workspace: \"ws-1\",\n *     securities: [],\n *   }\n * });\n * ```\n *\n * 3) Without cache invalidation (no queryKey):\n * ```ts\n * const { update } = usePortfolioMutations({});\n *\n * update.mutate({\n *   id: \"pf-123\",\n *   data: { description: \"Updated description\" }\n * });\n * // Mutation still runs and alerts are shown, but cached queries are not invalidated.\n * ```\n *\n * 4) Using `useFetchPortfolio` queryKey for automatic invalidation:\n * ```ts\n * const fetch = useFetchPortfolio({\n *   id: null,\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n * });\n *\n * const { remove } = usePortfolioMutations({ queryKey: fetch.queryKey });\n *\n * await remove.mutateAsync({ id: \"pf-123\", workspace: \"ws-1\" });\n * ```\n */\n\nexport const usePortfolioMutations = ({ queryKey }: UsePortfolioMutationsProps) => {\n    const { api } = useAxios();\n\n    const create = useEntityMutation({\n        mutationFn: ({ data }: CreatePortfolioProps) => createPortfolio(api, data),\n        queryKey,\n        successMessage: \"Portfolio created successfully.\",\n        errorMessage: \"Unable to create the portfolio. Please try again.\",\n    });\n\n    const update = useEntityMutation({\n        mutationFn: ({ id, data }: UpdatePortfolioProps) => updatePortfolio(api, id, data),\n        queryKey,\n        successMessage: \"Portfolio updated successfully.\",\n        errorMessage: \"Unable to update the portfolio. Please try again.\",\n    });\n\n    const remove = useEntityMutation({\n        mutationFn: ({ id, workspace }: DeletePortfolioProps) =>\n            deletePortfolio(api, id, workspace),\n        queryKey,\n        successMessage: \"Portfolio deleted successfully.\",\n        errorMessage: \"Unable to delete the portfolio. Please try again.\",\n    });\n\n    return { create, update, remove };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6KA,IAAa,yBAAyB,EAAE,eAA2C;CAC/E,MAAM,EAAE,QAAQ,SAAS;CAwBzB,OAAO;EAAE,QAtBM,kBAAkB;GAC7B,aAAa,EAAE,WAAiC,gBAAgB,KAAK,IAAI;GACzE;GACA,gBAAgB;GAChB,cAAc;EAClB,CAiBS;EAAQ,QAfF,kBAAkB;GAC7B,aAAa,EAAE,IAAI,WAAiC,gBAAgB,KAAK,IAAI,IAAI;GACjF;GACA,gBAAgB;GAChB,cAAc;EAClB,CAUiB;EAAQ,QARV,kBAAkB;GAC7B,aAAa,EAAE,IAAI,gBACf,gBAAgB,KAAK,IAAI,SAAS;GACtC;GACA,gBAAgB;GAChB,cAAc;EAClB,CAEyB;CAAO;AACpC"}

package/dist/hooks/profile/useFetchProfile.d.ts

@@ -1,48 +1,22 @@
 import type { Profile } from "../../types/profile.d.ts";
-import type { EntityQueryOptions } from "../../types/entityQuery.d.ts";
-export type FetchProfileProps<TData = Profile, TSelected = TData> = {
-    queryOptions?: EntityQueryOptions<TData, TSelected>;
-    /**
-     * Served instead of calling the API. Pass `DEV_PROFILE` while running the dev server,
-     * where `/api/profile` has no session to resolve.
-     */
+import type { FetchEntityProps } from "../../types/entityQuery.d.ts";
+export type FetchProfileProps<TData = Profile, TSelected = TData> = FetchEntityProps<TData, TSelected> & {
     fallback?: Profile;
 };
 /**
  * useFetchProfile
  *
- * Data-fetching hook built on TanStack Query to retrieve the profile of the logged user. It takes
- * no identifier: the API resolves the user from the session.
+ * Fetches the logged user's profile, once per session; `data` is the profile, or whatever
+ * `select` makes of it. `fallback` is what `getProfile` returns when the platform has none to
+ * give — see `getProfile` for why it is a parameter. A failure is shown as an error alert.
  *
- * It also:
- * - builds a stable React Query `queryKey`, shared by every consumer, so the profile is fetched
- *   once per session and read from cache afterwards
- * - triggers an error alert via `useAppAlert` whenever `query.error` is present
- *
- * Parameters (FetchProfileProps):
- * @param queryOptions
- *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
- *   Defaults keep the profile cached for the whole session.
- * @param fallback
- *   Served instead of calling the API. `/api/profile` only resolves in production, so an app
- *   running the dev server passes `DEV_PROFILE` here:
- *   `useFetchProfile({ fallback: import.meta.env.DEV ? DEV_PROFILE : undefined })`.
- *   The SDK cannot make that choice itself — see `getProfile`.
- *
- * Returns:
- * @returns {object}
- *   TanStack Query's `query` object extended with:
- *   - `queryKey`: the cache key used by React Query
- *
- * Example:
- * ```ts
- * const { data, isPending } = useFetchProfile();
- * // data -> Profile
- * ```
+ * @param {FetchProfileProps} [props] - `fallback`, `select` and TanStack `queryOptions`, merged
+ *   over the fetched-once defaults.
+ * @returns {object} The `useQuery` result, plus `queryKey`.
  */
-export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfileProps) => {
+export declare const useFetchProfile: <TSelected = Profile>({ fallback, select, queryOptions, }?: FetchProfileProps<Profile, TSelected>) => {
     queryKey: string[];
-    data: Profile;
+    data: TSelected;
     error: Error;
     isError: true;
     isPending: false;
@@ -65,11 +39,11 @@ export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfil
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Profile, 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: Profile;
+    data: TSelected;
     error: null;
     isError: false;
     isPending: false;
@@ -92,7 +66,7 @@ export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfil
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Profile, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -119,7 +93,7 @@ export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfil
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Profile, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -146,7 +120,7 @@ export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfil
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Profile, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -173,11 +147,11 @@ export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfil
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Profile, 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: Profile;
+    data: TSelected;
     isError: false;
     error: null;
     isPending: false;
@@ -200,7 +174,7 @@ export declare const useFetchProfile: ({ queryOptions, fallback, }?: FetchProfil
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Profile, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 };
 //# sourceMappingURL=useFetchProfile.d.ts.map

package/dist/hooks/profile/useFetchProfile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchProfile.d.ts","sourceRoot":"","sources":["../../../src/hooks/profile/useFetchProfile.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,OAAO,EAAE,SAAS,GAAG,KAAK,IAAI;IAChE,YAAY,CAAC,EAAE,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,eAAe,GAAI,8BAG7B,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxB,CAAC"}
+{"version":3,"file":"useFetchProfile.d.ts","sourceRoot":"","sources":["../../../src/hooks/profile/useFetchProfile.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAsB,MAAM,qBAAqB,CAAC;AAEhF,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,OAAO,EAAE,SAAS,GAAG,KAAK,IAAI,gBAAgB,CAChF,KAAK,EACL,SAAS,CACZ,GAAG;IACA,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAWF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,GAAG,OAAO,EAAE,sCAIlD,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5C,CAAC"}

package/dist/hooks/profile/useFetchProfile.js

@@ -1,10 +1,8 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityQuery } from "../useEntityQuery.js";
 import { getProfile } from "../../api/profile.js";
-import { useEffect } from "react";
-import { useQuery } from "@tanstack/react-query";
 //#region src/hooks/profile/useFetchProfile.ts
-var defaultQueryOptions = {
+var profileQueryOptions = {
 	staleTime: Infinity,
 	refetchOnMount: false,
 	refetchOnWindowFocus: false
@@ -12,55 +10,25 @@ var defaultQueryOptions = {
 /**
 * useFetchProfile
 *
-* Data-fetching hook built on TanStack Query to retrieve the profile of the logged user. It takes
-* no identifier: the API resolves the user from the session.
+* Fetches the logged user's profile, once per session; `data` is the profile, or whatever
+* `select` makes of it. `fallback` is what `getProfile` returns when the platform has none to
+* give — see `getProfile` for why it is a parameter. A failure is shown as an error alert.
 *
-* It also:
-* - builds a stable React Query `queryKey`, shared by every consumer, so the profile is fetched
-*   once per session and read from cache afterwards
-* - triggers an error alert via `useAppAlert` whenever `query.error` is present
-*
-* Parameters (FetchProfileProps):
-* @param queryOptions
-*   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
-*   Defaults keep the profile cached for the whole session.
-* @param fallback
-*   Served instead of calling the API. `/api/profile` only resolves in production, so an app
-*   running the dev server passes `DEV_PROFILE` here:
-*   `useFetchProfile({ fallback: import.meta.env.DEV ? DEV_PROFILE : undefined })`.
-*   The SDK cannot make that choice itself — see `getProfile`.
-*
-* Returns:
-* @returns {object}
-*   TanStack Query's `query` object extended with:
-*   - `queryKey`: the cache key used by React Query
-*
-* Example:
-* ```ts
-* const { data, isPending } = useFetchProfile();
-* // data -> Profile
-* ```
+* @param {FetchProfileProps} [props] - `fallback`, `select` and TanStack `queryOptions`, merged
+*   over the fetched-once defaults.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 */
-var useFetchProfile = ({ queryOptions = defaultQueryOptions, fallback } = {}) => {
+var useFetchProfile = ({ fallback, select, queryOptions } = {}) => {
 	const { api } = useAxios();
-	const { showAlert } = useAppAlert();
 	const queryKey = ["profile"];
-	const query = useQuery({
-		queryKey,
-		queryFn: async () => {
-			return await getProfile(api, fallback);
-		},
-		...queryOptions ?? {}
-	});
-	useEffect(() => {
-		if (!query.error) return;
-		showAlert({
-			severity: "error",
-			message: query.error.message
-		});
-	}, [query.error, showAlert]);
 	return {
-		...query,
+		...useEntityQuery({
+			queryKey,
+			fetchEntity: (signal) => getProfile(api, fallback, signal),
+			select,
+			defaultQueryOptions: profileQueryOptions,
+			queryOptions
+		}),
 		queryKey
 	};
 };

package/dist/hooks/profile/useFetchProfile.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchProfile.js","names":[],"sources":["../../../src/hooks/profile/useFetchProfile.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 type { Profile } from \"@/types/profile\";\nimport { getProfile } from \"@/api/profile\";\nimport type { EntityQueryOptions } from \"@/types/entityQuery\";\n\nexport type FetchProfileProps<TData = Profile, TSelected = TData> = {\n    queryOptions?: EntityQueryOptions<TData, TSelected>;\n    /**\n     * Served instead of calling the API. Pass `DEV_PROFILE` while running the dev server,\n     * where `/api/profile` has no session to resolve.\n     */\n    fallback?: Profile;\n};\n\n// The logged user's profile does not change during a session, so it is fetched once and kept —\n// unlike the entity hooks (staleTime/gcTime 0, refetch on every mount), which read data the\n// platform keeps changing.\nconst defaultQueryOptions: EntityQueryOptions<Profile> = {\n    staleTime: Infinity,\n    refetchOnMount: false,\n    refetchOnWindowFocus: false,\n};\n\n/**\n * useFetchProfile\n *\n * Data-fetching hook built on TanStack Query to retrieve the profile of the logged user. It takes\n * no identifier: the API resolves the user from the session.\n *\n * It also:\n * - builds a stable React Query `queryKey`, shared by every consumer, so the profile is fetched\n *   once per session and read from cache afterwards\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * Parameters (FetchProfileProps):\n * @param queryOptions\n *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *   Defaults keep the profile cached for the whole session.\n * @param fallback\n *   Served instead of calling the API. `/api/profile` only resolves in production, so an app\n *   running the dev server passes `DEV_PROFILE` here:\n *   `useFetchProfile({ fallback: import.meta.env.DEV ? DEV_PROFILE : undefined })`.\n *   The SDK cannot make that choice itself — see `getProfile`.\n *\n * Returns:\n * @returns {object}\n *   TanStack Query's `query` object extended with:\n *   - `queryKey`: the cache key used by React Query\n *\n * Example:\n * ```ts\n * const { data, isPending } = useFetchProfile();\n * // data -> Profile\n * ```\n */\nexport const useFetchProfile = ({\n    queryOptions = defaultQueryOptions,\n    fallback,\n}: FetchProfileProps = {}) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"profile\"];\n\n    const query = useQuery<Profile>({\n        queryKey,\n        queryFn: async () => {\n            const profile = await getProfile(api, fallback);\n            return profile;\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":";;;;;;AAsBA,IAAM,sBAAmD;CACrD,WAAW;CACX,gBAAgB;CAChB,sBAAsB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAmB,EAC5B,eAAe,qBACf,aACmB,CAAC,MAAM;CAE1B,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW,CAAC,SAAS;CAE3B,MAAM,QAAQ,SAAkB;EAC5B;EACA,SAAS,YAAY;GAEjB,OAAO,MADe,WAAW,KAAK,QAAQ;EAElD;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":"useFetchProfile.js","names":[],"sources":["../../../src/hooks/profile/useFetchProfile.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { getProfile } from \"@/api/profile\";\nimport type { Profile } from \"@/types/profile\";\nimport type { FetchEntityProps, EntityQueryOptions } from \"@/types/entityQuery\";\n\nexport type FetchProfileProps<TData = Profile, TSelected = TData> = FetchEntityProps<\n    TData,\n    TSelected\n> & {\n    fallback?: Profile;\n};\n\n// The logged user's profile does not change during a session, so it is fetched once and kept —\n// unlike the entity hooks (staleTime/gcTime 0, refetch on every mount), which read data the\n// platform keeps changing.\nconst profileQueryOptions: EntityQueryOptions<Profile> = {\n    staleTime: Infinity,\n    refetchOnMount: false,\n    refetchOnWindowFocus: false,\n};\n\n/**\n * useFetchProfile\n *\n * Fetches the logged user's profile, once per session; `data` is the profile, or whatever\n * `select` makes of it. `fallback` is what `getProfile` returns when the platform has none to\n * give — see `getProfile` for why it is a parameter. A failure is shown as an error alert.\n *\n * @param {FetchProfileProps} [props] - `fallback`, `select` and TanStack `queryOptions`, merged\n *   over the fetched-once defaults.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n */\nexport const useFetchProfile = <TSelected = Profile>({\n    fallback,\n    select,\n    queryOptions,\n}: FetchProfileProps<Profile, TSelected> = {}) => {\n    const { api } = useAxios();\n\n    const queryKey = [\"profile\"];\n\n    const query = useEntityQuery<Profile, TSelected>({\n        queryKey,\n        fetchEntity: (signal) => getProfile(api, fallback, signal),\n        select,\n        defaultQueryOptions: profileQueryOptions as EntityQueryOptions<Profile, TSelected>,\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;AAgBA,IAAM,sBAAmD;CACrD,WAAW;CACX,gBAAgB;CAChB,sBAAsB;AAC1B;;;;;;;;;;;;AAaA,IAAa,mBAAwC,EACjD,UACA,QACA,iBACuC,CAAC,MAAM;CAC9C,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW,CAAC,SAAS;CAU3B,OAAO;EAAE,GARK,eAAmC;GAC7C;GACA,cAAc,WAAW,WAAW,KAAK,UAAU,MAAM;GACzD;GACA,qBAAqB;GACrB;EACJ,CAEY;EAAO;CAAS;AAChC"}

package/dist/hooks/useAxios.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAxios.js","names":[],"sources":["../../src/hooks/useAxios.ts"],"sourcesContent":["import { useEffect, useMemo, useRef } from \"react\";\n\nimport axios, { type AxiosInstance, type InternalAxiosRequestConfig } from \"axios\";\n\nimport type { AnyRecord } from \"@/types/anyRecord\";\nimport type { FilterExpression } from \"@/types/entityQuery\";\nimport { useAppConfig } from \"@/contexts/appConfigContext/useAppConfig\";\n\n/**\n * useAxios\n *\n * Axios client hook that returns a memoized `AxiosInstance` configured with:\n * - `baseURL` derived from:\n *   - the optional `url` parameter, or\n *   - the relative `/api` by default. In dev, `/api` is proxied to `EVERYSK_API_URL`\n *     (see `vite/serverProxy.ts`); in production it is served behind the same host.\n *\n * Request behavior:\n * - Sets the `X-Everysk-Source` header on every request, identifying the app to the API as\n *   `everysk-user-app-<appId>` (the `appId` from `useAppConfig()`). When there is no app id (dev,\n *   where the host page hasn't injected `window.APP_ID`), it falls back to\n *   `everysk-user-app-development`.\n * - Registers a request interceptor that, for `GET` and `DELETE` requests, attempts to parse\n *   `config.params.query` (expected to be a JSON string) and extract a `workspace` filter from it.\n * - If a `workspace` value is found, it is injected into `config.params.workspace`.\n *\n * Lifecycle / cleanup:\n * - The interceptor is attached in `useEffect` and ejected on cleanup to avoid stacking interceptors\n *   across re-renders or unmount/mount cycles.\n *\n * Notes:\n * - `params.query` parsing is best-effort. Invalid JSON is ignored.\n * - This hook assumes a query structure containing `filters`, where the workspace filter is identified by\n *   `filter[0] === \"workspace\"`.\n *\n * Parameters:\n * @param {string | null} [url=null]\n *  Optional base URL override. If omitted/null, defaults to the relative `/api`.\n *\n * Return value:\n * @returns {{ api: AxiosInstance }}\n *  Returns an object containing the configured Axios instance.\n */\n\nexport const useAxios = (url: string | null = null) => {\n\n    const reqInterceptorId = useRef<number | null>(null);\n    const { appId } = useAppConfig();\n\n    const source = appId ? `everysk-user-app-${appId}` : \"everysk-user-app-development\";\n\n    const api: AxiosInstance = useMemo(() => {\n        const instance = axios.create({ baseURL: url ?? \"/api\" });\n        instance.defaults.headers.common[\"X-Everysk-Source\"] = source;\n        return instance;\n    }, [url, source]);\n\n    useEffect(() => {\n        reqInterceptorId.current = api.interceptors.request.use(\n            (config: InternalAxiosRequestConfig<AnyRecord>) => {\n                const method = (config.method ?? \"\").toLowerCase();\n\n                if (method === \"get\" || method === \"delete\") {\n                    const params = (config.params ?? {}) as Record<string, unknown>;\n\n                    try {\n                        const rawQuery = params.query;\n                        const queryObj = typeof rawQuery === \"string\" ? JSON.parse(rawQuery) : null;\n\n                        const workspaceFilter = queryObj?.filters?.find(\n                            (filter: FilterExpression) => filter?.[0] === \"workspace\"\n                        );\n\n                        const workspace =\n                            Array.isArray(workspaceFilter) ? workspaceFilter[workspaceFilter.length - 1] : null;\n\n                        if (workspace) {\n                            config.params = { ...params, workspace };\n                        }\n                    } catch {\n                        // ignore invalid query JSON\n                    }\n                }\n\n                return config;\n            }\n        );\n\n        return () => {\n            if (reqInterceptorId.current != null) {\n                api.interceptors.request.eject(reqInterceptorId.current);\n            }\n            reqInterceptorId.current = null;\n        };\n    }, [api]);\n\n    return { api };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,YAAY,MAAqB,SAAS;CAEnD,MAAM,mBAAmB,OAAsB,IAAI;CACnD,MAAM,EAAE,UAAU,aAAa;CAE/B,MAAM,SAAS,QAAQ,oBAAoB,UAAU;CAErD,MAAM,MAAqB,cAAc;EACrC,MAAM,WAAW,MAAM,OAAO,EAAE,SAAS,OAAO,OAAO,CAAC;EACxD,SAAS,SAAS,QAAQ,OAAO,sBAAsB;EACvD,OAAO;CACX,GAAG,CAAC,KAAK,MAAM,CAAC;CAEhB,gBAAgB;EACZ,iBAAiB,UAAU,IAAI,aAAa,QAAQ,KAC/C,WAAkD;GAC/C,MAAM,UAAU,OAAO,UAAU,GAAA,CAAI,YAAY;GAEjD,IAAI,WAAW,SAAS,WAAW,UAAU;IACzC,MAAM,SAAU,OAAO,UAAU,CAAC;IAElC,IAAI;KACA,MAAM,WAAW,OAAO;KAGxB,MAAM,mBAFW,OAAO,aAAa,WAAW,KAAK,MAAM,QAAQ,IAAI,KAAA,EAErC,SAAS,MACtC,WAA6B,SAAS,OAAO,WAClD;KAEA,MAAM,YACF,MAAM,QAAQ,eAAe,IAAI,gBAAgB,gBAAgB,SAAS,KAAK;KAEnF,IAAI,WACA,OAAO,SAAS;MAAE,GAAG;MAAQ;KAAU;IAE/C,QAAQ,CAER;GACJ;GAEA,OAAO;EACX,CACJ;EAEA,aAAa;GACT,IAAI,iBAAiB,WAAW,MAC5B,IAAI,aAAa,QAAQ,MAAM,iBAAiB,OAAO;GAE3D,iBAAiB,UAAU;EAC/B;CACJ,GAAG,CAAC,GAAG,CAAC;CAER,OAAO,EAAE,IAAI;AACjB"}
+{"version":3,"file":"useAxios.js","names":[],"sources":["../../src/hooks/useAxios.ts"],"sourcesContent":["import { useEffect, useMemo, useRef } from \"react\";\n\nimport axios, { type AxiosInstance, type InternalAxiosRequestConfig } from \"axios\";\n\nimport type { AnyRecord } from \"@/types/anyRecord\";\nimport type { FilterExpression } from \"@/types/entityQuery\";\nimport { useAppConfig } from \"@/contexts/appConfigContext/useAppConfig\";\n\n/**\n * useAxios\n *\n * Axios client hook that returns a memoized `AxiosInstance` configured with:\n * - `baseURL` derived from:\n *   - the optional `url` parameter, or\n *   - the relative `/api` by default. In dev, `/api` is proxied to `EVERYSK_API_URL`\n *     (see `vite/serverProxy.ts`); in production it is served behind the same host.\n *\n * Request behavior:\n * - Sets the `X-Everysk-Source` header on every request, identifying the app to the API as\n *   `everysk-user-app-<appId>` (the `appId` from `useAppConfig()`). When there is no app id (dev,\n *   where the host page hasn't injected `window.APP_ID`), it falls back to\n *   `everysk-user-app-development`.\n * - Registers a request interceptor that, for `GET` and `DELETE` requests, attempts to parse\n *   `config.params.query` (expected to be a JSON string) and extract a `workspace` filter from it.\n * - If a `workspace` value is found, it is injected into `config.params.workspace`.\n *\n * Lifecycle / cleanup:\n * - The interceptor is attached in `useEffect` and ejected on cleanup to avoid stacking interceptors\n *   across re-renders or unmount/mount cycles.\n *\n * Notes:\n * - `params.query` parsing is best-effort. Invalid JSON is ignored.\n * - This hook assumes a query structure containing `filters`, where the workspace filter is identified by\n *   `filter[0] === \"workspace\"`.\n *\n * Parameters:\n * @param {string | null} [url=null]\n *  Optional base URL override. If omitted/null, defaults to the relative `/api`.\n *\n * Return value:\n * @returns {{ api: AxiosInstance }}\n *  Returns an object containing the configured Axios instance.\n */\n\nexport const useAxios = (url: string | null = null) => {\n    const reqInterceptorId = useRef<number | null>(null);\n    const { appId } = useAppConfig();\n\n    const source = appId ? `everysk-user-app-${appId}` : \"everysk-user-app-development\";\n\n    const api: AxiosInstance = useMemo(() => {\n        const instance = axios.create({ baseURL: url ?? \"/api\" });\n        instance.defaults.headers.common[\"X-Everysk-Source\"] = source;\n        return instance;\n    }, [url, source]);\n\n    useEffect(() => {\n        reqInterceptorId.current = api.interceptors.request.use(\n            (config: InternalAxiosRequestConfig<AnyRecord>) => {\n                const method = (config.method ?? \"\").toLowerCase();\n\n                if (method === \"get\" || method === \"delete\") {\n                    const params = (config.params ?? {}) as Record<string, unknown>;\n\n                    try {\n                        const rawQuery = params.query;\n                        const queryObj = typeof rawQuery === \"string\" ? JSON.parse(rawQuery) : null;\n\n                        const workspaceFilter = queryObj?.filters?.find(\n                            (filter: FilterExpression) => filter?.[0] === \"workspace\",\n                        );\n\n                        const workspace = Array.isArray(workspaceFilter)\n                            ? workspaceFilter[workspaceFilter.length - 1]\n                            : null;\n\n                        if (workspace) {\n                            config.params = { ...params, workspace };\n                        }\n                    } catch {\n                        // ignore invalid query JSON\n                    }\n                }\n\n                return config;\n            },\n        );\n\n        return () => {\n            if (reqInterceptorId.current != null) {\n                api.interceptors.request.eject(reqInterceptorId.current);\n            }\n            reqInterceptorId.current = null;\n        };\n    }, [api]);\n\n    return { api };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,YAAY,MAAqB,SAAS;CACnD,MAAM,mBAAmB,OAAsB,IAAI;CACnD,MAAM,EAAE,UAAU,aAAa;CAE/B,MAAM,SAAS,QAAQ,oBAAoB,UAAU;CAErD,MAAM,MAAqB,cAAc;EACrC,MAAM,WAAW,MAAM,OAAO,EAAE,SAAS,OAAO,OAAO,CAAC;EACxD,SAAS,SAAS,QAAQ,OAAO,sBAAsB;EACvD,OAAO;CACX,GAAG,CAAC,KAAK,MAAM,CAAC;CAEhB,gBAAgB;EACZ,iBAAiB,UAAU,IAAI,aAAa,QAAQ,KAC/C,WAAkD;GAC/C,MAAM,UAAU,OAAO,UAAU,GAAA,CAAI,YAAY;GAEjD,IAAI,WAAW,SAAS,WAAW,UAAU;IACzC,MAAM,SAAU,OAAO,UAAU,CAAC;IAElC,IAAI;KACA,MAAM,WAAW,OAAO;KAGxB,MAAM,mBAFW,OAAO,aAAa,WAAW,KAAK,MAAM,QAAQ,IAAI,KAAA,EAErC,SAAS,MACtC,WAA6B,SAAS,OAAO,WAClD;KAEA,MAAM,YAAY,MAAM,QAAQ,eAAe,IACzC,gBAAgB,gBAAgB,SAAS,KACzC;KAEN,IAAI,WACA,OAAO,SAAS;MAAE,GAAG;MAAQ;KAAU;IAE/C,QAAQ,CAER;GACJ;GAEA,OAAO;EACX,CACJ;EAEA,aAAa;GACT,IAAI,iBAAiB,WAAW,MAC5B,IAAI,aAAa,QAAQ,MAAM,iBAAiB,OAAO;GAE3D,iBAAiB,UAAU;EAC/B;CACJ,GAAG,CAAC,GAAG,CAAC;CAER,OAAO,EAAE,IAAI;AACjB"}

package/dist/hooks/useEntityInfiniteQuery.d.ts

@@ -0,0 +1,88 @@
+import { type QueryKey } from "@tanstack/react-query";
+import type { PagedResponse, EntityInfiniteQueryOptions } from "../types/entityQuery.d.ts";
+/**
+ * Ceiling on `fetchAllPages`. Reaching it fails the read instead of returning what was read so
+ * far: a cursor that never ends is a bug, and a consolidated view shown from a partial read is
+ * a wrong answer that looks right. A set legitimately this long wants a larger `pageSize`.
+ */
+export declare const FETCH_ALL_PAGES_LIMIT = 100;
+/** The element type of a page's item array. */
+export type ItemOf<TPage, K extends keyof TPage> = TPage[K] extends (infer TItem)[] ? TItem : never;
+export type EntityInfiniteQueryProps<TPage extends PagedResponse, K extends keyof TPage, TData> = {
+    /**
+     * Must describe everything that changes the response, `fetchAllPages` included, or two reads
+     * share one cache entry. Build it with `buildQueryKey(keys, filters, { order, projection,
+     * pageSize, fetchAllPages })`, and return it from your hook so callers can write to the cache.
+     */
+    queryKey: QueryKey;
+    /** Where a page keeps its items (`"datastores"`, `"files"`, …). */
+    itemsKey: K;
+    /**
+     * Requests one page; `undefined` asks for the first. `signal` aborts when no screen wants the
+     * read any more — pass it to the request (`api.get(url, { signal })`) to cancel it in flight.
+     */
+    fetchPage: (pageToken: string | undefined, signal?: AbortSignal) => Promise<TPage>;
+    select?: (items: ItemOf<TPage, K>[]) => TData;
+    fetchAllPages?: boolean;
+    /**
+     * Your hook's own precondition for something legitimately not there yet (a selection the
+     * user has not made), ANDed with the caller's `queryOptions.enabled`. Unmet, the query stays
+     * idle. For something that should always be there, use `configError`: idle hides it.
+     */
+    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 as the error, without a request or a
+     * retry, and logs it with `console.error` once per message, in every environment: a
+     * misconfigured app shows up in the browser console and in test output, not as an empty
+     * screen.
+     * 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;
+    queryOptions?: EntityInfiniteQueryOptions<TPage, TData>;
+};
+/**
+ * Fails a query with its `configError`, logging it the first time. Shared by the SDK's query
+ * hooks.
+ */
+export declare const failWithConfigError: (configError: string) => never;
+/**
+ * useEntityInfiniteQuery
+ *
+ * The list hook every SDK list hook is built on, and the one to build on for an endpoint the
+ * SDK does not cover. A hook says how to request a page and where its items are; this merges
+ * the pages, applies the caller's `select`, and owns the paging modes (`fetchAllPages`, and
+ * `fetchNextPage` for `handleRowsScrollEnd`). It replaced seven copies of the same
+ * `useInfiniteQuery` call, which is how one `select` defect had reached all seven — an app
+ * copying a list hook instead of composing this would copy the next one too.
+ *
+ * `select` is composed with the merging after the caller's options are spread, so nothing in
+ * `queryOptions` can replace it. The composed function is memoised on the caller's `select`:
+ * TanStack skips a select whose data and reference are both unchanged.
+ *
+ * @returns {UseInfiniteQueryResult} The `useInfiniteQuery` result; `data` is the merged items,
+ *   or what `select` makes of them.
+ *
+ * Example:
+ * ```ts
+ * export const useFetchReports = <TData = Report[]>({ workspace, select, fetchAllPages = false }: Props<TData>) => {
+ *   const { api } = useAxios();
+ *   const filters = [{ field: "workspace", value: workspace }];
+ *   const queryKey = buildQueryKey(["reports"], filters, { fetchAllPages });
+ *
+ *   const query = useEntityInfiniteQuery<ReportListResponse, "reports", TData>({
+ *     queryKey,
+ *     itemsKey: "reports",
+ *     fetchPage: (pageToken) => listReports(api, workspace, pageToken),
+ *     select,
+ *     fetchAllPages,
+ *     configError: hasWorkspaceFilter(filters) ? undefined : missingWorkspaceError("useFetchReports"),
+ *   });
+ *
+ *   return { query, queryKey };
+ * };
+ * ```
+ */
+export declare function useEntityInfiniteQuery<TPage extends PagedResponse, K extends keyof TPage, TData = ItemOf<TPage, K>[]>({ queryKey, itemsKey, fetchPage, select, fetchAllPages, enabled, configError, queryOptions, }: EntityInfiniteQueryProps<TPage, K, TData>): import("@tanstack/react-query").UseInfiniteQueryResult<TData, Error>;
+//# sourceMappingURL=useEntityInfiniteQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityInfiniteQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityInfiniteQuery.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,KAAK,EACR,aAAa,EACb,0BAA0B,EAG7B,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,+CAA+C;AAC/C,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC,SAAS,MAAM,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpG,MAAM,MAAM,wBAAwB,CAAC,KAAK,SAAS,aAAa,EAAE,CAAC,SAAS,MAAM,KAAK,EAAE,KAAK,IAAI;IAC9F;;;;OAIG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB,mEAAmE;IACnE,QAAQ,EAAE,CAAC,CAAC;IACZ;;;OAGG;IACH,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACnF,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC;IAC9C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,0BAA0B,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CAC3D,CAAC;AAKF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,aAAa,MAAM,KAAG,KAOzD,CAAC;AAyCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,sBAAsB,CAClC,KAAK,SAAS,aAAa,EAC3B,CAAC,SAAS,MAAM,KAAK,EACrB,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAC5B,EACE,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,MAAM,EACN,aAAqB,EACrB,OAAc,EACd,WAAW,EACX,YAAY,GACf,EAAE,wBAAwB,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,wEAgC3C"}

package/dist/hooks/useEntityInfiniteQuery.js

@@ -0,0 +1,111 @@
+import { useCallback } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/useEntityInfiniteQuery.ts
+/**
+* Ceiling on `fetchAllPages`. Reaching it fails the read instead of returning what was read so
+* far: a cursor that never ends is a bug, and a consolidated view shown from a partial read is
+* a wrong answer that looks right. A set legitimately this long wants a larger `pageSize`.
+*/
+var FETCH_ALL_PAGES_LIMIT = 100;
+/** The `configError` messages already logged, so a render loop does not flood the console. */
+var loggedConfigErrors = /* @__PURE__ */ new Set();
+/**
+* Fails a query with its `configError`, logging it the first time. Shared by the SDK's query
+* hooks.
+*/
+var failWithConfigError = (configError) => {
+	if (!loggedConfigErrors.has(configError)) {
+		loggedConfigErrors.add(configError);
+		console.error(configError);
+	}
+	throw new Error(configError);
+};
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* Reads every page into one page, so the cache holds a single entry for the whole set and a
+* refetch rereads all of it.
+*
+* Stops as soon as `signal` aborts. TanStack aborts it when the last screen reading the query
+* unmounts — only because the query function takes it — and without this check the loop would
+* go on requesting every remaining page for nobody.
+*/
+var fetchEveryPage = async (fetchPage, itemsKey, signal) => {
+	let page = await fetchPage(void 0, signal);
+	const items = [...page[itemsKey]];
+	for (let count = 1; page.next_page_token; count++) {
+		signal.throwIfAborted();
+		if (count >= 100) throw new Error(`fetchAllPages stopped after 100 pages without reaching the end. Raise pageSize, or page on demand instead.`);
+		page = await fetchPage(page.next_page_token, signal);
+		items.push(...page[itemsKey]);
+	}
+	return {
+		...page,
+		[itemsKey]: items,
+		next_page_token: null
+	};
+};
+/**
+* useEntityInfiniteQuery
+*
+* The list hook every SDK list hook is built on, and the one to build on for an endpoint the
+* SDK does not cover. A hook says how to request a page and where its items are; this merges
+* the pages, applies the caller's `select`, and owns the paging modes (`fetchAllPages`, and
+* `fetchNextPage` for `handleRowsScrollEnd`). It replaced seven copies of the same
+* `useInfiniteQuery` call, which is how one `select` defect had reached all seven — an app
+* copying a list hook instead of composing this would copy the next one too.
+*
+* `select` is composed with the merging after the caller's options are spread, so nothing in
+* `queryOptions` can replace it. The composed function is memoised on the caller's `select`:
+* TanStack skips a select whose data and reference are both unchanged.
+*
+* @returns {UseInfiniteQueryResult} The `useInfiniteQuery` result; `data` is the merged items,
+*   or what `select` makes of them.
+*
+* Example:
+* ```ts
+* export const useFetchReports = <TData = Report[]>({ workspace, select, fetchAllPages = false }: Props<TData>) => {
+*   const { api } = useAxios();
+*   const filters = [{ field: "workspace", value: workspace }];
+*   const queryKey = buildQueryKey(["reports"], filters, { fetchAllPages });
+*
+*   const query = useEntityInfiniteQuery<ReportListResponse, "reports", TData>({
+*     queryKey,
+*     itemsKey: "reports",
+*     fetchPage: (pageToken) => listReports(api, workspace, pageToken),
+*     select,
+*     fetchAllPages,
+*     configError: hasWorkspaceFilter(filters) ? undefined : missingWorkspaceError("useFetchReports"),
+*   });
+*
+*   return { query, queryKey };
+* };
+* ```
+*/
+function useEntityInfiniteQuery({ queryKey, itemsKey, fetchPage, select, fetchAllPages = false, enabled = true, configError, queryOptions }) {
+	const selectMerged = useCallback((data) => {
+		const items = data.pages.flatMap((page) => page[itemsKey]);
+		return select ? select(items) : items;
+	}, [itemsKey, select]);
+	return useInfiniteQuery({
+		...defaultQueryOptions,
+		...queryOptions,
+		queryKey,
+		initialPageParam: null,
+		getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+		queryFn: async ({ pageParam, signal }) => {
+			if (configError) return failWithConfigError(configError);
+			return fetchAllPages ? fetchEveryPage(fetchPage, itemsKey, signal) : fetchPage(pageParam ?? void 0, signal);
+		},
+		...configError ? { retry: false } : {},
+		select: selectMerged,
+		enabled: configError || enabled ? queryOptions?.enabled ?? true : false
+	});
+}
+//#endregion
+export { FETCH_ALL_PAGES_LIMIT, failWithConfigError, useEntityInfiniteQuery };
+
+//# sourceMappingURL=useEntityInfiniteQuery.js.map