homeio

1import { NextResponse } from "next/server";
2import { z } from "zod";
3import { serverEnv } from "@/lib/server/env";
4import { requireApiSession } from "@/lib/server/modules/auth/api";
5import {
6  createRequestId,
7  logServerAction,
8  withServerTiming,
9} from "@/lib/server/logging/logger";
10import {
11  createDirectoryEntry,
12  createFileEntry,
13  FileServiceError,
14  getEntryInfo,
15  pasteEntry,
16  renameEntry,
17  toggleStarEntry,
18  unzipEntry,
19} from "@/lib/server/modules/files/service";
20
21export const runtime = "nodejs";
22
23const opsSchema = z.discriminatedUnion("action", [
24  z.object({
25    action: z.literal("create_folder"),
26    parentPath: z.string().trim().default(""),
27    name: z.string().trim().min(1),
28  }),
29  z.object({
30    action: z.literal("create_file"),
31    parentPath: z.string().trim().default(""),
32    name: z.string().trim().min(1),
33  }),
34  z.object({
35    action: z.literal("paste"),
36    sourcePath: z.string().trim().min(1),
37    destinationPath: z.string().trim().default(""),
38    operation: z.enum(["copy", "move"]),
39    collision: z.enum(["replace", "keep-both", "skip"]).optional(),
40  }),
41  z.object({
42    action: z.literal("rename"),
43    path: z.string().trim().min(1),
44    newName: z.string().trim().min(1),
45  }),
46  z.object({
47    action: z.literal("get_info"),
48    path: z.string().trim().min(1),
49  }),
50  z.object({
51    action: z.literal("toggle_star"),
52    path: z.string().trim().min(1),
53  }),
54  z.object({
55    action: z.literal("unzip"),
56    path: z.string().trim().min(1),
57  }),
58]);
59
60export async function POST(request: Request) {
61  const apiSession = await requireApiSession(request);
62  if (apiSession.response) return apiSession.response;
63  const requestId = createRequestId();
64
65  try {
66    return await withServerTiming(
67      {
68        layer: "api",
69        action: "files.ops.post",
70        requestId,
71      },
72      async () => {
73        const payload = await request.json();
74        const parsed = opsSchema.safeParse(payload);
75        if (!parsed.success) {
76          return NextResponse.json(
77            {
78              error: "Invalid files operation payload",
79              code: "invalid_path",
80            },
81            { status: 400 },
82          );
83        }
84
85        const includeHidden = serverEnv.FILES_ALLOW_HIDDEN;
86        if (parsed.data.action === "create_folder") {
87          const data = await createDirectoryEntry({
88            parentPath: parsed.data.parentPath,
89            name: parsed.data.name,
90            includeHidden,
91          });
92          return NextResponse.json(
93            { data },
94            {
95              headers: {
96                "Cache-Control": "no-store",
97              },
98            },
99          );
100        }
101
102        if (parsed.data.action === "create_file") {
103          const data = await createFileEntry({
104            parentPath: parsed.data.parentPath,
105            name: parsed.data.name,
106            includeHidden,
107          });
108          return NextResponse.json(
109            { data },
110            {
111              headers: {
112                "Cache-Control": "no-store",
113              },
114            },
115          );
116        }
117
118        if (parsed.data.action === "rename") {
119          const data = await renameEntry({
120            path: parsed.data.path,
121            newName: parsed.data.newName,
122            includeHidden,
123          });
124          return NextResponse.json(
125            { data },
126            {
127              headers: {
128                "Cache-Control": "no-store",
129              },
130            },
131          );
132        }
133
134        if (parsed.data.action === "get_info") {
135          const data = await getEntryInfo({
136            path: parsed.data.path,
137            includeHidden,
138          });
139          return NextResponse.json(
140            { data },
141            {
142              headers: {
143                "Cache-Control": "no-store",
144              },
145            },
146          );
147        }
148
149        if (parsed.data.action === "toggle_star") {
150          const data = await toggleStarEntry({
151            path: parsed.data.path,
152            includeHidden,
153          });
154          return NextResponse.json(
155            { data },
156            {
157              headers: {
158                "Cache-Control": "no-store",
159              },
160            },
161          );
162        }
163
164        if (parsed.data.action === "unzip") {
165          const data = await unzipEntry({
166            path: parsed.data.path,
167            includeHidden,
168          });
169          return NextResponse.json(
170            { data },
171            {
172              headers: {
173                "Cache-Control": "no-store",
174              },
175            },
176          );
177        }
178
179        const data = await pasteEntry({
180          sourcePath: parsed.data.sourcePath,
181          destinationPath: parsed.data.destinationPath,
182          operation: parsed.data.operation,
183          collision: parsed.data.collision,
184          includeHidden,
185        });
186        return NextResponse.json(
187          { data },
188          {
189            headers: {
190              "Cache-Control": "no-store",
191            },
192          },
193        );
194      },
195    );
196  } catch (error) {
197    if (error instanceof FileServiceError) {
198      return NextResponse.json(
199        {
200          error: error.message,
201          code: error.code,
202        },
203        {
204          status: error.statusCode,
205        },
206      );
207    }
208
209    logServerAction({
210      level: "error",
211      layer: "api",
212      action: "files.ops.post.response",
213      status: "error",
214      requestId,
215      message: "Unable to execute file operation",
216      error,
217    });
218
219    return NextResponse.json(
220      {
221        error: "Unable to execute file operation",
222        code: "internal_error",
223      },
224      {
225        status: 500,
226      },
227    );
228  }
229}
230