@everysk/apps-sdk 0.1.0-beta.0

package/dist/hooks/file/useFetchFiles.js

@@ -0,0 +1,89 @@
+import { useAxios } from "../useAxios.js";
+import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { listFiles } from "../../api/file.js";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/file/useFetchFiles.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* 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 ?? [];
+* ```
+*/
+function useFetchFiles({ filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+	const { api } = useAxios();
+	const queryKey = buildQueryKey(["files"], filters);
+	const mergedQueryOptions = useMemo(() => ({
+		...defaultQueryOptions,
+		...queryOptions ?? {}
+	}), [queryOptions]);
+	return {
+		query: useInfiniteQuery({
+			queryKey,
+			initialPageParam: null,
+			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+			queryFn: async ({ pageParam }) => {
+				const queryFilter = buildQueryObject({
+					filters,
+					order,
+					projection,
+					pageSize,
+					pageToken: pageParam ?? void 0
+				});
+				return await listFiles(api, queryFilter);
+			},
+			select: (data) => data.pages.flatMap((p) => p.files),
+			...mergedQueryOptions
+		}),
+		queryKey
+	};
+}
+//#endregion
+export { useFetchFiles };
+
+//# sourceMappingURL=useFetchFiles.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,161 @@
+import type { EveryskFile } from "../../types/file.d.ts";
+type CreateFileProps = {
+    data: Partial<EveryskFile>;
+};
+type UpdateFileProps = {
+    id: string;
+    data: Partial<EveryskFile>;
+};
+type DeleteFileProps = {
+    id: string;
+    workspace: string;
+};
+type UseFileMutationsProps = {
+    queryKey?: unknown[];
+};
+/**
+ * useFileMutations
+ *
+ * Mutation hook built on TanStack Query to perform EveryskFile write operations:
+ * - create a file (POST)
+ * - update a file (PUT)
+ * - delete a file (DELETE)
+ *
+ * It also:
+ * - optionally invalidates a target query cache key after successful mutations
+ * - displays success/error alerts via `useAppAlert`
+ *
+ * Important notes:
+ * - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchFile`.
+ * - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run
+ *   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,`)
+ *   - `content_type` should match the file MIME type (e.g., "text/csv", "application/pdf").
+ *
+ * Parameters (UseFileMutationsProps):
+ * @param {unknown[]} [queryKey]
+ *  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`
+ *  (e.g., file list/detail) so UI data is refreshed automatically after a write.
+ *
+ *  Tip:
+ *  - If you're using `useFetchFile`, you can pass its returned `queryKey` directly:
+ *    `const fetch = useFetchFile(...);`
+ *    `useFileMutations({ queryKey: fetch.queryKey });`
+ *
+ * Mutations:
+ * - `create`:
+ *   - mutationFn: `createFile(api, data)`
+ *   - variables: `{ data: Partial<EveryskFile> }`
+ *   - success message: "EveryskFile 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."
+ *   - 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."
+ *   - error message: "Unable to delete the file. Please try again." (fallback)
+ *
+ * Return value:
+ * @returns {object}
+ *  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>
+ *
+ * Each mutation includes standard TanStack Query helpers:
+ * - `mutate(variables, options?)`
+ * - `mutateAsync(variables, options?)`
+ * - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.
+ *
+ * Examples:
+ *
+ * 1) Invalidate a file list query after mutations:
+ * ```ts
+ * const { create, update, remove } = useFileMutations({ queryKey: ["file"] });
+ *
+ * // Create
+ * create.mutate({
+ *   data: {
+ *     name: "My file",
+ *     workspace: "ws-1",
+ *     content_type: "text/plain",
+ *     version: "1",
+ *     link_uid: null,
+ *     data: "SGVsbG8gd29ybGQ=", // Base64 content
+ *   }
+ * });
+ *
+ * // Update
+ * update.mutate({
+ *   id: "file-123",
+ *   data: {
+ *     name: "Renamed file",
+ *     content_type: "text/plain",
+ *     data: "SGVsbG8gd29ybGQ=", // Base64 content (optional if only renaming)
+ *   }
+ * });
+ *
+ * // Delete
+ * remove.mutate({ id: "file-123", workspace: "ws-1" });
+ * ```
+ *
+ * 2) Using async/await with `mutateAsync`:
+ * ```ts
+ * const { create } = useFileMutations({ queryKey: ["file"] });
+ *
+ * await create.mutateAsync({
+ *   data: {
+ *     name: "My file",
+ *     workspace: "ws-1",
+ *     content_type: "text/plain",
+ *     version: "1",
+ *     link_uid: null,
+ *     data: "SGVsbG8gd29ybGQ=",
+ *   }
+ * });
+ * ```
+ *
+ * 3) Without cache invalidation (no queryKey):
+ * ```ts
+ * const { update } = useFileMutations({});
+ *
+ * update.mutate({
+ *   id: "file-123",
+ *   data: {
+ *     name: "New name",
+ *     content_type: "text/plain",
+ *   }
+ * });
+ * // Mutation still runs and alerts are shown, but cached queries are not invalidated.
+ * ```
+ *
+ * 4) Using `useFetchFile` queryKey for automatic invalidation:
+ * ```ts
+ * const fetch = useFetchFile({
+ *   id: null,
+ *   filters: [{ field: "workspace", value: "ws-1" }],
+ * });
+ *
+ * const { remove } = useFileMutations({ queryKey: fetch.queryKey });
+ *
+ * await remove.mutateAsync({ id: "file-123", workspace: "ws-1" });
+ * ```
+ */
+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>;
+};
+export {};
+//# sourceMappingURL=useFileMutations.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/file/useFileMutations.js

