feat: 레거시 src/services/dataflowDiagramService.ts Prisma 제거

변경사항:
1. src/services/dataflowDiagramService.ts:
   - PrismaClient import 제거
   - database/db의 query, queryOne import 추가
   - 모든 Prisma 호출 Raw Query로 전환:
     ✅ getDataflowDiagrams: findMany + count → query + queryOne
     ✅ getDataflowDiagramById: findFirst → queryOne
     ✅ createDataflowDiagram: create → queryOne
     ✅ updateDataflowDiagram: update → queryOne (동적 UPDATE)
     ✅ deleteDataflowDiagram: delete → query
     ✅ copyDataflowDiagram: findFirst → queryOne

2. src/database/db.ts 생성:
   - backend-node/src/database/db.ts 복사
   - 레거시 코드와 호환성 유지

최종 확인:
- ✅ src/ 디렉토리: Prisma 호출 0개
- ✅ backend-node/ 디렉토리: Prisma 호출 0개
- ✅ 전체 프로젝트: Prisma 완전 제거

src/services/dataflowDiagramService.ts

@@ -1,6 +1,4 @@
-import { PrismaClient } from "@prisma/client";
-
-const prisma = new PrismaClient();
+import { query, queryOne } from "../database/db";
 
 export interface DataflowDiagram {
   diagram_id: number;
@@ -49,18 +47,33 @@ export class DataflowDiagramService {
       };
     }
 
-    const [diagrams, total] = await Promise.all([
-      prisma.dataflow_diagrams.findMany({
-        where: whereClause,
-        orderBy: { created_at: "desc" },
-        skip,
-        take: size,
-      }),
-      prisma.dataflow_diagrams.count({
-        where: whereClause,
-      }),
+    // WHERE 절 구성
+    const whereParts: string[] = ["company_code = $1"];
+    const params: any[] = [companyCode];
+
+    if (searchTerm) {
+      whereParts.push("diagram_name ILIKE $2");
+      params.push(`%${searchTerm}%`);
+    }
+
+    const whereSQL = whereParts.join(" AND ");
+
+    const [diagrams, totalResult] = await Promise.all([
+      query<DataflowDiagram>(
+        `SELECT * FROM dataflow_diagrams 
+         WHERE ${whereSQL}
+         ORDER BY created_at DESC
+         LIMIT $${params.length + 1} OFFSET $${params.length + 2}`,
+        [...params, size, skip]
+      ),
+      queryOne<{ count: string }>(
+        `SELECT COUNT(*) as count FROM dataflow_diagrams WHERE ${whereSQL}`,
+        params
+      ),
     ]);
 
+    const total = parseInt(totalResult?.count || "0", 10);
+
     return {
       diagrams,
       pagination: {
@@ -79,12 +92,11 @@ export class DataflowDiagramService {
     diagramId: number,
     companyCode: string
   ): Promise<DataflowDiagram | null> {
-    return await prisma.dataflow_diagrams.findFirst({
-      where: {
-        diagram_id: diagramId,
-        company_code: companyCode,
-      },
-    });
+    return await queryOne<DataflowDiagram>(
+      `SELECT * FROM dataflow_diagrams 
+       WHERE diagram_id = $1 AND company_code = $2`,
+      [diagramId, companyCode]
+    );
   }
 
   /**
@@ -93,14 +105,19 @@ export class DataflowDiagramService {
   async createDataflowDiagram(
     data: CreateDataflowDiagramData
   ): Promise<DataflowDiagram> {
-    return await prisma.dataflow_diagrams.create({
-      data: {
-        diagram_name: data.diagram_name,
-        relationships: data.relationships,
-        company_code: data.company_code,
-        created_by: data.created_by,
-      },
-    });
+    const result = await queryOne<DataflowDiagram>(
+      `INSERT INTO dataflow_diagrams 
+       (diagram_name, relationships, company_code, created_by, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, NOW(), NOW())
+       RETURNING *`,
+      [
+        data.diagram_name,
+        JSON.stringify(data.relationships),
+        data.company_code,
+        data.created_by || null,
+      ]
+    );
+    return result!;
   }
 
   /**
@@ -120,17 +137,33 @@ export class DataflowDiagramService {
       return null;
     }
 
-    return await prisma.dataflow_diagrams.update({
-      where: {
-        diagram_id: diagramId,
-      },
-      data: {
-        ...(data.diagram_name && { diagram_name: data.diagram_name }),
-        ...(data.relationships && { relationships: data.relationships }),
-        ...(data.updated_by && { updated_by: data.updated_by }),
-        updated_at: new Date(),
-      },
-    });
+    // 동적 UPDATE 쿼리 생성
+    const updateFields: string[] = ["updated_at = NOW()"];
+    const params: any[] = [];
+    let paramIndex = 1;
+
+    if (data.diagram_name !== undefined) {
+      updateFields.push(`diagram_name = $${paramIndex++}`);
+      params.push(data.diagram_name);
+    }
+    if (data.relationships !== undefined) {
+      updateFields.push(`relationships = $${paramIndex++}`);
+      params.push(JSON.stringify(data.relationships));
+    }
+    if (data.updated_by !== undefined) {
+      updateFields.push(`updated_by = $${paramIndex++}`);
+      params.push(data.updated_by);
+    }
+
+    params.push(diagramId);
+
+    return await queryOne<DataflowDiagram>(
+      `UPDATE dataflow_diagrams 
+       SET ${updateFields.join(", ")}
+       WHERE diagram_id = $${paramIndex}
+       RETURNING *`,
+      params
+    );
   }
 
   /**
@@ -149,11 +182,10 @@ export class DataflowDiagramService {
       return false;
     }
 
-    await prisma.dataflow_diagrams.delete({
-      where: {
-        diagram_id: diagramId,
-      },
-    });
+    await query(
+      `DELETE FROM dataflow_diagrams WHERE diagram_id = $1`,
+      [diagramId]
+    );
 
     return true;
   }
@@ -184,12 +216,11 @@ export class DataflowDiagramService {
 
       while (true) {
         copyName = `${baseName} (${counter})`;
-        const existing = await prisma.dataflow_diagrams.findFirst({
-          where: {
-            company_code: companyCode,
-            diagram_name: copyName,
-          },
-        });
+        const existing = await queryOne<DataflowDiagram>(
+          `SELECT * FROM dataflow_diagrams 
+           WHERE company_code = $1 AND diagram_name = $2`,
+          [companyCode, copyName]
+        );
 
         if (!existing) break;
         counter++;