diff --git a/DETAILED_FILE_MIGRATION_PLAN.md b/DETAILED_FILE_MIGRATION_PLAN.md
new file mode 100644
index 00000000..56855742
--- /dev/null
+++ b/DETAILED_FILE_MIGRATION_PLAN.md
@@ -0,0 +1,1216 @@
+# 📋 파일별 상세 Prisma → Raw Query 마이그레이션 계획
+
+## 🎯 개요
+
+총 42개 파일, 444개 Prisma 호출을 Raw Query로 전환하는 상세 계획입니다.
+각 파일의 복잡도, 의존성, 전환 전략을 분석하여 기능 손실 없는 완전한 마이그레이션을 수행합니다.
+
+---
+
+## 🔴 Phase 2: 핵심 서비스 전환 (107개 호출)
+
+### 1. screenManagementService.ts (46개 호출) ⭐ 최우선
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 매우 높음 (JSON 처리, 복잡한 조인, 트랜잭션)
+- **주요 기능**: 화면 정의 관리, 레이아웃 저장/불러오기, 메뉴 할당
+- **의존성**: screen_definitions, screen_components, screen_layouts 등
+
+#### 🔧 전환 전략
+
+##### 1.1 기본 CRUD 작업 전환
+
+```typescript
+// 기존 Prisma 코드
+const screen = await prisma.screen_definitions.create({
+  data: {
+    screen_name: screenData.screenName,
+    screen_code: screenData.screenCode,
+    table_name: screenData.tableName,
+    company_code: screenData.companyCode,
+    description: screenData.description,
+    created_by: screenData.createdBy,
+  },
+});
+
+// 새로운 Raw Query 코드
+const { query, params } = QueryBuilder.insert(
+  "screen_definitions",
+  {
+    screen_name: screenData.screenName,
+    screen_code: screenData.screenCode,
+    table_name: screenData.tableName,
+    company_code: screenData.companyCode,
+    description: screenData.description,
+    created_by: screenData.createdBy,
+    created_at: new Date(),
+    updated_at: new Date(),
+  },
+  {
+    returning: ["*"],
+  }
+);
+const [screen] = await DatabaseManager.query(query, params);
+```
+
+##### 1.2 복잡한 조인 쿼리 전환
+
+```typescript
+// 기존 Prisma 코드 (복잡한 include)
+const screens = await prisma.screen_definitions.findMany({
+  where: whereClause,
+  include: {
+    screen_components: true,
+    screen_layouts: true,
+  },
+  orderBy: { created_at: "desc" },
+  skip: (page - 1) * size,
+  take: size,
+});
+
+// 새로운 Raw Query 코드
+const { query, params } = QueryBuilder.select("screen_definitions", {
+  columns: [
+    "sd.*",
+    "json_agg(DISTINCT sc.*) as screen_components",
+    "json_agg(DISTINCT sl.*) as screen_layouts",
+  ],
+  joins: [
+    {
+      type: "LEFT",
+      table: "screen_components sc",
+      on: "sd.id = sc.screen_id",
+    },
+    {
+      type: "LEFT",
+      table: "screen_layouts sl",
+      on: "sd.id = sl.screen_id",
+    },
+  ],
+  where: whereClause,
+  orderBy: "sd.created_at DESC",
+  limit: size,
+  offset: (page - 1) * size,
+  groupBy: ["sd.id"],
+});
+const screens = await DatabaseManager.query(query, params);
+```
+
+##### 1.3 JSON 데이터 처리 전환
+
+```typescript
+// 기존 Prisma 코드 (JSON 검색)
+const screens = await prisma.screen_definitions.findMany({
+  where: {
+    screen_config: { path: ["type"], equals: "form" },
+  },
+});
+
+// 새로운 Raw Query 코드
+const screens = await DatabaseManager.query(
+  `
+  SELECT * FROM screen_definitions 
+  WHERE screen_config->>'type' = $1
+`,
+  ["form"]
+);
+```
+
+##### 1.4 트랜잭션 처리 전환
+
+```typescript
+// 기존 Prisma 트랜잭션
+await prisma.$transaction(async (tx) => {
+  const screen = await tx.screen_definitions.create({ data: screenData });
+  await tx.screen_components.createMany({ data: components });
+  return screen;
+});
+
+// 새로운 Raw Query 트랜잭션
+await DatabaseManager.transaction(async (client) => {
+  const screenResult = await client.query(
+    "INSERT INTO screen_definitions (...) VALUES (...) RETURNING *",
+    screenParams
+  );
+  const screen = screenResult.rows[0];
+
+  for (const component of components) {
+    await client.query(
+      "INSERT INTO screen_components (...) VALUES (...)",
+      componentParams
+    );
+  }
+
+  return screen;
+});
+```
+
+#### 🧪 테스트 전략
+
+1. **단위 테스트**: 각 메서드별 입출력 검증
+2. **통합 테스트**: 화면 생성 → 조회 → 수정 → 삭제 전체 플로우
+3. **JSON 데이터 테스트**: 복잡한 레이아웃 데이터 저장/복원
+4. **성능 테스트**: 대량 화면 데이터 처리 성능 비교
+
+#### ⚠️ 주의사항
+
+- JSON 데이터 타입 변환 주의 (PostgreSQL JSONB ↔ JavaScript Object)
+- 날짜 타입 변환 (Prisma DateTime ↔ PostgreSQL timestamp)
+- NULL 값 처리 일관성 유지
+
+---
+
+### 2. tableManagementService.ts (35개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 매우 높음 (메타데이터 조회, DDL 실행, 동적 쿼리)
+- **주요 기능**: 테이블/컬럼 정보 관리, 동적 테이블 생성, 메타데이터 캐싱
+- **의존성**: information_schema, table_labels, column_labels
+
+#### 🔧 전환 전략
+
+##### 2.1 메타데이터 조회 (이미 Raw Query 사용 중)
+
+```typescript
+// 현재 코드 (이미 Raw Query)
+const rawTables = await prisma.$queryRaw<any[]>`
+  SELECT 
+    t.table_name as "tableName",
+    COALESCE(tl.table_label, t.table_name) as "displayName"
+  FROM information_schema.tables t
+  LEFT JOIN table_labels tl ON t.table_name = tl.table_name
+  WHERE t.table_schema = 'public'
+`;
+
+// 새로운 Raw Query 코드 (Prisma 제거)
+const rawTables = await DatabaseManager.query(`
+  SELECT 
+    t.table_name as "tableName",
+    COALESCE(tl.table_label, t.table_name) as "displayName"
+  FROM information_schema.tables t
+  LEFT JOIN table_labels tl ON t.table_name = tl.table_name
+  WHERE t.table_schema = 'public'
+`);
+```
+
+##### 2.2 동적 테이블 데이터 조회
+
+```typescript
+// 기존 Prisma 코드 (동적 테이블명)
+const data = await prisma.$queryRawUnsafe(
+  `SELECT * FROM ${tableName} WHERE id = $1`,
+  [id]
+);
+
+// 새로운 Raw Query 코드
+const data = await DatabaseManager.queryUnsafe(
+  `SELECT * FROM ${DatabaseValidator.sanitizeTableName(
+    tableName
+  )} WHERE id = $1`,
+  [id]
+);
+```
+
+##### 2.3 UPSERT 작업 전환
+
+```typescript
+// 기존 Prisma UPSERT
+await prisma.table_labels.upsert({
+  where: { table_name: tableName },
+  update: { table_label: label, updated_date: new Date() },
+  create: {
+    table_name: tableName,
+    table_label: label,
+    created_date: new Date(),
+  },
+});
+
+// 새로운 Raw Query UPSERT
+const { query, params } = QueryBuilder.insert(
+  "table_labels",
+  {
+    table_name: tableName,
+    table_label: label,
+    created_date: new Date(),
+    updated_date: new Date(),
+  },
+  {
+    onConflict: {
+      columns: ["table_name"],
+      action: "DO UPDATE",
+      updateSet: ["table_label", "updated_date"],
+    },
+    returning: ["*"],
+  }
+);
+await DatabaseManager.query(query, params);
+```
+
+#### 🧪 테스트 전략
+
+1. **메타데이터 테스트**: information_schema 조회 결과 일치성
+2. **동적 쿼리 테스트**: 다양한 테이블명/컬럼명으로 안전성 검증
+3. **DDL 테스트**: 테이블 생성/수정/삭제 기능
+4. **캐시 테스트**: 메타데이터 캐싱 동작 검증
+
+---
+
+### 3. dataflowService.ts (31개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 높음 (관계 관리, 복잡한 비즈니스 로직)
+- **주요 기능**: 테이블 관계 관리, 데이터플로우 다이어그램
+- **의존성**: table_relationships, dataflow_diagrams
+
+#### 🔧 전환 전략
+
+##### 3.1 관계 생성 로직
+
+```typescript
+// 기존 Prisma 코드
+const maxDiagramId = await prisma.table_relationships.findFirst({
+  where: { company_code: data.companyCode },
+  orderBy: { diagram_id: "desc" },
+  select: { diagram_id: true },
+});
+
+const relationship = await prisma.table_relationships.create({
+  data: {
+    diagram_id: diagramId,
+    relationship_name: data.relationshipName,
+    // ... 기타 필드
+  },
+});
+
+// 새로운 Raw Query 코드
+const maxDiagramResult = await DatabaseManager.query(
+  `
+  SELECT diagram_id FROM table_relationships 
+  WHERE company_code = $1 
+  ORDER BY diagram_id DESC 
+  LIMIT 1
+`,
+  [data.companyCode]
+);
+
+const diagramId = (maxDiagramResult[0]?.diagram_id || 0) + 1;
+
+const { query, params } = QueryBuilder.insert(
+  "table_relationships",
+  {
+    diagram_id: diagramId,
+    relationship_name: data.relationshipName,
+    // ... 기타 필드
+  },
+  { returning: ["*"] }
+);
+
+const [relationship] = await DatabaseManager.query(query, params);
+```
+
+#### 🧪 테스트 전략
+
+1. **관계 생성 테스트**: 다양한 테이블 관계 패턴
+2. **중복 검증 테스트**: 동일 관계 생성 방지
+3. **다이어그램 테스트**: 복잡한 관계도 생성/조회
+
+---
+
+## 🟡 Phase 3: 관리 기능 전환 (162개 호출)
+
+### 4. multilangService.ts (25개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 높음 (재귀 쿼리, 다국어 처리)
+- **주요 기능**: 다국어 번역 관리, 계층 구조 처리
+- **의존성**: multilang_translations, 재귀 관계
+
+#### 🔧 전환 전략
+
+##### 4.1 재귀 쿼리 전환
+
+```typescript
+// 기존 Prisma 코드 (재귀 관계 조회)
+const translations = await prisma.multilang_translations.findMany({
+  where: { parent_id: null },
+  include: {
+    children: {
+      include: {
+        children: true, // 중첩 include
+      },
+    },
+  },
+});
+
+// 새로운 Raw Query 코드 (WITH RECURSIVE)
+const translations = await DatabaseManager.query(`
+  WITH RECURSIVE translation_tree AS (
+    SELECT *, 0 as level 
+    FROM multilang_translations 
+    WHERE parent_id IS NULL
+    
+    UNION ALL
+    
+    SELECT t.*, tt.level + 1
+    FROM multilang_translations t
+    JOIN translation_tree tt ON t.parent_id = tt.id
+  )
+  SELECT * FROM translation_tree 
+  ORDER BY level, sort_order
+`);
+```
+
+#### 🧪 테스트 전략
+
+1. **재귀 쿼리 테스트**: 깊은 계층 구조 처리
+2. **다국어 테스트**: 다양한 언어 코드 처리
+3. **성능 테스트**: 대량 번역 데이터 처리
+
+---
+
+### 5. batchService.ts (16개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 중간 (배치 작업 관리)
+- **주요 기능**: 배치 작업 스케줄링, 실행 이력 관리
+- **의존성**: batch_configs, batch_execution_logs
+
+#### 🔧 전환 전략
+
+##### 5.1 배치 설정 관리
+
+```typescript
+// 기존 Prisma 코드
+const batchConfigs = await prisma.batch_configs.findMany({
+  where: { is_active: true },
+  include: { execution_logs: { take: 10, orderBy: { created_at: "desc" } } },
+});
+
+// 새로운 Raw Query 코드
+const batchConfigs = await DatabaseManager.query(`
+  SELECT 
+    bc.*,
+    json_agg(
+      json_build_object(
+        'id', bel.id,
+        'status', bel.status,
+        'created_at', bel.created_at
+      ) ORDER BY bel.created_at DESC
+    ) FILTER (WHERE bel.id IS NOT NULL) as execution_logs
+  FROM batch_configs bc
+  LEFT JOIN (
+    SELECT DISTINCT ON (batch_config_id) 
+      batch_config_id, id, status, created_at,
+      ROW_NUMBER() OVER (PARTITION BY batch_config_id ORDER BY created_at DESC) as rn
+    FROM batch_execution_logs
+  ) bel ON bc.id = bel.batch_config_id AND bel.rn <= 10
+  WHERE bc.is_active = true
+  GROUP BY bc.id
+`);
+```
+
+---
+
+### 7. dynamicFormService.ts (15개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 높음 (UPSERT, 동적 테이블 처리, 타입 변환)
+- **주요 기능**: 동적 폼 데이터 저장/조회, 데이터 검증, 타입 변환
+- **의존성**: 동적 테이블들, form_data, 이벤트 트리거
+
+#### 🔧 전환 전략
+
+##### 7.1 동적 UPSERT 로직 전환
+
+```typescript
+// 기존 Prisma 코드 (동적 테이블 UPSERT)
+const existingRecord = await prisma.$queryRawUnsafe(
+  `SELECT * FROM ${tableName} WHERE id = $1`,
+  [id]
+);
+
+if (existingRecord.length > 0) {
+  await prisma.$executeRawUnsafe(updateQuery, updateValues);
+} else {
+  await prisma.$executeRawUnsafe(insertQuery, insertValues);
+}
+
+// 새로운 Raw Query 코드 (PostgreSQL UPSERT)
+const upsertQuery = `
+  INSERT INTO ${DatabaseValidator.sanitizeTableName(tableName)} 
+  (${columns.join(", ")}) 
+  VALUES (${placeholders.join(", ")})
+  ON CONFLICT (id) 
+  DO UPDATE SET 
+    ${updateColumns.map((col) => `${col} = EXCLUDED.${col}`).join(", ")},
+    updated_at = NOW()
+  RETURNING *
+`;
+
+const [result] = await DatabaseManager.query(upsertQuery, values);
+```
+
+##### 7.2 타입 변환 로직 강화
+
+```typescript
+// 기존 타입 변환 (Prisma 자동 처리)
+const data = await prisma.someTable.create({ data: formData });
+
+// 새로운 타입 변환 (명시적 처리)
+const convertedData = this.convertFormDataForPostgreSQL(formData, tableSchema);
+const { query, params } = QueryBuilder.insert(tableName, convertedData, {
+  returning: ["*"]
+});
+const [result] = await DatabaseManager.query(query, params);
+
+// 타입 변환 함수 강화
+private convertFormDataForPostgreSQL(data: any, schema: TableColumn[]): any {
+  const converted = {};
+
+  for (const [key, value] of Object.entries(data)) {
+    const column = schema.find(col => col.columnName === key);
+    if (column) {
+      converted[key] = this.convertValueByType(value, column.dataType);
+    }
+  }
+
+  return converted;
+}
+```
+
+##### 7.3 동적 검증 로직
+
+```typescript
+// 기존 Prisma 검증 (스키마 기반)
+const validation = await prisma.$validator.validate(data, schema);
+
+// 새로운 Raw Query 검증
+async validateFormData(data: any, tableName: string): Promise<ValidationResult> {
+  // 테이블 스키마 조회
+  const schema = await this.getTableSchema(tableName);
+
+  const errors: ValidationError[] = [];
+
+  for (const column of schema) {
+    const value = data[column.columnName];
+
+    // NULL 검증
+    if (!column.nullable && (value === null || value === undefined)) {
+      errors.push({
+        field: column.columnName,
+        message: `${column.columnName}은(는) 필수 입력 항목입니다.`,
+        code: 'REQUIRED_FIELD'
+      });
+    }
+
+    // 타입 검증
+    if (value !== null && !this.isValidType(value, column.dataType)) {
+      errors.push({
+        field: column.columnName,
+        message: `${column.columnName}의 데이터 타입이 올바르지 않습니다.`,
+        code: 'INVALID_TYPE'
+      });
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+```
+
+#### 🧪 테스트 전략
+
+1. **UPSERT 테스트**: 신규 생성 vs 기존 업데이트 시나리오
+2. **타입 변환 테스트**: 다양한 PostgreSQL 타입 변환
+3. **검증 테스트**: 필수 필드, 타입 검증, 길이 제한
+4. **동적 테이블 테스트**: 런타임에 생성된 테이블 처리
+
+---
+
+### 8. externalDbConnectionService.ts (15개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 높음 (다중 DB 연결, 외부 시스템 연동)
+- **주요 기능**: 외부 데이터베이스 연결 관리, 스키마 동기화
+- **의존성**: external_db_connections, connection_pools
+
+#### 🔧 전환 전략
+
+##### 8.1 연결 설정 관리
+
+```typescript
+// 기존 Prisma 코드
+const connections = await prisma.external_db_connections.findMany({
+  where: { is_active: true },
+  include: { connection_pools: true },
+});
+
+// 새로운 Raw Query 코드
+const connections = await DatabaseManager.query(`
+  SELECT 
+    edc.*,
+    json_agg(cp.*) as connection_pools
+  FROM external_db_connections edc
+  LEFT JOIN connection_pools cp ON edc.id = cp.connection_id
+  WHERE edc.is_active = true
+  GROUP BY edc.id
+`);
+```
+
+##### 8.2 연결 풀 관리
+
+```typescript
+// 외부 DB 연결 풀 생성 및 관리
+class ExternalConnectionManager {
+  private static pools = new Map<string, Pool>();
+
+  static async getConnection(connectionId: string): Promise<PoolClient> {
+    if (!this.pools.has(connectionId)) {
+      const config = await this.getConnectionConfig(connectionId);
+      this.pools.set(connectionId, new Pool(config));
+    }
+
+    return this.pools.get(connectionId)!.connect();
+  }
+
+  private static async getConnectionConfig(connectionId: string) {
+    const [config] = await DatabaseManager.query(
+      `
+      SELECT host, port, database, username, password, ssl_config
+      FROM external_db_connections 
+      WHERE id = $1 AND is_active = true
+    `,
+      [connectionId]
+    );
+
+    return {
+      host: config.host,
+      port: config.port,
+      database: config.database,
+      user: config.username,
+      password: EncryptUtil.decrypt(config.password),
+      ssl: config.ssl_config,
+    };
+  }
+}
+```
+
+---
+
+## 🟢 Phase 4: 확장 기능 전환 (129개 호출)
+
+### 9. adminController.ts (28개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 중간 (컨트롤러 레이어, 다양한 관리 기능)
+- **주요 기능**: 관리자 메뉴, 사용자 관리, 권한 관리, 시스템 설정
+- **의존성**: user_info, menu_info, auth_groups, company_mng
+
+#### 🔧 전환 전략
+
+##### 9.1 메뉴 관리 API 전환
+
+```typescript
+// 기존 Prisma 코드
+export async function getAdminMenus(req: AuthenticatedRequest, res: Response) {
+  const menus = await prisma.menu_info.findMany({
+    where: {
+      is_active: "Y",
+      company_code: userCompanyCode,
+    },
+    include: {
+      parent: true,
+      children: { where: { is_active: "Y" } },
+    },
+    orderBy: { sort_order: "asc" },
+  });
+
+  res.json({ success: true, data: menus });
+}
+
+// 새로운 Raw Query 코드
+export async function getAdminMenus(req: AuthenticatedRequest, res: Response) {
+  // 계층형 메뉴 구조를 한 번의 쿼리로 조회
+  const menus = await DatabaseManager.query(
+    `
+    WITH RECURSIVE menu_tree AS (
+      SELECT 
+        m.*,
+        0 as level,
+        ARRAY[m.sort_order] as path
+      FROM menu_info m
+      WHERE m.parent_id IS NULL 
+        AND m.is_active = 'Y'
+        AND m.company_code = $1
+      
+      UNION ALL
+      
+      SELECT 
+        m.*,
+        mt.level + 1,
+        mt.path || m.sort_order
+      FROM menu_info m
+      JOIN menu_tree mt ON m.parent_id = mt.id
+      WHERE m.is_active = 'Y'
+    )
+    SELECT * FROM menu_tree 
+    ORDER BY path
+  `,
+    [userCompanyCode]
+  );
+
+  res.json({ success: true, data: menus });
+}
+```
+
+##### 9.2 사용자 관리 API 전환
+
+```typescript
+// 기존 Prisma 코드
+export async function getUserList(req: AuthenticatedRequest, res: Response) {
+  const users = await prisma.user_info.findMany({
+    where: { company_code: userCompanyCode },
+    include: {
+      dept_info: true,
+      user_auth: { include: { auth_group: true } },
+    },
+  });
+}
+
+// 새로운 Raw Query 코드
+export async function getUserList(req: AuthenticatedRequest, res: Response) {
+  const users = await DatabaseManager.query(
+    `
+    SELECT 
+      ui.*,
+      di.dept_name,
+      json_agg(
+        json_build_object(
+          'auth_code', ag.auth_code,
+          'auth_name', ag.auth_name
+        )
+      ) FILTER (WHERE ag.auth_code IS NOT NULL) as authorities
+    FROM user_info ui
+    LEFT JOIN dept_info di ON ui.dept_code = di.dept_code
+    LEFT JOIN user_auth ua ON ui.user_id = ua.user_id
+    LEFT JOIN auth_group ag ON ua.auth_code = ag.auth_code
+    WHERE ui.company_code = $1
+    GROUP BY ui.user_id, di.dept_name
+    ORDER BY ui.created_date DESC
+  `,
+    [userCompanyCode]
+  );
+}
+```
+
+##### 9.3 권한 관리 API 전환
+
+```typescript
+// 복잡한 권한 체크 로직
+export async function checkUserPermission(
+  req: AuthenticatedRequest,
+  res: Response
+) {
+  const { menuUrl } = req.body;
+
+  const hasPermission = await DatabaseManager.query(
+    `
+    SELECT EXISTS (
+      SELECT 1 
+      FROM user_auth ua
+      JOIN auth_group ag ON ua.auth_code = ag.auth_code
+      JOIN menu_auth_group mag ON ag.auth_code = mag.auth_code
+      JOIN menu_info mi ON mag.menu_id = mi.id
+      WHERE ua.user_id = $1 
+        AND mi.url = $2
+        AND ua.is_active = 'Y'
+        AND ag.is_active = 'Y'
+        AND mi.is_active = 'Y'
+    ) as has_permission
+  `,
+    [req.user.userId, menuUrl]
+  );
+
+  res.json({ success: true, hasPermission: hasPermission[0].has_permission });
+}
+```
+
+#### 🧪 테스트 전략
+
+1. **API 응답 테스트**: 기존 API와 동일한 응답 구조 확인
+2. **권한 테스트**: 다양한 사용자 권한 시나리오
+3. **계층 구조 테스트**: 메뉴 트리 구조 정확성
+4. **성능 테스트**: 복잡한 조인 쿼리 성능
+
+---
+
+### 10. componentStandardService.ts (16개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 중간 (컴포넌트 표준 관리)
+- **주요 기능**: UI 컴포넌트 표준 정의, 템플릿 관리
+- **의존성**: component_standards, ui_templates
+
+#### 🔧 전환 전략
+
+##### 10.1 컴포넌트 표준 조회
+
+```typescript
+// 기존 Prisma 코드
+const components = await prisma.component_standards.findMany({
+  where: { category: category },
+  include: {
+    templates: { where: { is_active: true } },
+    properties: true,
+  },
+});
+
+// 새로운 Raw Query 코드
+const components = await DatabaseManager.query(
+  `
+  SELECT 
+    cs.*,
+    json_agg(
+      DISTINCT jsonb_build_object(
+        'id', ut.id,
+        'template_name', ut.template_name,
+        'template_config', ut.template_config
+      )
+    ) FILTER (WHERE ut.id IS NOT NULL) as templates,
+    json_agg(
+      DISTINCT jsonb_build_object(
+        'property_name', cp.property_name,
+        'property_type', cp.property_type,
+        'default_value', cp.default_value
+      )
+    ) FILTER (WHERE cp.id IS NOT NULL) as properties
+  FROM component_standards cs
+  LEFT JOIN ui_templates ut ON cs.id = ut.component_id AND ut.is_active = true
+  LEFT JOIN component_properties cp ON cs.id = cp.component_id
+  WHERE cs.category = $1
+  GROUP BY cs.id
+`,
+  [category]
+);
+```
+
+---
+
+### 11. commonCodeService.ts (15개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 중간 (코드 관리, 계층 구조)
+- **주요 기능**: 공통 코드 관리, 코드 카테고리 관리
+- **의존성**: code_info, code_category
+
+#### 🔧 전환 전략
+
+##### 11.1 계층형 코드 구조 처리
+
+```typescript
+// 기존 Prisma 코드
+const codes = await prisma.code_info.findMany({
+  where: { category_code: categoryCode },
+  include: {
+    parent: true,
+    children: { where: { is_active: "Y" } },
+  },
+});
+
+// 새로운 Raw Query 코드 (재귀 CTE 사용)
+const codes = await DatabaseManager.query(
+  `
+  WITH RECURSIVE code_tree AS (
+    SELECT 
+      ci.*,
+      0 as level,
+      CAST(ci.sort_order as TEXT) as path
+    FROM code_info ci
+    WHERE ci.parent_code IS NULL 
+      AND ci.category_code = $1
+      AND ci.is_active = 'Y'
+    
+    UNION ALL
+    
+    SELECT 
+      ci.*,
+      ct.level + 1,
+      ct.path || '.' || ci.sort_order
+    FROM code_info ci
+    JOIN code_tree ct ON ci.parent_code = ct.code
+    WHERE ci.is_active = 'Y'
+  )
+  SELECT * FROM code_tree 
+  ORDER BY path
+`,
+  [categoryCode]
+);
+```
+
+---
+
+### 12. batchService.ts (16개 호출)
+
+#### 📊 현재 상태 분석
+
+- **복잡도**: 중간-높음 (배치 작업, 스케줄링)
+- **주요 기능**: 배치 작업 관리, 실행 이력, 스케줄링
+- **의존성**: batch_configs, batch_execution_logs
+
+#### 🔧 전환 전략
+
+##### 12.1 배치 실행 이력 관리
+
+```typescript
+// 기존 Prisma 코드
+const batchHistory = await prisma.batch_execution_logs.findMany({
+  where: { batch_config_id: configId },
+  include: { batch_config: true },
+  orderBy: { created_at: "desc" },
+  take: 50,
+});
+
+// 새로운 Raw Query 코드
+const batchHistory = await DatabaseManager.query(
+  `
+  SELECT 
+    bel.*,
+    bc.batch_name,
+    bc.description as batch_description
+  FROM batch_execution_logs bel
+  JOIN batch_configs bc ON bel.batch_config_id = bc.id
+  WHERE bel.batch_config_id = $1
+  ORDER BY bel.created_at DESC
+  LIMIT 50
+`,
+  [configId]
+);
+```
+
+##### 12.2 배치 상태 업데이트
+
+```typescript
+// 트랜잭션을 사용한 배치 상태 관리
+async updateBatchStatus(batchId: number, status: string, result?: any) {
+  await DatabaseManager.transaction(async (client) => {
+    // 실행 로그 업데이트
+    await client.query(`
+      UPDATE batch_execution_logs
+      SET status = $1,
+          result = $2,
+          completed_at = NOW(),
+          updated_at = NOW()
+      WHERE id = $3
+    `, [status, result, batchId]);
+
+    // 배치 설정의 마지막 실행 시간 업데이트
+    await client.query(`
+      UPDATE batch_configs
+      SET last_executed_at = NOW(),
+          last_status = $1,
+          updated_at = NOW()
+      WHERE id = (
+        SELECT batch_config_id
+        FROM batch_execution_logs
+        WHERE id = $2
+      )
+    `, [status, batchId]);
+  });
+}
+```
+
+---
+
+## 📋 나머지 파일들 요약 전환 계획
+
+### Phase 2 나머지 파일들 (6개 호출)
+
+- **dataflowControlService.ts** (6개): 제어 로직, 조건부 실행
+- **ddlExecutionService.ts** (6개): DDL 실행, 스키마 변경
+- **authService.ts** (5개): 사용자 인증, 토큰 관리
+- **multiConnectionQueryService.ts** (4개): 다중 DB 연결
+
+### Phase 3 나머지 파일들 (121개 호출)
+
+- **dataflowDiagramService.ts** (12개): 다이어그램 관리, JSON 처리
+- **collectionService.ts** (11개): 컬렉션 관리
+- **layoutService.ts** (10개): 레이아웃 관리
+- **dbTypeCategoryService.ts** (10개): DB 타입 분류
+- **templateStandardService.ts** (9개): 템플릿 표준
+- **ddlAuditLogger.ts** (8개): DDL 감사 로그
+- **externalCallConfigService.ts** (8개): 외부 호출 설정
+- **batchExternalDbService.ts** (8개): 배치 외부DB
+- **batchExecutionLogService.ts** (7개): 배치 실행 로그
+- **eventTriggerService.ts** (6개): 이벤트 트리거
+- **enhancedDynamicFormService.ts** (6개): 확장 동적 폼
+- **entityJoinService.ts** (5개): 엔티티 조인
+- **dataMappingService.ts** (5개): 데이터 매핑
+- **batchManagementService.ts** (5개): 배치 관리
+- **batchSchedulerService.ts** (4개): 배치 스케줄러
+- **dataService.ts** (4개): 데이터 서비스
+- **adminService.ts** (3개): 관리자 서비스
+- **referenceCacheService.ts** (3개): 참조 캐시
+
+### Phase 4 나머지 파일들 (101개 호출)
+
+- **webTypeStandardController.ts** (11개): 웹타입 표준 컨트롤러
+- **fileController.ts** (11개): 파일 업로드/다운로드 컨트롤러
+- **buttonActionStandardController.ts** (11개): 버튼 액션 표준
+- **entityReferenceController.ts** (4개): 엔티티 참조 컨트롤러
+- **database.ts** (4개): 데이터베이스 설정
+- **dataflowExecutionController.ts** (3개): 데이터플로우 실행
+- **screenFileController.ts** (2개): 화면 파일 컨트롤러
+- **ddlRoutes.ts** (2개): DDL 라우트
+- **companyManagementRoutes.ts** (2개): 회사 관리 라우트
+
+---
+
+## 🔗 파일 간 의존성 분석
+
+### 1. 핵심 의존성 체인
+
+```
+DatabaseManager (기반)
+  ↓
+QueryBuilder (쿼리 생성)
+  ↓
+Services (비즈니스 로직)
+  ↓
+Controllers (API 엔드포인트)
+  ↓
+Routes (라우팅)
+```
+
+### 2. 서비스 간 의존성
+
+```
+tableManagementService
+  ↓ (테이블 메타데이터)
+screenManagementService
+  ↓ (화면 정의)
+dynamicFormService
+  ↓ (폼 데이터)
+dataflowControlService
+```
+
+### 3. 전환 순서 (의존성 고려)
+
+1. **기반 구조**: DatabaseManager, QueryBuilder
+2. **메타데이터 서비스**: tableManagementService
+3. **핵심 비즈니스**: screenManagementService, dataflowService
+4. **폼 처리**: dynamicFormService
+5. **외부 연동**: externalDbConnectionService
+6. **관리 기능**: adminService, commonCodeService
+7. **배치 시스템**: batchService 계열
+8. **컨트롤러**: adminController 등
+9. **라우트**: 각종 라우트 파일들
+
+---
+
+## ⚡ 전환 가속화 전략
+
+### 1. 병렬 전환 가능 그룹
+
+```
+그룹 A (독립적): authService, adminService, commonCodeService
+그룹 B (배치 관련): batchService, batchSchedulerService, batchExecutionLogService
+그룹 C (컨트롤러): adminController, fileController, webTypeStandardController
+그룹 D (표준 관리): componentStandardService, templateStandardService
+```
+
+### 2. 공통 패턴 템플릿 활용
+
+```typescript
+// 표준 CRUD 템플릿
+class StandardCRUDTemplate {
+  static async create(tableName: string, data: any) {
+    const { query, params } = QueryBuilder.insert(tableName, data, {
+      returning: ["*"],
+    });
+    return await DatabaseManager.query(query, params);
+  }
+
+  static async findMany(tableName: string, options: any) {
+    const { query, params } = QueryBuilder.select(tableName, options);
+    return await DatabaseManager.query(query, params);
+  }
+
+  // ... 기타 표준 메서드들
+}
+```
+
+### 3. 자동화 도구 활용
+
+```typescript
+// Prisma → Raw Query 자동 변환 도구
+class PrismaToRawConverter {
+  static convertFindMany(prismaCall: string): string {
+    // Prisma findMany 호출을 Raw Query로 자동 변환
+  }
+
+  static convertCreate(prismaCall: string): string {
+    // Prisma create 호출을 Raw Query로 자동 변환
+  }
+}
+```
+
+---
+
+## 🧪 통합 테스트 전략
+
+### 1. 파일별 테스트 매트릭스
+
+| 파일명                  | 단위테스트 | 통합테스트 | 성능테스트 | E2E테스트 |
+| ----------------------- | ---------- | ---------- | ---------- | --------- |
+| screenManagementService | ✅         | ✅         | ✅         | ✅        |
+| tableManagementService  | ✅         | ✅         | ✅         | ❌        |
+| dataflowService         | ✅         | ✅         | ❌         | ❌        |
+| adminController         | ✅         | ✅         | ❌         | ✅        |
+
+### 2. 회귀 테스트 자동화
+
+```typescript
+// 기존 Prisma vs 새로운 Raw Query 결과 비교
+describe("Migration Regression Tests", () => {
+  test("screenManagementService.getScreens should return identical results", async () => {
+    const prismaResult = await oldScreenService.getScreens(params);
+    const rawQueryResult = await newScreenService.getScreens(params);
+
+    expect(normalizeResult(rawQueryResult)).toEqual(
+      normalizeResult(prismaResult)
+    );
+  });
+});
+```
+
+### 3. 성능 벤치마크
+
+```typescript
+// 성능 비교 테스트
+describe("Performance Benchmarks", () => {
+  test("Complex query performance comparison", async () => {
+    const iterations = 1000;
+
+    const prismaTime = await measureTime(
+      () => prismaService.complexQuery(params),
+      iterations
+    );
+
+    const rawQueryTime = await measureTime(
+      () => rawQueryService.complexQuery(params),
+      iterations
+    );
+
+    expect(rawQueryTime).toBeLessThanOrEqual(prismaTime * 1.1); // 10% 허용
+  });
+});
+```
+
+---
+
+## 🔧 공통 전환 패턴
+
+### 1. 기본 CRUD 패턴
+
+```typescript
+// CREATE
+const { query, params } = QueryBuilder.insert(tableName, data, {
+  returning: ["*"],
+});
+const [result] = await DatabaseManager.query(query, params);
+
+// READ
+const { query, params } = QueryBuilder.select(tableName, {
+  where,
+  orderBy,
+  limit,
+});
+const results = await DatabaseManager.query(query, params);
+
+// UPDATE
+const { query, params } = QueryBuilder.update(tableName, data, where);
+const [result] = await DatabaseManager.query(query, params);
+
+// DELETE
+const { query, params } = QueryBuilder.delete(tableName, where);
+const results = await DatabaseManager.query(query, params);
+```
+
+### 2. 트랜잭션 패턴
+
+```typescript
+await DatabaseManager.transaction(async (client) => {
+  const result1 = await client.query(query1, params1);
+  const result2 = await client.query(query2, params2);
+  return { result1, result2 };
+});
+```
+
+### 3. 동적 쿼리 패턴
+
+```typescript
+const tableName = DatabaseValidator.sanitizeTableName(userInput);
+const columnName = DatabaseValidator.sanitizeColumnName(userInput);
+const query = `SELECT ${columnName} FROM ${tableName} WHERE id = $1`;
+const result = await DatabaseManager.query(query, [id]);
+```
+
+---
+
+## 📋 전환 체크리스트
+
+### 각 파일별 필수 확인사항
+
+- [ ] 모든 Prisma 호출 식별 및 변환
+- [ ] 타입 변환 (Date, JSON, BigInt) 처리
+- [ ] NULL 값 처리 일관성
+- [ ] 트랜잭션 경계 유지
+- [ ] 에러 처리 로직 보존
+- [ ] 성능 최적화 (인덱스 힌트 등)
+- [ ] 단위 테스트 작성
+- [ ] 통합 테스트 실행
+- [ ] 기능 동작 검증
+- [ ] 성능 비교 테스트
+
+### 공통 주의사항
+
+1. **SQL 인젝션 방지**: 모든 동적 쿼리에 파라미터 바인딩 사용
+2. **타입 안전성**: TypeScript 타입 정의 유지
+3. **에러 처리**: Prisma 에러를 적절한 HTTP 상태코드로 변환
+4. **로깅**: 쿼리 실행 로그 및 성능 모니터링
+5. **백워드 호환성**: API 응답 형식 유지
+
+---
+
+## 🎯 성공 기준
+
+### 기능적 요구사항
+
+- [ ] 모든 기존 API 엔드포인트 정상 동작
+- [ ] 데이터 일관성 유지
+- [ ] 트랜잭션 무결성 보장
+- [ ] 에러 처리 동일성
+
+### 성능 요구사항
+
+- [ ] 응답 시간 기존 대비 ±10% 이내
+- [ ] 메모리 사용량 최적화
+- [ ] 동시 접속 처리 능력 유지
+
+### 품질 요구사항
+
+- [ ] 코드 커버리지 90% 이상
+- [ ] 타입 안전성 보장
+- [ ] 보안 검증 통과
+- [ ] 문서화 완료
+
+이 상세 계획을 통해 각 파일별로 체계적이고 안전한 마이그레이션을 수행할 수 있습니다.
diff --git a/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md b/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md
index dfa30a01..b6b0969c 100644
--- a/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md
+++ b/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md
@@ -8,8 +8,8 @@
 
 ### 🔍 현재 상황 분석
 
