homeio

1"use client";
2
3import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
4import type { FileReadResponse } from "@/lib/shared/contracts/files";
5import { queryKeys } from "@/lib/shared/query-keys";
6import {
7  createFile,
8  createFolder,
9  fetchDirectory,
10  fetchFileContent,
11  fetchRoot,
12  fetchStarredFiles,
13  getFileInfo,
14  getParentPath,
15  pasteFile,
16  renameFile,
17  searchFilesRequest,
18  saveFileContent,
19  toFilePath,
20  toggleStar,
21  unzipFile,
22  uploadFilesToPath,
23} from "@/modules/files/hooks/files-api";
24
25export { buildAssetUrl, buildDownloadUrl, buildZipUrl, toFilePath } from "@/modules/files/hooks/files-api";
26export type { FilePasteCollision } from "@/modules/files/hooks/files-api";
27
28export function useFilesRoot() {
29  return useQuery({
30    queryKey: queryKeys.filesRoot,
31    queryFn: fetchRoot,
32    staleTime: 5_000,
33  });
34}
35
36export function useFilesDirectory(
37  pathSegments: string[],
38  includeHidden = false,
39  options: { enabled?: boolean } = {},
40) {
41  const filePath = toFilePath(pathSegments);
42
43  return useQuery({
44    queryKey: queryKeys.filesList(filePath, includeHidden),
45    queryFn: () => fetchDirectory(filePath, includeHidden),
46    staleTime: 3_000,
47    enabled: options.enabled !== false,
48  });
49}
50
51export function useFileContent(filePath: string | null) {
52  return useQuery({
53    queryKey: queryKeys.fileContent(filePath ?? ""),
54    queryFn: () => fetchFileContent(filePath ?? ""),
55    enabled: Boolean(filePath),
56    staleTime: 0,
57  });
58}
59
60export function useSaveFileContent() {
61  const queryClient = useQueryClient();
62
63  return useMutation({
64    mutationFn: saveFileContent,
65    onSuccess: (data, variables) => {
66      void queryClient.invalidateQueries({
67        queryKey: queryKeys.fileContent(variables.path),
68      });
69      void queryClient.invalidateQueries({
70        queryKey: ["files", "list", getParentPath(variables.path)],
71      });
72      queryClient.setQueryData(queryKeys.fileContent(variables.path), (
73        prev: { data: FileReadResponse } | FileReadResponse | undefined,
74      ) => {
75        const previous =
76          prev && "data" in prev
77            ? prev.data
78            : (prev as FileReadResponse | undefined);
79
80        if (!previous || previous.mode !== "text") return previous;
81
82        return {
83          ...previous,
84          content: variables.content,
85          mtimeMs: data.mtimeMs,
86          modifiedAt: data.modifiedAt,
87          sizeBytes: data.sizeBytes,
88        } satisfies FileReadResponse;
89      });
90    },
91  });
92}
93
94function invalidateFileListPath(queryClient: ReturnType<typeof useQueryClient>, filePath: string) {
95  void queryClient.invalidateQueries({
96    queryKey: ["files", "list", filePath],
97  });
98}
99
100export function useCreateFolder() {
101  const queryClient = useQueryClient();
102
103  return useMutation({
104    mutationFn: createFolder,
105    onSuccess: (_, variables) => {
106      invalidateFileListPath(queryClient, variables.parentPath);
107    },
108  });
109}
110
111export function useCreateFile() {
112  const queryClient = useQueryClient();
113
114  return useMutation({
115    mutationFn: createFile,
116    onSuccess: (_, variables) => {
117      invalidateFileListPath(queryClient, variables.parentPath);
118    },
119  });
120}
121
122export function usePasteFileEntry() {
123  const queryClient = useQueryClient();
124
125  return useMutation({
126    mutationFn: pasteFile,
127    onSuccess: (_, variables) => {
128      invalidateFileListPath(queryClient, variables.destinationPath);
129      invalidateFileListPath(queryClient, getParentPath(variables.sourcePath));
130      if (variables.operation === "move") {
131        void queryClient.invalidateQueries({
132          queryKey: queryKeys.fileContent(variables.sourcePath),
133        });
134      }
135    },
136  });
137}
138
139export function useRenameFileEntry() {
140  const queryClient = useQueryClient();
141
142  return useMutation({
143    mutationFn: renameFile,
144    onSuccess: (data, variables) => {
145      invalidateFileListPath(queryClient, getParentPath(variables.path));
146      if (getParentPath(variables.path) !== getParentPath(data.path)) {
147        invalidateFileListPath(queryClient, getParentPath(data.path));
148      }
149      void queryClient.invalidateQueries({
150        queryKey: queryKeys.fileContent(variables.path),
151      });
152      void queryClient.invalidateQueries({
153        queryKey: queryKeys.fileContent(data.path),
154      });
155    },
156  });
157}
158
159export function useFileEntryInfo() {
160  return useMutation({
161    mutationFn: getFileInfo,
162  });
163}
164
165export function useToggleFileStar() {
166  const queryClient = useQueryClient();
167
168  return useMutation({
169    mutationFn: toggleStar,
170    onSuccess: (_data, pathValue) => {
171      invalidateFileListPath(queryClient, getParentPath(pathValue));
172      void queryClient.invalidateQueries({ queryKey: queryKeys.filesStarred });
173    },
174  });
175}
176
177export function useStarredFiles() {
178  return useQuery({
179    queryKey: queryKeys.filesStarred,
180    queryFn: fetchStarredFiles,
181    staleTime: 5_000,
182  });
183}
184
185export function useSearchFiles(params: {
186  query: string;
187  basePath?: string;
188  includeHidden?: boolean;
189  enabled?: boolean;
190}) {
191  return useQuery({
192    queryKey: queryKeys.filesSearch(
193      params.query,
194      params.basePath ?? "",
195      params.includeHidden ?? false,
196    ),
197    queryFn: () =>
198      searchFilesRequest({
199        query: params.query,
200        basePath: params.basePath,
201        includeHidden: params.includeHidden,
202      }),
203    enabled: Boolean(params.enabled) && params.query.trim().length >= 2,
204    staleTime: 10_000,
205  });
206}
207
208export function useUploadFiles() {
209  const queryClient = useQueryClient();
210
211  return useMutation({
212    mutationFn: uploadFilesToPath,
213    onSuccess: (_data, variables) => {
214      invalidateFileListPath(queryClient, variables.destinationPath);
215    },
216  });
217}
218
219export function useUnzipFile() {
220  const queryClient = useQueryClient();
221
222  return useMutation({
223    mutationFn: (pathValue: string) => unzipFile(pathValue),
224    onSuccess: (data) => {
225      invalidateFileListPath(queryClient, data.destinationPath);
226    },
227  });
228}
229
230