Finish migration prisma to drizzle.

app/api/agent/[agentId]/backup/route.ts

@@ -1,25 +1,27 @@
 import {NextResponse} from "next/server";
-import {prisma} from "@/prisma";
 import {isUuidv4} from "@/utils/verify-uuid";
 import {uploadLocalPrivate} from "@/features/upload/private/upload.action";
 import {v4 as uuidv4} from "uuid";
-import {Backup, Database} from "@prisma/client";
 import {eventEmitter} from "../../../events/route";
+import {db} from "@/db";
+import {Backup} from "@/db/schema/06_database";
+import {and, eq} from "drizzle-orm";
+import * as drizzleDb from "@/db";
 
 export async function POST(
     request: Request,
-    { params }: { params: Promise<{ agentId: string }> }
+    {params}: { params: Promise<{ agentId: string }> }
 ) {
     try {
         const contentType = request.headers.get("Content-Type");
 
         if (!contentType || !contentType.includes("multipart/form-data")) {
             return NextResponse.json(
-                { error: "Unsupported or missing Content-Type" },
-                { status: 400 }
+                {error: "Unsupported or missing Content-Type"},
+                {status: 400}
             );
         }
-        eventEmitter.emit('modification', { update: true });
+        eventEmitter.emit('modification', {update: true});
 
         const agentId = (await params).agentId;
         const formData = await request.formData();
@@ -28,61 +30,64 @@ export async function POST(
 
         if (!generatedId || !isUuidv4(generatedId)) {
             return NextResponse.json(
-                { error: "generatedId is not a valid UUID" },
-                { status: 400 }
+                {error: "generatedId is not a valid UUID"},
+                {status: 400}
             );
         }
 
-        const agent = await prisma.agent.findFirst({
-            where: { id: agentId },
+        const agent = await db.query.agent.findFirst({
+            where: eq(drizzleDb.schemas.agent.id, agentId),
         });
 
         if (!agent) {
             return NextResponse.json(
-                { error: "Agent not found" },
-                { status: 404 }
+                {error: "Agent not found"},
+                {status: 404}
             );
         }
 
-        const database = await prisma.database.findFirst({
-            where: { generatedId },
+        const database = await db.query.database.findFirst({
+            where: eq(drizzleDb.schemas.database.agentDatabaseId, generatedId),
         });
 
         if (!database) {
             return NextResponse.json(
-                { error: "Database associated with generatedId not found" },
-                { status: 404 }
+                {error: "Database associated with generatedId not found"},
+                {status: 404}
             );
         }
 
-        let backup: Backup | null = null;
+        let backup: Backup | null | undefined = null;
 
         if (method === "automatic") {
-            backup = await prisma.backup.create({
-                data: {
-                    status: "ongoing",
+            [backup] = await db
+                .insert(drizzleDb.schemas.backup)
+                .values({
+                    status: 'ongoing',
                     databaseId: database.id,
-                },
-            });
+                })
+                .returning();
+
 
             if (!backup) {
                 return NextResponse.json(
-                    { error: "Unable to create an automatic backup" },
-                    { status: 500 }
+                    {error: "Unable to create an automatic backup"},
+                    {status: 500}
                 );
             }
         } else {
-            backup = await prisma.backup.findFirst({
-                where: {
-                    status: "ongoing",
-                    databaseId: database.id,
-                },
+            backup = await db.query.backup.findFirst({
+                where: and(
+                    eq(drizzleDb.schemas.backup.status, 'ongoing'),
+                    eq(drizzleDb.schemas.backup.databaseId, database.id),
+                ),
             });
 
+
             if (!backup) {
                 return NextResponse.json(
-                    { error: "Unable to find the corresponding backup" },
-                    { status: 404 }
+                    {error: "Unable to find the corresponding backup"},
+                    {status: 404}
                 );
             }
         }
@@ -94,8 +99,8 @@ export async function POST(
 
             if (!file) {
                 return NextResponse.json(
-                    { error: "File is required for successful backup" },
-                    { status: 400 }
+                    {error: "File is required for successful backup"},
+                    {status: 400}
                 );
             }
 
@@ -103,49 +108,52 @@ export async function POST(
             const fileName = `${uuid}.dump`;
             const buffer = Buffer.from(await file.arrayBuffer());
 
-            const { success, message, filePath } = await uploadLocalPrivate(fileName, buffer);
+            const {success, message, filePath} = await uploadLocalPrivate(fileName, buffer);
 
             if (!success) {
                 return NextResponse.json(
-                    { error: message },
-                    { status: 500 }
+                    {error: message},
+                    {status: 500}
                 );
             }
 
-            await prisma.backup.update({
-                where: { id: backup.id },
-                data: {
+            await db
+                .update(drizzleDb.schemas.backup)
+                .set({
                     file: fileName,
-                    status: "success",
-                },
-            });
-            eventEmitter.emit('modification', { update: true });
+                    status: 'success',
+                })
+                .where(eq(drizzleDb.schemas.backup.id, backup.id));
+
+            eventEmitter.emit('modification', {update: true});
 
             return NextResponse.json(
                 {
                     message: "Backup successfully uploaded",
                 },
-                { status: 200 }
+                {status: 200}
             );
         } else {
-            await prisma.backup.update({
-                where: { id: backup.id },
-                data: { status: "failed" },
-            });
-            eventEmitter.emit('modification', { update: true });
+
+            await db
+                .update(drizzleDb.schemas.backup)
+                .set({status: 'failed'})
+                .where(eq(drizzleDb.schemas.backup.id, backup.id));
+
+            eventEmitter.emit('modification', {update: true});
 
             return NextResponse.json(
                 {
                     message: "Backup successfully updated with status failed",
                 },
-                { status: 200 }
+                {status: 200}
             );
         }
     } catch (error) {
         console.error("Error in POST handler:", error);
         return NextResponse.json(
-            { error: "Internal server error" },
-            { status: 500 }
+            {error: "Internal server error"},
+            {status: 500}
         );
     }
 }

app/api/agent/[agentId]/restore/route.ts

@@ -1,14 +1,17 @@
 import {NextResponse} from "next/server";
 import {isUuidv4} from "@/utils/verify-uuid";
-import {prisma} from "@/prisma";
 import {eventEmitter} from "../../../events/route";
-
+import * as drizzleDb from "@/db";
+import {db} from "@/db";
+import {and, eq} from "drizzle-orm";
 
 
 export type BodyResultRestore = {
     generatedId: string
     status: string
 }
+type RestorationStatus = 'waiting' | 'ongoing' | 'failed' | 'success';
+
 
 
 export async function POST(
@@ -17,7 +20,7 @@ export async function POST(
 ) {
 
     try {
-        eventEmitter.emit('modification', { update: true });
+        eventEmitter.emit('modification', {update: true});
 
         const agentId = (await params).agentId
         const body: BodyResultRestore = await request.json();
@@ -33,53 +36,44 @@ export async function POST(
             );
         }
 
-        const agent = await prisma.agent.findFirst({
-            where: {
-                id: agentId
-            }
+        const agent = await db.query.agent.findFirst({
+            where: eq(drizzleDb.schemas.agent.id, agentId)
         })
         if (!agent) {
             return NextResponse.json({error: "Agent not found"}, {status: 404})
         }
 
-        const database = await prisma.database.findFirst({
-            where: {
-                generatedId: body.generatedId
-            }
+        const database = await db.query.database.findFirst({
+            where: eq(drizzleDb.schemas.database.agentDatabaseId, body.generatedId)
+
         })
 
         if (!database) {
             return NextResponse.json({error: "Database associated with generatedId provided not found"}, {status: 404})
         }
 
-        const restoration = await prisma.restoration.findFirst({
-            where: {
-                status : "ongoing",
-                databaseId: database.id
-            }
+        const restoration = await db.query.restoration.findFirst({
+            where: and(eq(drizzleDb.schemas.restoration.status, "ongoing"), eq(drizzleDb.schemas.restoration.databaseId, database.id),)
         })
+
         if (!restoration) {
             return NextResponse.json({error: "Unable to fin the corresponding restoration"}, {status: 404})
         }
 
-        await prisma.restoration.update({
-            where:{
-                id : restoration.id
-            },
-            data: {
-                status: body.status
-            }
-        })
+        await db
+            .update(drizzleDb.schemas.restoration)
+            .set({ status: body.status as RestorationStatus })
+            .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
 
         const response = {
             message: true,
             details: "Restoration successfully updated"
         }
 
-        eventEmitter.emit('modification', { update: true });
+        eventEmitter.emit('modification', {update: true});
 
 
-        return Response.json(response , {status: 200})
+        return Response.json(response, {status: 200})
 
 
     } catch (error) {

app/api/agent/[agentId]/status/helpers.ts

@@ -1,16 +1,18 @@
-import {Agent, Database} from "@prisma/client";
-import {prisma} from "@/prisma";
 import {NextResponse} from "next/server";
 import {Body} from "./route";
 import {isUuidv4} from "@/utils/verify-uuid";
 import {getFileUrlPresignedLocal} from "@/features/upload/private/upload.action";
-
+import {Agent} from "@/db/schema/07_agent";
+import {Database} from "@/db/schema/06_database";
+import * as drizzleDb from "@/db";
+import {db as dbClient} from "@/db";
+import {and, eq} from "drizzle-orm";
 
 export async function handleDatabases(body: Body, agent: Agent, lastContact: Date) {
     const databasesResponse = [];
 
     const formatDatabase = (database: Database, backupAction: boolean, restoreAction: boolean, UrlBackup: string) => ({
-        generatedId: database.generatedId,
+        generatedId: database.agentDatabaseId,
         dbms: database.dbms,
         data: {
             backup: {
@@ -25,15 +27,14 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
     });
 
     for (const db of body.databases) {
-        const existingDatabase = await prisma.database.findFirst({
-            where: {
-                generatedId: db.generatedId,
-            },
+
+        const existingDatabase = await dbClient.query.database.findFirst({
+            where: eq(drizzleDb.schemas.database.agentDatabaseId, db.generatedId)
         });
 
         let backupAction: boolean = false
         let restoreAction: boolean = false
-        let UrlBackup: string = null
+        let UrlBackup: string = ""
 
         if (!existingDatabase) {
             if (!isUuidv4(db.generatedId)) {
@@ -42,74 +43,69 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
                     { status: 500 }
                 );
             }
-            const databaseCreated = await prisma.database.create({
-                data: {
+
+            const [databaseCreated] = await dbClient
+                .insert(drizzleDb.schemas.database)
+                .values({
                     agentId: agent.id,
                     name: db.name,
                     dbms: db.dbms,
-                    generatedId: db.generatedId,
+                    agentDatabaseId: db.generatedId,
                     lastContact: lastContact,
-                },
-            });
+                })
+                .returning();
 
             if (databaseCreated) {
                 databasesResponse.push(formatDatabase(databaseCreated, backupAction,restoreAction, UrlBackup));
             }
         } else {
-            const databaseUpdated = await prisma.database.update({
-                where: {
-                    id: existingDatabase.id,
-                },
-                data: {
-                    lastContact: lastContact,
-                },
-            });
 
-            const backup = await prisma.backup.findFirst({
-                where: {
-                    databaseId: databaseUpdated.id,
-                    status: "waiting"
-                }
+
+
+            const [databaseUpdated] = await dbClient
+                .update(drizzleDb.schemas.database)
+                .set({ lastContact: lastContact })
+                .where(eq(drizzleDb.schemas.database.id, existingDatabase.id))
+                .returning();
+
+
+
+            const backup = await dbClient.query.backup.findFirst({
+                where: and(eq(drizzleDb.schemas.backup.databaseId, databaseUpdated.id), eq(drizzleDb.schemas.backup.status,"waiting"))
             })
 
-            const restoration = await prisma.restoration.findFirst({
-                where:{
-                    databaseId: databaseUpdated.id,
-                    status: "waiting"
-                }
+
+            const restoration = await dbClient.query.restoration.findFirst({
+                where: and(eq(drizzleDb.schemas.restoration.databaseId, databaseUpdated.id), eq(drizzleDb.schemas.restoration.status,"waiting"))
             })
 
 
             if(backup){
                 backupAction = true
-                await prisma.backup.update({
-                    where:{
-                        id: backup.id
-                    },
-                    data: {
-                        status: "ongoing"
-                    }
-                })
+
+                await dbClient
+                    .update(drizzleDb.schemas.backup)
+                    .set({ status: "ongoing" })
+                    .where(eq(drizzleDb.schemas.backup.id, backup.id));
             }
 
             if(restoration){
                 restoreAction = true
 
-                const backupToRestore = await prisma.backup.findFirst({
-                    where:{
-                        id: restoration.backupId
-                    }
-                })
-                const fileName = backupToRestore.file
-                UrlBackup = await getFileUrlPresignedLocal(fileName)
-                await prisma.restoration.update({
-                    where: {
-                        id: restoration.id
-                    },
-                    data:{
-                        status: "ongoing"
-                    }
+
+                const backupToRestore = await dbClient.query.backup.findFirst({
+                    where: eq(drizzleDb.schemas.backup.id, restoration.backupId),
                 })
+
+
+                const fileName = backupToRestore?.file
+                UrlBackup = await getFileUrlPresignedLocal(fileName ?? "")
+
+                await dbClient
+                    .update(drizzleDb.schemas.restoration)
+                    .set({ status: "ongoing" })
+                    .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
+
             }
 
 

app/api/agent/[agentId]/status/route.ts

@@ -1,14 +1,15 @@
-import {prisma} from "@/prisma";
 import {NextResponse} from "next/server";
-import {Dbms} from "@prisma/client";
 import {getFileUrlPresignedLocal} from "@/features/upload/private/upload.action";
 import {handleDatabases} from "./helpers";
 import {eventEmitter} from "../../../events/route";
-
+import * as drizzleDb from "@/db";
+import {db} from "@/db";
+import {EDbmsSchema} from "@/db/schema/types";
+import {eq} from "drizzle-orm";
 
 export type databaseAgent = {
     name: string,
-    dbms: Dbms,
+    dbms: EDbmsSchema,
     generatedId: string
 }
 
@@ -33,25 +34,23 @@ export async function POST(
         const body: Body = await request.json();
         const lastContact = new Date();
 
-        const agent = await prisma.agent.findFirst({
-            where: {
-                id: agentId
-            }
+
+        const agent = await db.query.agent.findFirst({
+            where: eq(drizzleDb.schemas.agent.id, agentId),
         })
+
         if (!agent) {
             return NextResponse.json({error: "Agent not found"}, {status: 404})
         }
         const databasesResponse = await handleDatabases(body, agent, lastContact)
-        await prisma.agent.update({
-            where:{
-                id: agentId,
-            },
-            data:{
-                lastContact: lastContact,
-            }
-        })
 
-        eventEmitter.emit('modification', { update: true });
+
+        await db
+            .update(drizzleDb.schemas.agent)
+            .set({ lastContact: lastContact })
+            .where(eq(drizzleDb.schemas.agent.id, agentId));
+
+        eventEmitter.emit('modification', {update: true});
 
         const response = {
             agent: {