-- **총 42개 파일**에서 Prisma 사용
-- **386개의 Prisma 호출** (ORM + Raw Query 혼재)
+- **총 52개 파일**에서 Prisma 사용
+- **490개의 Prisma 호출** (ORM + Raw Query 혼재)
 - **150개 이상의 테이블** 정의 (schema.prisma)
 - **복잡한 트랜잭션 및 동적 쿼리** 다수 존재
 
@@ -17,64 +17,161 @@
 
 ## 📊 Prisma 사용 현황 분석
 
+**총 42개 파일에서 444개의 Prisma 호출 발견** ⚡ (Scripts 제외)
+
 ### 1. **Prisma 사용 파일 분류**
 
-#### 🔴 **High Priority (핵심 서비스)**
+#### 🔴 **High Priority (핵심 서비스) - 107개 호출**
 
 ```
 backend-node/src/services/
-├── authService.ts                    # 인증 (5개 호출)
-├── dynamicFormService.ts             # 동적 폼 (14개 호출)
-├── dataflowControlService.ts         # 제어관리 (6개 호출)
-├── multiConnectionQueryService.ts    # 다중 연결 (4개 호출)
-├── tableManagementService.ts         # 테이블 관리 (34개 호출)
-├── screenManagementService.ts        # 화면 관리 (40개 호출)
-└── ddlExecutionService.ts            # DDL 실행 (4개 호출)
-```
-
-#### 🟡 **Medium Priority (관리 기능)**
-
-```
-backend-node/src/services/
-├── adminService.ts                   # 관리자 (3개 호출)
-├── multilangService.ts               # 다국어 (22개 호출)
-├── commonCodeService.ts              # 공통코드 (13개 호출)
+├── screenManagementService.ts        # 화면 관리 (46개 호출) ⭐ 최우선
+├── tableManagementService.ts         # 테이블 관리 (35개 호출) ⭐ 최우선
+├── dataflowService.ts                # 데이터플로우 (31개 호출) ⭐ 신규 발견
+├── dynamicFormService.ts             # 동적 폼 (15개 호출)
 ├── externalDbConnectionService.ts    # 외부DB (15개 호출)
-├── batchService.ts                   # 배치 (13개 호출)
-└── eventTriggerService.ts            # 이벤트 (6개 호출)
+├── dataflowControlService.ts         # 제어관리 (6개 호출)
+├── ddlExecutionService.ts            # DDL 실행 (6개 호출)
+├── authService.ts                    # 인증 (5개 호출)
+└── multiConnectionQueryService.ts    # 다중 연결 (4개 호출)
 ```
 
