homeio

1import "server-only";
2
3import type { ReadableStream as WebReadableStream } from "stream/web";
4import { type NextRequest, NextResponse } from "next/server";
5import { Readable } from "node:stream";
6import busboy from "busboy";
7import { requireApiSession } from "@/lib/server/modules/auth/api";
8import {
9  createRequestId,
10  logServerAction,
11  withServerTiming,
12} from "@/lib/server/logging/logger";
13import {
14  FileServiceError,
15  uploadFiles,
16} from "@/lib/server/modules/files/service";
17import type { FileUploadResponse } from "@/lib/shared/contracts/files";
18
19export const runtime = "nodejs";
20
21export const maxDuration = 300;
22
23/**
24 * Stream-parse a multipart upload and pipe each file directly to disk via
25 * uploadFiles, so the full file body is never held in memory at once.
26 *
27 * Fields (path, includeHidden) MUST appear before file parts in the
28 * multipart body — this is the convention and what the client sends.
29 */
30function streamingUpload(req: NextRequest): Promise<FileUploadResponse> {
31  return new Promise((resolve, reject) => {
32    const contentType = req.headers.get("content-type") ?? "";
33
34    let bb: ReturnType<typeof busboy>;
35    try {
36      bb = busboy({ headers: { "content-type": contentType } });
37    } catch (err) {
38      reject(new Error(`Invalid multipart request: ${String(err)}`));
39      return;
40    }
41
42    let destinationPath = "";
43    let includeHidden = false;
44    const filePromises: Promise<FileUploadResponse>[] = [];
45
46    bb.on("field", (name, value) => {
47      if (name === "path") destinationPath = value;
48      if (name === "includeHidden") includeHidden = value === "true";
49    });
50
51    bb.on("file", (_field, fileStream, info) => {
52      // Capture field values at the moment the file part begins.
53      // The client sends fields first so these are already populated.
54      const dest = destinationPath;
55      const hidden = includeHidden;
56
57      // Wrap the live busboy Node.js Readable as a web ReadableStream so it
58      // matches the uploadFiles interface. uploadFiles calls stream() and
59      // immediately pipes the result — data flows directly to disk without
60      // any intermediate in-memory buffer.
61      let byteCount = 0;
62      fileStream.on("data", (chunk: Buffer) => {
63        byteCount += chunk.length;
64      });
65
66      const webStream = Readable.toWeb(fileStream) as ReadableStream;
67
68      filePromises.push(
69        uploadFiles({
70          destinationPath: dest,
71          includeHidden: hidden,
72          files: [
73            {
74              name: info.filename,
75              get size() {
76                return byteCount;
77              },
78              stream: () => webStream,
79            },
80          ],
81        }),
82      );
83    });
84
85    bb.on("finish", () => {
86      Promise.all(filePromises)
87        .then((results) => {
88          const merged: FileUploadResponse = { uploaded: [], skipped: [] };
89          for (const r of results) {
90            merged.uploaded.push(...r.uploaded);
91            merged.skipped.push(...r.skipped);
92          }
93          resolve(merged);
94        })
95        .catch(reject);
96    });
97
98    bb.on("error", reject);
99
100    if (!req.body) {
101      reject(new Error("No request body"));
102      return;
103    }
104    Readable.fromWeb(req.body as WebReadableStream).pipe(bb);
105  });
106}
107
108export async function POST(request: NextRequest) {
109  const apiSession = await requireApiSession(request);
110  if (apiSession.response) return apiSession.response;
111  const requestId = createRequestId();
112
113  try {
114    return await withServerTiming(
115      {
116        layer: "api",
117        action: "files.upload.post",
118        requestId,
119      },
120      async () => {
121        const data = await streamingUpload(request);
122
123        if (data.uploaded.length === 0 && data.skipped.length === 0) {
124          return NextResponse.json(
125            { error: "No files provided" },
126            { status: 400 },
127          );
128        }
129
130        return NextResponse.json({ data });
131      },
132    );
133  } catch (error) {
134    if (error instanceof FileServiceError) {
135      return NextResponse.json(
136        { error: error.message, code: error.code },
137        { status: error.statusCode },
138      );
139    }
140
141    logServerAction({
142      layer: "api",
143      action: "files.upload.post",
144      requestId,
145      error: error instanceof Error ? error : new Error(String(error)),
146    });
147
148    return NextResponse.json(
149      { error: "Failed to upload files" },
150      { status: 500 },
151    );
152  }
153}
154