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

package/dist/hooks/file/useFetchFile.js

@@ -1,83 +1,43 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityQuery } from "../useEntityQuery.js";
+import { missingWorkspaceError } from "../../api/entityQuery.js";
 import { getFile } from "../../api/file.js";
-import { useEffect } from "react";
-import { useQuery } from "@tanstack/react-query";
+import { withoutData } from "./fileData.js";
+import { useCallback } from "react";
 //#region src/hooks/file/useFetchFile.ts
-var defaultQueryOptions = {
-	refetchOnMount: "always",
-	staleTime: 0,
-	gcTime: 0
-};
 /**
 * useFetchFile
 *
-* Data-fetching hook built on TanStack Query to retrieve a single file by ID.
-*
-* It also:
-* - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
-* - triggers an error alert via `useAppAlert` whenever `query.error` is present
-*
-* Important notes:
-* - Always returns a single `EveryskFile` object.
-* - `EveryskFile.data` represents the file content and is expected to be a Base64-encoded string
-*   when provided by the API (or when sending content through mutations).
-*
-* Parameters (FetchFileProps):
-* @param {string} id
-*   EveryskFile identifier (required).
-*
-* @param {string} workspace
-*   Workspace the file belongs to (required by `getFile`).
-*
-* @param {EntityQueryOptions<any>} [queryOptions=defaultQueryOptions]
-*   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
-*
-* Returns:
-* @returns {object}
-*   TanStack Query's `query` object extended with:
-*   - `queryKey`: the cache key used by React Query
-*
-* Tip:
-* - The returned `queryKey` can be reused by mutation hooks for cache invalidation:
-*   ```ts
-*   const fetch = useFetchFile({ id: "file-123", workspace: "ws-1" });
-*   useFileMutations({ queryKey: fetch.queryKey });
-*   ```
+* Fetches one file; `data` is the file, or whatever `select` makes of it. Idle while `id` is
+* empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error
+* alert. The file comes without its content unless `withData` asks for it: show or download it
+* through its `url`.
 *
-* Example:
-* ```ts
-* const { data, isLoading } = useFetchFile({
-*   id: "file-123",
-*   workspace: "ws-1",
-* });
-* // data -> EveryskFile
-* ```
+* @param {FetchFileProps} props - `id`, `workspace`, `withData`, `select` and TanStack
+*   `queryOptions`.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 */
-var useFetchFile = ({ id, workspace, queryOptions = defaultQueryOptions }) => {
+var useFetchFile = ({ id, workspace, select, queryOptions, withData = false }) => {
 	const { api } = useAxios();
-	const { showAlert } = useAppAlert();
 	const queryKey = [
 		"file",
 		id,
-		workspace
+		workspace,
+		{ withData }
 	];
-	const query = useQuery({
-		queryKey,
-		queryFn: async () => {
-			return await getFile(api, id, workspace);
-		},
-		...queryOptions ?? {}
-	});
-	useEffect(() => {
-		if (!query.error) return;
-		showAlert({
-			severity: "error",
-			message: query.error.message
-		});
-	}, [query.error, showAlert]);
+	const selectFile = useCallback((file) => {
+		const visible = withData ? file : withoutData(file);
+		return select ? select(visible) : visible;
+	}, [withData, select]);
 	return {
-		...query,
+		...useEntityQuery({
+			queryKey,
+			fetchEntity: (signal) => getFile(api, id, workspace, { withData }, signal),
+			select: selectFile,
+			enabled: Boolean(id),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchFile"),
+			queryOptions
+		}),
 		queryKey
 	};
 };

package/dist/hooks/file/useFetchFile.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchFile.js","names":[],"sources":["../../../src/hooks/file/useFetchFile.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport type { EveryskFile } from \"@/types/file\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { getFile } from \"@/api/file\";\nimport type { EntityQueryOptions, FetchEntityParams } from \"@/types/entityQuery\";\n\nexport type FetchFileProps<TData = EveryskFile, TSelected = TData> = FetchEntityParams<TData, TSelected>;\n\nconst defaultQueryOptions: EntityQueryOptions<EveryskFile> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0\n}\n\n/**\n * useFetchFile\n *\n * Data-fetching hook built on TanStack Query to retrieve a single file by ID.\n *\n * It also:\n * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * Important notes:\n * - Always returns a single `EveryskFile` object.\n * - `EveryskFile.data` represents the file content and is expected to be a Base64-encoded string\n *   when provided by the API (or when sending content through mutations).\n *\n * Parameters (FetchFileProps):\n * @param {string} id\n *   EveryskFile identifier (required).\n *\n * @param {string} workspace\n *   Workspace the file belongs to (required by `getFile`).\n *\n * @param {EntityQueryOptions<any>} [queryOptions=defaultQueryOptions]\n *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\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 * Tip:\n * - The returned `queryKey` can be reused by mutation hooks for cache invalidation:\n *   ```ts\n *   const fetch = useFetchFile({ id: \"file-123\", workspace: \"ws-1\" });\n *   useFileMutations({ queryKey: fetch.queryKey });\n *   ```\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchFile({\n *   id: \"file-123\",\n *   workspace: \"ws-1\",\n * });\n * // data -> EveryskFile\n * ```\n */\nexport const useFetchFile = ({ id, workspace, queryOptions = defaultQueryOptions }: FetchFileProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"file\", id, workspace];\n\n    const query = useQuery<EveryskFile>({\n        queryKey,\n        queryFn: async () => {\n            const file = await getFile(api, id, workspace);\n            return file;\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;AAYA,IAAM,sBAAuD;CACzD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAgB,EAAE,IAAI,WAAW,eAAe,0BAA0C;CAEnG,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EAAC;EAAQ;EAAI;CAAS;CAEvC,MAAM,QAAQ,SAAsB;EAChC;EACA,SAAS,YAAY;GAEjB,OAAO,MADY,QAAQ,KAAK,IAAI,SAAS;EAEjD;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":"useFetchFile.js","names":[],"sources":["../../../src/hooks/file/useFetchFile.ts"],"sourcesContent":["import { useCallback } from \"react\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { missingWorkspaceError } from \"@/api/entityQuery\";\nimport { getFile } from \"@/api/file\";\nimport type { EveryskFile } from \"@/types/file\";\nimport type { FetchEntityByIdProps } from \"@/types/entityQuery\";\nimport { withoutData, type FileDataProps } from \"./fileData\";\n\nexport type FetchFileProps<TData = EveryskFile, TSelected = TData> = FetchEntityByIdProps<\n    TData,\n    TSelected\n> &\n    FileDataProps;\n\n/**\n * useFetchFile\n *\n * Fetches one file; `data` is the file, or whatever `select` makes of it. Idle while `id` is\n * empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error\n * alert. The file comes without its content unless `withData` asks for it: show or download it\n * through its `url`.\n *\n * @param {FetchFileProps} props - `id`, `workspace`, `withData`, `select` and TanStack\n *   `queryOptions`.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n */\nexport const useFetchFile = <TSelected = EveryskFile>({\n    id,\n    workspace,\n    select,\n    queryOptions,\n    withData = false,\n}: FetchFileProps<EveryskFile, TSelected>) => {\n    const { api } = useAxios();\n\n    const queryKey = [\"file\", id, workspace, { withData }];\n\n    const selectFile = useCallback(\n        (file: EveryskFile): TSelected => {\n            const visible = withData ? file : withoutData(file);\n            return select ? select(visible) : (visible as TSelected);\n        },\n        [withData, select],\n    );\n\n    const query = useEntityQuery<EveryskFile, TSelected>({\n        queryKey,\n        fetchEntity: (signal) => getFile(api, id, workspace, { withData }, signal),\n        select: selectFile,\n        enabled: Boolean(id),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchFile\"),\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA4BA,IAAa,gBAAyC,EAClD,IACA,WACA,QACA,cACA,WAAW,YAC+B;CAC1C,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW;EAAC;EAAQ;EAAI;EAAW,EAAE,SAAS;CAAC;CAErD,MAAM,aAAa,aACd,SAAiC;EAC9B,MAAM,UAAU,WAAW,OAAO,YAAY,IAAI;EAClD,OAAO,SAAS,OAAO,OAAO,IAAK;CACvC,GACA,CAAC,UAAU,MAAM,CACrB;CAWA,OAAO;EAAE,GATK,eAAuC;GACjD;GACA,cAAc,WAAW,QAAQ,KAAK,IAAI,WAAW,EAAE,SAAS,GAAG,MAAM;GACzE,QAAQ;GACR,SAAS,QAAQ,EAAE;GACnB,aAAa,YAAY,KAAA,IAAY,sBAAsB,cAAc;GACzE;EACJ,CAEY;EAAO;CAAS;AAChC"}

package/dist/hooks/file/useFetchFiles.d.ts

@@ -1,60 +1,26 @@
-import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
 import type { EveryskFile, FileListResponse } from "../../types/file.d.ts";
-import type { FetchEntitiesParams } from "../../types/entityQuery.d.ts";
-type PageToken = string | null;
-type InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<FileListResponse, Error, TData, QueryKey, PageToken>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
-export type FetchInfiniteFileProps = FetchEntitiesParams<EveryskFile[], InfiniteOptions<EveryskFile[]>> & {
-    pageSize?: number;
-};
+import type { FetchEntitiesProps, ListQueryProps, ListCache } from "../../types/entityQuery.d.ts";
+import { type FileDataProps } from "./fileData";
+/** The query cache of `useFetchFiles`, for typing `setQueryData`. */
+export type FilesCache = ListCache<FileListResponse>;
+export type FetchFilesProps<TData = EveryskFile[]> = ListQueryProps & FetchEntitiesProps<EveryskFile, TData, FileListResponse> & FileDataProps;
 /**
  * useFetchFiles
  *
- * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
- * files with cursor-based pagination.
- *
- * It also:
- * - flattens all pages into a single `EveryskFile[]` via `select`
- *
- * Important notes:
- * - `query.data` returns a flat `EveryskFile[]` (all pages merged).
- *
- * Parameters (FetchInfiniteFileProps):
- * @param {FilterClause[]} [filters=[]]
- *   Filters applied to every page request. Must include a `workspace` filter.
- *
- * @param {string[]} [order=[]]
- *   Sorting applied to every page request.
- *
- * @param {string} [projection=""]
- *   Single field to project: `"field"` returns only that field (others come back null),
- *   `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
- *
- * @param {number} [pageSize=10]
- *   Number of files to fetch per page.
- *
- * @param {InfiniteOptions<EveryskFile[]>} [queryOptions]
- *   TanStack Query options passed through to `useInfiniteQuery`
- *   (e.g., enabled, staleTime, gcTime, etc.).
- *
- * Returns:
- * @returns {object}
- *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
- *   - `queryKey`: the cache key used by React Query
- *
- * Example:
- * ```ts
- * const { query } = useFetchFiles({
- *   filters: [{ field: "workspace", value: "ws-1" }],
- *   pageSize: 20,
- * });
- *
- * // Flat list of all fetched files
- * const files = query.data ?? [];
- * ```
+ * Lists files with cursor pagination; `query.data` is every loaded page merged, or whatever
+ * `select` makes of it. Paging, `select`, `fetchAllPages` and the missing-workspace error
+ * behave as in `useFetchDatastores`. The files come without their content unless `withData`
+ * asks for it: show or download each through its `url`. The exclusion of `data` is added to a
+ * `projection` of the app's own that only excludes fields; one that includes fields is sent as
+ * given (see `projectionToSend`). Either way the content is left out of what the hook returns
+ * unless `withData` asks for it.
+ *
+ * @param {FetchFilesProps} props - Filters (one must be `workspace`), order, projection,
+ *   page size, `withData`, `select`, `fetchAllPages` and TanStack `queryOptions`.
+ * @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.
  */
-export declare function useFetchFiles({ filters, order, projection, pageSize, queryOptions }: FetchInfiniteFileProps): {
-    query: import("@tanstack/react-query").UseInfiniteQueryResult<EveryskFile[], Error>;
+export declare function useFetchFiles<TData = EveryskFile[]>({ filters, order, projection, pageSize, select, fetchAllPages, queryOptions, withData, }: FetchFilesProps<TData>): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<TData, Error>;
     queryKey: unknown[];
 };
-export {};
 //# sourceMappingURL=useFetchFiles.d.ts.map

package/dist/hooks/file/useFetchFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchFiles.d.ts","sourceRoot":"","sources":["../../../src/hooks/file/useFetchFiles.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAG/D,KAAK,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/B,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAC9B,uBAAuB,CAAC,gBAAgB,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,EAC5E,UAAU,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CACnE,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,CAAC,WAAW,EAAE,EAAE,eAAe,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG;IACtG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,aAAa,CAAC,EAAE,OAAY,EAAE,KAAU,EAAE,UAAe,EAAE,QAAa,EAAE,YAAY,EAAE,EAAE,sBAAsB;;;EAoC/H"}
+{"version":3,"file":"useFetchFiles.d.ts","sourceRoot":"","sources":["../../../src/hooks/file/useFetchFiles.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EACR,kBAAkB,EAClB,cAAc,EACd,SAAS,EAEZ,MAAM,qBAAqB,CAAC;AAO7B,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAE7D,qEAAqE;AACrE,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;AAErD,MAAM,MAAM,eAAe,CAAC,KAAK,GAAG,WAAW,EAAE,IAAI,cAAc,GAC/D,kBAAkB,CAAC,WAAW,EAAE,KAAK,EAAE,gBAAgB,CAAC,GACxD,aAAa,CAAC;AAqBlB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,GAAG,WAAW,EAAE,EAAE,EACjD,OAAY,EACZ,KAAU,EACV,UAAe,EACf,QAAa,EACb,MAAM,EACN,aAAqB,EACrB,YAAY,EACZ,QAAgB,GACnB,EAAE,eAAe,CAAC,KAAK,CAAC;;;EA2CxB"}

package/dist/hooks/file/useFetchFiles.js

@@ -1,84 +1,68 @@
 import { useAxios } from "../useAxios.js";
-import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { useEntityInfiniteQuery } from "../useEntityInfiniteQuery.js";
+import { buildQueryKey, buildQueryObject, hasWorkspaceFilter, missingWorkspaceError } from "../../api/entityQuery.js";
 import { listFiles } from "../../api/file.js";
-import { useMemo } from "react";
-import { useInfiniteQuery } from "@tanstack/react-query";
+import { withoutData } from "./fileData.js";
+import { useCallback } from "react";
 //#region src/hooks/file/useFetchFiles.ts
-var defaultQueryOptions = {
-	refetchOnMount: "always",
-	staleTime: 0,
-	gcTime: 0
+/** What leaves the content out of a list: the JSON query returns `data` in full otherwise. */
+var WITHOUT_DATA_PROJECTION = "-data";
+/**
+* The projection a list read sends. The content is left out unless asked for: alone when the app
+* gave no projection, and added to one that only excludes fields. A projection that includes
+* fields is sent as given, since mixing an inclusion with an exclusion is a 500; it then decides
+* itself whether `data` is read.
+*/
+var projectionToSend = (projection, withData) => {
+	if (withData) return projection;
+	const fields = typeof projection === "string" ? [projection].filter(Boolean) : projection;
+	if (fields.length === 0) return WITHOUT_DATA_PROJECTION;
+	if (!fields.every((field) => field.startsWith("-")) || fields.includes(WITHOUT_DATA_PROJECTION)) return projection;
+	return [...fields, WITHOUT_DATA_PROJECTION];
 };
 /**
 * useFetchFiles
 *
-* Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
-* files with cursor-based pagination.
-*
-* It also:
-* - flattens all pages into a single `EveryskFile[]` via `select`
-*
-* Important notes:
-* - `query.data` returns a flat `EveryskFile[]` (all pages merged).
-*
-* Parameters (FetchInfiniteFileProps):
-* @param {FilterClause[]} [filters=[]]
-*   Filters applied to every page request. Must include a `workspace` filter.
-*
-* @param {string[]} [order=[]]
-*   Sorting applied to every page request.
-*
-* @param {string} [projection=""]
-*   Single field to project: `"field"` returns only that field (others come back null),
-*   `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
-*
-* @param {number} [pageSize=10]
-*   Number of files to fetch per page.
-*
-* @param {InfiniteOptions<EveryskFile[]>} [queryOptions]
-*   TanStack Query options passed through to `useInfiniteQuery`
-*   (e.g., enabled, staleTime, gcTime, etc.).
-*
-* Returns:
-* @returns {object}
-*   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
-*   - `queryKey`: the cache key used by React Query
-*
-* Example:
-* ```ts
-* const { query } = useFetchFiles({
-*   filters: [{ field: "workspace", value: "ws-1" }],
-*   pageSize: 20,
-* });
+* Lists files with cursor pagination; `query.data` is every loaded page merged, or whatever
+* `select` makes of it. Paging, `select`, `fetchAllPages` and the missing-workspace error
+* behave as in `useFetchDatastores`. The files come without their content unless `withData`
+* asks for it: show or download each through its `url`. The exclusion of `data` is added to a
+* `projection` of the app's own that only excludes fields; one that includes fields is sent as
+* given (see `projectionToSend`). Either way the content is left out of what the hook returns
+* unless `withData` asks for it.
 *
-* // Flat list of all fetched files
-* const files = query.data ?? [];
-* ```
+* @param {FetchFilesProps} props - Filters (one must be `workspace`), order, projection,
+*   page size, `withData`, `select`, `fetchAllPages` and TanStack `queryOptions`.
+* @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.
 */
-function useFetchFiles({ filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+function useFetchFiles({ filters = [], order = [], projection = "", pageSize = 10, select, fetchAllPages = false, queryOptions, withData = false }) {
 	const { api } = useAxios();
-	const queryKey = buildQueryKey(["files"], filters);
-	const mergedQueryOptions = useMemo(() => ({
-		...defaultQueryOptions,
-		...queryOptions ?? {}
-	}), [queryOptions]);
+	const sentProjection = projectionToSend(projection, withData);
+	const queryKey = buildQueryKey(["files"], filters, {
+		order,
+		projection: sentProjection,
+		pageSize,
+		fetchAllPages
+	});
+	const selectFiles = useCallback((files) => {
+		const visible = withData ? files : files.map(withoutData);
+		return select ? select(visible) : visible;
+	}, [withData, select]);
 	return {
-		query: useInfiniteQuery({
+		query: useEntityInfiniteQuery({
 			queryKey,
-			initialPageParam: null,
-			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
-			queryFn: async ({ pageParam }) => {
-				const queryFilter = buildQueryObject({
-					filters,
-					order,
-					projection,
-					pageSize,
-					pageToken: pageParam ?? void 0
-				});
-				return await listFiles(api, queryFilter);
-			},
-			select: (data) => data.pages.flatMap((p) => p.files),
-			...mergedQueryOptions
+			itemsKey: "files",
+			fetchPage: (pageToken, signal) => listFiles(api, buildQueryObject({
+				filters,
+				order,
+				projection: sentProjection,
+				pageSize,
+				pageToken
+			}), signal),
+			select: selectFiles,
+			fetchAllPages,
+			configError: hasWorkspaceFilter(filters) ? void 0 : missingWorkspaceError("useFetchFiles"),
+			queryOptions
 		}),
 		queryKey
 	};

package/dist/hooks/file/useFetchFiles.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFetchFiles.js","names":[],"sources":["../../../src/hooks/file/useFetchFiles.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useInfiniteQuery, type UseInfiniteQueryOptions, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { listFiles } from \"@/api/file\";\nimport type { EveryskFile, FileListResponse } from \"@/types/file\";\nimport type { FetchEntitiesParams } from \"@/types/entityQuery\";\nimport { buildQueryKey, buildQueryObject } from \"@/api/entityQuery\";\n\ntype PageToken = string | null;\n\ntype InfiniteOptions<TData> = Omit<\n    UseInfiniteQueryOptions<FileListResponse, Error, TData, QueryKey, PageToken>,\n    \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\"\n>;\n\nexport type FetchInfiniteFileProps = FetchEntitiesParams<EveryskFile[], InfiniteOptions<EveryskFile[]>> & {\n    pageSize?: number;\n};\n\nconst defaultQueryOptions: InfiniteOptions<EveryskFile[]> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchFiles\n *\n * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve\n * files with cursor-based pagination.\n *\n * It also:\n * - flattens all pages into a single `EveryskFile[]` via `select`\n *\n * Important notes:\n * - `query.data` returns a flat `EveryskFile[]` (all pages merged).\n *\n * Parameters (FetchInfiniteFileProps):\n * @param {FilterClause[]} [filters=[]]\n *   Filters applied to every page request. Must include a `workspace` filter.\n *\n * @param {string[]} [order=[]]\n *   Sorting applied to every page request.\n *\n * @param {string} [projection=\"\"]\n *   Single field to project: `\"field\"` returns only that field (others come back null),\n *   `\"-field\"` returns every field except that one. One field only — lists 500. Omitted when empty.\n *\n * @param {number} [pageSize=10]\n *   Number of files to fetch per page.\n *\n * @param {InfiniteOptions<EveryskFile[]>} [queryOptions]\n *   TanStack Query options passed through to `useInfiniteQuery`\n *   (e.g., enabled, staleTime, gcTime, etc.).\n *\n * Returns:\n * @returns {object}\n *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)\n *   - `queryKey`: the cache key used by React Query\n *\n * Example:\n * ```ts\n * const { query } = useFetchFiles({\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n *   pageSize: 20,\n * });\n *\n * // Flat list of all fetched files\n * const files = query.data ?? [];\n * ```\n */\nexport function useFetchFiles({ filters = [], order = [], projection = \"\", pageSize = 10, queryOptions }: FetchInfiniteFileProps) {\n    const { api } = useAxios();\n\n    const queryKey = buildQueryKey([\"files\"], filters);\n\n    const mergedQueryOptions = useMemo<InfiniteOptions<EveryskFile[]>>(() => ({\n        ...defaultQueryOptions,\n        ...(queryOptions ?? {}),\n    }), [queryOptions]);\n\n    const query = useInfiniteQuery<FileListResponse, Error, EveryskFile[], QueryKey, PageToken>({\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n\n        queryFn: async ({ pageParam }) => {\n            const queryFilter = buildQueryObject({\n                filters,\n                order,\n                projection,\n                pageSize,\n                pageToken: pageParam ?? undefined,\n            });\n\n            return await listFiles(api, queryFilter);\n        },\n\n        select: (data) => data.pages.flatMap((p) => p.files),\n\n        ...mergedQueryOptions,\n    });\n\n    return {\n        query,\n        queryKey,\n    };\n}"],"mappings":";;;;;;AAoBA,IAAM,sBAAsD;CACxD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,cAAc,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,GAAG,aAAa,IAAI,WAAW,IAAI,gBAAwC;CAC9H,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW,cAAc,CAAC,OAAO,GAAG,OAAO;CAEjD,MAAM,qBAAqB,eAA+C;EACtE,GAAG;EACH,GAAI,gBAAgB,CAAC;CACzB,IAAI,CAAC,YAAY,CAAC;CAwBlB,OAAO;EACH,OAvBU,iBAA8E;GACxF;GACA,kBAAkB;GAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;GAE5D,SAAS,OAAO,EAAE,gBAAgB;IAC9B,MAAM,cAAc,iBAAiB;KACjC;KACA;KACA;KACA;KACA,WAAW,aAAa,KAAA;IAC5B,CAAC;IAED,OAAO,MAAM,UAAU,KAAK,WAAW;GAC3C;GAEA,SAAS,SAAS,KAAK,MAAM,SAAS,MAAM,EAAE,KAAK;GAEnD,GAAG;EACP,CAGI;EACA;CACJ;AACJ"}
+{"version":3,"file":"useFetchFiles.js","names":[],"sources":["../../../src/hooks/file/useFetchFiles.ts"],"sourcesContent":["import { useCallback } from \"react\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityInfiniteQuery } from \"@/hooks/useEntityInfiniteQuery\";\nimport { listFiles } from \"@/api/file\";\nimport type { EveryskFile, FileListResponse } from \"@/types/file\";\nimport type {\n    FetchEntitiesProps,\n    ListQueryProps,\n    ListCache,\n    Projection,\n} from \"@/types/entityQuery\";\nimport {\n    buildQueryKey,\n    buildQueryObject,\n    hasWorkspaceFilter,\n    missingWorkspaceError,\n} from \"@/api/entityQuery\";\nimport { withoutData, type FileDataProps } from \"./fileData\";\n\n/** The query cache of `useFetchFiles`, for typing `setQueryData`. */\nexport type FilesCache = ListCache<FileListResponse>;\n\nexport type FetchFilesProps<TData = EveryskFile[]> = ListQueryProps &\n    FetchEntitiesProps<EveryskFile, TData, FileListResponse> &\n    FileDataProps;\n\n/** What leaves the content out of a list: the JSON query returns `data` in full otherwise. */\nconst WITHOUT_DATA_PROJECTION = \"-data\";\n\n/**\n * The projection a list read sends. The content is left out unless asked for: alone when the app\n * gave no projection, and added to one that only excludes fields. A projection that includes\n * fields is sent as given, since mixing an inclusion with an exclusion is a 500; it then decides\n * itself whether `data` is read.\n */\nconst projectionToSend = (projection: Projection, withData: boolean): Projection => {\n    if (withData) return projection;\n\n    const fields = typeof projection === \"string\" ? [projection].filter(Boolean) : projection;\n    if (fields.length === 0) return WITHOUT_DATA_PROJECTION;\n    if (!fields.every((field) => field.startsWith(\"-\")) || fields.includes(WITHOUT_DATA_PROJECTION))\n        return projection;\n    return [...fields, WITHOUT_DATA_PROJECTION];\n};\n\n/**\n * useFetchFiles\n *\n * Lists files with cursor pagination; `query.data` is every loaded page merged, or whatever\n * `select` makes of it. Paging, `select`, `fetchAllPages` and the missing-workspace error\n * behave as in `useFetchDatastores`. The files come without their content unless `withData`\n * asks for it: show or download each through its `url`. The exclusion of `data` is added to a\n * `projection` of the app's own that only excludes fields; one that includes fields is sent as\n * given (see `projectionToSend`). Either way the content is left out of what the hook returns\n * unless `withData` asks for it.\n *\n * @param {FetchFilesProps} props - Filters (one must be `workspace`), order, projection,\n *   page size, `withData`, `select`, `fetchAllPages` and TanStack `queryOptions`.\n * @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.\n */\nexport function useFetchFiles<TData = EveryskFile[]>({\n    filters = [],\n    order = [],\n    projection = \"\",\n    pageSize = 10,\n    select,\n    fetchAllPages = false,\n    queryOptions,\n    withData = false,\n}: FetchFilesProps<TData>) {\n    const { api } = useAxios();\n    const sentProjection = projectionToSend(projection, withData);\n\n    const queryKey = buildQueryKey([\"files\"], filters, {\n        order,\n        projection: sentProjection,\n        pageSize,\n        fetchAllPages,\n    });\n\n    const selectFiles = useCallback(\n        (files: EveryskFile[]): TData => {\n            const visible = withData ? files : files.map(withoutData);\n            return select ? select(visible) : (visible as TData);\n        },\n        [withData, select],\n    );\n\n    const query = useEntityInfiniteQuery<FileListResponse, \"files\", TData>({\n        queryKey,\n        itemsKey: \"files\",\n        fetchPage: (pageToken, signal) =>\n            listFiles(\n                api,\n                buildQueryObject({\n                    filters,\n                    order,\n                    projection: sentProjection,\n                    pageSize,\n                    pageToken,\n                }),\n                signal,\n            ),\n        select: selectFiles,\n        fetchAllPages,\n        configError: hasWorkspaceFilter(filters)\n            ? undefined\n            : missingWorkspaceError(\"useFetchFiles\"),\n        queryOptions,\n    });\n\n    return { query, queryKey };\n}\n"],"mappings":";;;;;;;;AA4BA,IAAM,0BAA0B;;;;;;;AAQhC,IAAM,oBAAoB,YAAwB,aAAkC;CAChF,IAAI,UAAU,OAAO;CAErB,MAAM,SAAS,OAAO,eAAe,WAAW,CAAC,UAAU,CAAC,CAAC,OAAO,OAAO,IAAI;CAC/E,IAAI,OAAO,WAAW,GAAG,OAAO;CAChC,IAAI,CAAC,OAAO,OAAO,UAAU,MAAM,WAAW,GAAG,CAAC,KAAK,OAAO,SAAS,uBAAuB,GAC1F,OAAO;CACX,OAAO,CAAC,GAAG,QAAQ,uBAAuB;AAC9C;;;;;;;;;;;;;;;;AAiBA,SAAgB,cAAqC,EACjD,UAAU,CAAC,GACX,QAAQ,CAAC,GACT,aAAa,IACb,WAAW,IACX,QACA,gBAAgB,OAChB,cACA,WAAW,SACY;CACvB,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,iBAAiB,iBAAiB,YAAY,QAAQ;CAE5D,MAAM,WAAW,cAAc,CAAC,OAAO,GAAG,SAAS;EAC/C;EACA,YAAY;EACZ;EACA;CACJ,CAAC;CAED,MAAM,cAAc,aACf,UAAgC;EAC7B,MAAM,UAAU,WAAW,QAAQ,MAAM,IAAI,WAAW;EACxD,OAAO,SAAS,OAAO,OAAO,IAAK;CACvC,GACA,CAAC,UAAU,MAAM,CACrB;CAyBA,OAAO;EAAE,OAvBK,uBAAyD;GACnE;GACA,UAAU;GACV,YAAY,WAAW,WACnB,UACI,KACA,iBAAiB;IACb;IACA;IACA,YAAY;IACZ;IACA;GACJ,CAAC,GACD,MACJ;GACJ,QAAQ;GACR;GACA,aAAa,mBAAmB,OAAO,IACjC,KAAA,IACA,sBAAsB,eAAe;GAC3C;EACJ,CAES;EAAO;CAAS;AAC7B"}

package/dist/hooks/file/useFileMutations.d.ts

@@ -34,7 +34,8 @@ type UseFileMutationsProps = {
  *
  * - EveryskFile content (`data`):
  *   - When creating/updating a file, the file content must be provided in `data` as a Base64-encoded string.
- *   - Send only the raw Base64 content (do not include a data URL prefix like `data:<mime>;base64,`)
+ *   - Send only the raw Base64 content (do not include a data URL prefix like `data:<mime>;base64,`):
+ *     `fileToBase64(file)` gives it from a `File`, and a data URL is refused before the request
  *   - `content_type` should match the file MIME type (e.g., "text/csv", "application/pdf").
  *
  * Parameters (UseFileMutationsProps):
@@ -51,19 +52,19 @@ type UseFileMutationsProps = {
  * - `create`:
  *   - mutationFn: `createFile(api, data)`
  *   - variables: `{ data: Partial<EveryskFile> }`
- *   - success message: "EveryskFile created successfully."
+ *   - success message: "File created successfully."
  *   - error message: "Unable to create the file. Please try again." (fallback)
  *
  * - `update`:
  *   - mutationFn: `updateFile(api, id, data)`
  *   - variables: `{ id: string; data: Partial<EveryskFile> }`
- *   - success message: "EveryskFile updated successfully."
+ *   - success message: "File updated successfully."
  *   - error message: "Unable to update the file. Please try again." (fallback)
  *
  * - `remove`:
  *   - mutationFn: `deleteFile(api, id, workspace)`
  *   - variables: `{ id: string; workspace: string }`
- *   - success message: "EveryskFile deleted successfully."
+ *   - success message: "File deleted successfully."
  *   - error message: "Unable to delete the file. Please try again." (fallback)
  *
  * Return value:
@@ -71,7 +72,7 @@ type UseFileMutationsProps = {
  *  Returns an object with the three TanStack Query mutation results:
  *  - `create`: UseMutationResult<EveryskFile, Error, CreateFileProps, unknown>
  *  - `update`: UseMutationResult<EveryskFile, Error, UpdateFileProps, unknown>
- *  - `remove`: UseMutationResult<EveryskFile, Error, DeleteFileProps, unknown>
+ *  - `remove`: UseMutationResult<DeletedEntity, Error, DeleteFileProps, unknown>
  *
  * Each mutation includes standard TanStack Query helpers:
  * - `mutate(variables, options?)`
@@ -153,9 +154,9 @@ type UseFileMutationsProps = {
  * ```
  */
 export declare const useFileMutations: ({ queryKey }: UseFileMutationsProps) => {
-    create: import("@tanstack/react-query").UseMutationResult<EveryskFile, unknown, CreateFileProps, unknown>;
-    update: import("@tanstack/react-query").UseMutationResult<EveryskFile, unknown, UpdateFileProps, unknown>;
-    remove: import("@tanstack/react-query").UseMutationResult<import("../..").DeleteEntityDefaultResponse[], unknown, DeleteFileProps, unknown>;
+    create: import("@tanstack/react-query").UseMutationResult<EveryskFile, Error, CreateFileProps, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<EveryskFile, Error, UpdateFileProps, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<import("../..").DeletedEntity, Error, DeleteFileProps, unknown>;
 };
 export {};
 //# sourceMappingURL=useFileMutations.d.ts.map

package/dist/hooks/file/useFileMutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFileMutations.d.ts","sourceRoot":"","sources":["../../../src/hooks/file/useFileMutations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,KAAK,eAAe,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,eAAe,GAAG;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,eAAe,GAAG;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACxB,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0IG;AAEH,eAAO,MAAM,gBAAgB,GAAI,cAAc,qBAAqB;;;;CAuEnE,CAAC"}
+{"version":3,"file":"useFileMutations.d.ts","sourceRoot":"","sources":["../../../src/hooks/file/useFileMutations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,KAAK,eAAe,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,eAAe,GAAG;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,eAAe,GAAG;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2IG;AAEH,eAAO,MAAM,gBAAgB,GAAI,cAAc,qBAAqB;;;;CAyBnE,CAAC"}

package/dist/hooks/file/useFileMutations.js

@@ -1,9 +1,7 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityMutation } from "../useEntityMutation.js";
 import { createFile, deleteFile, updateFile } from "../../api/file.js";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
 //#region src/hooks/file/useFileMutations.ts
-var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? err.message : fallback;
 /**
 * useFileMutations
 *
@@ -22,10 +20,11 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 *   mutations and show alerts, but it will NOT invalidate any cached queries.
 * - `remove` requires a `workspace` parameter because the underlying API helper `deleteFile(api, id, workspace)`
 *   expects it as a query param.
-* 
+*
 * - EveryskFile content (`data`):
 *   - When creating/updating a file, the file content must be provided in `data` as a Base64-encoded string.
-*   - Send only the raw Base64 content (do not include a data URL prefix like `data:<mime>;base64,`)
+*   - Send only the raw Base64 content (do not include a data URL prefix like `data:<mime>;base64,`):
+*     `fileToBase64(file)` gives it from a `File`, and a data URL is refused before the request
 *   - `content_type` should match the file MIME type (e.g., "text/csv", "application/pdf").
 *
 * Parameters (UseFileMutationsProps):
@@ -42,19 +41,19 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 * - `create`:
 *   - mutationFn: `createFile(api, data)`
 *   - variables: `{ data: Partial<EveryskFile> }`
-*   - success message: "EveryskFile created successfully."
+*   - success message: "File created successfully."
 *   - error message: "Unable to create the file. Please try again." (fallback)
 *
 * - `update`:
 *   - mutationFn: `updateFile(api, id, data)`
 *   - variables: `{ id: string; data: Partial<EveryskFile> }`
-*   - success message: "EveryskFile updated successfully."
+*   - success message: "File updated successfully."
 *   - error message: "Unable to update the file. Please try again." (fallback)
 *
 * - `remove`:
 *   - mutationFn: `deleteFile(api, id, workspace)`
 *   - variables: `{ id: string; workspace: string }`
-*   - success message: "EveryskFile deleted successfully."
+*   - success message: "File deleted successfully."
 *   - error message: "Unable to delete the file. Please try again." (fallback)
 *
 * Return value:
@@ -62,7 +61,7 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 *  Returns an object with the three TanStack Query mutation results:
 *  - `create`: UseMutationResult<EveryskFile, Error, CreateFileProps, unknown>
 *  - `update`: UseMutationResult<EveryskFile, Error, UpdateFileProps, unknown>
-*  - `remove`: UseMutationResult<EveryskFile, Error, DeleteFileProps, unknown>
+*  - `remove`: UseMutationResult<DeletedEntity, Error, DeleteFileProps, unknown>
 *
 * Each mutation includes standard TanStack Query helpers:
 * - `mutate(variables, options?)`
@@ -145,60 +144,24 @@ var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? e
 */
 var useFileMutations = ({ 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 }) => createFile(api, data),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "EveryskFile created successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "Unable to create the file. Please try again.")
-				});
-			}
+		create: useEntityMutation({
+			mutationFn: ({ data }) => createFile(api, data),
+			queryKey,
+			successMessage: "File created successfully.",
+			errorMessage: "Unable to create the file. Please try again."
 		}),
-		update: useMutation({
-			mutationFn: async ({ id, data }) => updateFile(api, id, data),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "EveryskFile updated successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "Unable to update the file. Please try again.")
-				});
-			}
+		update: useEntityMutation({
+			mutationFn: ({ id, data }) => updateFile(api, id, data),
+			queryKey,
+			successMessage: "File updated successfully.",
+			errorMessage: "Unable to update the file. Please try again."
 		}),
-		remove: useMutation({
-			mutationFn: async ({ id, workspace }) => deleteFile(api, id, workspace),
-			onSuccess: async () => {
-				await invalidate();
-				showAlert({
-					severity: "success",
-					message: "EveryskFile deleted successfully."
-				});
-			},
-			onError: (err) => {
-				showAlert({
-					severity: "error",
-					message: getErrorMessage(err, "Unable to delete the file. Please try again.")
-				});
-			}
+		remove: useEntityMutation({
+			mutationFn: ({ id, workspace }) => deleteFile(api, id, workspace),
+			queryKey,
+			successMessage: "File deleted successfully.",
+			errorMessage: "Unable to delete the file. Please try again."
 		})
 	};
 };