portabase/src/features/api/upload/index.ts

import express, {Request, Response, Router} from "express";
import {v4 as uuidv4} from "uuid";
import {and, eq} from "drizzle-orm";
import * as drizzleDb from "@/db";
import {db} from "@/db";
import {createDecryptionStream, getFileExtension} from "./helpers";
import {isUuidv4} from "@/utils/verify-uuid";
import uploadTempFileToProviders from "@/features/api/upload/helpers/common";
import {sendNotificationsBackupRestore} from "@/features/notifications/helpers";
import {Backup} from "@/db/schema/07_database";
import {withUpdatedAt} from "@/db/utils";
import {eventEmitter} from "@/features/shared/event";

const router: Router = express.Router();

router.post("/:agentId", async (req: Request, res: Response) => {
    try {
        const agentId = req.params.agentId as string | undefined;
        const generatedId = req.headers["x-generated-id"] as string | undefined;
        const status = req.headers["x-status"] as string | undefined;
        const encryptedAesKeyHex = req.headers["x-aes-key"] as string | undefined;
        const ivHex = req.headers["x-iv"] as string | undefined;
        const method = (req.headers["x-method"] as string) ?? "manual";
        const extension = req.headers["x-extension"] as string | undefined;


        if (!generatedId || !encryptedAesKeyHex || !ivHex || !agentId || !status) {
            return res.status(400).json({error: "Missing required headers/params"});
        }

        if (!isUuidv4(generatedId)) {
            return res.status(400).json({error: "generatedId is not a valid UUID"});
        }

        const agent = await db.query.agent.findFirst({
            where: eq(drizzleDb.schemas.agent.id, agentId),
        });

        if (!agent) {
            return res.status(404).json({error: "Agent not found"});
        }


        const database = await db.query.database.findFirst({
            where: eq(drizzleDb.schemas.database.agentDatabaseId, generatedId),
            with: {
                project: true,
                storagePolicies: true,
            },
        });

        if (!database) {
            return res.status(404).json({error: "Database not found"});
        }

        let backup: Backup | null | undefined = null;

        if (method === "automatic") {
            [backup] = await db
                .insert(drizzleDb.schemas.backup)
                .values({
                    status: "ongoing",
                    databaseId: database.id,
                })
                .returning();
        } else {
            backup = await db.query.backup.findFirst({
                where: and(
                    eq(drizzleDb.schemas.backup.databaseId, database.id),
                    eq(drizzleDb.schemas.backup.status, "ongoing")
                ),
            });
        }

        if (!backup) {
            return res.status(404).json({error: "Backup not found"});
        }


        if (status === "success") {

            const decipher = createDecryptionStream(encryptedAesKeyHex, ivHex);

            const fileExt = extension || getFileExtension(database.dbms);
            const fileName = `${uuidv4()}${fileExt}`;

            const decryptedStream = req.pipe(decipher);

            await uploadTempFileToProviders(backup, database, decryptedStream, fileName);
            await sendNotificationsBackupRestore(database, "success_backup");
            eventEmitter.emit('modification', {update: true});

            return res.json({success: true});
        } else {
            await db
                .update(drizzleDb.schemas.backup)
                .set(withUpdatedAt({status: 'failed'}))
                .where(eq(drizzleDb.schemas.backup.id, backup.id));

            eventEmitter.emit('modification', {update: true});

            await sendNotificationsBackupRestore(database, "error_backup");

            return res.status(200).json({
                error: "Backup successfully updated with status failed",
            });
        }
    } catch (err: any) {
        console.error("Upload error:", err);
        return res.status(500).json({
            error: "Upload failed",
            detail: err.message,
        });
    }
});


export default router;