fix: migration storage backend and also user avatar upload.

app/api/images/[fileName]/route.ts

@@ -8,43 +8,36 @@ import path from "path";
 import {db} from "@/db";
 import * as drizzleDb from "@/db";
 import {eq} from "drizzle-orm";
-import fs from "fs/promises";
-
-function nodeStreamToWebStream(nodeStream: stream.Readable) {
-    return new ReadableStream({
-        start(controller) {
-            nodeStream.on("data", chunk => controller.enqueue(chunk));
-            nodeStream.on("end", () => controller.close());
-            nodeStream.on("error", err => controller.error(err));
-        },
-        cancel() {
-            nodeStream.destroy();
-        },
-    });
-}
-
-const privateS3ImageDir = "images/";
-
+import {StorageInput} from "@/features/storages/types";
+import {dispatchStorage} from "@/features/storages/dispatch";
+import {Readable} from "node:stream";
 
 export async function GET(
     req: Request,
     {params}: { params: Promise<{ fileName: string }> }
 ) {
+
+
     const fileName = (await params).fileName;
+
+
     if (!fileName) return NextResponse.json({error: "Missing file parameter"}, {status: 400});
 
     const session = await auth.api.getSession({headers: await headers()});
     if (!session) return NextResponse.json({error: "Unauthorized"}, {status: 403});
 
-    const [settings] = await db
-        .select()
-        .from(drizzleDb.schemas.setting)
-        .where(eq(drizzleDb.schemas.setting.name, "system"))
-        .limit(1);
+    const settings = await db.query.setting.findFirst({
+        where: eq(drizzleDb.schemas.setting.name, "system"),
+        with: {
+            storageChannel: true
+        }
+    });
+
+    if (!settings || !settings.storageChannel) {
+        return NextResponse.json({error: "Unable to get settings or no default storage channel"});
+    }
 
-    if (!settings) throw new Error("System settings not found.");
 
-    const storageType = settings.storage; // "local" or "s3"
     const ext = fileName.split(".").pop()?.toLowerCase();
     const contentType =
         ext === "png"
@@ -58,44 +51,43 @@ export async function GET(
                         : "application/octet-stream";
 
     try {
-        if (storageType === "local") {
-            const filePath = path.join(process.cwd(), "private/uploads/images", fileName);
 
-            try {
-                await fs.access(filePath);
-                const file = await fs.readFile(filePath);
+        const path = `images/${fileName}`;
 
-                return new NextResponse(file, {
-                    headers: {
-                        "Content-Type": contentType,
-                        "Cache-Control": "no-store",
-                        "Content-Disposition": `inline; filename="${fileName}"`,
-                    },
-                });
-            } catch {
-                // if not found locally, fallback to S3
+        const input: StorageInput = {
+            action: "get",
+            data: {
+                path: path,
             }
         }
 
-        const exists = await checkFileExistsInBucket({
-            bucketName: env.S3_BUCKET_NAME!,
-            fileName: `${privateS3ImageDir}${fileName}`,
-        });
-        if (!exists) return NextResponse.json({error: "File not found"}, {status: 404});
+        const result = await dispatchStorage(input, undefined, settings.storageChannel.id);
 
-        const nodeStream = await getObjectFromClient({
-            bucketName: env.S3_BUCKET_NAME!,
-            fileName: `${privateS3ImageDir}${fileName}`,
-        });
-        const webStream = nodeStreamToWebStream(nodeStream);
+        if (!result.file || !Buffer.isBuffer(result.file)) {
+            return NextResponse.json(
+                {error: "Invalid file payload"},
+                {status: 500}
+            );
+        }
 
-        return new NextResponse(webStream, {
-            headers: {
-                "Content-Type": contentType,
-                "Cache-Control": "no-store",
-                "Content-Disposition": `inline; filename="${fileName}"`,
+        const fileStream = Readable.from(result.file);
+
+        const stream = new ReadableStream({
+            start(controller) {
+                fileStream.on('data', (chunk) => controller.enqueue(chunk));
+                fileStream.on('end', () => controller.close());
+                fileStream.on('error', (err) => controller.error(err));
             },
         });
+
+        return new NextResponse(stream, {
+            headers: {
+                'Content-Disposition': `inline; filename="${fileName}"`,
+                "Cache-Control": "no-store",
+                "Content-Type": contentType,
+            },
+        });
+
     } catch (err) {
         console.error("Error streaming image:", err);
         return NextResponse.json({error: "Error fetching file"}, {status: 500});