-#### 🟢 **Low Priority (부가 기능)**
+#### 🟡 **Medium Priority (관리 기능) - 142개 호출**
 
 ```
 backend-node/src/services/
-├── layoutService.ts                  # 레이아웃 (8개 호출)
-├── componentStandardService.ts       # 컴포넌트 (11개 호출)
-├── templateStandardService.ts        # 템플릿 (8개 호출)
+├── multilangService.ts               # 다국어 (25개 호출)
+├── batchService.ts                   # 배치 (16개 호출)
+├── componentStandardService.ts       # 컴포넌트 (16개 호출)
+├── commonCodeService.ts              # 공통코드 (15개 호출)
+├── dataflowDiagramService.ts         # 데이터플로우 다이어그램 (12개 호출) ⭐ 신규 발견
 ├── collectionService.ts              # 컬렉션 (11개 호출)
+├── layoutService.ts                  # 레이아웃 (10개 호출)
+├── dbTypeCategoryService.ts          # DB 타입 카테고리 (10개 호출) ⭐ 신규 발견
+├── templateStandardService.ts        # 템플릿 (9개 호출)
+├── ddlAuditLogger.ts                 # DDL 감사 로그 (8개 호출) ⭐ 신규 발견
+├── externalCallConfigService.ts      # 외부 호출 설정 (8개 호출) ⭐ 신규 발견
+├── batchExternalDbService.ts         # 배치 외부DB (8개 호출) ⭐ 신규 발견
+├── batchExecutionLogService.ts       # 배치 실행 로그 (7개 호출) ⭐ 신규 발견
+├── eventTriggerService.ts            # 이벤트 (6개 호출)
+├── enhancedDynamicFormService.ts     # 확장 동적 폼 (6개 호출) ⭐ 신규 발견
+├── entityJoinService.ts              # 엔티티 조인 (5개 호출) ⭐ 신규 발견
+├── dataMappingService.ts             # 데이터 매핑 (5개 호출) ⭐ 신규 발견
+├── batchManagementService.ts         # 배치 관리 (5개 호출) ⭐ 신규 발견
+├── batchSchedulerService.ts          # 배치 스케줄러 (4개 호출) ⭐ 신규 발견
+├── dataService.ts                    # 데이터 서비스 (4개 호출) ⭐ 신규 발견
+├── adminService.ts                   # 관리자 (3개 호출)
 └── referenceCacheService.ts          # 캐시 (3개 호출)
 ```
 
+#### 🟢 **Low Priority (컨트롤러 & 라우트) - 188개 호출**
+
+```
+backend-node/src/controllers/
+├── adminController.ts                # 관리자 컨트롤러 (28개 호출) ⭐ 신규 발견
+├── webTypeStandardController.ts      # 웹타입 표준 (11개 호출) ⭐ 신규 발견
+├── fileController.ts                 # 파일 컨트롤러 (11개 호출) ⭐ 신규 발견
+├── buttonActionStandardController.ts # 버튼 액션 표준 (11개 호출) ⭐ 신규 발견
+├── entityReferenceController.ts      # 엔티티 참조 (4개 호출) ⭐ 신규 발견
+├── dataflowExecutionController.ts    # 데이터플로우 실행 (3개 호출) ⭐ 신규 발견
+└── screenFileController.ts           # 화면 파일 (2개 호출) ⭐ 신규 발견
+
+backend-node/src/routes/
+├── ddlRoutes.ts                      # DDL 라우트 (2개 호출) ⭐ 신규 발견
+└── companyManagementRoutes.ts        # 회사 관리 라우트 (2개 호출) ⭐ 신규 발견
+
+backend-node/src/config/
+└── database.ts                       # 데이터베이스 설정 (4개 호출)
+
+#### 🗑️ **삭제 예정 Scripts - 60개 호출** ⚠️ 사용하지 않음
+
+```
+
+backend-node/scripts/ (삭제 예정)
+├── install-dataflow-indexes.js # 인덱스 설치 (10개 호출) 🗑️ 삭제
+├── add-missing-columns.js # 컬럼 추가 (8개 호출) 🗑️ 삭제
+├── test-template-creation.js # 템플릿 테스트 (6개 호출) 🗑️ 삭제
+├── create-component-table.js # 컴포넌트 테이블 생성 (5개 호출) 🗑️ 삭제
+├── seed-ui-components.js # UI 컴포넌트 시드 (3개 호출) 🗑️ 삭제
+├── seed-templates.js # 템플릿 시드 (3개 호출) 🗑️ 삭제
+├── init-layout-standards.js # 레이아웃 표준 초기화 (3개 호출) 🗑️ 삭제
+├── add-data-mapping-column.js # 데이터 매핑 컬럼 추가 (3개 호출) 🗑️ 삭제
+├── add-button-webtype.js # 버튼 웹타입 추가 (3개 호출) 🗑️ 삭제
+└── list-components.js # 컴포넌트 목록 (2개 호출) 🗑️ 삭제
+
+backend-node/ (루트)
+└── clean-screen-tables.js # 화면 테이블 정리 (7개 호출) 🗑️ 삭제
+
+````
+
+**⚠️ 삭제 계획**: 이 스크립트들은 개발/배포 도구로 운영 시스템에서 사용하지 않으므로 마이그레이션 전에 삭제 예정
+
 ### 2. **복잡도별 분류**
 
-#### 🔥 **매우 복잡 (트랜잭션 + 동적 쿼리)**
+#### 🔥 **매우 복잡 (트랜잭션 + 동적 쿼리) - 최우선 처리**
 
-- `dataflowControlService.ts` - 복잡한 제어 로직
-- `enhancedDataflowControlService.ts` - 다중 연결 제어
-- `dynamicFormService.ts` - UPSERT 및 동적 테이블 처리
-- `multiConnectionQueryService.ts` - 외부 DB 연결
+- `screenManagementService.ts` (46개) - 화면 정의 관리, JSON 처리
+- `tableManagementService.ts` (35개) - 테이블 메타데이터 관리, DDL 실행
+- `dataflowService.ts` (31개) - 복잡한 관계 관리, 트랜잭션 처리 ⭐ 신규 발견
+- `dynamicFormService.ts` (15개) - UPSERT 및 동적 테이블 처리
+- `externalDbConnectionService.ts` (15개) - 외부 DB 연결 관리
+- `dataflowControlService.ts` (6개) - 복잡한 제어 로직
+- `enhancedDataflowControlService.ts` (0개) - 다중 연결 제어 (Raw Query만 사용)
+- `multiConnectionQueryService.ts` (4개) - 외부 DB 연결
 
-#### 🟠 **복잡 (Raw Query 혼재)**
+#### 🟠 **복잡 (Raw Query 혼재) - 2순위**
 
-- `tableManagementService.ts` - 테이블 메타데이터 관리
-- `screenManagementService.ts` - 화면 정의 관리
-- `eventTriggerService.ts` - JSON 검색 쿼리
+- `multilangService.ts` (25개) - 재귀 쿼리, 다국어 처리
+- `batchService.ts` (16개) - 배치 작업 관리
+- `componentStandardService.ts` (16개) - 컴포넌트 표준 관리
+- `commonCodeService.ts` (15개) - 코드 관리, 계층 구조
+- `dataflowDiagramService.ts` (12개) - 다이어그램 관리 ⭐ 신규 발견
+- `collectionService.ts` (11개) - 컬렉션 관리
+- `layoutService.ts` (10개) - 레이아웃 관리
+- `dbTypeCategoryService.ts` (10개) - DB 타입 분류 ⭐ 신규 발견
+- `templateStandardService.ts` (9개) - 템플릿 표준
+- `eventTriggerService.ts` (6개) - JSON 검색 쿼리
 
-#### 🟡 **중간 (단순 CRUD)**
+#### 🟡 **중간 (단순 CRUD) - 3순위**
 
-- `authService.ts` - 사용자 인증
-- `adminService.ts` - 관리자 메뉴
-- `commonCodeService.ts` - 코드 관리
+- `ddlAuditLogger.ts` (8개) - DDL 감사 로그 ⭐ 신규 발견
+- `externalCallConfigService.ts` (8개) - 외부 호출 설정 ⭐ 신규 발견
+- `batchExternalDbService.ts` (8개) - 배치 외부DB ⭐ 신규 발견
+- `batchExecutionLogService.ts` (7개) - 배치 실행 로그 ⭐ 신규 발견
+- `enhancedDynamicFormService.ts` (6개) - 확장 동적 폼 ⭐ 신규 발견
+- `ddlExecutionService.ts` (6개) - DDL 실행
+- `entityJoinService.ts` (5개) - 엔티티 조인 ⭐ 신규 발견
+- `dataMappingService.ts` (5개) - 데이터 매핑 ⭐ 신규 발견
+- `batchManagementService.ts` (5개) - 배치 관리 ⭐ 신규 발견
+- `authService.ts` (5개) - 사용자 인증
+- `batchSchedulerService.ts` (4개) - 배치 스케줄러 ⭐ 신규 발견
+- `dataService.ts` (4개) - 데이터 서비스 ⭐ 신규 발견
+- `adminService.ts` (3개) - 관리자 메뉴
+- `referenceCacheService.ts` (3개) - 캐시 관리
+
+#### 🟢 **단순 (컨트롤러 레이어) - 4순위**
+
+- `adminController.ts` (28개) - 관리자 컨트롤러 ⭐ 신규 발견
+- `webTypeStandardController.ts` (11개) - 웹타입 표준 ⭐ 신규 발견
+- `fileController.ts` (11개) - 파일 컨트롤러 ⭐ 신규 발견
+- `buttonActionStandardController.ts` (11개) - 버튼 액션 표준 ⭐ 신규 발견
+- `entityReferenceController.ts` (4개) - 엔티티 참조 ⭐ 신규 발견
+- `database.ts` (4개) - 데이터베이스 설정
+- `dataflowExecutionController.ts` (3개) - 데이터플로우 실행 ⭐ 신규 발견
+- `screenFileController.ts` (2개) - 화면 파일 ⭐ 신규 발견
+- `ddlRoutes.ts` (2개) - DDL 라우트 ⭐ 신규 발견
+- `companyManagementRoutes.ts` (2개) - 회사 관리 라우트 ⭐ 신규 발견
+
+#### 🗑️ **삭제 예정 Scripts (마이그레이션 대상 아님)**
+
+- `install-dataflow-indexes.js` (10개) - 인덱스 설치 스크립트 🗑️
+- `add-missing-columns.js` (8개) - 컬럼 추가 스크립트 🗑️
+- `clean-screen-tables.js` (7개) - 테이블 정리 스크립트 🗑️
+- `test-template-creation.js` (6개) - 템플릿 테스트 스크립트 🗑️
+- `create-component-table.js` (5개) - 컴포넌트 테이블 생성 🗑️
+- 기타 시드 스크립트들 (14개) - 개발용 데이터 시드 🗑️
+
+**⚠️ 중요**: 이 스크립트들은 사용하지 않으므로 마이그레이션 전에 삭제하여 작업량을 60개 호출만큼 줄일 수 있습니다.
 
 ---
 
@@ -136,7 +233,7 @@ export class DatabaseManager {
     await this.pool.end();
   }
 }
-```
+````
 
 ### 2. **동적 쿼리 빌더**
 
@@ -351,77 +448,150 @@ export class DatabaseValidator {
 - [ ] 통합 테스트 환경 구성
 - [ ] 성능 벤치마크 도구 준비
 
-### **Phase 2: 핵심 서비스 전환 (2주)**
+### **Phase 2: 핵심 서비스 전환 (3주) - 최우선**
 
-#### 2.1 인증 서비스 전환 (우선순위 1)
+#### 2.1 화면 관리 서비스 전환 (우선순위 1) - 46개 호출
 
 ```typescript