@@ -0,0 +1,208 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.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
+*
+* Mutation hook built on TanStack Query to perform EveryskFile write operations:
+* - create a file (POST)
+* - update a file (PUT)
+* - delete a file (DELETE)
+*
+* It also:
+* - optionally invalidates a target query cache key after successful mutations
+* - displays success/error alerts via `useAppAlert`
+*
+* Important notes:
+* - This hook is intended for side-effect operations only. Reading/retrieving data should be done via `useQuery` or `useFetchFile`.
+* - Cache invalidation is controlled by `queryKey`. If `queryKey` is not provided, the hook will still run
+*   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,`)
+*   - `content_type` should match the file MIME type (e.g., "text/csv", "application/pdf").
+*
+* Parameters (UseFileMutationsProps):
+* @param {unknown[]} [queryKey]
+*  Query key to invalidate after successful mutations. Use the same `queryKey` you pass to the relevant `useQuery`
+*  (e.g., file list/detail) so UI data is refreshed automatically after a write.
+*
+*  Tip:
+*  - If you're using `useFetchFile`, you can pass its returned `queryKey` directly:
+*    `const fetch = useFetchFile(...);`
+*    `useFileMutations({ queryKey: fetch.queryKey });`
+*
+* Mutations:
+* - `create`:
+*   - mutationFn: `createFile(api, data)`
+*   - variables: `{ data: Partial<EveryskFile> }`
+*   - success message: "EveryskFile 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."
+*   - 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."
+*   - error message: "Unable to delete the file. Please try again." (fallback)
+*
+* Return value:
+* @returns {object}
+*  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>
+*
+* Each mutation includes standard TanStack Query helpers:
+* - `mutate(variables, options?)`
+* - `mutateAsync(variables, options?)`
+* - `isPending`, `isSuccess`, `isError`, `error`, `data`, etc.
+*
+* Examples:
+*
+* 1) Invalidate a file list query after mutations:
+* ```ts
+* const { create, update, remove } = useFileMutations({ queryKey: ["file"] });
+*
+* // Create
+* create.mutate({
+*   data: {
+*     name: "My file",
+*     workspace: "ws-1",
+*     content_type: "text/plain",
+*     version: "1",
+*     link_uid: null,
+*     data: "SGVsbG8gd29ybGQ=", // Base64 content
+*   }
+* });
+*
+* // Update
+* update.mutate({
+*   id: "file-123",
+*   data: {
+*     name: "Renamed file",
+*     content_type: "text/plain",
+*     data: "SGVsbG8gd29ybGQ=", // Base64 content (optional if only renaming)
+*   }
+* });
+*
+* // Delete
+* remove.mutate({ id: "file-123", workspace: "ws-1" });
+* ```
+*
+* 2) Using async/await with `mutateAsync`:
+* ```ts
+* const { create } = useFileMutations({ queryKey: ["file"] });
+*
+* await create.mutateAsync({
+*   data: {
+*     name: "My file",
+*     workspace: "ws-1",
+*     content_type: "text/plain",
+*     version: "1",
+*     link_uid: null,
+*     data: "SGVsbG8gd29ybGQ=",
+*   }
+* });
+* ```
+*
+* 3) Without cache invalidation (no queryKey):
+* ```ts
+* const { update } = useFileMutations({});
+*
+* update.mutate({
+*   id: "file-123",
+*   data: {
+*     name: "New name",
+*     content_type: "text/plain",
+*   }
+* });
+* // Mutation still runs and alerts are shown, but cached queries are not invalidated.
+* ```
+*
+* 4) Using `useFetchFile` queryKey for automatic invalidation:
+* ```ts
+* const fetch = useFetchFile({
+*   id: null,
+*   filters: [{ field: "workspace", value: "ws-1" }],
+* });
+*
+* const { remove } = useFileMutations({ queryKey: fetch.queryKey });
+*
+* await remove.mutateAsync({ id: "file-123", workspace: "ws-1" });
+* ```
+*/
+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.")
+				});
+			}
+		}),
+		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.")
+				});
+			}
+		}),
+		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.")
+				});
+			}
+		})
+	};
+};
+//#endregion
+export { useFileMutations };
+
+//# sourceMappingURL=useFileMutations.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFileMutations.js","names":[],"sources":["../../../src/hooks/file/useFileMutations.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport type { EveryskFile } from \"@/types/file\";\nimport { deleteFile, createFile, updateFile } from \"@/api/file\";\n\ntype CreateFileProps = {\n    data: Partial<EveryskFile>;\n};\n\ntype UpdateFileProps = {\n    id: string;\n    data: Partial<EveryskFile>;\n};\n\ntype DeleteFileProps = {\n    id: string;\n    workspace: string;\n};\n\ntype UseFileMutationsProps = {\n    queryKey?: unknown[];\n};\n\nconst getErrorMessage = (err: unknown, fallback: string) =>\n    err instanceof Error && err.message ? err.message : fallback;\n\n/**\n * useFileMutations\n *\n * Mutation hook built on TanStack Query to perform EveryskFile write operations:\n * - create a file (POST)\n * - update a file (PUT)\n * - delete a file (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 `useFetchFile`.\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 `deleteFile(api, id, workspace)`\n *   expects it as a query param.\n * \n * - EveryskFile content (`data`):\n *   - When creating/updating a file, the file content must be provided in `data` as a Base64-encoded string.\n *   - Send only the raw Base64 content (do not include a data URL prefix like `data:<mime>;base64,`)\n *   - `content_type` should match the file MIME type (e.g., \"text/csv\", \"application/pdf\").\n *\n * Parameters (UseFileMutationsProps):\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., file list/detail) so UI data is refreshed automatically after a write.\n *\n *  Tip:\n *  - If you're using `useFetchFile`, you can pass its returned `queryKey` directly:\n *    `const fetch = useFetchFile(...);`\n *    `useFileMutations({ queryKey: fetch.queryKey });`\n *\n * Mutations:\n * - `create`:\n *   - mutationFn: `createFile(api, data)`\n *   - variables: `{ data: Partial<EveryskFile> }`\n *   - success message: \"EveryskFile created successfully.\"\n *   - error message: \"Unable to create the file. Please try again.\" (fallback)\n *\n * - `update`:\n *   - mutationFn: `updateFile(api, id, data)`\n *   - variables: `{ id: string; data: Partial<EveryskFile> }`\n *   - success message: \"EveryskFile updated successfully.\"\n *   - error message: \"Unable to update the file. Please try again.\" (fallback)\n *\n * - `remove`:\n *   - mutationFn: `deleteFile(api, id, workspace)`\n *   - variables: `{ id: string; workspace: string }`\n *   - success message: \"EveryskFile deleted successfully.\"\n *   - error message: \"Unable to delete the file. 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<EveryskFile, Error, CreateFileProps, unknown>\n *  - `update`: UseMutationResult<EveryskFile, Error, UpdateFileProps, unknown>\n *  - `remove`: UseMutationResult<EveryskFile, Error, DeleteFileProps, 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 file list query after mutations:\n * ```ts\n * const { create, update, remove } = useFileMutations({ queryKey: [\"file\"] });\n *\n * // Create\n * create.mutate({\n *   data: {\n *     name: \"My file\",\n *     workspace: \"ws-1\",\n *     content_type: \"text/plain\",\n *     version: \"1\",\n *     link_uid: null,\n *     data: \"SGVsbG8gd29ybGQ=\", // Base64 content\n *   }\n * });\n *\n * // Update\n * update.mutate({\n *   id: \"file-123\",\n *   data: {\n *     name: \"Renamed file\",\n *     content_type: \"text/plain\",\n *     data: \"SGVsbG8gd29ybGQ=\", // Base64 content (optional if only renaming)\n *   }\n * });\n *\n * // Delete\n * remove.mutate({ id: \"file-123\", workspace: \"ws-1\" });\n * ```\n *\n * 2) Using async/await with `mutateAsync`:\n * ```ts\n * const { create } = useFileMutations({ queryKey: [\"file\"] });\n *\n * await create.mutateAsync({\n *   data: {\n *     name: \"My file\",\n *     workspace: \"ws-1\",\n *     content_type: \"text/plain\",\n *     version: \"1\",\n *     link_uid: null,\n *     data: \"SGVsbG8gd29ybGQ=\",\n *   }\n * });\n * ```\n *\n * 3) Without cache invalidation (no queryKey):\n * ```ts\n * const { update } = useFileMutations({});\n *\n * update.mutate({\n *   id: \"file-123\",\n *   data: {\n *     name: \"New name\",\n *     content_type: \"text/plain\",\n *   }\n * });\n * // Mutation still runs and alerts are shown, but cached queries are not invalidated.\n * ```\n *\n * 4) Using `useFetchFile` queryKey for automatic invalidation:\n * ```ts\n * const fetch = useFetchFile({\n *   id: null,\n *   filters: [{ field: \"workspace\", value: \"ws-1\" }],\n * });\n *\n * const { remove } = useFileMutations({ queryKey: fetch.queryKey });\n *\n * await remove.mutateAsync({ id: \"file-123\", workspace: \"ws-1\" });\n * ```\n */\n\nexport const useFileMutations = ({ queryKey }: UseFileMutationsProps) => {\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 }: CreateFileProps) => createFile(api, data),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"EveryskFile created successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(\n                    err,\n                    \"Unable to create the file. Please try again.\"\n                ),\n            });\n        },\n    });\n\n    const update = useMutation({\n        mutationFn: async ({ id, data }: UpdateFileProps) => updateFile(api, id, data),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"EveryskFile updated successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(\n                    err,\n                    \"Unable to update the file. Please try again.\"\n                ),\n            });\n        },\n    });\n\n    const remove = useMutation({\n        mutationFn: async ({ id, workspace }: DeleteFileProps) => deleteFile(api, id, workspace),\n        onSuccess: async () => {\n            await invalidate();\n            showAlert({\n                severity: \"success\",\n                message: \"EveryskFile deleted successfully.\",\n            });\n        },\n        onError: (err: unknown) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(\n                    err,\n                    \"Unable to delete the file. 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8IxD,IAAa,oBAAoB,EAAE,eAAsC;CACrE,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,WAA4B,WAAW,KAAK,IAAI;GACrE,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,8CACJ;IACJ,CAAC;GACL;EACJ,CA0CS;EAAQ,QAxCF,YAAY;GACvB,YAAY,OAAO,EAAE,IAAI,WAA4B,WAAW,KAAK,IAAI,IAAI;GAC7E,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,8CACJ;IACJ,CAAC;GACL;EACJ,CAsBiB;EAAQ,QApBV,YAAY;GACvB,YAAY,OAAO,EAAE,IAAI,gBAAiC,WAAW,KAAK,IAAI,SAAS;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,8CACJ;IACJ,CAAC;GACL;EACJ,CAEyB;CAAO;AACpC"}