homeio

1import { createReadStream } from "node:fs";
2import { Readable } from "node:stream";
3import { type NextRequest, NextResponse } from "next/server";
4import { serverEnv } from "@/lib/server/env";
5import { requireApiSession } from "@/lib/server/modules/auth/api";
6import {
7  createRequestId,
8  logServerAction,
9  withServerTiming,
10} from "@/lib/server/logging/logger";
11import {
12  FileServiceError,
13  readFileForViewer,
14  resolveReadableFileAbsolutePath,
15} from "@/lib/server/modules/files/service";
16
17export const runtime = "nodejs";
18
19export async function GET(request: NextRequest) {
20  const apiSession = await requireApiSession(request);
21  if (apiSession.response) return apiSession.response;
22  const requestId = createRequestId();
23
24  try {
25    return await withServerTiming(
26      {
27        layer: "api",
28        action: "files.asset.get",
29        requestId,
30      },
31      async () => {
32        const filePath = request.nextUrl.searchParams.get("path");
33        if (!filePath) {
34          return NextResponse.json(
35            {
36              error: "Missing file path",
37              code: "invalid_path",
38            },
39            { status: 400 },
40          );
41        }
42
43        const details = await readFileForViewer({
44          path: filePath,
45          includeHidden: serverEnv.FILES_ALLOW_HIDDEN,
46        });
47        if (
48          details.mode !== "image" &&
49          details.mode !== "pdf" &&
50          details.mode !== "video" &&
51          details.mode !== "audio"
52        ) {
53          return NextResponse.json(
54            {
55              error: "Unsupported asset preview type",
56              code: "unsupported_file",
57            },
58            {
59              status: 415,
60            },
61          );
62        }
63
64        const resolved = await resolveReadableFileAbsolutePath({
65          path: filePath,
66          includeHidden: serverEnv.FILES_ALLOW_HIDDEN,
67        });
68
69        // For video/audio files, support HTTP Range requests so the browser
70        // can seek without downloading the whole file first.
71        if (details.mode === "video" || details.mode === "audio") {
72          const rangeHeader = request.headers.get("range");
73          const { absolutePath } = resolved;
74          const fileSize = details.sizeBytes;
75
76          if (rangeHeader) {
77            const [startStr, endStr] = rangeHeader.replace(/bytes=/, "").split("-");
78            const start = parseInt(startStr, 10);
79            const end = endStr ? parseInt(endStr, 10) : fileSize - 1;
80            const chunkSize = end - start + 1;
81
82            const stream = createReadStream(absolutePath, { start, end });
83            return new NextResponse(Readable.toWeb(stream) as ReadableStream, {
84              status: 206,
85              headers: {
86                "Content-Range": `bytes ${start}-${end}/${fileSize}`,
87                "Accept-Ranges": "bytes",
88                "Content-Length": String(chunkSize),
89                "Content-Type": details.mimeType ?? "application/octet-stream",
90                "Cache-Control": "no-store",
91              },
92            });
93          }
94
95          const stream = createReadStream(absolutePath);
96          return new NextResponse(Readable.toWeb(stream) as ReadableStream, {
97            status: 200,
98            headers: {
99              "Accept-Ranges": "bytes",
100              "Content-Length": String(fileSize),
101              "Content-Type": details.mimeType ?? "application/octet-stream",
102              "Cache-Control": "no-store",
103            },
104          });
105        }
106
107        const stream = createReadStream(resolved.absolutePath);
108
109        return new NextResponse(Readable.toWeb(stream) as ReadableStream, {
110          status: 200,
111          headers: {
112            "Cache-Control": "no-store",
113            "Content-Type": details.mimeType ?? "application/octet-stream",
114            "Content-Length": String(details.sizeBytes),
115            "X-Content-Type-Options": "nosniff",
116          },
117        });
118      },
119    );
120  } catch (error) {
121    if (error instanceof FileServiceError) {
122      return NextResponse.json(
123        {
124          error: error.message,
125          code: error.code,
126        },
127        {
128          status: error.statusCode,
129        },
130      );
131    }
132
133    logServerAction({
134      level: "error",
135      layer: "api",
136      action: "files.asset.get.response",
137      status: "error",
138      requestId,
139      message: "Unable to stream file asset",
140      error,
141    });
142
143    return NextResponse.json(
144      {
145        error: "Unable to stream file asset",
146        code: "internal_error",
147      },
148      {
149        status: 500,
150      },
151    );
152  }
153}
154