homeio

1import { lstat, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
2import os from "node:os";
3import path from "node:path";
4import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
5
6let mockDataRoot = "";
7
8vi.mock("@/lib/server/modules/files/path-resolver", () => {
9  class FilesPathError extends Error {
10    code: string;
11    statusCode: number;
12
13    constructor(
14      message: string,
15      options?: {
16        code?: string;
17        statusCode?: number;
18      },
19    ) {
20      super(message);
21      this.code = options?.code ?? "internal_error";
22      this.statusCode = options?.statusCode ?? 500;
23    }
24  }
25
26  function ensureWithinRoot(rootPath: string, absolutePath: string) {
27    const relative = path.relative(rootPath, absolutePath);
28    const within =
29      relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
30    if (!within) {
31      throw new FilesPathError("Path escapes root", {
32        code: "path_outside_root",
33        statusCode: 400,
34      });
35    }
36  }
37
38  return {
39    FilesPathError,
40    resolvePathWithinFilesRoot: vi.fn(async (input: {
41      inputPath?: string;
42      allowHiddenSegments?: boolean;
43      requiredPrefix?: string;
44      allowMissingLeaf?: boolean;
45    }) => {
46      const cleaned = (input.inputPath ?? "").trim().replaceAll("\\", "/");
47      const normalized = cleaned ? path.posix.normalize(cleaned) : "";
48      if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
49        throw new FilesPathError("Invalid path", {
50          code: "invalid_path",
51          statusCode: 400,
52        });
53      }
54
55      const relativePath = normalized;
56      const segments = relativePath.split("/");
57      if (!input.allowHiddenSegments && segments.some((segment) => segment.startsWith("."))) {
58        throw new FilesPathError("Hidden files are not allowed", {
59          code: "hidden_blocked",
60          statusCode: 403,
61        });
62      }
63      if (
64        input.requiredPrefix &&
65        relativePath !== input.requiredPrefix &&
66        !relativePath.startsWith(`${input.requiredPrefix}/`)
67      ) {
68        throw new FilesPathError("Invalid path", {
69          code: "invalid_path",
70          statusCode: 400,
71        });
72      }
73
74      let current = mockDataRoot;
75      for (const segment of segments) {
76        current = path.join(current, segment);
77        try {
78          const info = await lstat(current);
79          if (info.isSymbolicLink()) {
80            throw new FilesPathError("Symlinks are not allowed", {
81              code: "symlink_blocked",
82              statusCode: 403,
83            });
84          }
85        } catch (error) {
86          const nodeError = error as NodeJS.ErrnoException;
87          if (nodeError?.code === "ENOENT") {
88            if (input.allowMissingLeaf) break;
89            throw new FilesPathError("File or directory not found", {
90              code: "not_found",
91              statusCode: 404,
92            });
93          }
94          throw error;
95        }
96      }
97
98      const absolutePath = path.resolve(mockDataRoot, relativePath);
99      ensureWithinRoot(mockDataRoot, absolutePath);
100
101      return {
102        rootPath: mockDataRoot,
103        relativePath,
104        absolutePath,
105        segments,
106        exists: true,
107      };
108    }),
109  };
110});
111
112vi.mock("@/lib/server/modules/files/trash-repository", () => ({
113  upsertTrashEntryInDb: vi.fn(),
114  getTrashEntryFromDb: vi.fn(),
115  deleteTrashEntryFromDb: vi.fn(),
116}));
117
118import {
119  deleteFromTrash,
120  moveToTrash,
121  restoreFromTrash,
122  type TrashServiceError,
123} from "@/lib/server/modules/files/trash-service";
124import { resolvePathWithinFilesRoot } from "@/lib/server/modules/files/path-resolver";
125import {
126  deleteTrashEntryFromDb,
127  getTrashEntryFromDb,
128  upsertTrashEntryInDb,
129} from "@/lib/server/modules/files/trash-repository";
130
131describe("trash service", () => {
132  beforeEach(async () => {
133    mockDataRoot = await mkdtemp(path.join(os.tmpdir(), "home-server-trash-"));
134    await mkdir(path.join(mockDataRoot, "Trash"), { recursive: true });
135    await mkdir(path.join(mockDataRoot, "Documents"), { recursive: true });
136  });
137
138  afterEach(async () => {
139    if (mockDataRoot) {
140      await rm(mockDataRoot, { recursive: true, force: true });
141    }
142    vi.clearAllMocks();
143  });
144
145  it("moves files to Trash and stores metadata", async () => {
146    await writeFile(path.join(mockDataRoot, "Documents", "notes.txt"), "hello", "utf8");
147
148    const moved = await moveToTrash("Documents/notes.txt");
149
150    expect(moved.trashPath.startsWith("Trash/")).toBe(true);
151    expect(moved.originalPath).toBe("Documents/notes.txt");
152    expect(
153      await readFile(path.join(mockDataRoot, moved.trashPath), "utf8"),
154    ).toBe("hello");
155    expect(vi.mocked(upsertTrashEntryInDb)).toHaveBeenCalledWith(
156      expect.objectContaining({
157        trashPath: moved.trashPath,
158        originalPath: "Documents/notes.txt",
159      }),
160    );
161  });
162
163  it("restores using keep-both collision policy", async () => {
164    await writeFile(path.join(mockDataRoot, "Trash", "notes.txt"), "from-trash", "utf8");
165    await writeFile(path.join(mockDataRoot, "Documents", "notes.txt"), "existing", "utf8");
166
167    vi.mocked(getTrashEntryFromDb).mockResolvedValueOnce({
168      id: "trash-1",
169      trashPath: "Trash/notes.txt",
170      originalPath: "Documents/notes.txt",
171      deletedAt: new Date(),
172    });
173
174    const restored = await restoreFromTrash("Trash/notes.txt", "keep-both");
175
176    expect(restored.sourceTrashPath).toBe("Trash/notes.txt");
177    expect(restored.restoredPath).toBe("Documents/notes (2).txt");
178    expect(
179      await readFile(path.join(mockDataRoot, "Documents", "notes (2).txt"), "utf8"),
180    ).toBe("from-trash");
181    expect(vi.mocked(deleteTrashEntryFromDb)).toHaveBeenCalledWith("Trash/notes.txt");
182  });
183
184  it("restores when original target no longer exists", async () => {
185    await writeFile(path.join(mockDataRoot, "Trash", "restorable.txt"), "from-trash", "utf8");
186
187    vi.mocked(getTrashEntryFromDb).mockResolvedValueOnce({
188      id: "trash-restore-1",
189      trashPath: "Trash/restorable.txt",
190      originalPath: "Documents/restorable.txt",
191      deletedAt: new Date(),
192    });
193
194    const restored = await restoreFromTrash("Trash/restorable.txt", "keep-both");
195
196    expect(restored.sourceTrashPath).toBe("Trash/restorable.txt");
197    expect(restored.restoredPath).toBe("Documents/restorable.txt");
198    expect(
199      await readFile(path.join(mockDataRoot, "Documents", "restorable.txt"), "utf8"),
200    ).toBe("from-trash");
201    expect(vi.mocked(deleteTrashEntryFromDb)).toHaveBeenCalledWith("Trash/restorable.txt");
202  });
203
204  it("restores when source recheck transiently reports not_found", async () => {
205    await writeFile(path.join(mockDataRoot, "Trash", "race.txt"), "from-trash", "utf8");
206
207    vi.mocked(getTrashEntryFromDb).mockResolvedValueOnce({
208      id: "trash-race-1",
209      trashPath: "Trash/race.txt",
210      originalPath: "Documents/race.txt",
211      deletedAt: new Date(),
212    });
213
214    const defaultResolver = vi.mocked(resolvePathWithinFilesRoot).getMockImplementation();
215    if (!defaultResolver) {
216      throw new Error("Expected mocked resolvePathWithinFilesRoot implementation");
217    }
218
219    let trashResolveCount = 0;
220    vi.mocked(resolvePathWithinFilesRoot).mockImplementation(async (input) => {
221      if (input.inputPath === "Trash/race.txt") {
222        trashResolveCount += 1;
223        if (trashResolveCount === 2) {
224          const transientNotFound = new Error("transient not found") as Error & {
225            code?: string;
226          };
227          transientNotFound.code = "ENOENT";
228          throw transientNotFound;
229        }
230      }
231      return defaultResolver(input);
232    });
233
234    const restored = await restoreFromTrash("Trash/race.txt", "keep-both");
235
236    expect(restored.sourceTrashPath).toBe("Trash/race.txt");
237    expect(restored.restoredPath).toBe("Documents/race.txt");
238    expect(
239      await readFile(path.join(mockDataRoot, "Documents", "race.txt"), "utf8"),
240    ).toBe("from-trash");
241    expect(vi.mocked(deleteTrashEntryFromDb)).toHaveBeenCalledWith("Trash/race.txt");
242  });
243
244  it("deletes items permanently from Trash", async () => {
245    await writeFile(path.join(mockDataRoot, "Trash", "old.log"), "bye", "utf8");
246
247    const deleted = await deleteFromTrash("Trash/old.log");
248
249    expect(deleted.deleted).toBe(true);
250    expect(deleted.path).toBe("Trash/old.log");
251    expect(vi.mocked(deleteTrashEntryFromDb)).toHaveBeenCalledWith("Trash/old.log");
252  });
253
254  it("errors when trash metadata is missing on restore", async () => {
255    await writeFile(path.join(mockDataRoot, "Trash", "missing.txt"), "x", "utf8");
256    vi.mocked(getTrashEntryFromDb).mockResolvedValueOnce(null);
257
258    await expect(restoreFromTrash("Trash/missing.txt", "keep-both")).rejects.toMatchObject<
259      Partial<TrashServiceError>
260    >({
261      code: "trash_meta_missing",
262      statusCode: 404,
263    });
264  });
265});
266