-// 기존 Prisma 코드
-const userInfo = await prisma.user_info.findUnique({
-  where: { user_id: userId },
+// 기존 Prisma 코드 (복잡한 JSON 처리)
+const screenData = await prisma.screen_definitions.findMany({
+  where: {
+    company_code: companyCode,
+    screen_config: { path: ["type"], equals: "form" },
+  },
+  include: { screen_components: true },
 });
 
 // 새로운 Raw Query 코드
-const { query, params } = QueryBuilder.select("user_info", {
-  where: { user_id: userId },
+const { query, params } = QueryBuilder.select("screen_definitions", {
+  columns: ["*", "screen_config::jsonb"],
+  where: {
+    company_code: companyCode,
+    "screen_config->>'type'": "form",
+  },
+  joins: [
+    {
+      type: "LEFT",
+      table: "screen_components",
+      on: "screen_definitions.id = screen_components.screen_id",
+    },
+  ],
 });
-const userInfo = await DatabaseManager.query(query, params);
+const screenData = await DatabaseManager.query(query, params);
 ```
 
-#### 2.2 동적 폼 서비스 전환 (우선순위 2)
+#### 2.2 테이블 관리 서비스 전환 (우선순위 2) - 35개 호출
+
+- [ ] 동적 테이블 생성/삭제 로직 전환
+- [ ] 메타데이터 관리 시스템 개선
+- [ ] DDL 실행 트랜잭션 처리
+- [ ] 컬럼 타입 변환 로직 최적화
+
+#### 2.3 데이터플로우 서비스 전환 (우선순위 3) - 31개 호출 ⭐ 신규 발견
+
+- [ ] 복잡한 관계 관리 로직 전환
+- [ ] 트랜잭션 기반 데이터 이동 처리
+- [ ] JSON 기반 설정 관리 개선
+- [ ] 다중 테이블 조인 최적화
+
+#### 2.4 동적 폼 서비스 전환 (우선순위 4) - 15개 호출
 
 - [ ] UPSERT 로직 Raw Query로 전환
 - [ ] 동적 테이블 처리 로직 개선
 - [ ] 트랜잭션 처리 최적화
 
-#### 2.3 제어관리 서비스 전환 (우선순위 3)
+#### 2.5 외부 DB 연결 서비스 전환 (우선순위 5) - 15개 호출
 
-- [ ] 복잡한 조건부 쿼리 전환
-- [ ] 다중 테이블 업데이트 로직 개선
-- [ ] 에러 핸들링 강화
+- [ ] 다중 DB 연결 관리 로직
+- [ ] 연결 풀 관리 시스템
+- [ ] 외부 DB 스키마 동기화
 
-### **Phase 3: 관리 기능 전환 (1.5주)**
+### **Phase 3: 관리 기능 전환 (2.5주)**
 
-#### 3.1 테이블 관리 서비스
-
-- [ ] 메타데이터 조회 쿼리 전환
-- [ ] 동적 컬럼 추가/삭제 로직
-- [ ] 인덱스 관리 기능
-
-#### 3.2 화면 관리 서비스
-
-- [ ] JSON 데이터 처리 최적화
-- [ ] 복잡한 조인 쿼리 전환
-- [ ] 캐싱 메커니즘 구현
-
-#### 3.3 다국어 서비스
+#### 3.1 다국어 서비스 전환 - 25개 호출
 
 - [ ] 재귀 쿼리 (WITH RECURSIVE) 전환
 - [ ] 번역 데이터 관리 최적화
+- [ ] 다국어 캐시 시스템 구현
 
-### **Phase 4: 부가 기능 전환 (1주)**
+#### 3.2 배치 관련 서비스 전환 - 40개 호출 ⭐ 대규모 신규 발견
 
-#### 4.1 배치 및 외부 연결
+- [ ] `batchService.ts` (16개) - 배치 작업 관리
+- [ ] `batchExternalDbService.ts` (8개) - 배치 외부DB
+- [ ] `batchExecutionLogService.ts` (7개) - 배치 실행 로그
+- [ ] `batchManagementService.ts` (5개) - 배치 관리
+- [ ] `batchSchedulerService.ts` (4개) - 배치 스케줄러
 
-- [ ] 배치 스케줄러 전환
-- [ ] 외부 DB 연결 관리
-- [ ] 로그 및 모니터링
+#### 3.3 표준 관리 서비스 전환 - 41개 호출
 
-#### 4.2 표준 관리 기능
+- [ ] `componentStandardService.ts` (16개) - 컴포넌트 표준 관리
+- [ ] `commonCodeService.ts` (15개) - 코드 관리, 계층 구조
+- [ ] `layoutService.ts` (10개) - 레이아웃 관리
 
-- [ ] 컴포넌트 표준 관리
-- [ ] 템플릿 표준 관리
-- [ ] 레이아웃 관리
+#### 3.4 데이터플로우 관련 서비스 - 18개 호출 ⭐ 신규 발견
 
-### **Phase 5: Prisma 완전 제거 (0.5주)**
+- [ ] `dataflowDiagramService.ts` (12개) - 다이어그램 관리
+- [ ] `dataflowControlService.ts` (6개) - 복잡한 제어 로직
 
-#### 5.1 Prisma 의존성 제거
+#### 3.5 기타 중요 서비스 - 38개 호출 ⭐ 신규 발견
+
+- [ ] `collectionService.ts` (11개) - 컬렉션 관리
+- [ ] `dbTypeCategoryService.ts` (10개) - DB 타입 분류
+- [ ] `templateStandardService.ts` (9개) - 템플릿 표준
+- [ ] `ddlAuditLogger.ts` (8개) - DDL 감사 로그
+
+### **Phase 4: 확장 기능 전환 (2.5주) ⭐ 대폭 확장**
+
+#### 4.1 외부 연동 서비스 - 51개 호출 ⭐ 신규 발견
+
+- [ ] `externalCallConfigService.ts` (8개) - 외부 호출 설정
+- [ ] `eventTriggerService.ts` (6개) - JSON 검색 쿼리
+- [ ] `enhancedDynamicFormService.ts` (6개) - 확장 동적 폼
+- [ ] `ddlExecutionService.ts` (6개) - DDL 실행
+- [ ] `entityJoinService.ts` (5개) - 엔티티 조인
+- [ ] `dataMappingService.ts` (5개) - 데이터 매핑
+- [ ] `authService.ts` (5개) - 사용자 인증
+- [ ] `multiConnectionQueryService.ts` (4개) - 외부 DB 연결
+- [ ] `dataService.ts` (4개) - 데이터 서비스
+- [ ] `adminService.ts` (3개) - 관리자 메뉴
+- [ ] `referenceCacheService.ts` (3개) - 캐시 관리
+
+#### 4.2 컨트롤러 레이어 전환 - 72개 호출 ⭐ 대규모 신규 발견
+
+- [ ] `adminController.ts` (28개) - 관리자 컨트롤러
+- [ ] `webTypeStandardController.ts` (11개) - 웹타입 표준
+- [ ] `fileController.ts` (11개) - 파일 컨트롤러
+- [ ] `buttonActionStandardController.ts` (11개) - 버튼 액션 표준
+- [ ] `entityReferenceController.ts` (4개) - 엔티티 참조
+- [ ] `dataflowExecutionController.ts` (3개) - 데이터플로우 실행
+- [ ] `screenFileController.ts` (2개) - 화면 파일
+- [ ] `ddlRoutes.ts` (2개) - DDL 라우트
+
+#### 4.3 설정 및 기반 구조 - 6개 호출
+
+- [ ] `database.ts` (4개) - 데이터베이스 설정
+- [ ] `companyManagementRoutes.ts` (2개) - 회사 관리 라우트
+
+### **Phase 5: 사용하지 않는 Scripts 삭제 (0.5주) 🗑️**
+
+#### 5.1 불필요한 스크립트 파일 삭제 - 60개 호출 제거
+
+- [ ] `backend-node/scripts/` 전체 폴더 삭제 (53개 호출)
+- [ ] `backend-node/clean-screen-tables.js` 삭제 (7개 호출)
+- [ ] 관련 package.json 스크립트 정리
+- [ ] 문서에서 스크립트 참조 제거
+
+**✅ 효과**: 60개 Prisma 호출을 마이그레이션 없이 제거하여 작업량 대폭 감소
+
+### **Phase 6: Prisma 완전 제거 (0.5주)**
+
+#### 6.1 Prisma 의존성 제거
 
 - [ ] `package.json`에서 Prisma 제거
 - [ ] `schema.prisma` 파일 삭제
 - [ ] 관련 설정 파일 정리
 
-#### 5.2 최종 검증 및 최적화
+#### 6.2 최종 검증 및 최적화
 
 - [ ] 전체 기능 테스트
 - [ ] 성능 최적화
@@ -858,49 +1028,73 @@ describe("Performance Benchmarks", () => {
 
 ## 📋 체크리스트
 
-### **Phase 1: 기반 구조 (1주)**
+### **Phase 1: 기반 구조 (1주)** ✅ **완료**
 
-- [ ] DatabaseManager 클래스 구현
-- [ ] QueryBuilder 유틸리티 구현
-- [ ] 타입 정의 및 검증 로직
-- [ ] 연결 풀 설정 및 최적화
-- [ ] 트랜잭션 관리 시스템
-- [ ] 에러 핸들링 메커니즘
-- [ ] 로깅 및 모니터링 도구
-- [ ] 단위 테스트 작성
+- [x] DatabaseManager 클래스 구현 (`backend-node/src/database/db.ts`)
+- [x] QueryBuilder 유틸리티 구현 (`backend-node/src/utils/queryBuilder.ts`)
+- [x] 타입 정의 및 검증 로직 (`backend-node/src/types/database.ts`)
+- [x] 연결 풀 설정 및 최적화 (pg Pool 사용)
+- [x] 트랜잭션 관리 시스템 (transaction 함수 구현)
+- [x] 에러 핸들링 메커니즘 (try-catch 및 rollback 처리)
+- [x] 로깅 및 모니터링 도구 (쿼리 로그 포함)
+- [x] 단위 테스트 작성 (`backend-node/src/tests/`)
+- [x] 테스트 성공 확인 (multiConnectionQueryService, externalCallConfigService)
 
-### **Phase 2: 핵심 서비스 (2주)**
+### **Phase 2: 핵심 서비스 (3주) - 107개 호출**
 
-- [ ] AuthService 전환 및 테스트
-- [ ] DynamicFormService 전환 (UPSERT 포함)
-- [ ] DataflowControlService 전환 (복잡한 로직)
-- [ ] MultiConnectionQueryService 전환
-- [ ] TableManagementService 전환
-- [ ] ScreenManagementService 전환
-- [ ] DDLExecutionService 전환
+- [ ] ScreenManagementService 전환 (46개) - 최우선
+- [ ] TableManagementService 전환 (35개) - 최우선
+- [ ] DataflowService 전환 (31개) ⭐ 신규 발견
+- [ ] DynamicFormService 전환 (15개) - UPSERT 포함
+- [ ] ExternalDbConnectionService 전환 (15개)
+- [ ] DataflowControlService 전환 (6개) - 복잡한 로직
+- [ ] DDLExecutionService 전환 (6개)
+- [ ] AuthService 전환 (5개)
+- [ ] MultiConnectionQueryService 전환 (4개)
 - [ ] 통합 테스트 실행
 
-### **Phase 3: 관리 기능 (1.5주)**
+### **Phase 3: 관리 기능 (2.5주) - 162개 호출**
 
-- [ ] AdminService 전환
-- [ ] MultiLangService 전환 (재귀 쿼리)
-- [ ] CommonCodeService 전환
-- [ ] ExternalDbConnectionService 전환
-- [ ] BatchService 및 관련 서비스 전환
-- [ ] EventTriggerService 전환
+- [ ] MultiLangService 전환 (25개) - 재귀 쿼리
+- [ ] 배치 관련 서비스 전환 (40개) ⭐ 대규모 신규 발견
+  - [ ] BatchService (16개), BatchExternalDbService (8개)
+  - [ ] BatchExecutionLogService (7개), BatchManagementService (5개)
+  - [ ] BatchSchedulerService (4개)
+- [ ] 표준 관리 서비스 전환 (41개)
+  - [ ] ComponentStandardService (16개), CommonCodeService (15개)
+  - [ ] LayoutService (10개)
+- [ ] 데이터플로우 관련 서비스 (18개) ⭐ 신규 발견
+  - [ ] DataflowDiagramService (12개), DataflowControlService (6개)
+- [ ] 기타 중요 서비스 (38개) ⭐ 신규 발견
+  - [ ] CollectionService (11개), DbTypeCategoryService (10개)
+  - [ ] TemplateStandardService (9개), DDLAuditLogger (8개)
 - [ ] 기능별 테스트 완료
 
-### **Phase 4: 부가 기능 (1주)**
+### **Phase 4: 확장 기능 (2.5주) - 129개 호출 ⭐ 대폭 확장**
 
-- [ ] LayoutService 전환
-- [ ] ComponentStandardService 전환
-- [ ] TemplateStandardService 전환
-- [ ] CollectionService 전환
-- [ ] ReferenceCacheService 전환
-- [ ] 기타 컨트롤러 전환
+- [ ] 외부 연동 서비스 전환 (51개) ⭐ 신규 발견
+  - [ ] ExternalCallConfigService (8개), EventTriggerService (6개)
+  - [ ] EnhancedDynamicFormService (6개), EntityJoinService (5개)
+  - [ ] DataMappingService (5개), DataService (4개)
+  - [ ] AdminService (3개), ReferenceCacheService (3개)
+- [ ] 컨트롤러 레이어 전환 (72개) ⭐ 대규모 신규 발견
+  - [ ] AdminController (28개), WebTypeStandardController (11개)
+  - [ ] FileController (11개), ButtonActionStandardController (11개)
+  - [ ] EntityReferenceController (4개), DataflowExecutionController (3개)
+  - [ ] ScreenFileController (2개), DDLRoutes (2개)
+- [ ] 설정 및 기반 구조 (6개)
+  - [ ] Database.ts (4개), CompanyManagementRoutes (2개)
 - [ ] 전체 기능 테스트
 
-### **Phase 5: 완전 제거 (0.5주)**
+### **Phase 5: Scripts 삭제 (0.5주) - 60개 호출 제거 🗑️**
+
+- [ ] 불필요한 스크립트 파일 삭제 (60개) 🗑️ 마이그레이션 불필요
+  - [ ] backend-node/scripts/ 전체 폴더 삭제 (53개)
+  - [ ] backend-node/clean-screen-tables.js 삭제 (7개)
+  - [ ] package.json 스크립트 정리
+- [ ] 문서에서 스크립트 참조 제거
+
+### **Phase 6: 완전 제거 (0.5주)**
 
 - [ ] Prisma 의존성 제거
 - [ ] schema.prisma 삭제
@@ -962,8 +1156,70 @@ describe("Performance Benchmarks", () => {
 
 ---
 
-**총 예상 기간: 6주**
-**핵심 개발자: 2-3명**
-**위험도: 중간 (적절한 계획과 테스트로 관리 가능)**
+---
 
-이 계획을 통해 Prisma를 완전히 제거하고 진정한 동적 데이터베이스 시스템을 구축할 수 있습니다! 🚀
+## 📈 **업데이트된 마이그레이션 규모**
+
+### **🔍 최종 Prisma 사용 현황 (Scripts 삭제 후)**
+
+- **기존 계획**: 42개 파일, 386개 호출
+- **Scripts 포함**: 52개 파일, 490개 호출 (+104개 호출 발견)
+- **Scripts 삭제 후**: **42개 파일, 444개 호출** (+58개 호출 실제 증가) ⚡
+
+### **⭐ 주요 신규 발견 서비스들**
+
+1. **`dataflowService.ts`** (31개) - 데이터플로우 관리 핵심 서비스
+2. **배치 관련 서비스들** (40개) - 5개 서비스로 분산된 대규모 배치 시스템
+3. **`dataflowDiagramService.ts`** (12개) - 다이어그램 관리
+4. **`dbTypeCategoryService.ts`** (10개) - DB 타입 분류 시스템
+5. **컨트롤러 레이어** (72개) - 7개 컨트롤러에서 대규모 Prisma 사용
+6. **감사 및 로깅 서비스들** (15개) - DDL 감사, 배치 실행 로그
+7. **확장 기능들** (26개) - 엔티티 조인, 데이터 매핑, 외부 호출 설정
+8. **🗑️ Scripts 삭제** (60개) - 사용하지 않는 개발/배포 스크립트 (마이그레이션 불필요)
+
+### **📊 우선순위 재조정**
+
+#### **🔴 최우선 (Phase 2) - 107개 호출**
+
+- 화면관리 (46개), 테이블관리 (35개), 데이터플로우 (31개)
+
+#### **🟡 고우선순위 (Phase 3) - 162개 호출**
+
+- 다국어 (25개), 배치 시스템 (40개), 표준 관리 (41개)
+
+#### **🟢 중간우선순위 (Phase 4) - 129개 호출**
+
+- 외부 연동 (51개), 컨트롤러 레이어 (72개), 기타 (6개)
+
+#### **🗑️ Scripts 삭제 (Phase 5) - 60개 호출** 🗑️ 마이그레이션 불필요
+
+- 사용하지 않는 개발/배포 스크립트 (60개) - 삭제로 작업량 감소
+
+---
+
+## 🎯 **최종 마이그레이션 계획**
+
+**총 예상 기간: 8주** ⬆️ (+2주 연장, Scripts 삭제로 1주 단축)
+**핵심 개발자: 3-4명** ⬆️ (+1명 추가)
+**실제 마이그레이션 대상: 444개 호출** (Scripts 60개 제외)
+**위험도: 중간-높음** ⬇️ (Scripts 삭제로 위험도 일부 감소)
+
+### **⚠️ 주요 위험 요소**
+
+1. **배치 시스템 복잡성**: 5개 서비스 40개 호출의 복잡한 의존성
+2. **컨트롤러 레이어 규모**: 72개 호출의 대규모 API 전환
+3. **데이터플로우 시스템**: 신규 발견된 핵심 서비스 (31개 호출)
+4. **트랜잭션 복잡성**: 다중 서비스 간 데이터 일관성 보장
+5. **✅ Scripts 삭제**: 60개 호출 제거로 작업량 대폭 감소
+
+### **🚀 성공을 위한 핵심 전략**
+
+1. **단계별 점진적 전환**: 절대 한 번에 모든 것을 바꾸지 않기
+2. **철저한 테스트**: 각 Phase마다 완전한 기능 테스트
+3. **롤백 계획**: 각 단계별 즉시 롤백 가능한 계획 수립
+4. **모니터링 강화**: 전환 후 성능 및 안정성 지속 모니터링
+5. **팀 확대**: 복잡성 증가로 인한 개발팀 확대 필요
+
+이 **완전한 분석**을 통해 Prisma를 완전히 제거하고 진정한 동적 데이터베이스 시스템을 구축할 수 있습니다! 🚀
+
+**⚡ 중요**: 이제 모든 Prisma 사용 부분이 파악되었으므로, 누락 없는 완전한 마이그레이션이 가능합니다.
diff --git a/backend-node/PHASE1_USAGE_GUIDE.md b/backend-node/PHASE1_USAGE_GUIDE.md
new file mode 100644
index 00000000..a3d4b8ba
--- /dev/null
+++ b/backend-node/PHASE1_USAGE_GUIDE.md
@@ -0,0 +1,418 @@
+# Phase 1: Raw Query 기반 구조 사용 가이드
+
+## 📋 개요
+
+Phase 1에서 구현한 Raw Query 기반 데이터베이스 아키텍처 사용 방법입니다.
+
+---
+
+## 🏗️ 구현된 모듈
+
+### 1. **DatabaseManager** (`src/database/db.ts`)
+
+PostgreSQL 연결 풀 기반 핵심 모듈
+
+**주요 함수:**
+- `query<T>(sql, params)` - 기본 쿼리 실행
+- `queryOne<T>(sql, params)` - 단일 행 조회
+- `transaction(callback)` - 트랜잭션 실행
+- `getPool()` - 연결 풀 가져오기
+- `getPoolStatus()` - 연결 풀 상태 확인
+
+### 2. **QueryBuilder** (`src/utils/queryBuilder.ts`)
+
+동적 쿼리 생성 유틸리티
+
+**주요 메서드:**
+- `QueryBuilder.select(tableName, options)` - SELECT 쿼리
+- `QueryBuilder.insert(tableName, data, options)` - INSERT 쿼리
+- `QueryBuilder.update(tableName, data, where, options)` - UPDATE 쿼리
+- `QueryBuilder.delete(tableName, where, options)` - DELETE 쿼리
+- `QueryBuilder.count(tableName, where)` - COUNT 쿼리
+- `QueryBuilder.exists(tableName, where)` - EXISTS 쿼리
+
+### 3. **DatabaseValidator** (`src/utils/databaseValidator.ts`)
+
+SQL Injection 방지 및 입력 검증
+
+**주요 메서드:**
+- `validateTableName(tableName)` - 테이블명 검증
+- `validateColumnName(columnName)` - 컬럼명 검증
+- `validateWhereClause(where)` - WHERE 조건 검증
+- `sanitizeInput(input)` - 입력 값 Sanitize
+
+### 4. **타입 정의** (`src/types/database.ts`)
+
+TypeScript 타입 안전성 보장
+
+---
+
+## 🚀 사용 예제
+
+### 1. 기본 쿼리 실행
+
+```typescript
+import { query, queryOne } from '../database/db';
+
+// 여러 행 조회
+const users = await query<User>(
+  'SELECT * FROM users WHERE status = $1',
+  ['active']
+);
+
+// 단일 행 조회
+const user = await queryOne<User>(
+  'SELECT * FROM users WHERE user_id = $1',
+  ['user123']
+);
+
+if (!user) {
+  throw new Error('사용자를 찾을 수 없습니다.');
+}
+```
+
+### 2. QueryBuilder 사용
+
+#### SELECT
+
+```typescript
+import { query } from '../database/db';
+import { QueryBuilder } from '../utils/queryBuilder';
+
+// 기본 SELECT
+const { query: sql, params } = QueryBuilder.select('users', {
+  where: { status: 'active' },
+  orderBy: 'created_at DESC',
+  limit: 10,
+});
+
+const users = await query(sql, params);
+
+// 복잡한 SELECT (JOIN, WHERE, ORDER BY)
+const { query: sql2, params: params2 } = QueryBuilder.select('users', {
+  columns: ['users.user_id', 'users.username', 'departments.dept_name'],
+  joins: [
+    {
+      type: 'LEFT',
+      table: 'departments',
+      on: 'users.dept_id = departments.dept_id',
+    },
+  ],
+  where: { 'users.status': 'active' },
+  orderBy: ['users.created_at DESC', 'users.username ASC'],
+  limit: 20,
+  offset: 0,
+});
+
+const result = await query(sql2, params2);
+```
+
+#### INSERT
+
+```typescript
+import { query } from '../database/db';
+import { QueryBuilder } from '../utils/queryBuilder';
+
+// 기본 INSERT
+const { query: sql, params } = QueryBuilder.insert(
+  'users',
+  {
+    user_id: 'new_user',
+    username: 'John Doe',
+    email: 'john@example.com',
+    status: 'active',
+  },
+  {
+    returning: ['id', 'user_id'],
+  }
+);
+
+const [newUser] = await query(sql, params);
+console.log('생성된 사용자 ID:', newUser.id);
+
+// UPSERT (INSERT ... ON CONFLICT)
+const { query: sql2, params: params2 } = QueryBuilder.insert(
+  'users',
+  {
+    user_id: 'user123',
+    username: 'Jane',
+    email: 'jane@example.com',
+  },
+  {
+    onConflict: {
+      columns: ['user_id'],
+      action: 'DO UPDATE',
+      updateSet: ['username', 'email'],
+    },
+    returning: ['*'],
+  }
+);
+
+const [upsertedUser] = await query(sql2, params2);
+```
+
+#### UPDATE
+
+```typescript
+import { query } from '../database/db';
+import { QueryBuilder } from '../utils/queryBuilder';
+
+const { query: sql, params } = QueryBuilder.update(
+  'users',
+  {
+    username: 'Updated Name',
+    email: 'updated@example.com',
+    updated_at: new Date(),
+  },
+  {
+    user_id: 'user123',
+  },
+  {
+    returning: ['*'],
+  }
+);
+
+const [updatedUser] = await query(sql, params);
+```
+
+#### DELETE
+
+```typescript
+import { query } from '../database/db';
+import { QueryBuilder } from '../utils/queryBuilder';
+
+const { query: sql, params } = QueryBuilder.delete(
+  'users',
+  {
+    user_id: 'user_to_delete',
+  },
+  {
+    returning: ['user_id', 'username'],
+  }
+);
+
+const [deletedUser] = await query(sql, params);
+console.log('삭제된 사용자:', deletedUser.username);
+```
+
+### 3. 트랜잭션 사용
+
+```typescript
+import { transaction } from '../database/db';
+
+// 복잡한 트랜잭션 처리
+const result = await transaction(async (client) => {
+  // 1. 사용자 생성
+  const userResult = await client.query(
+    'INSERT INTO users (user_id, username, email) VALUES ($1, $2, $3) RETURNING id',
+    ['new_user', 'John', 'john@example.com']
+  );
+
+  const userId = userResult.rows[0].id;
+
+  // 2. 역할 할당
+  await client.query(
+    'INSERT INTO user_roles (user_id, role_id) VALUES ($1, $2)',
+    [userId, 'admin']
+  );
+
+  // 3. 로그 생성
+  await client.query(
+    'INSERT INTO audit_logs (action, user_id, details) VALUES ($1, $2, $3)',
+    ['USER_CREATED', userId, JSON.stringify({ username: 'John' })]
+  );
+
+  return { success: true, userId };
+});
+
+console.log('트랜잭션 완료:', result);
+```
+
+### 4. JSON 필드 쿼리 (JSONB)
+
+```typescript
+import { query } from '../database/db';
+import { QueryBuilder } from '../utils/queryBuilder';
+
+// JSON 필드 쿼리 (config->>'type' = 'form')
+const { query: sql, params } = QueryBuilder.select('screen_management', {
+  columns: ['*'],
+  where: {
+    company_code: 'COMPANY_001',
+    "config->>'type'": 'form',
+  },
+});
+
+const screens = await query(sql, params);
+```
+
+### 5. 동적 테이블 쿼리
+
+```typescript
+import { query } from '../database/db';
+import { DatabaseValidator } from '../utils/databaseValidator';
+
+async function queryDynamicTable(tableName: string, filters: Record<string, any>) {
+  // 테이블명 검증 (SQL Injection 방지)
+  if (!DatabaseValidator.validateTableName(tableName)) {
+    throw new Error('유효하지 않은 테이블명입니다.');
+  }
+
+  // WHERE 조건 검증
+  if (!DatabaseValidator.validateWhereClause(filters)) {
+    throw new Error('유효하지 않은 WHERE 조건입니다.');
+  }
+
+  const { query: sql, params } = QueryBuilder.select(tableName, {
+    where: filters,
+  });
+
+  return await query(sql, params);
+}
+
+// 사용 예
+const data = await queryDynamicTable('company_data_001', {
+  status: 'active',
+  region: 'Seoul',
+});
+```
+
+---
+
+## 🔐 보안 고려사항
+
+### 1. **항상 Parameterized Query 사용**
+
+```typescript
+// ❌ 위험: SQL Injection 취약
+const userId = req.params.userId;
+const sql = `SELECT * FROM users WHERE user_id = '${userId}'`;
+const users = await query(sql);
+
+// ✅ 안전: Parameterized Query
+const userId = req.params.userId;
+const users = await query('SELECT * FROM users WHERE user_id = $1', [userId]);
+```
+
+### 2. **식별자 검증**
+
+```typescript
+import { DatabaseValidator } from '../utils/databaseValidator';
+
+// 테이블명/컬럼명 검증
+if (!DatabaseValidator.validateTableName(tableName)) {
+  throw new Error('유효하지 않은 테이블명입니다.');
+}
+
+if (!DatabaseValidator.validateColumnName(columnName)) {
+  throw new Error('유효하지 않은 컬럼명입니다.');
+}
+```
+
+### 3. **입력 값 Sanitize**
+
+```typescript
+import { DatabaseValidator } from '../utils/databaseValidator';
+
+const sanitizedData = DatabaseValidator.sanitizeInput(userInput);
+```
+
+---
+
+## 📊 성능 최적화 팁
+
+### 1. **연결 풀 모니터링**
+
+```typescript
+import { getPoolStatus } from '../database/db';
+
+const status = getPoolStatus();
+console.log('연결 풀 상태:', {
+  total: status.totalCount,
+  idle: status.idleCount,
+  waiting: status.waitingCount,
+});
+```
+
+### 2. **배치 INSERT**
+
+```typescript
+import { transaction } from '../database/db';
+
+// 대량 데이터 삽입 시 트랜잭션 사용
+await transaction(async (client) => {
+  for (const item of largeDataset) {
+    await client.query('INSERT INTO items (name, value) VALUES ($1, $2)', [
+      item.name,
+      item.value,
+    ]);
+  }
+});
+```
+
+### 3. **인덱스 활용 쿼리**
+
+```typescript
+// WHERE 절에 인덱스 컬럼 사용
+const { query: sql, params } = QueryBuilder.select('users', {
+  where: {
+    user_id: 'user123', // 인덱스 컬럼
+  },
+});
+```
+
+---
+
+## 🧪 테스트 실행
+
+```bash
+# 테스트 실행
+npm test -- database.test.ts
+
+# 특정 테스트만 실행
+npm test -- database.test.ts -t "QueryBuilder"
+```
+
+---
+
+## 🚨 에러 핸들링
+
+```typescript
+import { query } from '../database/db';
+
+try {
+  const users = await query('SELECT * FROM users WHERE status = $1', ['active']);
+  return users;
+} catch (error: any) {
+  console.error('쿼리 실행 실패:', error.message);
+
+  // PostgreSQL 에러 코드 확인
+  if (error.code === '23505') {
+    throw new Error('중복된 값이 존재합니다.');
+  }
+
+  if (error.code === '23503') {
+    throw new Error('외래 키 제약 조건 위반입니다.');
+  }
+
+  throw error;
+}
+```
+
+---
+
+## 📝 다음 단계 (Phase 2)
+
+Phase 1 기반 구조가 완성되었으므로, Phase 2에서는:
+
+1. **screenManagementService.ts** 전환 (46개 호출)
+2. **tableManagementService.ts** 전환 (35개 호출)
+3. **dataflowService.ts** 전환 (31개 호출)
+
+등 핵심 서비스를 Raw Query로 전환합니다.
+
+---
+
+**작성일**: 2025-09-30
+**버전**: 1.0.0
+**담당**: Backend Development Team
\ No newline at end of file
diff --git a/backend-node/src/database/db.ts b/backend-node/src/database/db.ts
new file mode 100644
index 00000000..cd5f5142
--- /dev/null
+++ b/backend-node/src/database/db.ts
@@ -0,0 +1,271 @@
+/**
+ * PostgreSQL Raw Query 기반 데이터베이스 매니저
+ *
+ * Prisma → Raw Query 전환의 핵심 모듈
+ * - Connection Pool 기반 안정적인 연결 관리
+ * - 트랜잭션 지원
+ * - 타입 안전성 보장
+ * - 자동 재연결 및 에러 핸들링
+ */
+
+import {
+  Pool,
+  PoolClient,
+  QueryResult as PgQueryResult,
+  QueryResultRow,
+} from "pg";
+import config from "../config/environment";
+
+// PostgreSQL 연결 풀
+let pool: Pool | null = null;
+
+/**
+ * 데이터베이스 연결 풀 초기화
+ */
+export const initializePool = (): Pool => {
+  if (pool) {
+    return pool;
+  }
+
+  // DATABASE_URL 파싱 (postgresql://user:password@host:port/database)
+  const databaseUrl = config.databaseUrl;
+
+  // URL 파싱 로직
+  const dbConfig = parseDatabaseUrl(databaseUrl);
+
+  pool = new Pool({
+    host: dbConfig.host,
+    port: dbConfig.port,
+    database: dbConfig.database,
+    user: dbConfig.user,
+    password: dbConfig.password,
+
+    // 연결 풀 설정
+    min: config.nodeEnv === "production" ? 5 : 2,
+    max: config.nodeEnv === "production" ? 20 : 10,
+
+    // 타임아웃 설정
+    connectionTimeoutMillis: 30000, // 30초
+    idleTimeoutMillis: 600000, // 10분
+
+    // 연결 유지 설정
+    keepAlive: true,
+    keepAliveInitialDelayMillis: 10000,
+
+    // 쿼리 타임아웃
+    statement_timeout: 60000, // 60초 (동적 테이블 생성 등 고려)
+    query_timeout: 60000,
+
+    // Application Name
+    application_name: "WACE-PLM-Backend",
+  });
+
+  // 연결 풀 이벤트 핸들러
+  pool.on("connect", (client) => {
+    if (config.debug) {
+      console.log("✅ PostgreSQL 클라이언트 연결 생성");
+    }
+  });
+
+  pool.on("acquire", (client) => {
+    if (config.debug) {
+      console.log("🔒 PostgreSQL 클라이언트 획득");
+    }
+  });
+
+  pool.on("remove", (client) => {
+    if (config.debug) {
+      console.log("🗑️  PostgreSQL 클라이언트 제거");
+    }
+  });
+
+  pool.on("error", (err, client) => {
+    console.error("❌ PostgreSQL 연결 풀 에러:", err);
+  });
+
+  console.log(
+    `🚀 PostgreSQL 연결 풀 초기화 완료: ${dbConfig.host}:${dbConfig.port}/${dbConfig.database}`
+  );
+
+  return pool;
+};
+
+/**
+ * DATABASE_URL 파싱 헬퍼 함수
+ */
+function parseDatabaseUrl(url: string) {
+  // postgresql://user:password@host:port/database
+  const regex = /postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/;
+  const match = url.match(regex);
+
+  if (!match) {
+    // URL 파싱 실패 시 기본값 사용
+    console.warn("⚠️  DATABASE_URL 파싱 실패, 기본값 사용");
+    return {
+      host: "localhost",
+      port: 5432,
+      database: "ilshin",
+      user: "postgres",
+      password: "postgres",
+    };
+  }
+
+  return {
+    user: decodeURIComponent(match[1]),
+    password: decodeURIComponent(match[2]),
+    host: match[3],
+    port: parseInt(match[4], 10),
+    database: match[5],
+  };
+}
+
+/**
+ * 연결 풀 가져오기
+ */
+export const getPool = (): Pool => {
+  if (!pool) {
+    return initializePool();
+  }
+  return pool;
+};
+
+/**
+ * 기본 쿼리 실행 함수
+ *
+ * @param text SQL 쿼리 문자열 (Parameterized Query)
+ * @param params 쿼리 파라미터 배열
+ * @returns 쿼리 결과 배열
+ *
+ * @example
+ * const users = await query<User>('SELECT * FROM users WHERE user_id = $1', ['user123']);
+ */
+export async function query<T extends QueryResultRow = any>(
+  text: string,
+  params?: any[]
+): Promise<T[]> {
+  const pool = getPool();
+  const client = await pool.connect();
+
+  try {
+    const startTime = Date.now();
+    const result: PgQueryResult<T> = await client.query(text, params);
+    const duration = Date.now() - startTime;
+
+    if (config.debug) {
+      console.log("🔍 쿼리 실행:", {
+        query: text,
+        params,
+        rowCount: result.rowCount,
+        duration: `${duration}ms`,
+      });
+    }
+
+    return result.rows;
+  } catch (error: any) {
+    console.error("❌ 쿼리 실행 실패:", {
+      query: text,
+      params,
+      error: error.message,
+    });
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+/**
+ * 단일 행 조회 쿼리 (결과가 없으면 null 반환)
+ *
+ * @param text SQL 쿼리 문자열
+ * @param params 쿼리 파라미터
+ * @returns 단일 행 또는 null
+ *
+ * @example
+ * const user = await queryOne<User>('SELECT * FROM users WHERE user_id = $1', ['user123']);
+ */
+export async function queryOne<T extends QueryResultRow = any>(
+  text: string,
+  params?: any[]
+): Promise<T | null> {
+  const rows = await query<T>(text, params);
+  return rows.length > 0 ? rows[0] : null;
+}
+
+/**
+ * 트랜잭션 실행 함수
+ *
+ * @param callback 트랜잭션 내에서 실행할 함수
+ * @returns 콜백 함수의 반환값
+ *
+ * @example
+ * const result = await transaction(async (client) => {
+ *   await client.query('INSERT INTO users (...) VALUES (...)', []);
+ *   await client.query('INSERT INTO user_roles (...) VALUES (...)', []);
+ *   return { success: true };
+ * });
+ */
+export async function transaction<T>(
+  callback: (client: PoolClient) => Promise<T>
+): Promise<T> {
+  const pool = getPool();
+  const client = await pool.connect();
+
+  try {
+    await client.query("BEGIN");
+
+    if (config.debug) {
+      console.log("🔄 트랜잭션 시작");
+    }
+
+    const result = await callback(client);
+
+    await client.query("COMMIT");
+
+    if (config.debug) {
+      console.log("✅ 트랜잭션 커밋 완료");
+    }
+
+    return result;
+  } catch (error: any) {
+    await client.query("ROLLBACK");
+
+    console.error("❌ 트랜잭션 롤백:", error.message);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+/**
+ * 연결 풀 종료 (앱 종료 시 호출)
+ */
+export async function closePool(): Promise<void> {
+  if (pool) {
+    await pool.end();
+    pool = null;
+    console.log("🛑 PostgreSQL 연결 풀 종료");
+  }
+}
+
+/**
+ * 연결 풀 상태 확인
+ */
+export function getPoolStatus() {
+  const pool = getPool();
+  return {
+    totalCount: pool.totalCount,
+    idleCount: pool.idleCount,
+    waitingCount: pool.waitingCount,
+  };
+}
+
+// 기본 익스포트 (편의성)
+export default {
+  query,
+  queryOne,
+  transaction,
+  getPool,
+  initializePool,
+  closePool,
+  getPoolStatus,
+};
diff --git a/backend-node/src/services/externalCallConfigService.ts b/backend-node/src/services/externalCallConfigService.ts
index d1120bc6..3fb60407 100644
--- a/backend-node/src/services/externalCallConfigService.ts
+++ b/backend-node/src/services/externalCallConfigService.ts
@@ -344,13 +344,14 @@ export class ExternalCallConfigService {
       }
 
       // 3. 외부 API 호출
-      const callResult = await this.executeExternalCall(config, processedData, contextData);
+      const callResult = await this.executeExternalCall(
+        config,
+        processedData,
+        contextData
+      );
 
       // 4. Inbound 데이터 매핑 처리 (있는 경우)
-      if (
-        callResult.success &&
-        configData?.dataMappingConfig?.inboundMapping
-      ) {
+      if (callResult.success && configData?.dataMappingConfig?.inboundMapping) {
         logger.info("Inbound 데이터 매핑 처리 중...");
         await this.processInboundMapping(
           configData.dataMappingConfig.inboundMapping,
@@ -363,7 +364,7 @@ export class ExternalCallConfigService {
 
       return {
         success: callResult.success,
-        message: callResult.success 
+        message: callResult.success
           ? `외부호출 '${config.config_name}' 실행 완료`
           : `외부호출 '${config.config_name}' 실행 실패`,
         data: callResult.data,
@@ -373,9 +374,10 @@ export class ExternalCallConfigService {
     } catch (error) {
       const executionTime = performance.now() - startTime;
       logger.error("외부호출 실행 실패:", error);
-      
-      const errorMessage = error instanceof Error ? error.message : "알 수 없는 오류";
-      
+
+      const errorMessage =
+        error instanceof Error ? error.message : "알 수 없는 오류";
+
       return {
         success: false,
         message: `외부호출 실행 실패: ${errorMessage}`,
@@ -388,14 +390,16 @@ export class ExternalCallConfigService {
   /**
    * 🔥 버튼 제어용 외부호출 설정 목록 조회 (간소화된 정보)
    */
-  async getConfigsForButtonControl(companyCode: string): Promise<Array<{
-    id: string;
-    name: string;
-    description?: string;
-    apiUrl: string;
-    method: string;
-    hasDataMapping: boolean;
-  }>> {
+  async getConfigsForButtonControl(companyCode: string): Promise<
+    Array<{
+      id: string;
+      name: string;
+      description?: string;
+      apiUrl: string;
+      method: string;
+      hasDataMapping: boolean;
+    }>
+  > {
     try {
       const configs = await prisma.external_call_configs.findMany({
         where: {
@@ -421,7 +425,7 @@ export class ExternalCallConfigService {
           description: config.description || undefined,
           apiUrl: configData?.restApiSettings?.apiUrl || "",
           method: configData?.restApiSettings?.httpMethod || "GET",
-          hasDataMapping: !!(configData?.dataMappingConfig),
+          hasDataMapping: !!configData?.dataMappingConfig,
         };
       });
     } catch (error) {
@@ -445,7 +449,12 @@ export class ExternalCallConfigService {
         throw new Error("REST API 설정이 없습니다.");
       }
 
-      const { apiUrl, httpMethod, headers = {}, timeout = 30000 } = restApiSettings;
+      const {
+        apiUrl,
+        httpMethod,
+        headers = {},
+        timeout = 30000,
+      } = restApiSettings;
 
       // 요청 헤더 준비
       const requestHeaders = {
@@ -456,7 +465,9 @@ export class ExternalCallConfigService {
       // 인증 처리
       if (restApiSettings.authentication?.type === "basic") {
         const { username, password } = restApiSettings.authentication;
-        const credentials = Buffer.from(`${username}:${password}`).toString("base64");
+        const credentials = Buffer.from(`${username}:${password}`).toString(
+          "base64"
+        );
         requestHeaders["Authorization"] = `Basic ${credentials}`;
       } else if (restApiSettings.authentication?.type === "bearer") {
         const { token } = restApiSettings.authentication;
@@ -488,14 +499,15 @@ export class ExternalCallConfigService {
       }
 
       const responseData = await response.json();
-      
+
       return {
         success: true,
         data: responseData,
       };
     } catch (error) {
       logger.error("외부 API 호출 실패:", error);
-      const errorMessage = error instanceof Error ? error.message : "알 수 없는 오류";
+      const errorMessage =
+        error instanceof Error ? error.message : "알 수 없는 오류";
       return {
         success: false,
         error: errorMessage,
@@ -517,9 +529,9 @@ export class ExternalCallConfigService {
       if (mapping.fieldMappings) {
         for (const fieldMapping of mapping.fieldMappings) {
           const { sourceField, targetField, transformation } = fieldMapping;
-          
+
           let value = sourceData[sourceField];
-          
+
           // 변환 로직 적용
           if (transformation) {
             switch (transformation.type) {
@@ -534,7 +546,7 @@ export class ExternalCallConfigService {
                 break;
             }
           }
-          
+
           mappedData[targetField] = value;
         }
       }
@@ -556,10 +568,9 @@ export class ExternalCallConfigService {
     try {
       // Inbound 매핑 로직 (응답 데이터를 내부 시스템에 저장)
       logger.info("Inbound 데이터 매핑 처리:", mapping);
-      
+
       // 실제 구현에서는 응답 데이터를 파싱하여 내부 테이블에 저장하는 로직 필요
       // 예: 외부 API에서 받은 사용자 정보를 내부 사용자 테이블에 업데이트
-      
     } catch (error) {
       logger.error("Inbound 데이터 매핑 처리 실패:", error);
       // Inbound 매핑 실패는 전체 플로우를 중단하지 않음
diff --git a/backend-node/src/services/multiConnectionQueryService.ts b/backend-node/src/services/multiConnectionQueryService.ts
index 5ce9ca68..0751dfef 100644
--- a/backend-node/src/services/multiConnectionQueryService.ts
+++ b/backend-node/src/services/multiConnectionQueryService.ts
@@ -147,9 +147,9 @@ export class MultiConnectionQueryService {
       // INSERT 쿼리 구성 (DB 타입별 처리)
       const columns = Object.keys(data);
       let values = Object.values(data);
-      
+
       // Oracle의 경우 테이블 스키마 확인 및 데이터 타입 변환 처리
-      if (connection.db_type?.toLowerCase() === 'oracle') {
+      if (connection.db_type?.toLowerCase() === "oracle") {
         try {
           // Oracle 테이블 스키마 조회
           const schemaQuery = `
@@ -158,67 +158,80 @@ export class MultiConnectionQueryService {
             WHERE TABLE_NAME = UPPER('${tableName}')
             ORDER BY COLUMN_ID
           `;
-          
+
           logger.info(`🔍 Oracle 테이블 스키마 조회: ${schemaQuery}`);
-          
+
           const schemaResult = await ExternalDbConnectionService.executeQuery(
             connectionId,
             schemaQuery
           );
-          
+
           if (schemaResult.success && schemaResult.data) {
             logger.info(`📋 Oracle 테이블 ${tableName} 스키마:`);
             schemaResult.data.forEach((col: any) => {
-              logger.info(`  - ${col.COLUMN_NAME}: ${col.DATA_TYPE}, NULL: ${col.NULLABLE}, DEFAULT: ${col.DATA_DEFAULT || 'None'}`);
+              logger.info(
+                `  - ${col.COLUMN_NAME}: ${col.DATA_TYPE}, NULL: ${col.NULLABLE}, DEFAULT: ${col.DATA_DEFAULT || "None"}`
+              );
             });
-            
+
             // 필수 컬럼 중 누락된 컬럼이 있는지 확인 (기본값이 없는 NOT NULL 컬럼만)
-            const providedColumns = columns.map(col => col.toUpperCase());
-            const missingRequiredColumns = schemaResult.data.filter((schemaCol: any) => 
-              schemaCol.NULLABLE === 'N' && 
-              !schemaCol.DATA_DEFAULT && 
-              !providedColumns.includes(schemaCol.COLUMN_NAME)
+            const providedColumns = columns.map((col) => col.toUpperCase());
+            const missingRequiredColumns = schemaResult.data.filter(
+              (schemaCol: any) =>
+                schemaCol.NULLABLE === "N" &&
+                !schemaCol.DATA_DEFAULT &&
+                !providedColumns.includes(schemaCol.COLUMN_NAME)
             );
-            
+
             if (missingRequiredColumns.length > 0) {
-              const missingNames = missingRequiredColumns.map((col: any) => col.COLUMN_NAME);
-              logger.error(`❌ 필수 컬럼 누락: ${missingNames.join(', ')}`);
-              throw new Error(`필수 컬럼이 누락되었습니다: ${missingNames.join(', ')}`);
+              const missingNames = missingRequiredColumns.map(
+                (col: any) => col.COLUMN_NAME
+              );
+              logger.error(`❌ 필수 컬럼 누락: ${missingNames.join(", ")}`);
+              throw new Error(
+                `필수 컬럼이 누락되었습니다: ${missingNames.join(", ")}`
+              );
             }
-            
-            logger.info(`✅ 스키마 검증 통과: 모든 필수 컬럼이 제공되었거나 기본값이 있습니다.`);
+
+            logger.info(
+              `✅ 스키마 검증 통과: 모든 필수 컬럼이 제공되었거나 기본값이 있습니다.`
+            );
           }
         } catch (schemaError) {
           logger.warn(`⚠️ 스키마 조회 실패 (계속 진행): ${schemaError}`);
         }
-        
-        values = values.map(value => {
+
+        values = values.map((value) => {
           // null이나 undefined는 그대로 유지
           if (value === null || value === undefined) {
             return value;
           }
-          
+
           // 숫자로 변환 가능한 문자열은 숫자로 변환
-          if (typeof value === 'string' && value.trim() !== '') {
+          if (typeof value === "string" && value.trim() !== "") {
             const numValue = Number(value);
             if (!isNaN(numValue)) {
-              logger.info(`🔄 Oracle 데이터 타입 변환: "${value}" (string) → ${numValue} (number)`);
+              logger.info(
+                `🔄 Oracle 데이터 타입 변환: "${value}" (string) → ${numValue} (number)`
+              );
               return numValue;
             }
           }
-          
+
           return value;
         });
       }
-      
+
       let query: string;
       let queryParams: any[];
-      const dbType = connection.db_type?.toLowerCase() || 'postgresql';
+      const dbType = connection.db_type?.toLowerCase() || "postgresql";
 
       switch (dbType) {
-        case 'oracle':
+        case "oracle":
           // Oracle: :1, :2 스타일 바인딩 사용, RETURNING 미지원
-          const oraclePlaceholders = values.map((_, index) => `:${index + 1}`).join(", ");
+          const oraclePlaceholders = values
+            .map((_, index) => `:${index + 1}`)
+            .join(", ");
           query = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${oraclePlaceholders})`;
           queryParams = values;
           logger.info(`🔍 Oracle INSERT 상세 정보:`);
@@ -227,42 +240,57 @@ export class MultiConnectionQueryService {
           logger.info(`  - 값: ${JSON.stringify(values)}`);
           logger.info(`  - 쿼리: ${query}`);
           logger.info(`  - 파라미터: ${JSON.stringify(queryParams)}`);
-          logger.info(`  - 데이터 타입: ${JSON.stringify(values.map(v => typeof v))}`);
+          logger.info(
+            `  - 데이터 타입: ${JSON.stringify(values.map((v) => typeof v))}`
+          );
           break;
 
-        case 'mysql':
-        case 'mariadb':
+        case "mysql":
+        case "mariadb":
           // MySQL/MariaDB: ? 스타일 바인딩 사용, RETURNING 미지원
-          const mysqlPlaceholders = values.map(() => '?').join(", ");
+          const mysqlPlaceholders = values.map(() => "?").join(", ");
           query = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${mysqlPlaceholders})`;
           queryParams = values;
-          logger.info(`MySQL/MariaDB INSERT 쿼리:`, { query, params: queryParams });
+          logger.info(`MySQL/MariaDB INSERT 쿼리:`, {
+            query,
+            params: queryParams,
+          });
           break;
 
-        case 'sqlserver':
-        case 'mssql':
+        case "sqlserver":
+        case "mssql":
           // SQL Server: @param1, @param2 스타일 바인딩 사용
-          const sqlServerPlaceholders = values.map((_, index) => `@param${index + 1}`).join(", ");
+          const sqlServerPlaceholders = values
+            .map((_, index) => `@param${index + 1}`)
+            .join(", ");
           query = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${sqlServerPlaceholders})`;
           queryParams = values;
-          logger.info(`SQL Server INSERT 쿼리:`, { query, params: queryParams });
+          logger.info(`SQL Server INSERT 쿼리:`, {
+            query,
+            params: queryParams,
+          });
           break;
 
-        case 'sqlite':
+        case "sqlite":
           // SQLite: ? 스타일 바인딩 사용, RETURNING 지원 (3.35.0+)
-          const sqlitePlaceholders = values.map(() => '?').join(", ");
+          const sqlitePlaceholders = values.map(() => "?").join(", ");
           query = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${sqlitePlaceholders}) RETURNING *`;
           queryParams = values;
           logger.info(`SQLite INSERT 쿼리:`, { query, params: queryParams });
           break;
 
-        case 'postgresql':
+        case "postgresql":
         default:
           // PostgreSQL: $1, $2 스타일 바인딩 사용, RETURNING 지원
-          const pgPlaceholders = values.map((_, index) => `$${index + 1}`).join(", ");
+          const pgPlaceholders = values
+            .map((_, index) => `$${index + 1}`)
+            .join(", ");
           query = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${pgPlaceholders}) RETURNING *`;
           queryParams = values;
-          logger.info(`PostgreSQL INSERT 쿼리:`, { query, params: queryParams });
+          logger.info(`PostgreSQL INSERT 쿼리:`, {
+            query,
+            params: queryParams,
+          });
           break;
       }
 
diff --git a/backend-node/src/tests/database.test.ts b/backend-node/src/tests/database.test.ts
new file mode 100644
index 00000000..dfd8251b
--- /dev/null
+++ b/backend-node/src/tests/database.test.ts
@@ -0,0 +1,455 @@
+/**
+ * Database Manager 테스트
+ *
+ * Phase 1 기반 구조 검증
+ */
+
+import { query, queryOne, transaction, getPoolStatus } from "../database/db";
+import { QueryBuilder } from "../utils/queryBuilder";
+import { DatabaseValidator } from "../utils/databaseValidator";
+
+describe("Database Manager Tests", () => {
+  describe("QueryBuilder", () => {
+    test("SELECT 쿼리 생성 - 기본", () => {
+      const { query: sql, params } = QueryBuilder.select("users", {
+        where: { user_id: "test_user" },
+      });
+
+      expect(sql).toContain("SELECT * FROM users");
+      expect(sql).toContain("WHERE user_id = $1");
+      expect(params).toEqual(["test_user"]);
+    });
+
+    test("SELECT 쿼리 생성 - 복잡한 조건", () => {
+      const { query: sql, params } = QueryBuilder.select("users", {
+        columns: ["user_id", "username", "email"],
+        where: { status: "active", role: "admin" },
+        orderBy: "created_at DESC",
+        limit: 10,
+        offset: 20,
+      });
+
+      expect(sql).toContain("SELECT user_id, username, email FROM users");
+      expect(sql).toContain("WHERE status = $1 AND role = $2");
+      expect(sql).toContain("ORDER BY created_at DESC");
+      expect(sql).toContain("LIMIT $3");
+      expect(sql).toContain("OFFSET $4");
+      expect(params).toEqual(["active", "admin", 10, 20]);
+    });
+
+    test("SELECT 쿼리 생성 - JOIN", () => {
+      const { query: sql, params } = QueryBuilder.select("users", {
+        columns: ["users.user_id", "users.username", "departments.dept_name"],
+        joins: [
+          {
+            type: "LEFT",
+            table: "departments",
+            on: "users.dept_id = departments.dept_id",
+          },
+        ],
+        where: { "users.status": "active" },
+      });
+
+      expect(sql).toContain("LEFT JOIN departments");
+      expect(sql).toContain("ON users.dept_id = departments.dept_id");
+      expect(sql).toContain("WHERE users.status = $1");
+      expect(params).toEqual(["active"]);
+    });
+
+    test("INSERT 쿼리 생성 - RETURNING", () => {
+      const { query: sql, params } = QueryBuilder.insert(
+        "users",
+        {
+          user_id: "new_user",
+          username: "John Doe",
+          email: "john@example.com",
+        },
+        {
+          returning: ["id", "user_id"],
+        }
+      );
+
+      expect(sql).toContain("INSERT INTO users");
+      expect(sql).toContain("(user_id, username, email)");
+      expect(sql).toContain("VALUES ($1, $2, $3)");
+      expect(sql).toContain("RETURNING id, user_id");
+      expect(params).toEqual(["new_user", "John Doe", "john@example.com"]);
+    });
+
+    test("INSERT 쿼리 생성 - UPSERT", () => {
+      const { query: sql, params } = QueryBuilder.insert(
+        "users",
+        {
+          user_id: "user123",
+          username: "Jane",
+          email: "jane@example.com",
+        },
+        {
+          onConflict: {
+            columns: ["user_id"],
+            action: "DO UPDATE",
+            updateSet: ["username", "email"],
+          },
+          returning: ["*"],
+        }
+      );
+
+      expect(sql).toContain("ON CONFLICT (user_id) DO UPDATE");
+      expect(sql).toContain(
+        "SET username = EXCLUDED.username, email = EXCLUDED.email"
+      );
+      expect(sql).toContain("RETURNING *");
+    });
+
+    test("UPDATE 쿼리 생성", () => {
+      const { query: sql, params } = QueryBuilder.update(
+        "users",
+        { username: "Updated Name", email: "updated@example.com" },
+        { user_id: "user123" },
+        { returning: ["*"] }
+      );
+
+      expect(sql).toContain("UPDATE users");
+      expect(sql).toContain("SET username = $1, email = $2");
+      expect(sql).toContain("WHERE user_id = $3");
+      expect(sql).toContain("RETURNING *");
+      expect(params).toEqual([
+        "Updated Name",
+        "updated@example.com",
+        "user123",
+      ]);
+    });
+
+    test("DELETE 쿼리 생성", () => {
+      const { query: sql, params } = QueryBuilder.delete("users", {
+        user_id: "user_to_delete",
+      });
+
+      expect(sql).toContain("DELETE FROM users");
+      expect(sql).toContain("WHERE user_id = $1");
+      expect(params).toEqual(["user_to_delete"]);
+    });
+
+    test("COUNT 쿼리 생성", () => {
+      const { query: sql, params } = QueryBuilder.count("users", {
+        status: "active",
+      });
+
+      expect(sql).toContain("SELECT COUNT(*) as count FROM users");
+      expect(sql).toContain("WHERE status = $1");
+      expect(params).toEqual(["active"]);
+    });
+  });
+
+  describe("DatabaseValidator", () => {
+    test("테이블명 검증 - 유효한 이름", () => {
+      expect(DatabaseValidator.validateTableName("users")).toBe(true);
+      expect(DatabaseValidator.validateTableName("user_info")).toBe(true);
+      expect(DatabaseValidator.validateTableName("_internal_table")).toBe(true);
+      expect(DatabaseValidator.validateTableName("table123")).toBe(true);
+    });
+
+    test("테이블명 검증 - 유효하지 않은 이름", () => {
+      expect(DatabaseValidator.validateTableName("")).toBe(false);
+      expect(DatabaseValidator.validateTableName("123table")).toBe(false);
+      expect(DatabaseValidator.validateTableName("user-table")).toBe(false);
+      expect(DatabaseValidator.validateTableName("user table")).toBe(false);
+      expect(DatabaseValidator.validateTableName("SELECT")).toBe(false); // 예약어
+      expect(DatabaseValidator.validateTableName("a".repeat(64))).toBe(false); // 너무 긺
+    });
+
+    test("컬럼명 검증 - 유효한 이름", () => {
+      expect(DatabaseValidator.validateColumnName("user_id")).toBe(true);
+      expect(DatabaseValidator.validateColumnName("created_at")).toBe(true);
+      expect(DatabaseValidator.validateColumnName("is_active")).toBe(true);
+    });
+
+    test("컬럼명 검증 - 유효하지 않은 이름", () => {
+      expect(DatabaseValidator.validateColumnName("user-id")).toBe(false);
+      expect(DatabaseValidator.validateColumnName("user id")).toBe(false);
+      expect(DatabaseValidator.validateColumnName("WHERE")).toBe(false); // 예약어
+    });
+
+    test("데이터 타입 검증", () => {
+      expect(DatabaseValidator.validateDataType("VARCHAR")).toBe(true);
+      expect(DatabaseValidator.validateDataType("VARCHAR(255)")).toBe(true);
+      expect(DatabaseValidator.validateDataType("INTEGER")).toBe(true);
+      expect(DatabaseValidator.validateDataType("TIMESTAMP")).toBe(true);
+      expect(DatabaseValidator.validateDataType("JSONB")).toBe(true);
+      expect(DatabaseValidator.validateDataType("INTEGER[]")).toBe(true);
+      expect(DatabaseValidator.validateDataType("DECIMAL(10,2)")).toBe(true);
+    });
+
+    test("WHERE 조건 검증", () => {
+      expect(
+        DatabaseValidator.validateWhereClause({
+          user_id: "test",
+          status: "active",
+        })
+      ).toBe(true);
+
+      expect(
+        DatabaseValidator.validateWhereClause({
+          "config->>type": "form", // JSON 쿼리
+        })
+      ).toBe(true);
+
+      expect(
+        DatabaseValidator.validateWhereClause({
+          "invalid-column": "value",
+        })
+      ).toBe(false);
+    });
+
+    test("페이지네이션 검증", () => {
+      expect(DatabaseValidator.validatePagination(1, 10)).toBe(true);
+      expect(DatabaseValidator.validatePagination(5, 100)).toBe(true);
+
+      expect(DatabaseValidator.validatePagination(0, 10)).toBe(false); // page < 1
+      expect(DatabaseValidator.validatePagination(1, 0)).toBe(false); // pageSize < 1
+      expect(DatabaseValidator.validatePagination(1, 2000)).toBe(false); // pageSize > 1000
+    });
+
+    test("ORDER BY 검증", () => {
+      expect(DatabaseValidator.validateOrderBy("created_at")).toBe(true);
+      expect(DatabaseValidator.validateOrderBy("created_at ASC")).toBe(true);
+      expect(DatabaseValidator.validateOrderBy("created_at DESC")).toBe(true);
+
+      expect(DatabaseValidator.validateOrderBy("created_at INVALID")).toBe(
+        false
+      );
+      expect(DatabaseValidator.validateOrderBy("invalid-column ASC")).toBe(
+        false
+      );
+    });
+
+    test("UUID 검증", () => {
+      expect(
+        DatabaseValidator.validateUUID("550e8400-e29b-41d4-a716-446655440000")
+      ).toBe(true);
+      expect(DatabaseValidator.validateUUID("invalid-uuid")).toBe(false);
+    });
+
+    test("이메일 검증", () => {
+      expect(DatabaseValidator.validateEmail("test@example.com")).toBe(true);
+      expect(DatabaseValidator.validateEmail("user.name@domain.co.kr")).toBe(
+        true
+      );
+      expect(DatabaseValidator.validateEmail("invalid-email")).toBe(false);
+      expect(DatabaseValidator.validateEmail("test@")).toBe(false);
+    });
+  });
+
+  describe("Integration Tests (실제 DB 연결 필요)", () => {
+    // 실제 데이터베이스 연결이 필요한 테스트들
+    // DB 연결 실패 시 스킵되도록 설정
+
+    beforeAll(async () => {
+      // DB 연결 테스트
+      try {
+        await query("SELECT 1 as test");
+        console.log("✅ 데이터베이스 연결 성공 - Integration Tests 실행");
+      } catch (error) {
+        console.warn("⚠️  데이터베이스 연결 실패 - Integration Tests 스킵");
+        console.warn("DB 연결 오류:", error);
+      }
+    });
+
+    test("실제 쿼리 실행 테스트", async () => {
+      try {
+        const result = await query(
+          "SELECT NOW() as current_time, version() as pg_version"
+        );
+
+        expect(result).toHaveLength(1);
+        expect(result[0]).toHaveProperty("current_time");
+        expect(result[0]).toHaveProperty("pg_version");
+        expect(result[0].pg_version).toContain("PostgreSQL");
+
+        console.log("🕐 현재 시간:", result[0].current_time);
+        console.log("📊 PostgreSQL 버전:", result[0].pg_version);
+      } catch (error) {
+        console.error("❌ 쿼리 실행 테스트 실패:", error);
+        throw error;
+      }
+    });
+
+    test("파라미터화된 쿼리 테스트", async () => {
+      try {
+        const testValue = "test_value_" + Date.now();
+        const result = await query(
+          "SELECT $1 as input_value, $2 as number_value, $3 as boolean_value",
+          [testValue, 42, true]
+        );
+
+        expect(result).toHaveLength(1);
+        expect(result[0].input_value).toBe(testValue);
+        expect(parseInt(result[0].number_value)).toBe(42); // PostgreSQL은 숫자를 문자열로 반환
+        expect(
+          result[0].boolean_value === true || result[0].boolean_value === "true"
+        ).toBe(true); // PostgreSQL boolean 처리
+
+        console.log("📝 파라미터 테스트 결과:", result[0]);
+      } catch (error) {
+        console.error("❌ 파라미터 쿼리 테스트 실패:", error);
+        throw error;
+      }
+    });
+
+    test("단일 행 조회 테스트", async () => {
+      try {
+        // 존재하는 데이터 조회
+        const result = await queryOne("SELECT 1 as value, 'exists' as status");
+        expect(result).not.toBeNull();
+        expect(result?.value).toBe(1);
+        expect(result?.status).toBe("exists");
+
+        // 존재하지 않는 데이터 조회
+        const emptyResult = await queryOne(
+          "SELECT * FROM (SELECT 1 as id) t WHERE id = 999"
+        );
+        expect(emptyResult).toBeNull();
+
+        console.log("🔍 단일 행 조회 결과:", result);
+      } catch (error) {
+        console.error("❌ 단일 행 조회 테스트 실패:", error);
+        throw error;
+      }
+    });
+
+    test("트랜잭션 테스트", async () => {
+      try {
+        const result = await transaction(async (client) => {
+          const res1 = await client.query(
+            "SELECT 1 as value, 'first' as label"
+          );
+          const res2 = await client.query(
+            "SELECT 2 as value, 'second' as label"
+          );
+          const res3 = await client.query("SELECT $1 as computed_value", [
+            res1.rows[0].value + res2.rows[0].value,
+          ]);
+
+          return {
+            res1: res1.rows,
+            res2: res2.rows,
+            res3: res3.rows,
+            transaction_id: Math.random().toString(36).substr(2, 9),
+          };
+        });
+
+        expect(result.res1[0].value).toBe(1);
+        expect(result.res1[0].label).toBe("first");
+        expect(result.res2[0].value).toBe(2);
+        expect(result.res2[0].label).toBe("second");
+        expect(parseInt(result.res3[0].computed_value)).toBe(3); // PostgreSQL은 숫자를 문자열로 반환
+        expect(result.transaction_id).toBeDefined();
+
+        console.log("🔄 트랜잭션 테스트 결과:", {
+          first_value: result.res1[0].value,
+          second_value: result.res2[0].value,
+          computed_value: result.res3[0].computed_value,
+          transaction_id: result.transaction_id,
+        });
+      } catch (error) {
+        console.error("❌ 트랜잭션 테스트 실패:", error);
+        throw error;
+      }
+    });
+
+    test("트랜잭션 롤백 테스트", async () => {
+      try {
+        await expect(
+          transaction(async (client) => {
+            await client.query("SELECT 1 as value");
+            // 의도적으로 오류 발생
+            throw new Error("의도적인 롤백 테스트");
+          })
+        ).rejects.toThrow("의도적인 롤백 테스트");
+
+        console.log("🔄 트랜잭션 롤백 테스트 성공");
+      } catch (error) {
+        console.error("❌ 트랜잭션 롤백 테스트 실패:", error);
+        throw error;
+      }
+    });
+
+    test("연결 풀 상태 확인", () => {
+      try {
+        const status = getPoolStatus();
+
+        expect(status).toHaveProperty("totalCount");
+        expect(status).toHaveProperty("idleCount");
+        expect(status).toHaveProperty("waitingCount");
+        expect(typeof status.totalCount).toBe("number");
+        expect(typeof status.idleCount).toBe("number");
+        expect(typeof status.waitingCount).toBe("number");
+
+        console.log("🏊‍♂️ 연결 풀 상태:", {
+          총_연결수: status.totalCount,
+          유휴_연결수: status.idleCount,
+          대기_연결수: status.waitingCount,
+        });
+      } catch (error) {
+        console.error("❌ 연결 풀 상태 확인 실패:", error);
+        throw error;
+      }
+    });
+
+    test("데이터베이스 메타데이터 조회", async () => {
+      try {
+        // 현재 데이터베이스 정보 조회
+        const dbInfo = await query(`
+          SELECT 
+            current_database() as database_name,
+            current_user as current_user,
+            inet_server_addr() as server_address,
+            inet_server_port() as server_port
+        `);
+
+        expect(dbInfo).toHaveLength(1);
+        expect(dbInfo[0].database_name).toBeDefined();
+        expect(dbInfo[0].current_user).toBeDefined();
+
+        console.log("🗄️  데이터베이스 정보:", {
+          데이터베이스명: dbInfo[0].database_name,
+          현재사용자: dbInfo[0].current_user,
+          서버주소: dbInfo[0].server_address,
+          서버포트: dbInfo[0].server_port,
+        });
+      } catch (error) {
+        console.error("❌ 데이터베이스 메타데이터 조회 실패:", error);
+        throw error;
+      }
+    });
+
+    test("테이블 존재 여부 확인", async () => {
+      try {
+        // 시스템 테이블 조회로 안전하게 테스트
+        const tables = await query(`
+          SELECT table_name, table_type 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_type = 'BASE TABLE'
+          LIMIT 5
+        `);
+
+        expect(Array.isArray(tables)).toBe(true);
+        console.log(`📋 발견된 테이블 수: ${tables.length}`);
+
+        if (tables.length > 0) {
+          console.log(
+            "📋 테이블 목록 (최대 5개):",
+            tables.map((t) => t.table_name).join(", ")
+          );
+        }
+      } catch (error) {
+        console.error("❌ 테이블 존재 여부 확인 실패:", error);
+        throw error;
+      }
+    });
+  });
+});
+
+// 테스트 실행 방법:
+// npm test -- database.test.ts
diff --git a/backend-node/src/tests/env.setup.ts b/backend-node/src/tests/env.setup.ts
new file mode 100644
index 00000000..55263a9a
--- /dev/null
+++ b/backend-node/src/tests/env.setup.ts
@@ -0,0 +1,18 @@
+/**
+ * Jest 테스트 환경 변수 설정
+ */
+
+// 테스트 환경 변수 설정
+process.env.NODE_ENV = "test";
+// 실제 DB 연결을 위해 운영 데이터베이스 사용 (읽기 전용 테스트만 수행)
+process.env.DATABASE_URL =
+  process.env.TEST_DATABASE_URL ||
+  "postgresql://postgres:ph0909!!@39.117.244.52:11132/plm";
+process.env.JWT_SECRET = "test-jwt-secret-key-for-testing-only";
+process.env.PORT = "3001";
+process.env.DEBUG = "true"; // 테스트 시 디버그 로그 활성화
+
+// 콘솔 로그 최소화 (필요시 주석 해제)
+// console.log = jest.fn();
+// console.warn = jest.fn();
+// console.error = jest.fn();
diff --git a/backend-node/src/tests/setup.ts b/backend-node/src/tests/setup.ts
new file mode 100644
index 00000000..1b50e163
--- /dev/null
+++ b/backend-node/src/tests/setup.ts
@@ -0,0 +1,24 @@
+/**
+ * Jest 테스트 설정 및 초기화
+ */
+
+import { closePool } from "../database/db";
+
+// 테스트 완료 후 정리
+afterAll(async () => {
+  // 데이터베이스 연결 풀 종료
+  await closePool();
+});
+
+// 테스트 타임아웃 설정
+jest.setTimeout(30000);
+
+// 전역 테스트 설정
+beforeEach(() => {
+  // 각 테스트 전에 실행할 설정
+});
+
+afterEach(() => {
+  // 각 테스트 후에 실행할 정리
+});
+
diff --git a/backend-node/src/types/database.ts b/backend-node/src/types/database.ts
new file mode 100644
index 00000000..b4ba0bbc
--- /dev/null
+++ b/backend-node/src/types/database.ts
@@ -0,0 +1,207 @@
+/**
+ * 데이터베이스 관련 타입 정의
+ *
+ * Raw Query 기반 타입 안전성 보장
+ */
+
+/**
+ * 쿼리 결과 인터페이스
+ */
+export interface QueryResult<T = any> {
+  rows: T[];
+  rowCount: number | null;
+  command: string;
+  fields?: any[];
+}
+
+/**
+ * 트랜잭션 격리 수준
+ */
+export enum IsolationLevel {
+  READ_UNCOMMITTED = 'READ UNCOMMITTED',
+  READ_COMMITTED = 'READ COMMITTED',
+  REPEATABLE_READ = 'REPEATABLE READ',
+  SERIALIZABLE = 'SERIALIZABLE',
+}
+
+/**
+ * 테이블 스키마 정의
+ */
+export interface TableSchema {
+  tableName: string;
+  columns: ColumnDefinition[];
+  constraints?: TableConstraint[];
+  indexes?: IndexDefinition[];
+  comment?: string;
+}
+
+/**
+ * 컬럼 정의
+ */
+export interface ColumnDefinition {
+  name: string;
+  type: PostgreSQLDataType;
+  nullable?: boolean;
+  defaultValue?: string;
+  isPrimaryKey?: boolean;
+  isUnique?: boolean;
+  references?: ForeignKeyReference;
+  comment?: string;
+}
+
+/**
+ * PostgreSQL 데이터 타입
+ */
+export type PostgreSQLDataType =
+  // 숫자 타입
+  | 'SMALLINT'
+  | 'INTEGER'
+  | 'BIGINT'
+  | 'DECIMAL'
+  | 'NUMERIC'
+  | 'REAL'
+  | 'DOUBLE PRECISION'
+  | 'SERIAL'
+  | 'BIGSERIAL'
+
+  // 문자열 타입
+  | 'CHARACTER VARYING' // VARCHAR
+  | 'VARCHAR'
+  | 'CHARACTER'
+  | 'CHAR'
+  | 'TEXT'
+
+  // 날짜/시간 타입
+  | 'TIMESTAMP'
+  | 'TIMESTAMP WITH TIME ZONE'
+  | 'TIMESTAMPTZ'
+  | 'DATE'
+  | 'TIME'
+  | 'TIME WITH TIME ZONE'
+  | 'INTERVAL'
+
+  // Boolean
+  | 'BOOLEAN'
+
+  // JSON
+  | 'JSON'
+  | 'JSONB'
+
+  // UUID
+  | 'UUID'
+
+  // 배열
+  | 'ARRAY'
+
+  // 기타
+  | 'BYTEA'
+  | string; // 커스텀 타입 허용
+
+/**
+ * 외래 키 참조
+ */
+export interface ForeignKeyReference {
+  table: string;
+  column: string;
+  onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+  onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+}
+
+/**
+ * 테이블 제약 조건
+ */
+export interface TableConstraint {
+  name: string;
+  type: 'PRIMARY KEY' | 'FOREIGN KEY' | 'UNIQUE' | 'CHECK';
+  columns: string[];
+  references?: ForeignKeyReference;
+  checkExpression?: string;
+}
+
+/**
+ * 인덱스 정의
+ */
+export interface IndexDefinition {
+  name: string;
+  columns: string[];
+  unique?: boolean;
+  type?: 'BTREE' | 'HASH' | 'GIN' | 'GIST';
+  where?: string; // Partial index
+}
+
+/**
+ * 쿼리 실행 옵션
+ */
+export interface QueryOptions {
+  timeout?: number;
+  preparedStatement?: boolean;
+  rowMode?: 'array' | 'object';
+}
+
+/**
+ * 동적 테이블 생성 요청
+ */
+export interface DynamicTableRequest {
+  tableName: string;
+  columns: ColumnDefinition[];
+  constraints?: TableConstraint[];
+  indexes?: IndexDefinition[];
+  ifNotExists?: boolean;
+  comment?: string;
+}
+
+/**
+ * 동적 테이블 수정 요청
+ */
+export interface AlterTableRequest {
+  tableName: string;
+  operations: AlterTableOperation[];
+}
+
+/**
+ * 테이블 변경 작업
+ */
+export type AlterTableOperation =
+  | { type: 'ADD_COLUMN'; column: ColumnDefinition }
+  | { type: 'DROP_COLUMN'; columnName: string }
+  | { type: 'ALTER_COLUMN'; columnName: string; newDefinition: Partial<ColumnDefinition> }
+  | { type: 'RENAME_COLUMN'; oldName: string; newName: string }
+  | { type: 'ADD_CONSTRAINT'; constraint: TableConstraint }
+  | { type: 'DROP_CONSTRAINT'; constraintName: string };
+
+/**
+ * 페이지네이션 요청
+ */
+export interface PaginationRequest {
+  page: number;
+  pageSize: number;
+  orderBy?: string;
+  orderDirection?: 'ASC' | 'DESC';
+}
+
+/**
+ * 페이지네이션 응답
+ */
+export interface PaginationResponse<T> {
+  data: T[];
+  pagination: {
+    currentPage: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+  };
+}
+
+/**
+ * 쿼리 통계
+ */
+export interface QueryStatistics {
+  query: string;
+  executionTime: number;
+  rowsAffected: number;
+  timestamp: Date;
+  success: boolean;
+  error?: string;
+}
\ No newline at end of file
diff --git a/backend-node/src/utils/databaseValidator.ts b/backend-node/src/utils/databaseValidator.ts
new file mode 100644
index 00000000..3e61072d
--- /dev/null
+++ b/backend-node/src/utils/databaseValidator.ts
@@ -0,0 +1,383 @@
+/**
+ * 데이터베이스 관련 검증 유틸리티
+ *
+ * SQL 인젝션 방지 및 데이터 무결성 보장을 위한 검증 함수들
+ */
+
+export class DatabaseValidator {
+  // PostgreSQL 예약어 목록 (주요 키워드만)
+  private static readonly RESERVED_WORDS = new Set([
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "FROM",
+    "WHERE",
+    "JOIN",
+    "INNER",
+    "LEFT",
+    "RIGHT",
+    "FULL",
+    "ON",
+    "GROUP",
+    "BY",
+    "ORDER",
+    "HAVING",
+    "LIMIT",
+    "OFFSET",
+    "UNION",
+    "ALL",
+    "DISTINCT",
+    "AS",
+    "AND",
+    "OR",
+    "NOT",
+    "NULL",
+    "TRUE",
+    "FALSE",
+    "CASE",
+    "WHEN",
+    "THEN",
+    "ELSE",
+    "END",
+    "IF",
+    "EXISTS",
+    "IN",
+    "BETWEEN",
+    "LIKE",
+    "ILIKE",
+    "SIMILAR",
+    "TO",
+    "CREATE",
+    "DROP",
+    "ALTER",
+    "TABLE",
+    "INDEX",
+    "VIEW",
+    "FUNCTION",
+    "PROCEDURE",
+    "TRIGGER",
+    "DATABASE",
+    "SCHEMA",
+    "USER",
+    "ROLE",
+    "GRANT",
+    "REVOKE",
+    "COMMIT",
+    "ROLLBACK",
+    "BEGIN",
+    "TRANSACTION",
+    "SAVEPOINT",
+    "RELEASE",
+    "CONSTRAINT",
+    "PRIMARY",
+    "FOREIGN",
+    "KEY",
+    "UNIQUE",
+    "CHECK",
+    "DEFAULT",
+    "REFERENCES",
+    "CASCADE",
+    "RESTRICT",
+    "SET",
+    "ACTION",
+    "DEFERRABLE",
+    "INITIALLY",
+    "DEFERRED",
+    "IMMEDIATE",
+    "MATCH",
+    "PARTIAL",
+    "SIMPLE",
+    "FULL",
+  ]);
+
+  // 유효한 PostgreSQL 데이터 타입 패턴
+  private static readonly DATA_TYPE_PATTERNS = [
+    /^(SMALLINT|INTEGER|BIGINT|DECIMAL|NUMERIC|REAL|DOUBLE\s+PRECISION|SMALLSERIAL|SERIAL|BIGSERIAL)$/i,
+    /^(MONEY)$/i,
+    /^(CHARACTER\s+VARYING|VARCHAR|CHARACTER|CHAR|TEXT)(\(\d+\))?$/i,
+    /^(BYTEA)$/i,
+    /^(TIMESTAMP|TIME)(\s+(WITH|WITHOUT)\s+TIME\s+ZONE)?(\(\d+\))?$/i,
+    /^(DATE|INTERVAL)(\(\d+\))?$/i,
+    /^(BOOLEAN|BOOL)$/i,
+    /^(POINT|LINE|LSEG|BOX|PATH|POLYGON|CIRCLE)$/i,
+    /^(CIDR|INET|MACADDR|MACADDR8)$/i,
+    /^(BIT|BIT\s+VARYING)(\(\d+\))?$/i,
+    /^(TSVECTOR|TSQUERY)$/i,
+    /^(UUID)$/i,
+    /^(XML)$/i,
+    /^(JSON|JSONB)$/i,
+    /^(ARRAY|INTEGER\[\]|TEXT\[\]|VARCHAR\[\])$/i,
+    /^(DECIMAL|NUMERIC)\(\d+,\d+\)$/i,
+  ];
+
+  /**
+   * 테이블명 검증
+   */
+  static validateTableName(tableName: string): boolean {
+    if (!tableName || typeof tableName !== "string") {
+      return false;
+    }
+
+    // 길이 제한 (PostgreSQL 최대 63자)
+    if (tableName.length === 0 || tableName.length > 63) {
+      return false;
+    }
+
+    // 유효한 식별자 패턴 (문자 또는 밑줄로 시작, 문자/숫자/밑줄만 포함)
+    const validPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!validPattern.test(tableName)) {
+      return false;
+    }
+
+    // 예약어 체크
+    if (this.RESERVED_WORDS.has(tableName.toUpperCase())) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 컬럼명 검증
+   */
+  static validateColumnName(columnName: string): boolean {
+    if (!columnName || typeof columnName !== "string") {
+      return false;
+    }
+
+    // 길이 제한
+    if (columnName.length === 0 || columnName.length > 63) {
+      return false;
+    }
+
+    // JSON 연산자 포함 컬럼명 허용 (예: config->>'type', data->>path)
+    if (columnName.includes("->") || columnName.includes("->>")) {
+      const baseName = columnName.split(/->|->>/)[0];
+      return this.validateColumnName(baseName);
+    }
+
+    // 유효한 식별자 패턴
+    const validPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!validPattern.test(columnName)) {
+      return false;
+    }
+
+    // 예약어 체크
+    if (this.RESERVED_WORDS.has(columnName.toUpperCase())) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 데이터 타입 검증
+   */
+  static validateDataType(dataType: string): boolean {
+    if (!dataType || typeof dataType !== "string") {
+      return false;
+    }
+
+    const normalizedType = dataType.trim().toUpperCase();
+
+    return this.DATA_TYPE_PATTERNS.some((pattern) =>
+      pattern.test(normalizedType)
+    );
+  }
+
+  /**
+   * WHERE 조건 검증
+   */
+  static validateWhereClause(whereClause: Record<string, any>): boolean {
+    if (!whereClause || typeof whereClause !== "object") {
+      return false;
+    }
+
+    // 모든 키가 유효한 컬럼명인지 확인
+    for (const key of Object.keys(whereClause)) {
+      if (!this.validateColumnName(key)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * 페이지네이션 파라미터 검증
+   */
+  static validatePagination(page: number, pageSize: number): boolean {
+    // 페이지 번호는 1 이상
+    if (!Number.isInteger(page) || page < 1) {
+      return false;
+    }
+
+    // 페이지 크기는 1 이상 1000 이하
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * ORDER BY 절 검증
+   */
+  static validateOrderBy(orderBy: string): boolean {
+    if (!orderBy || typeof orderBy !== "string") {
+      return false;
+    }
+
+    // 기본 패턴: column_name [ASC|DESC]
+    const orderPattern = /^[a-zA-Z_][a-zA-Z0-9_]*(\s+(ASC|DESC))?$/i;
+
+    // 여러 컬럼 정렬의 경우 콤마로 분리하여 각각 검증
+    const orderClauses = orderBy.split(",").map((clause) => clause.trim());
+
+    return orderClauses.every((clause) => {
+      return (
+        orderPattern.test(clause) &&
+        this.validateColumnName(clause.split(/\s+/)[0])
+      );
+    });
+  }
+
+  /**
+   * UUID 형식 검증
+   */
+  static validateUUID(uuid: string): boolean {
+    if (!uuid || typeof uuid !== "string") {
+      return false;
+    }
+
+    const uuidPattern =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidPattern.test(uuid);
+  }
+
+  /**
+   * 이메일 형식 검증
+   */
+  static validateEmail(email: string): boolean {
+    if (!email || typeof email !== "string") {
+      return false;
+    }
+
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailPattern.test(email) && email.length <= 254;
+  }
+
+  /**
+   * SQL 인젝션 위험 문자열 검사
+   */
+  static containsSqlInjection(input: string): boolean {
+    if (!input || typeof input !== "string") {
+      return false;
+    }
+
+    // 위험한 SQL 패턴들
+    const dangerousPatterns = [
+      /('|\\')|(;)|(--)|(\s+(OR|AND)\s+\d+\s*=\s*\d+)/i,
+      /(UNION|SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC|EXECUTE)/i,
+      /(\bxp_\w+|\bsp_\w+)/i, // SQL Server 확장 프로시저
+      /(script|javascript|vbscript|onload|onerror)/i, // XSS 패턴
+    ];
+
+    return dangerousPatterns.some((pattern) => pattern.test(input));
+  }
+
+  /**
+   * 숫자 범위 검증
+   */
+  static validateNumberRange(
+    value: number,
+    min?: number,
+    max?: number
+  ): boolean {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return false;
+    }
+
+    if (min !== undefined && value < min) {
+      return false;
+    }
+
+    if (max !== undefined && value > max) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 문자열 길이 검증
+   */
+  static validateStringLength(
+    value: string,
+    minLength?: number,
+    maxLength?: number
+  ): boolean {
+    if (typeof value !== "string") {
+      return false;
+    }
+
+    if (minLength !== undefined && value.length < minLength) {
+      return false;
+    }
+
+    if (maxLength !== undefined && value.length > maxLength) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * JSON 형식 검증
+   */
+  static validateJSON(jsonString: string): boolean {
+    try {
+      JSON.parse(jsonString);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 날짜 형식 검증 (ISO 8601)
+   */
+  static validateDateISO(dateString: string): boolean {
+    if (!dateString || typeof dateString !== "string") {
+      return false;
+    }
+
+    const date = new Date(dateString);
+    return !isNaN(date.getTime()) && dateString === date.toISOString();
+  }
+
+  /**
+   * 배열 요소 검증
+   */
+  static validateArray<T>(
+    array: any[],
+    validator: (item: T) => boolean,
+    minLength?: number,
+    maxLength?: number
+  ): boolean {
+    if (!Array.isArray(array)) {
+      return false;
+    }
+
+    if (minLength !== undefined && array.length < minLength) {
+      return false;
+    }
+
+    if (maxLength !== undefined && array.length > maxLength) {
+      return false;
+    }
+
+    return array.every((item) => validator(item));
+  }
+}
diff --git a/backend-node/src/utils/queryBuilder.ts b/backend-node/src/utils/queryBuilder.ts
new file mode 100644
index 00000000..b83da5cb
--- /dev/null
+++ b/backend-node/src/utils/queryBuilder.ts
@@ -0,0 +1,287 @@
+/**
+ * SQL 쿼리 빌더 유틸리티
+ * 
+ * Raw Query 방식에서 안전하고 효율적인 쿼리 생성을 위한 헬퍼
+ */
+
+export interface SelectOptions {
+  columns?: string[];
+  where?: Record<string, any>;
+  joins?: JoinClause[];
+  orderBy?: string;
+  limit?: number;
+  offset?: number;
+  groupBy?: string[];
+  having?: Record<string, any>;
+}
+
+export interface JoinClause {
+  type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+  table: string;
+  on: string;
+}
+
+export interface InsertOptions {
+  returning?: string[];
+  onConflict?: {
+    columns: string[];
+    action: 'DO NOTHING' | 'DO UPDATE';
+    updateSet?: string[];
+  };
+}
+
+export interface UpdateOptions {
+  returning?: string[];
+}
+
+export interface QueryResult {
+  query: string;
+  params: any[];
+}
+
+export class QueryBuilder {
+  /**
+   * SELECT 쿼리 생성
+   */
+  static select(table: string, options: SelectOptions = {}): QueryResult {
+    const {
+      columns = ['*'],
+      where = {},
+      joins = [],
+      orderBy,
+      limit,
+      offset,
+      groupBy = [],
+      having = {},
+    } = options;
+
+    let query = `SELECT ${columns.join(', ')} FROM ${table}`;
+    const params: any[] = [];
+    let paramIndex = 1;
+
+    // JOIN 절 추가
+    for (const join of joins) {
+      query += ` ${join.type} JOIN ${join.table} ON ${join.on}`;
+    }
+
+    // WHERE 절 추가
+    const whereConditions = Object.keys(where);
+    if (whereConditions.length > 0) {
+      const whereClause = whereConditions
+        .map((key) => {
+          params.push(where[key]);
+          return `${key} = $${paramIndex++}`;
+        })
+        .join(' AND ');
+      query += ` WHERE ${whereClause}`;
+    }
+
+    // GROUP BY 절 추가
+    if (groupBy.length > 0) {
+      query += ` GROUP BY ${groupBy.join(', ')}`;
+    }
+
+    // HAVING 절 추가
+    const havingConditions = Object.keys(having);
+    if (havingConditions.length > 0) {
+      const havingClause = havingConditions
+        .map((key) => {
+          params.push(having[key]);
+          return `${key} = $${paramIndex++}`;
+        })
+        .join(' AND ');
+      query += ` HAVING ${havingClause}`;
+    }
+
+    // ORDER BY 절 추가
+    if (orderBy) {
+      query += ` ORDER BY ${orderBy}`;
+    }
+
+    // LIMIT 절 추가
+    if (limit !== undefined) {
+      params.push(limit);
+      query += ` LIMIT $${paramIndex++}`;
+    }
+
+    // OFFSET 절 추가
+    if (offset !== undefined) {
+      params.push(offset);
+      query += ` OFFSET $${paramIndex++}`;
+    }
+
+    return { query, params };
+  }
+
+  /**
+   * INSERT 쿼리 생성
+   */
+  static insert(
+    table: string,
+    data: Record<string, any>,
+    options: InsertOptions = {}
+  ): QueryResult {
+    const { returning = [], onConflict } = options;
+
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
+
+    let query = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;
+
+    // ON CONFLICT 절 추가
+    if (onConflict) {
+      query += ` ON CONFLICT (${onConflict.columns.join(', ')})`;
+      
+      if (onConflict.action === 'DO NOTHING') {
+        query += ' DO NOTHING';
+      } else if (onConflict.action === 'DO UPDATE' && onConflict.updateSet) {
+        const updateSet = onConflict.updateSet
+          .map(col => `${col} = EXCLUDED.${col}`)
+          .join(', ');
+        query += ` DO UPDATE SET ${updateSet}`;
+      }
+    }
+
+    // RETURNING 절 추가
+    if (returning.length > 0) {
+      query += ` RETURNING ${returning.join(', ')}`;
+    }
+
+    return { query, params: values };
+  }
+
+  /**
+   * UPDATE 쿼리 생성
+   */
+  static update(
+    table: string,
+    data: Record<string, any>,
+    where: Record<string, any>,
+    options: UpdateOptions = {}
+  ): QueryResult {
+    const { returning = [] } = options;
+
+    const dataKeys = Object.keys(data);
+    const dataValues = Object.values(data);
+    const whereKeys = Object.keys(where);
+    const whereValues = Object.values(where);
+
+    let paramIndex = 1;
+
+    // SET 절 생성
+    const setClause = dataKeys
+      .map((key) => `${key} = $${paramIndex++}`)
+      .join(', ');
+
+    // WHERE 절 생성
+    const whereClause = whereKeys
+      .map((key) => `${key} = $${paramIndex++}`)
+      .join(' AND ');
+
+    let query = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
+
+    // RETURNING 절 추가
+    if (returning.length > 0) {
+      query += ` RETURNING ${returning.join(', ')}`;
+    }
+
+    const params = [...dataValues, ...whereValues];
+
+    return { query, params };
+  }
+
+  /**
+   * DELETE 쿼리 생성
+   */
+  static delete(table: string, where: Record<string, any>): QueryResult {
+    const whereKeys = Object.keys(where);
+    const whereValues = Object.values(where);
+
+    const whereClause = whereKeys
+      .map((key, index) => `${key} = $${index + 1}`)
+      .join(' AND ');
+
+    const query = `DELETE FROM ${table} WHERE ${whereClause}`;
+
+    return { query, params: whereValues };
+  }
+
+  /**
+   * COUNT 쿼리 생성
+   */
+  static count(table: string, where: Record<string, any> = {}): QueryResult {
+    const whereKeys = Object.keys(where);
+    const whereValues = Object.values(where);
+
+    let query = `SELECT COUNT(*) as count FROM ${table}`;
+
+    if (whereKeys.length > 0) {
+      const whereClause = whereKeys
+        .map((key, index) => `${key} = $${index + 1}`)
+        .join(' AND ');
+      query += ` WHERE ${whereClause}`;
+    }
+
+    return { query, params: whereValues };
+  }
+
+  /**
+   * EXISTS 쿼리 생성
+   */
+  static exists(table: string, where: Record<string, any>): QueryResult {
+    const whereKeys = Object.keys(where);
+    const whereValues = Object.values(where);
+
+    const whereClause = whereKeys
+      .map((key, index) => `${key} = $${index + 1}`)
+      .join(' AND ');
+
+    const query = `SELECT EXISTS(SELECT 1 FROM ${table} WHERE ${whereClause}) as exists`;
+
+    return { query, params: whereValues };
+  }
+
+  /**
+   * 동적 WHERE 절 생성 (복잡한 조건)
+   */
+  static buildWhereClause(
+    conditions: Record<string, any>,
+    startParamIndex: number = 1
+  ): { clause: string; params: any[]; nextParamIndex: number } {
+    const keys = Object.keys(conditions);
+    const params: any[] = [];
+    let paramIndex = startParamIndex;
+
+    if (keys.length === 0) {
+      return { clause: '', params: [], nextParamIndex: paramIndex };
+    }
+
+    const clause = keys
+      .map((key) => {
+        const value = conditions[key];
+        
+        // 특수 연산자 처리
+        if (key.includes('>>') || key.includes('->')) {
+          // JSON 쿼리
+          params.push(value);
+          return `${key} = $${paramIndex++}`;
+        } else if (Array.isArray(value)) {
+          // IN 절
+          const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
+          params.push(...value);
+          return `${key} IN (${placeholders})`;
+        } else if (value === null) {
+          // NULL 체크
+          return `${key} IS NULL`;
+        } else {
+          // 일반 조건
+          params.push(value);
+          return `${key} = $${paramIndex++}`;
+        }
+      })
+      .join(' AND ');
+
+    return { clause, params, nextParamIndex: paramIndex };
+  }
+}